本文探讨了一个基于网络的城市崛起与战争模拟问题，通过构建一个由城市和道路组成的网络，研究了城市崛起顺序对战争次数的影响。文章提出了一种算法，能够计算在所有可能的崛起顺序中，战争次数的最大值，并在城市崛起次数发生变化时，快速更新计算结果。
九条可怜是一个热爱阅读的女孩子。
这段时间，她看了一本非常有趣的小说，这本小说的架空世界引起了她的兴趣。
这个世界有 \(n\) 个城市，这 \(n\) 个城市被恰好 \(n-1\) 条双向道路联通，即任意两个城市都可以互相到达。同时城市 \(1\) 坐落在世界的中心，占领了这个城市就称霸了这个世界。
在最开始，这 \(n\) 个城市都不在任何国家的控制之下，但是随着社会的发展，一些城市会崛起形成国家并夺取世界的霸权。为了方便，我们标记第 \(i\) 个城市崛起产生的国家为第 \(i\) 个国家。在第 \(i\) 个城市崛起的过程中，第 \(i\) 个国家会取得城市 \(i\) 到城市 \(1\) 路径上所有城市的控制权。
新的城市的崛起往往意味着战争与死亡，若第 \(i\) 个国家在崛起中，需要取得一个原本被国家 \(j\)（\(j\ne i\)）控制的城市的控制权，那么国家 \(i\) 就必须向国家 \(j\) 宣战并进行战争。
现在，可怜知道了，在历史上，第 \(i\) 个城市一共崛起了 \(a_i\) 次。但是这些事件发生的相对顺序已经无从考究了，唯一的信息是，在一个城市崛起称霸世界之前，新的城市是不会崛起的。
战争对人民来说是灾难性的。可怜定义一次崛起的灾难度为崛起的过程中会和多少不同的国家进行战争（和同一个国家进行多次战争只会被计入一次）。可怜想要知道，在所有可能的崛起顺序中，灾难度之和最大是多少。
同时，在考古学家的努力下，越来越多的历史资料被发掘了出来，根据这些新的资料，可怜会对 \(a_i\) 进行一些修正。具体来说，可怜会对 \(a_i\) 进行一些操作，每次会将 \(a_x\) 加上 \(w\)。她希望在每次修改之后，都能计算得到最大的灾难度。
然而可怜对复杂的计算并不感兴趣，因此她想让你来帮她计算一下这些数值。
对题面的一些补充:
同一个城市多次崛起形成的国家是同一个国家，这意味着同一个城市连续崛起两次是不会和任何国家开战的：因为这些城市原来就在它的控制之下。 在历史的演变过程中，第 $i$ 个国家可能会有一段时间没有任何城市的控制权。但是这并不意味着第 $i$ 个国家灭亡了，在城市 $i$ 崛起的时候，第 $i$ 个国家仍然会取得 $1$ 到 $i$ 路径上的城市的控制权。输入格式
第一行输入两个整数 \(n,m\) 表示城市个数和操作个数。
第二行输入 \(n\) 个整数表示 \(a_i\) 的初始值。
接下来 \(n-1\) 行，每行输入两个整数 \(u_i,v_i\)（\(1\le u_i,v_i\le n\)）描述了一条道路。
接下来 \(m\) 行每行输入两个整数 \(x_i,w_i\) 表示将 \(a_{x_i}\) 加上 \(w_i\)。
输出格式
输出共 \(m+1\) 行，第一行表示初始的 \(a_i\) 的答案，接下来 \(m\) 行每行表示这次修正后的答案。
样例一
input
5 3
1 1 1 1 1
1 2
1 3
2 4
2 5
2 1
3 1
4 1
output
6
7
9
10
explanation
在修正开始之前，如果按照所在城市 \(4,1,5,3,2\) 的顺序崛起，那么依次会和 \(0,1,2,1,2\) 个国家进行战争。这时一共会产生 \(6\) 对敌对关系。可以证明这是所有崛起顺序中的最大值。
样例二
见样例数据下载。
限制与约定
| 测试点 | $n$ | $m$ | 其他约定 |
|---|---|---|---|
| 1 | $\le 10$ | $=0$ | $a_i=1$ |
| 2 | $\le 150000$ | $\le 150000$ | 第 $i$ 条道路连接 $i$ 和 $i + 1$ |
| 3 | |||
| 4 | $=0$ | 无 | |
| 5 | |||
| 6 | $\le 150000$ | ||
| 7 | |||
| 8 | |||
| 9 | $\le 4\times 10^5$ | $\le 4\times 10^5$ | |
| 10 |
对于 100% 的数据，\(1\le a_i,w_i\le 10^7\)，\(1\le x_i\le n\)。
时间限制：\(2\texttt{s}\)
空间限制：\(512\texttt{MB}\)
题解
首先考虑静态询问答案，我们令 \(sum_i\) 表示 \(i\) 的子树的 \(a_v\) 之和，然后想要求这个点的儿子的子树中对当前点能产生的最大贡献
正常情况下是：\(sum_i-1\)，就是每次从不同儿子的子树中交错上来
但是如果存在一个儿子 \(v\) 的 \(sum_v\) 大于 \(sum_i\) 的一半，那么我们就做不到每次交错地选，最后一定会有剩下的从同一子树上来，这样是无法产生贡献的（与同一个国家的战争只算一次贡献，这样的贡献在儿子处已经计算完了）。这样的情况下，答案是 \(2(sum_i-\max\{\max\{sum_v\},a_i\})\)
这样我们就得到了一个 \(O(n)\) 的静态算法
考虑动态的时候，我们发现修改一个点的 \(a_i\) 改变的就是这个点到根路径上的 \(sum_f\) 值，我们要对这些点进行修改。这不就想LCT的access吗，我们只要把重儿子的定义修改为存在上述第二种情况，然后每次修改的时候就可以重新计算贡献了
#include<bits/stdc++.h>
#define ui unsigned int
#define ll long long
#define db double
#define ld long double
#define ull unsigned long long
#define ft first
#define sd second
#define pb(a) push_back(a)
#define PII std::pair<int,int>
#define PLL std::pair<ll,ll>
#define mp(a,b) std::make_pair(a,b)
#define ITR(a,b) for(auto a:b)
#define REP(a,b,c) for(register int a=(b),a##end=(c);a<=a##end;++a)
#define DEP(a,b,c) for(register int a=(b),a##end=(c);a>=a##end;--a)
const int MAXN=400000+10;
int n,m,hson[MAXN],e,beg[MAXN],nex[MAXN<<1],to[MAXN<<1];
ll size[MAXN],a[MAXN],ans,val[MAXN];
template<typename T> inline void read(T &x)
{
T data=0,w=1;
char ch=0;
while(ch!='-'&&(ch<'0'||ch>'9'))ch=getchar();
if(ch=='-')w=-1,ch=getchar();
while(ch>='0'&&ch<='9')data=((T)data<<3)+((T)data<<1)+(ch^'0'),ch=getchar();
x=data*w;
}
template<typename T> inline void write(T x,char ch='\0')
{
if(x<0)putchar('-'),x=-x;
if(x>9)write(x/10);
putchar(x%10+'0');
if(ch!='\0')putchar(ch);
}
template<typename T> inline bool chkmin(T &x,T y){return y<x?(x=y,true):false;}
template<typename T> inline bool chkmax(T &x,T y){return y>x?(x=y,true):false;}
template<typename T> inline T min(T x,T y){return x<y?x:y;}
template<typename T> inline T max(T x,T y){return x>y?x:y;}
inline void calc(int x)
{
ans-=val[x];
val[x]=hson[x]?2*(size[x]-size[hson[x]]):size[x]-1;
if(a[x]*2>size[x]+1)val[x]=2*(size[x]-a[x]);
ans+=val[x];
}
#define lc(x) ch[(x)][0]
#define rc(x) ch[(x)][1]
struct LinkCut_Tree{
int fa[MAXN],ch[MAXN][2],stk[MAXN],cnt;
ll add[MAXN];
inline bool nroot(int x)
{
return lc(fa[x])==x||rc(fa[x])==x;
}
inline void plus(int x,ll v)
{
size[x]+=v;add[x]+=v;
}
inline void pushdown(int x)
{
if(add[x])
{
if(lc(x))plus(lc(x),add[x]);
if(rc(x))plus(rc(x),add[x]);
add[x]=0;
}
}
inline void rotate(int x)
{
int f=fa[x],p=fa[f],c=(rc(f)==x);
if(nroot(f))ch[p][rc(p)==f]=x;
fa[ch[f][c]=ch[x][c^1]]=f;
fa[ch[x][c^1]=f]=x;
fa[x]=p;
}
inline void splay(int x)
{
cnt=0;
stk[++cnt]=x;
for(register int i=x;nroot(i);i=fa[i])stk[++cnt]=fa[i];
while(cnt)pushdown(stk[cnt--]);
for(register int y=fa[x];nroot(x);rotate(x),y=fa[x])
if(nroot(y))rotate((lc(y)==x)==(lc(fa[y])==y)?y:x);
}
inline int findroot(int x)
{
while(lc(x))pushdown(x),x=lc(x);
return x;
}
inline void access(int x,int v)
{
for(register int y=0;x;x=fa[y=x])
{
splay(x);size[x]+=v;
if(lc(x))plus(lc(x),v);
if(hson[x])
{
cnt=0;
stk[++cnt]=hson[x];
for(register int i=hson[x];nroot(i);i=fa[i])stk[++cnt]=fa[i];
while(cnt)pushdown(stk[cnt--]);
if(size[hson[x]]*2<=size[x]+1)hson[x]=rc(x)=0;
}
int nrt=findroot(y);
if(size[nrt]*2>size[x]+1)hson[x]=nrt,rc(x)=y;
calc(x);
}
}
};
LinkCut_Tree T;
#undef lc
#undef rc
inline void insert(int x,int y)
{
to[++e]=y;
nex[e]=beg[x];
beg[x]=e;
}
inline void dfs(int x,int f)
{
ll res=0;
size[x]=a[x];T.fa[x]=f;
for(register int i=beg[x];i;i=nex[i])
if(to[i]==f)continue;
else
{
dfs(to[i],x);
size[x]+=size[to[i]];
if(chkmax(res,size[to[i]]))hson[x]=to[i];
}
if(size[hson[x]]*2<=size[x])hson[x]=0;
T.ch[x][1]=hson[x];
calc(x);
}
int main()
{
read(n);read(m);
REP(i,1,n)read(a[i]);
REP(i,1,n-1)
{
int u,v;read(u);read(v);
insert(u,v);insert(v,u);
}
dfs(1,0);
printf("%lld\n",ans);
while(m--)
{
int x,w;read(x);read(w);
a[x]+=w;T.access(x,w);
printf("%lld\n",ans);
}
return 0;
}
扫一扫
332
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
