Toàn cục cân bằng nhị xoa thụ

std::vectorint>G[N];
intn,fa[N],son[N],sz[N];

voiddfsS(intu){
sz[u]=1;
for(intv:G[u]){
dfsS(v);
sz[u]+=sz[v];
if(sz[v]>sz[son[u]])son[u]=v;
}
}

intb[N],bs[N],l[N],r[N],f[N],ss[N];

// cấp b trung [bl,br) nội điểm kiến nhị xoa thụ, phản hồi nhị xoa thụ căn
intcbuild(intbl,intbr){
intx=bl,y=br;
while(y-x>1){
intmid=(x+y)>>1;
if(2*(bs[mid]-bs[bl])bs[br]-bs[bl])
x=mid;
else
y=mid;
}
// nhị phân cầu ra ấn bs thêm quyền điểm giữa
y=b[x];
ss[y]=br-bl;// ss: Nhị xoa thụ trung hạt cơ bản thụ lớn nhỏ
if(blx){
l[y]=cbuild(bl,x);
f[l[y]]=y;
}
if(x+1br){
r[y]=cbuild(x+1,br);
f[r[y]]=y;
}
returny;
}

intbuild(intx){
inty=x;
do
for(intv:G[y])
if(v!=son[y])
f[build(v)]=
y;// đệ quy thành tựu cũng liền nhẹ biên, chú ý muốn từ nhị xoa thụ căn liền biên, không phải từ nhi tử liền biên
while(y=son[y]);
y=0;
do{
b[y++]=x;// gửi trọng liên trung điểm
bs[y]=bs[y-1]+sz[x]-sz[son[x]];// bs: Nhẹ nhi tử size cùng +1, cầu tiền tố cùng
}while(x=son[x]);
returncbuild(0,y);
}

// a: Tử thụ thêm đánh dấu
// s: Tử thụ cùng ( không tính thêm đánh dấu )
inta[N],s[N];

voidadd(intx){
boolt=true;
intz=0;
while(x){
s[x]+=z;
if(t){
a[x]++;
if(r[x])a[r[x]]--;
z+=1+ss[l[x]];
s[x]-=ss[r[x]];
}
t=(x!=l[f[x]]);
if(t&&x!=r[f[x]])z=0;// nhảy qua nhẹ biên muốn quét sạch
x=f[x];
}
}

intquery(intx){
intret=0;
boolt=true;
intz=0;
while(x){
if(t){
ret+=s[x]-s[r[x]];
ret-=1ll*ss[r[x]]*a[r[x]];
z+=1+ss[l[x]];
}
ret+=1ll*z*a[x];
t=(x!=l[f[x]]);
if(t&&x!=r[f[x]])z=0;// nhảy qua nhẹ biên muốn quét sạch
x=f[x];
}
returnret;
}

#include&LTalgorithm>
#include&LTcstdio>
#include&LTcstring>
constexprintMAXN=1000000;
constexprintMAXM=3000000;
constexprintINF=0x3FFFFFFF;
usingnamespacestd;

structedge{
intto;
edge*nxt;
}edges[MAXN*2+5];

edge*ncnt=&edges[0],*Adj[MAXN+5];
intn,m;

structMatrix{
intM[2][2];

Matrixoperator*(constMatrix&B)const{
staticMatrixret;
for(inti=0;i2;i++)
for(intj=0;j2;j++){
ret.M[i][j]=-INF;
for(intk=0;k2;k++)
ret.M[i][j]=max(ret.M[i][j],M[i][k]+B.M[k][j]);
}
returnret;
}
}matr1[MAXN+5],matr2[MAXN+5];// mỗi cái điểm giữ gìn hai cái Ma trận

introot;
intw[MAXN+5],dep[MAXN+5],son[MAXN+5],siz[MAXN+5],lsiz[MAXN+5];
intg[MAXN+5][2],f[MAXN+5][2],trfa[MAXN+5],bstch[MAXN+5][2];
intstk[MAXN+5],tp;
boolvis[MAXN+5];

voidAddEdge(intu,intv){
edge*p=++ncnt;
p->to=v;
p->nxt=Adj[u];
Adj[u]=p;

edge*q=++ncnt;
q->to=u;
q->nxt=Adj[v];
Adj[v]=q;
}

voidDFS(intu,intfa){
siz[u]=1;
for(edge*p=Adj[u];p!=NULL;p=p->nxt){
intv=p->to;
if(v==fa)continue;
dep[v]=dep[u]+1;
DFS(v,u);
siz[u]+=siz[v];
if(!son[u]||siz[son[u]]siz[v])son[u]=v;
}
lsiz[u]=siz[u]-siz[son[u]];// nhẹ nhi tử siz cùng +1
}

voidDFS2(intu,intfa){
f[u][1]=w[u],f[u][0]=0;
g[u][1]=w[u],g[u][0]=0;
if(son[u]){
DFS2(son[u],u);
f[u][0]+=max(f[son[u]][0],f[son[u]][1]);
f[u][1]+=f[son[u]][0];
}
for(edge*p=Adj[u];p!=NULL;p=p->nxt){
intv=p->to;
if(v==fa||v==son[u])continue;
DFS2(v,u);
f[u][0]+=max(f[v][0],f[v][1]);// f[][] chính là bình thường DP số tổ
f[u][1]+=f[v][0];
g[u][0]+=max(f[v][0],f[v][1]);// g[][] số tổ chỉ thống kê chính mình cùng nhẹ nhi tử tin tức
g[u][1]+=f[v][0];
}
}

voidPushUp(intu){
matr2[u]=matr1[u];// matr1 là đơn điểm hơn nữa nhẹ nhi tử tin tức, matr2 là khu gian tin tức
if(bstch[u][0])matr2[u]=matr2[bstch[u][0]]*matr2[u];
// chú ý dời đi phương hướng, nhưng là nếu chúng ta củ thừa định nghĩa bất đồng, khả năng phương hướng cũng sẽ bất đồng
if(bstch[u][1])matr2[u]=matr2[u]*matr2[bstch[u][1]];
}

intgetmx2(intu){returnmax(matr2[u].M[0][0],matr2[u].M[0][1]);}

intgetmx1(intu){returnmax(getmx2(u),matr2[u].M[1][0]);}

intSBuild(intl,intr){
if(l>r)return0;
inttot=0;
for(inti=l;ir;i++)tot+=lsiz[stk[i]];
for(inti=l,sumn=lsiz[stk[l]];ir;i++,sumn+=lsiz[stk[i]])
if(sumn*2>=tot)// là trọng tâm
{
intlch=SBuild(l,i-1),rch=SBuild(i+1,r);
bstch[stk[i]][0]=lch;
bstch[stk[i]][1]=rch;
trfa[lch]=trfa[rch]=stk[i];
PushUp(stk[i]);// đem khu gian tin tức thống kê đi lên
returnstk[i];
}
return0;
}

intBuild(intu){
for(intpos=u;pos;pos=son[pos])vis[pos]=true;
for(intpos=u;pos;pos=son[pos])
for(edge*p=Adj[pos];p!=NULL;p=p->nxt)
if(!vis[p->to])// là nhẹ nhi tử
{
intv=p->to,ret=Build(v);
trfa[ret]=pos;// nhẹ nhi tử treefa[] tiếp đi lên
}
tp=0;
for(intpos=u;pos;pos=son[pos])stk[++tp]=pos;// đem trọng liên lấy ra
intret=SBuild(1,tp);// đối trọng liên tiến hành đơn độc SBuild( ta đoán là Special Build?)
returnret;// phản hồi trước mặt trọng liên nhị xoa thụ căn
}

voidModify(intu,intval){
matr1[u].M[1][0]+=val-w[u];
w[u]=val;
for(intpos=u;pos;pos=trfa[pos])
if(trfa[pos]&&bstch[trfa[pos]][0]!=pos&&bstch[trfa[pos]][1]!=pos){
matr1[trfa[pos]].M[0][0]-=getmx1(pos);
matr1[trfa[pos]].M[0][1]=matr1[trfa[pos]].M[0][0];
matr1[trfa[pos]].M[1][0]-=getmx2(pos);
PushUp(pos);
matr1[trfa[pos]].M[0][0]+=getmx1(pos);
matr1[trfa[pos]].M[0][1]=matr1[trfa[pos]].M[0][0];
matr1[trfa[pos]].M[1][0]+=getmx2(pos);
}else
PushUp(pos);
}

intread(){
intret=0,f=1;
charc=0;
while(c'0'||c>'9'){
c=getchar();
if(c=='-')f=-f;
}
ret=10*ret+c-'0';
while(true){
c=getchar();
if(c'0'||c>'9')break;
ret=10*ret+c-'0';
}
returnret*f;
}

voidprint(intx){
if(x==0)return;
print(x/10);
putchar(x%10+'0');
}

intmain(){
scanf("%d %d",&n,&m);
for(inti=1;in;i++)w[i]=read();
intu,v;
for(inti=1;in;i++){
u=read(),v=read();
AddEdge(u,v);
}
DFS(1,-1);
// cầu trọng nhi tử
DFS2(1,-1);
// cầu mới bắt đầu DP giá trị, cũng có thể ở Build() bên trong cầu, nhưng là như vậy viết liền cùng thụ mổ phương pháp sáng tác thống nhất
for(inti=1;in;i++){
matr1[i].M[0][0]=matr1[i].M[0][1]=g[i][0];
matr1[i].M[1][0]=g[i][1],matr1[i].M[1][1]=-INF;// khởi động lại Ma trận
}
root=Build(1);// root tức làm gốc tiết điểm nơi trọng liên trọng tâm
intlastans=0;
for(inti=1;im;i++){
u=read(),v=read();
u^=lastans;// cưỡng chế tại tuyến
Modify(u,v);
lastans=getmx1(root);// trực tiếp lấy giá trị
if(lastans==0)
putchar('0');
else
print(lastans);
putchar('\n');
}
return0;
}