洛谷T3401 洛谷树 树剖&&分治

这道题好干燥啊。。。折腾了半个月。。。感谢bogo大佬对个人指导。。。
题目要求支持的操做：1.查询某段路径的全部子路径的xor值之和；2.修改某条边的权值。重点是操做1。
刚开始，我看到了操做1以后就不自觉的想到了非~常暴力的东西。。。还好大佬及时把我引上正途：分治！

你们知道，最大子段和有个分治算法，本题的方法就跟这个比较相似。
对于一段子路径，若它能对答案产生贡献，那么它要么彻底在左儿子中，要么彻底在右儿子中，要么跨越左右儿子。
对于每段路径，咱们须要记录以下变量：yh:异或和，ans:答案，就是要查询的东西，p0[i]:此序列的前缀序列中，异或和的二进制第i位为0的序列有多少段，后面的p1,s0,s1相似。
因而，在分治的合并阶段，答案便分为两个部分：第一部分是左右儿子返回的ans；第二部分是左儿子的s0[i]*p1[i]和s1[i]*p0[i]，这两个结果还要再乘以(1 << i)，表示有多少段跨越左右儿子的子路径的xor值的二进制第i位为1，乘上(1 << i)以后就表示答案实际应该累加的值。由于0和一、1和0异或的结果是1嘛，所以就对答案产生了贡献。
咱们固然也要维护p0、p一、s0、s1。这里较上面简单一些，细节详见代码的rg_a结构体定义部分。
以上讨论的都是链上的作法，题目给定的是一棵树，那么树剖就Ok了，以后扔到线段树里大力merge便可~
对于修改操做，在线段树底层重建节点，而后顺次merge其全部祖先便可。

下面说几个疑难的问题：
一.要建线段树，要求权值在点上，但题目却说在边上。怎么办呢？能够把每条边的边权下放到树中此条边下方链接的节点上。这样，根节点就不会被下放，可是并不影响结果，至于为何，会在下面提到。
二.查询时，对于一段路径u->lca->v，由于lca也被下放了权值，可是它对应的边并不在u->v路径中，所以不能被统计，因此查询时只统计路径上除lca以外的点。鉴于此，上面提到的根节点便无所谓是否下放了。具体操做时，在树剖“跳”的过程的末端稍加修改便可。
三.这点很是重要！
我在作这题时，前几份代码狂WA不止，后来找到缘由：merge操做不知足交换律，可是我在查询时却出现了运算顺序的漏洞。通过一番脑洞，我找到了正确的运算顺序，现描述以下：
1.将树剖的待合并结果分红u->lca和lca->v两部分，存入数组TL和TR；
2.将TL和TR的结果分别所有合并到TL[1]和TR[1]中(注意这里的运算顺序，建议手动画图验证)；
3.进行特判，若是TL为空，那么直接返回TR[1].ans，反之亦然；
4.若TL、TR均非空，则先将TL[1]进行“翻转”(细节见代码，一样建议画图验证)，而后合并TL[1]、TR[1]，返回合并后的ans便可。
四.有个小坑，或许是我不够细心吧，那就是查询的路径的起点和终点有多是同一个点。开始没注意这个，结果致使WA成70分。因此我在查询时加了个特判，若u==v则直接返回0。
代码以下，又丑又长，见谅见谅：

 1 #include<cstdio>
 2 #include<iostream>
 3 #include<cstring>
 4 #include<cmath>
 5 #include<ctime>
 6 #include<cstdlib>
 7 
 8 #include<string>
 9 #include<stack>
 10 #include<queue>
 11 #include<vector>
 12 #include<algorithm>
 13 #include<map>
 14 #include<set>
 15 
 16 #define inf 2147483647
 17 #define ri register int
 18 #define ll long long
 19 
 20 #define mid (l+r>>1)
 21 #define lson (o<<1)
 22 #define rson ((o<<1)+1)
 23 
 24 using namespace std;  25 
 26 inline void read(int &x){  27     x=0;  28     char t=getchar();  29     bool f=0;  30     
 31     while(t<'0' || t>'9'){  32         if(t=='-')f=1;  33         t=getchar();  34  }  35     
 36     while(t>='0' && t<='9'){  37         x=(x<<3)+(x<<1)+t-'0';  38         t=getchar();  39  }  40     
 41     if(f)x=-x;  42 }  43 
 44 inline void addedge(int,int,int);  45 int u[60005];  46 int v[60005];  47 int w[60005];  48 int fi[30005];  49 int ne[60005];  50 int pe=0;  //无向邻接表 
 51 
 52 int wp[30005];  //下放的点权 
 53 
 54 void dfs1(int);  55 int fa[30005];  //父亲 
 56 int dep[30005];  //深度 
 57 int size[30005];  //子树大小 
 58 int son[30005];  //重儿子 
 59 
 60 void dfs2(int);  61 int top[30005];  //链顶节点 
 62 int dfsx[30005];  //dfs序 
 63 int xu=0;  64 
 65 int pos[30005];  //节点位置,in Sgt.
 66 
 67 struct rg_a{  68     ll yh;  //异或和 
 69     ll ans;  //答案 
 70     ll p0[10],p1[10],s0[10],s1[10];  //本段区间二进制第j位为0/1的前/后缀区间数 
 71     
 72     inline void merge(rg_a &A,rg_a &B){  //合并 
 73  rg_a T;  74         int bl,br;  75         
 76         T.yh=A.yh^B.yh;  77         T.ans=A.ans+B.ans;  78         
 79         for(ri i=0;i<10;i++){  80             T.ans+=A.s0[i]*B.p1[i]*(1<<i);  81             T.ans+=A.s1[i]*B.p0[i]*(1<<i);  82             
 83             bl=(A.yh>>i)&1;  84             br=(B.yh>>i)&1;  85             
 86             T.p0[i]=A.p0[i];  87             if(bl)T.p0[i]+=B.p1[i];  88             else T.p0[i]+=B.p0[i];  89             
 90             T.p1[i]=A.p1[i];  91             if(bl)T.p1[i]+=B.p0[i];  92             else T.p1[i]+=B.p1[i];  93             
 94             T.s0[i]=B.s0[i];  95             if(br)T.s0[i]+=A.s1[i];  96             else T.s0[i]+=A.s0[i];  97             
 98             T.s1[i]=B.s1[i];  99             if(br)T.s1[i]+=A.s0[i]; 100             else T.s1[i]+=A.s1[i]; 101  } 102         
103         *this=T; 104  } 105 }; 106 
107 struct sgt{  //线段树
108     rg_a node[120005]; 109     
110     void build(int o,int l,int r){ 111         if(l==r){ 112             node[o].yh=node[o].ans=wp[dfsx[l]]; 113             
114             for(ri i=0;i<10;i++){ 115                 node[o].p0[i]=node[o].s0[i]=((node[o].yh>>i)&1)^1; 116                 node[o].p1[i]=node[o].s1[i]=(node[o].yh>>i)&1; 117  } 118  } 119         else{ 120  build(lson,l,mid); 121             build(rson,mid+1,r); 122             
123  node[o].merge(node[lson],node[rson]); 124  } 125  } 126     
127     void update(int o,int l,int r,int p,int x){ 128         if(l==r && l==p){ 129             node[o].yh=node[o].ans=x; 130             
131             for(ri i=0;i<10;i++){ 132                 node[o].p0[i]=node[o].s0[i]=((x>>i)&1)^1; 133                 node[o].p1[i]=node[o].s1[i]=(x>>i)&1; 134  } 135  } 136         else{ 137             if(p<=mid)update(lson,l,mid,p,x); 138             else update(rson,mid+1,r,p,x); 139             
140  node[o].merge(node[lson],node[rson]); 141  } 142  } 143     
144     rg_a query(int o,int l,int r,int a,int b){ 145         if(l>=a && r<=b)return node[o]; 146         else{ 147             if(b<=mid)return query(lson,l,mid,a,b); 148             else if(a>mid)return query(rson,mid+1,r,a,b); 149             else{ 150                 rg_a tl=query(lson,l,mid,a,b); 151                 rg_a tr=query(rson,mid+1,r,a,b); 152                 
153  tl.merge(tl,tr); 154                 return tl; 155  } 156  } 157  } 158 } tree; 159 
160 inline ll path_query(int,int); 161 rg_a TL[50],TR[50];  //外层查询临时结果
162 int pl,pr;  //记录TL和TR存放的临时结果的数量
163 
164 int n,q; 165 int f,x,y,z; 166 int root; 167 
168 int main(){ 169     srand(time(0)+19260817); 170     
171  read(n);read(q); 172     root=rand()%n+1;  //Ha~
173     
174     for(ri i=1;i<n;i++){ 175  read(x);read(y);read(z); 176  addedge(x,y,z); 177  addedge(y,x,z); 178  } 179     
180     fa[root]=0; 181     dep[root]=1; 182     wp[root]=0; 183  dfs1(root); 184     
185     top[root]=root; 186  dfs2(root); 187     
188     for(ri i=1;i<=n;i++)pos[dfsx[i]]=i; 189     
190     tree.build(1,1,n); 191     
192     while(q--){ 193  read(f); 194         
195         if(f==1){ 196  read(x);read(y); 197             printf("%lld\n",path_query(x,y)); 198  } 199         else{ 200  read(x);read(y);read(z); 201             if(pos[x]<pos[y])tree.update(1,1,n,pos[y],z); 202             else tree.update(1,1,n,pos[x],z); 203  } 204  } 205     
206     return 0; 207 } 208 
209 inline void addedge(int x,int y,int z){ 210     pe++; 211     u[pe]=x; 212     v[pe]=y; 213     w[pe]=z; 214     ne[pe]=fi[x]; 215     fi[x]=pe; 216 } 217 
218 void dfs1(int s){ 219     size[s]=1; 220     int maxson=0; 221     
222     int t=fi[s]; 223     int to=v[t]; 224     
225     while(t){ 226         if(to!=fa[s]){ 227             fa[to]=s; 228             dep[to]=dep[s]+1; 229             wp[to]=w[t]; 230             
231  dfs1(to); 232             
233             size[s]+=size[to]; 234             if(size[to]>maxson){ 235                 son[s]=to; 236                 maxson=size[to]; 237  } 238  } 239         
240         t=ne[t]; 241         to=v[t]; 242  } 243 } 244 
245 void dfs2(int s){ 246     xu++; 247     dfsx[xu]=s; 248     
249     if(son[s]){ 250         top[son[s]]=top[s]; 251  dfs2(son[s]); 252  } 253     
254     int t=fi[s]; 255     int to=v[t]; 256     
257     while(t){ 258         if(to!=fa[s] && to!=son[s]){ 259             top[to]=to; 260  dfs2(to); 261  } 262         
263         t=ne[t]; 264         to=v[t]; 265  } 266 } 267 
268 inline ll path_query(int x,int y){ 269     if(x==y)return 0;  //特判起终点相同
270     
271     pl=pr=0;  //重置临时结果数组
272     
273     int tx=top[x],ty=top[y]; 274     
275     while(tx!=ty){ 276         if(dep[tx]>dep[ty]){ 277             pl++; 278             TL[pl]=tree.query(1,1,n,pos[tx],pos[x]); 279             x=fa[tx]; 280             tx=top[x]; 281  } 282         else{ 283             pr++; 284             TR[pr]=tree.query(1,1,n,pos[ty],pos[y]); 285             y=fa[ty]; 286             ty=top[y]; 287  } 288  } 289     
290     if(x!=y){ 291         if(pos[x]<pos[y]){ 292             pr++; 293             TR[pr]=tree.query(1,1,n,pos[x]+1,pos[y]); 294  } 295         else{ 296             pl++; 297             TL[pl]=tree.query(1,1,n,pos[y]+1,pos[x]); 298  } 299  } 300     
301     for(ri i=2;i<=pl;i++)TL[1].merge(TL[i],TL[1]); 302     for(ri i=2;i<=pr;i++)TR[1].merge(TR[i],TR[1]); 303     //这里所有都要注意运算顺序！
304     if(!pl)return TR[1].ans; 305     else if(!pr)return TL[1].ans;  //特判答案仅在lca一侧的状况
306     else{ 307         for(ri i=0;i<10;i++){ 308             swap(TL[1].p0[i],TL[1].s0[i]); 309             swap(TL[1].p1[i],TL[1].s1[i]); 310         }  //“翻转”TL[1]
311         
312         TL[1].merge(TL[1],TR[1]); 313         return TL[1].ans; 314  } 315 }