BZOJ3589 动态树[树剖/暴力/容斥]

操作0，显然直接线段树解决。

操作1，瓶颈在于重叠的链只算一次。在线段树上来看，如果一个区间被覆盖了，那么只算这个区间，子树里面也就不管了。

考虑对节点打标记来表示是否覆盖。但是，如果统一打完之后，并不方便计算打上标记的点的和。明确目标，现在希望能覆盖很多小区间的一个大区间被打上标记之后用他来更新答案。`````

可以对每一个点维护$acc_i$表示这个点子树内被覆盖的区间的和。那么，当有更大的区间覆盖上去的时候，直接把$acc_i$改成$sum_i$，传上去即可，同时在这个点打上已覆盖的标记。否则正常pushup。答案是$acc_{root}$

这样就保证了覆盖后答案只算一次的正确性。

还有一个问题，在操作完之后，显然应当把标记删掉。这里考虑区间覆盖性标记$tag$，当他是1的时候就是之前的完全覆盖，是-1表示没有覆盖，为了使得下一操作时清除$acc$记录，设0表示要把子树内覆盖的区间清掉。

在下放标记的时候，就可以保证左右子树以及根的$acc$都是0，能重新用。当$tag$是1的时候，可以正常下放，也可以不下放，但将0和1统一一下code更简单。复杂度$O(nklog^2n)$

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 #define dbg(x) cerr << #x << " = " << x <<endl
 using namespace std;
 typedef long long ll;
 typedef double db;
 typedef pair<int,int> pii;
 template<typename T>inline T _min(T A,T B){return A<B?A:B;}
 template<typename T>inline T _max(T A,T B){return A>B?A:B;}
 template<typename T>inline char MIN(T&A,T B){return A>B?(A=B,):;}
 template<typename T>inline char MAX(T&A,T B){return A<B?(A=B,):;}
 template<typename T>inline void _swap(T&A,T&B){A^=B^=A^=B;}
 template<typename T>inline T read(T&x){
     x=;int f=;char c;while(!isdigit(c=getchar()))if(c=='-')f=;
     while(isdigit(c))x=x*+(c&),c=getchar();return f?x=-x:x;
 }
 const int N=2e5+;
 struct thxorz{int to,nxt;}G[N<<];
 int hd[N],tot;
 int n,q;
 inline void Addedge(int x,int y){
     G[++tot].to=y,G[tot].nxt=hd[x],hd[x]=tot;
     G[++tot].to=x,G[tot].nxt=hd[y],hd[y]=tot;
 }
 #define y G[j].to
 int fa[N],d[N],son[N],cnt[N],topfa[N],st[N],tim;
 void dfs1(int x,int f){
     fa[x]=f,d[x]=d[f]+,cnt[x]=;int tmp=-;
     for(register int j=hd[x];j;j=G[j].nxt)if(y^f)dfs1(y,x),cnt[x]+=cnt[y],MAX(tmp,cnt[y])&&(son[x]=y);
 }
 void dfs2(int x,int topf){
     topfa[x]=topf,st[x]=++tim;if(!son[x])return;dfs2(son[x],topf);
     for(register int j=hd[x];j;j=G[j].nxt)if(y^fa[x]&&y^son[x])dfs2(y,y);
 }
 #undef y
 #define lc i<<1
 #define rc i<<1|1
 int sumv[N<<],acc[N<<],stag[N<<],atag[N<<];
 inline void Pushup(int i){sumv[i]=sumv[lc]+sumv[rc],acc[i]=acc[lc]+acc[rc];}
 inline void pd_sum(int i,int L,int R){
     if(stag[i]){
         int mid=L+R>>;
         sumv[lc]+=(mid-L+)*stag[i],sumv[rc]+=(R-mid)*stag[i],stag[lc]+=stag[i],stag[rc]+=stag[i],stag[i]=;
     }
 }
 inline void pd_acc(int i){
     if(~atag[i])
         acc[lc]=atag[i]?sumv[lc]:,acc[rc]=atag[i]?sumv[rc]:,atag[rc]=atag[lc]=atag[i],atag[i]=-;
 }
 void Update_add(int i,int L,int R,int ql,int qr,int k){
     if(ql<=L&&qr>=R){sumv[i]+=(R-L+)*k,stag[i]+=k;return;}
     int mid=L+R>>;pd_sum(i,L,R);
     if(ql<=mid)Update_add(lc,L,mid,ql,qr,k);
     if(qr>mid)Update_add(rc,mid+,R,ql,qr,k);
     Pushup(i);
 }
 void Update_account(int i,int L,int R,int ql,int qr){
     if(ql<=L&&qr>=R){acc[i]=sumv[i],atag[i]=;return;}
     int mid=L+R>>;pd_sum(i,L,R),pd_acc(i);
     if(ql<=mid)Update_account(lc,L,mid,ql,qr);
     if(qr>mid)Update_account(rc,mid+,R,ql,qr);
     Pushup(i);
 }
 inline void clear_the_tree(){atag[]=,acc[]=;}
 inline void Tree_query(int x,int y){
     if(d[x]<d[y])x^=y^=x^=y;
     while(topfa[x]^topfa[y])Update_account(,,n,st[topfa[x]],st[x]),x=fa[topfa[x]];
     Update_account(,,n,st[y],st[x]);
 }

 int main(){//freopen("test.in","r",stdin);freopen("test.ans","w",stdout);
     read(n);for(register int i=,x,y;i<n;++i)read(x),read(y),Addedge(x,y);
     dfs1(,),dfs2(,);
     read(q);memset(atag,-,sizeof atag);
     for(register int i=,opt,k,x,y;i<=q;++i){
         read(opt);
         if(opt){
             read(k);while(k--)read(x),read(y),Tree_query(x,y);
             printf("%d\n",acc[]&0x7fffffff);clear_the_tree();
         }
         else read(x),read(k),Update_add(,,n,st[x],st[x]+cnt[x]-,k);
     }
     return ;
 }

还有一个点，对$2^{31}$取模用int自然溢出是因为前31位爆掉，进位到符号位，符号位会变化，但不影响前31位的mod结果。最后只要把符号位改一下即可，所以要$\text{and}2^{31}-1$。

反思：标记的表示设计想的不太好。当线段树设计有限制条件的询问时，可以维护一些附加信息，如本题的覆盖区间的和。

附：本题还有另外两种做法。

一：暴力

每次询问把跳过的每条重链全弄出来，把这些区间按dfs序从小到大排序，然后合并区间，暴力查询。复杂度$O(n(klognlog(klogn)+klog^2n))$。比较卡。

二：容斥

这个询问相当于求若干链的并，可以容斥。

$sum(\bigcup\limits_{i=1}^{n}A_i)=\sum\limits_{k=1}^{n}(-1)^{k-1}\sum\limits_{1<=j_1<j_2<...<j_k<=n}sum(A_{j_1}\cap
A_{j_2}\cap ...\cap A_{j_k})$

参考这篇。