树链剖分 （ZQU1607）

这道题与模板之间，多了个确定哪个为根的操作；

这道题有技巧，并不需要真正去建立以某个节点为根的树

关于路径的操作，无论以哪个点为根，得出的答案无影响；

关于对子节点进行操作的，有几种情况，

当查询节点刚好是根节点的话，就直接从1开始遍历就好 （因为这道题是以1为根节点）

当查询的节点的孩子或孙子中包括根节点的话，则需要用根节点得出的值去剪掉这个根节点得出的值 

（这里以查询作为例子，更新值也是同样的道理）

所以，整个代码中跟模板的区别是，多了一步 确定查询节点跟根节点关系的代码 （代码中的函数名为work2）

 

#include<algorithm>
#include<iostream>
#include<cstdlib>
#include<cstring>
#include<cstdio>
#define Rint register int
#define mem(a,b) memset(a,(b),sizeof(a))
#define Temp template<typename T>
using namespace std;
typedef long long ll;

#define mid ((l+r)>>1)
#define lson rt<<1,l,mid
#define rson rt<<1|1,mid+1,r
#define len (r-l+1)
ll root,n;   //n需要作为全局变量
const ll maxn=200000+10;
//见题意
ll e,beg[maxn],nex[maxn],to[maxn],w[maxn],wt[maxn];
//链式前向星数组，w[]、wt[]初始点权数组
ll a[maxn<<2],laz[maxn<<2];
//线段树数组、lazy操作
ll son[maxn],id[maxn],fa[maxn],cnt,dep[maxn],siz[maxn],top[maxn];
//son[]重儿子编号,id[]新编号,fa[]父亲节点,cnt dfs_clock/dfs序,dep[]深度,siz[]子树大小,top[]当前链顶端节点
ll res=0;
//查询答案

inline void add(ll x,ll y){//链式前向星加边
    to[++e]=y;
    nex[e]=beg[x];
    beg[x]=e;
}
//-------------------------------------- 以下为线段树
inline void pushdown(ll rt,ll lenn){
    laz[rt<<1]+=laz[rt];
    laz[rt<<1|1]+=laz[rt];
    a[rt<<1]+=laz[rt]*(lenn-(lenn>>1));
    a[rt<<1|1]+=laz[rt]*(lenn>>1);
  //  a[rt<<1]%=mod;
  //  a[rt<<1|1]%=mod;
    laz[rt]=0;
}

inline void build(ll rt,ll l,ll r){
    if(l==r){
        a[rt]=wt[l];
   //     if(a[rt]>mod)a[rt]%=mod;
        return;
    }
    build(lson);
    build(rson);
    a[rt]=a[rt<<1]+a[rt<<1|1];
}

inline void query(ll rt,ll l,ll r,ll L,ll R){
    if(L<=l&&r<=R){res+=a[rt];return;}
    else{
        if(laz[rt])pushdown(rt,len);
        if(L<=mid)query(lson,L,R);
        if(R>mid)query(rson,L,R);
    }
}

inline void update(ll rt,ll l,ll r,ll L,ll R,ll k){
    if(L<=l&&r<=R){
        laz[rt]+=k;
        a[rt]+=k*len;
    }
    else{
        if(laz[rt])pushdown(rt,len);
        if(L<=mid)update(lson,L,R,k);
        if(R>mid)update(rson,L,R,k);
        a[rt]=a[rt<<1]+a[rt<<1|1];
    }
}
//---------------------------------以上为线段树
inline ll qRange(ll x,ll y){
    ll ans=0;
    while(top[x]!=top[y]){//当两个点不在同一条链上
        if(dep[top[x]]<dep[top[y]])swap(x,y);//把x点改为所在链顶端的深度更深的那个点
        res=0;
        query(1,1,n,id[top[x]],id[x]);//ans加上x点到x所在链顶端 这一段区间的点权和
        ans+=res;
       // ans%=mod;//按题意取模
        x=fa[top[x]];//把x跳到x所在链顶端的那个点的上面一个点
    }
    //直到两个点处于一条链上
    if(dep[x]>dep[y])swap(x,y);//把x点深度更深的那个点
    res=0;
    query(1,1,n,id[x],id[y]);//这时再加上此时两个点的区间和即可
    ans+=res;
    return ans;
}

inline void updRange(ll x,ll y,ll k){//同上
    //k%=mod;
    while(top[x]!=top[y]){
        if(dep[top[x]]<dep[top[y]])swap(x,y);
        update(1,1,n,id[top[x]],id[x],k);
        x=fa[top[x]];
    }
    if(dep[x]>dep[y])swap(x,y);
    update(1,1,n,id[x],id[y],k);
}

inline ll qSon(ll x){
    res=0;
    query(1,1,n,id[x],id[x]+siz[x]-1);//子树区间右端点为id[x]+siz[x]-1
    return res;
}

inline void updSon(ll x,ll k){//同上
    update(1,1,n,id[x],id[x]+siz[x]-1,k);
}

inline void dfs1(ll x,ll f,ll deep){//x当前节点，f父亲，deep深度
    dep[x]=deep;//标记每个点的深度
    fa[x]=f;//标记每个点的父亲
    siz[x]=1;//标记每个非叶子节点的子树大小
    ll maxson=-1;//记录重儿子的儿子数
    for(ll i=beg[x];i;i=nex[i]){
        ll y=to[i];
        if(y==f)continue;//若为父亲则continue
        dfs1(y,x,deep+1);//dfs其儿子
        siz[x]+=siz[y];//把它的儿子数加到它身上
        if(siz[y]>maxson)son[x]=y,maxson=siz[y];//标记每个非叶子节点的重儿子编号
    }
}

inline void dfs2(ll x,ll topf){//x当前节点，topf当前链的最顶端的节点
    id[x]=++cnt;//标记每个点的新编号
    wt[cnt]=w[x];//把每个点的初始值赋到新编号上来
    top[x]=topf;//这个点所在链的顶端
    if(!son[x])return;//如果没有儿子则返回
    dfs2(son[x],topf);//按先处理重儿子，再处理轻儿子的顺序递归处理
    for(ll i=beg[x];i;i=nex[i]){
        ll y=to[i];
        if(y==fa[x]||y==son[x])continue;
        dfs2(y,y);//对于每一个轻儿子都有一条从它自己开始的链
    }
}
ll check2(ll xx,ll yy){
    ll rt=xx,lst=yy;
    while(top[xx]!=top[yy]){
        if(dep[top[xx]]<dep[top[yy]]) swap(xx,yy);
        lst=top[xx];xx=fa[top[xx]];
    }
    if(dep[xx]>dep[yy]) swap(xx,yy); 
    if(xx!=rt) return 0;    //如果得出的点不是等于查询节点
    //则说明没有关系，这里举个例子，比如在一个树中，他的父亲节点是根节点，
    //那么就没有关系；换一个说法（如果yy不是xx的子树，则没有影响）
    //两个节点没有关系，return 0
    if(fa[lst]==xx) return lst; //如果lst的父亲是这个查询节点，则根节点 
                                //便是这个lst；
    return son[xx];  //可以说return son[xx]是最难理解的了。
}   //不过还是理解了，开心！ 如果fa[lst]的节点是查询节点的子节点或者孙节点；
  //那么从他重儿子以下的点都是不在查询范围（更新范围）的，这里画图模拟一遍
  //就会发现就是这么个道理。
int main()
{
    scanf("%lld",&n);
    for(ll i=1;i<=n;i++) scanf("%lld",&w[i]);
    for(ll i=2;i<=n;i++){
        ll t;
        scanf("%lld",&t);
        add(t,i);add(i,t);
    }
    ll m;
    scanf("%lld",&m);
    dfs1(1,0,1);
    dfs2(1,1);
    build(1,1,n);
    root=1;
    while(m--){
        ll k,x,y,z;
        scanf("%lld",&k);
        if(k==1){
            scanf("%lld",&root);
        }
        if(k==2){
            scanf("%lld%lld%lld",&x,&y,&z);
            updRange(x,y,z);
        }
        if(k==3){
            scanf("%lld%lld",&x,&z);
            if(x==root) {updSon(1,z);continue;}
            y=check2(x,root);
            if(y==0) updSon(x,z);
            else{
                updSon(1,z);
                updSon(y,-z);
            }
        }
        if(k==4){
            scanf("%lld%lld",&x,&y);
            printf("%lld\n",qRange(x,y));
        }
        if(k==5){
            scanf("%lld",&x);
            if(x==root){
                printf("%lld\n",qSon(1));
                continue;
            }
            y=check2(x,root);
            if(y==0) printf("%lld\n",qSon(x));
            else{
                printf("%lld\n",qSon(1)-qSon(y));
            }
        }
    }
    return 0;
}