洛谷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、1和0异或的结果是1嘛，因此就对答案产生了贡献。
我们当然也要维护p0、p1、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。
代码如下，又丑又长，见谅见谅：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
#include<ctime>
#include<cstdlib>

#include<string>
#include<stack>
#include<queue>
#include<vector>
#include<algorithm>
#include<map>
#include<set>

#define inf 2147483647
#define ri register int
#define ll long long

#define mid (l+r>>1)
#define lson (o<<1)
#define rson ((o<<1)+1)

using namespace std;

inline void read(int &x){
    x=0;
    char t=getchar();
    bool f=0;
    
    while(t<'0' || t>'9'){
        if(t=='-')f=1;
        t=getchar();
    }
    
    while(t>='0' && t<='9'){
        x=(x<<3)+(x<<1)+t-'0';
        t=getchar();
    }
    
    if(f)x=-x;
}

inline void addedge(int,int,int);
int u[60005];
int v[60005];
int w[60005];
int fi[30005];
int ne[60005];
int pe=0;  //无向邻接表 

int wp[30005];  //下放的点权 

void dfs1(int);
int fa[30005];  //父亲 
int dep[30005];  //深度 
int size[30005];  //子树大小 
int son[30005];  //重儿子 

void dfs2(int);
int top[30005];  //链顶节点 
int dfsx[30005];  //dfs序 
int xu=0;

int pos[30005];  //节点位置,in Sgt.

struct rg_a{
    ll yh;  //异或和 
    ll ans;  //答案 
    ll p0[10],p1[10],s0[10],s1[10];  //本段区间二进制第j位为0/1的前/后缀区间数 
    
    inline void merge(rg_a &A,rg_a &B){  //合并 
        rg_a T;
        int bl,br;
        
        T.yh=A.yh^B.yh;
        T.ans=A.ans+B.ans;
        
        for(ri i=0;i<10;i++){
            T.ans+=A.s0[i]*B.p1[i]*(1<<i);
            T.ans+=A.s1[i]*B.p0[i]*(1<<i);
            
            bl=(A.yh>>i)&1;
            br=(B.yh>>i)&1;
            
            T.p0[i]=A.p0[i];
            if(bl)T.p0[i]+=B.p1[i];
            else T.p0[i]+=B.p0[i];
            
            T.p1[i]=A.p1[i];
            if(bl)T.p1[i]+=B.p0[i];
            else T.p1[i]+=B.p1[i];
            
            T.s0[i]=B.s0[i];
            if(br)T.s0[i]+=A.s1[i];
            else T.s0[i]+=A.s0[i];
            
            T.s1[i]=B.s1[i];
            if(br)T.s1[i]+=A.s0[i];
            else T.s1[i]+=A.s1[i];
        }
        
        *this=T;
    }
};

struct sgt{  //线段树
    rg_a node[120005];
    
    void build(int o,int l,int r){
        if(l==r){
            node[o].yh=node[o].ans=wp[dfsx[l]];
            
            for(ri i=0;i<10;i++){
                node[o].p0[i]=node[o].s0[i]=((node[o].yh>>i)&1)^1;
                node[o].p1[i]=node[o].s1[i]=(node[o].yh>>i)&1;
            }
        }
        else{
            build(lson,l,mid);
            build(rson,mid+1,r);
            
            node[o].merge(node[lson],node[rson]);
        }
    }
    
    void update(int o,int l,int r,int p,int x){
        if(l==r && l==p){
            node[o].yh=node[o].ans=x;
            
            for(ri i=0;i<10;i++){
                node[o].p0[i]=node[o].s0[i]=((x>>i)&1)^1;
                node[o].p1[i]=node[o].s1[i]=(x>>i)&1;
            }
        }
        else{
            if(p<=mid)update(lson,l,mid,p,x);
            else update(rson,mid+1,r,p,x);
            
            node[o].merge(node[lson],node[rson]);
        }
    }
    
    rg_a query(int o,int l,int r,int a,int b){
        if(l>=a && r<=b)return node[o];
        else{
            if(b<=mid)return query(lson,l,mid,a,b);
            else if(a>mid)return query(rson,mid+1,r,a,b);
            else{
                rg_a tl=query(lson,l,mid,a,b);
                rg_a tr=query(rson,mid+1,r,a,b);
                
                tl.merge(tl,tr);
                return tl;
            }
        }
    }
} tree;

inline ll path_query(int,int);
rg_a TL[50],TR[50];  //外层查询临时结果
int pl,pr;  //记录TL和TR存放的临时结果的数量

int n,q;
int f,x,y,z;
int root;

int main(){
    srand(time(0)+19260817);
    
    read(n);read(q);
    root=rand()%n+1;  //Ha~
    
    for(ri i=1;i<n;i++){
        read(x);read(y);read(z);
        addedge(x,y,z);
        addedge(y,x,z);
    }
    
    fa[root]=0;
    dep[root]=1;
    wp[root]=0;
    dfs1(root);
    
    top[root]=root;
    dfs2(root);
    
    for(ri i=1;i<=n;i++)pos[dfsx[i]]=i;
    
    tree.build(1,1,n);
    
    while(q--){
        read(f);
        
        if(f==1){
            read(x);read(y);
            printf("%lld
",path_query(x,y));
        }
        else{
            read(x);read(y);read(z);
            if(pos[x]<pos[y])tree.update(1,1,n,pos[y],z);
            else tree.update(1,1,n,pos[x],z);
        }
    }
    
    return 0;
}

inline void addedge(int x,int y,int z){
    pe++;
    u[pe]=x;
    v[pe]=y;
    w[pe]=z;
    ne[pe]=fi[x];
    fi[x]=pe;
}

void dfs1(int s){
    size[s]=1;
    int maxson=0;
    
    int t=fi[s];
    int to=v[t];
    
    while(t){
        if(to!=fa[s]){
            fa[to]=s;
            dep[to]=dep[s]+1;
            wp[to]=w[t];
            
            dfs1(to);
            
            size[s]+=size[to];
            if(size[to]>maxson){
                son[s]=to;
                maxson=size[to];
            }
        }
        
        t=ne[t];
        to=v[t];
    }
}

void dfs2(int s){
    xu++;
    dfsx[xu]=s;
    
    if(son[s]){
        top[son[s]]=top[s];
        dfs2(son[s]);
    }
    
    int t=fi[s];
    int to=v[t];
    
    while(t){
        if(to!=fa[s] && to!=son[s]){
            top[to]=to;
            dfs2(to);
        }
        
        t=ne[t];
        to=v[t];
    }
}

inline ll path_query(int x,int y){
    if(x==y)return 0;  //特判起终点相同
    
    pl=pr=0;  //重置临时结果数组
    
    int tx=top[x],ty=top[y];
    
    while(tx!=ty){
        if(dep[tx]>dep[ty]){
            pl++;
            TL[pl]=tree.query(1,1,n,pos[tx],pos[x]);
            x=fa[tx];
            tx=top[x];
        }
        else{
            pr++;
            TR[pr]=tree.query(1,1,n,pos[ty],pos[y]);
            y=fa[ty];
            ty=top[y];
        }
    }
    
    if(x!=y){
        if(pos[x]<pos[y]){
            pr++;
            TR[pr]=tree.query(1,1,n,pos[x]+1,pos[y]);
        }
        else{
            pl++;
            TL[pl]=tree.query(1,1,n,pos[y]+1,pos[x]);
        }
    }
    
    for(ri i=2;i<=pl;i++)TL[1].merge(TL[i],TL[1]);
    for(ri i=2;i<=pr;i++)TR[1].merge(TR[i],TR[1]);
    //这里全部都要注意运算顺序！
    if(!pl)return TR[1].ans;
    else if(!pr)return TL[1].ans;  //特判答案仅在lca一侧的情况
    else{
        for(ri i=0;i<10;i++){
            swap(TL[1].p0[i],TL[1].s0[i]);
            swap(TL[1].p1[i],TL[1].s1[i]);
        }  //“翻转”TL[1]
        
        TL[1].merge(TL[1],TR[1]);
        return TL[1].ans;
    }
}