树链剖分【学习 + 洛谷P3384】

树链剖分

LCA:  Nearest Common Ancestors 【POJ 1330】

• 求树上两个结点的最近公共祖先(LCA)

树上差分： Network【POJ  3417】 

DFS序：Apple Tree【POJ 3321】

 要求要求你进行上述五种操作，并且将询问输出，用上面两种算法来解决就比较吃力
 这就要靠树链剖分来解决了
 参考博客：https://www.cnblogs.com/chinhhh/p/7965433.html
                  https://www.cnblogs.com/ivanovcraft/p/9019090.html

• 将树从x到y结点最短路径上所有节点的值都加上z 
• 求树从x到y结点最短路径上所有节点的值之和
   
• 将以x为根节点的子树内所有节点值都加上z 
• 求以x为根节点的子树内所有节点值之和
   

 主要概念

重儿子：父亲节点的所有儿子中子树结点数目最多（size最大）的结点

轻儿子：父亲节点中除了重儿子以外的儿子

重边：父亲结点和重儿子连成的边

轻边：父亲节点和轻儿子连成的边

重链：由多条重边连接而成的路径

轻链：由多条轻边连接而成的路径

比如上面这幅图中，用黑线连接的结点都是重结点，其余均是轻结点

2-11就是重链，2-5就是轻链，用红点标记的就是该结点所在重链的起点，也就是下文提到的top结点

如果一个点的多个儿子所在子树大小相等且最大，那随便找一个当做它的重儿子就好了

叶节点没有重儿子，非叶节点有且只有一个重儿子

 变量名

father[ s ]	保存结点 s 的父亲结点
depth[ s ]	保存结点 s 的在树上的深度
sizes[ s ]	保存以 s 为根的子树结点个数(包括本身)
h_son[ s ]	保存 s 结点的重儿子
id[ s ]	结点 s 在 DFS的时间戳(可以认为是DFS序吧) 也是该点在线段树上的编号
ranks[ time ]	保存time时间经过的结点 s
top [ s ]	保存 s 所在重链的顶点

 实现过程

DFS1：
记录每个结点的父亲结点   每个结点的深度  以s为根的子树的结点个数  每个结点的重儿子

void dfs1(int s,int pre)
{
    father[s]=pre;
    sizes[s]=1; ///要计算本身
    for(int i=head[s];i!=-1;i=load[i].p)
    {
        int e=load[i].e;
        if(e!=pre)
        {
            depth[e]=depth[s]+1;
            dfs1(e,s);
            sizes[s]+=sizes[e];
            if(sizes[e]>sizes[h_son[s]])
                h_son[s]=e;
        }
    }
}
dfs1(root,0);   ///从题目给的根节点开始

DFS2：

记录每个结点的DFS序    每个结点所在重链的顶点   每个时间经过的结点
 

void dfs2(int s,int root)
{
    top[s]=root;    ///记录重链的顶端
    id[s]=++times;   /// DFS序
    ranks[times]=s;
    if(!h_son[s])   ///如果是叶子结点
        return ;
    dfs2(h_son[s],root);
    ///我们选择优先进入重儿子来保证一条重链上各个节点DFS序连续
    ///一个点和它的重儿子处于同一条重链，所以重儿子所在重链的顶端还是root
    for(int i=head[s];i!=-1;i=load[i].p)
    {
        int e=load[i].e;
        if(e!=h_son[s]&&e!=father[s])
            dfs2(e,e);
    }
}
dfs2(root,root);
/// 从根节点开始,根节点肯定是重链的顶点

建树(线段树)：

线段树可以解决连续区间问题，经过dfs2过程可以将一条重链上结点的dfs序变为连续，所以我们建树的要求是以dfs序来建的树，在线段树中的 1对应的是 id[ s ]==1的结点s ,就是ranks[1]。

void pushup(int sign)
{
    root[sign]=(root[sign<<1]+root[sign<<1|1])%mod;
}
void pushdown(int sign,int l,int r)
{
    int mid=(l+r)>>1;
    if(lazy[sign])
    {
        lazy[sign<<1]=(lazy[sign<<1]+lazy[sign])%mod;
        lazy[sign<<1|1]=(lazy[sign<<1|1]+lazy[sign])%mod;
        root[sign<<1]=(root[sign<<1]+lazy[sign]*(mid-l+1))%mod;
        root[sign<<1|1]=(root[sign<<1|1]+lazy[sign]*(r-mid))%mod;
        lazy[sign]=0;
    }
}

void build_root(int sign,int l,int r)
{
    if(l==r)
    {
        root[sign]=value[ranks[l]];
        return ;
    }
    int mid=(l+r)>>1;
    build_root(sign<<1,l,mid);
    build_root(sign<<1|1,mid+1,r);
    pushup(sign);
}

void update(int sign,int l,int r,int a,int b,int x)
{
    if(l==a&&r==b)
    {
        lazy[sign]+=x;
        root[sign]=(root[sign]+(r-l+1)*x)%mod;
        return ;
    }
    pushdown(sign,l,r);
    int mid=(l+r)>>1;
    if(b<=mid)
        update(sign<<1,l,mid,a,b,x);
    else if(a>mid)
        update(sign<<1|1,mid+1,r,a,b,x);
    else
    {
        update(sign<<1,l,mid,a,mid,x);
        update(sign<<1|1,mid+1,r,mid+1,b,x);
    }
    pushup(sign);
}

int query(int sign,int l,int r,int a,int b)
{
    if(l==a&&r==b)
        return root[sign];
    pushdown(sign,l,r);
    int mid=(l+r)>>1;
    if(b<=mid)
        return query(sign<<1,l,mid,a,b);
    else if(a>mid)
        return query(sign<<1|1,mid+1,r,a,b);
    else
        return (query(sign<<1,l,mid,a,mid)+query(sign<<1|1,mid+1,r,mid+1,b))%mod;
}

我们要进行上述的某三种操作都需要求解LCA，树链剖分也可以求LCA   tql
求解LCA我们需要利用到top数组 (假如我们求解结点 a 和 b 的LCA)
首先我门要将 a 和 b 跳转到同一条重链上，然后其中结点深度低的就是 a 和 b 的LCA

while(top[a]!=top[b])
{
    if(depth[top[a]]>depth[top[b]])
        swap(a,b);
    b=father[top[b]];
}
int lca=depth[a]>depth[b]?b:a;

修改和查询

既然线段树我们也建好了，LCA我们也知道怎么求了，剩下的就是套用了
修改 s - > e 路径上的值 和查询 s -> e 路径上的和
 

void update_line(int a,int b,int x)///更新
{
    while(top[a]!=top[b])
    {
        if(depth[top[a]]>depth[top[b]])
            swap(a,b);
        update(1,1,n,id[top[b]],id[b],x);
        b=father[top[b]];
    }
    if(depth[a]>depth[b])
        swap(a,b);
    update(1,1,n,id[a],id[b],x);
}

int find_line(int a,int b)///查询
{
    int ans=0;
    while(top[a]!=top[b])
    {
        if(depth[top[a]]>depth[top[b]])
            swap(a,b);
        ans=(ans+query(1,1,n,id[top[b]],id[b]))%mod;
        b=father[top[b]];
    }
    if(depth[a]>depth[b])
        swap(a,b);
    ans=(ans+query(1,1,n,id[a],id[b]))%mod;
    return ans;
}

子树的修改和查询

我们知道以 s 为根的子树上所有的所有结点的DFS均大于 id[ s ]，并且该子树的所在区间为[  id[ s ] ，id[ s ] + sizes[ s ] - 1 ]
子树的修改和查询就是线段树的区间修改和查询

 树链剖分的时间复杂度

树链剖分的两个性质：

1，如果( s, e )是一条轻边，那么size( e ) < size( s )/2；

2，从根结点到任意结点的路所经过的轻重链的个数必定都小于logn；

可以证明，树链剖分的时间复杂度为O(nlog^2n)

 模板题：洛谷P3384

///#include<bits/stdc++.h>
///#include<unordered_map>
///#include<unordered_set>
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<cmath>
#include<queue>
#include<set>
#include<stack>
#include<map>
#include<new>
#include<vector>
#define MT(a,b) memset(a,b,sizeof(a));
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const double pai=acos(-1.0);
const double E=2.718281828459;
const int INF=0x3f3f3f3f;

int n,q,r;
int value[100005],mod;

int root[400005];
int lazy[400005];

struct node
{
    int e;
    int p;
}load[200005];
int head[100005],sign;

void add_edge(int s,int e)
{
    load[++sign]=node{e,head[s]};
    head[s]=sign;
}
/// DFS1
int father[100005];
int depth[100005];
int sizes[100005];
int h_son[100005];///重儿子初始化为0
/// DFS2
int times;
int top[100005];
int ranks[100005];
int id[100005];

void dfs1(int s,int pre)
{
    father[s]=pre;
    sizes[s]=1; ///要计算本身
    for(int i=head[s];i!=-1;i=load[i].p)
    {
        int e=load[i].e;
        if(e!=pre)
        {
            depth[e]=depth[s]+1;
            dfs1(e,s);
            sizes[s]+=sizes[e];
            if(sizes[e]>sizes[h_son[s]])
                h_son[s]=e;
        }
    }
}

void dfs2(int s,int root)
{
    top[s]=root;    ///记录重链的顶端
    id[s]=++times;   /// DFS序
    ranks[times]=s;
    if(!h_son[s])   ///如果是叶子结点
        return ;
    dfs2(h_son[s],root);
///我们选择优先进入重儿子来保证一条重链上各个节点DFS序连续
///一个点和它的重儿子处于同一条重链，所以重儿子所在重链的顶端还是root
    for(int i=head[s];i!=-1;i=load[i].p)
    {
        int e=load[i].e;
        if(e!=h_son[s]&&e!=father[s])
            dfs2(e,e);
    }
}

void init()
{
    ///线段树和邻接表
    sign=0;
    memset(head,-1,sizeof(head));
    memset(lazy,0,sizeof(lazy));
    memset(root,0,sizeof(root));
    /// DFS1
    memset(depth,0,sizeof(depth));
    memset(father,0,sizeof(father));
    memset(sizes,0,sizeof(sizes));
    memset(h_son,0,sizeof(h_son));
    depth[0]=-1;
    /// DFS2
    times=0;
    memset(top,0,sizeof(top));
    memset(ranks,0,sizeof(ranks));
    memset(id,0,sizeof(id));
}

void pushup(int sign)
{
    root[sign]=(root[sign<<1]+root[sign<<1|1])%mod;
}
void pushdown(int sign,int l,int r)
{
    int mid=(l+r)>>1;
    if(lazy[sign])
    {
        lazy[sign<<1]=(lazy[sign<<1]+lazy[sign])%mod;
        lazy[sign<<1|1]=(lazy[sign<<1|1]+lazy[sign])%mod;
        root[sign<<1]=(root[sign<<1]+lazy[sign]*(mid-l+1))%mod;
        root[sign<<1|1]=(root[sign<<1|1]+lazy[sign]*(r-mid))%mod;
        lazy[sign]=0;
    }
}

void build_root(int sign,int l,int r)
{
    if(l==r)
    {
        root[sign]=value[ranks[l]];
        return ;
    }
    int mid=(l+r)>>1;
    build_root(sign<<1,l,mid);
    build_root(sign<<1|1,mid+1,r);
    pushup(sign);
}

void update(int sign,int l,int r,int a,int b,int x)
{
    if(l==a&&r==b)
    {
        lazy[sign]+=x;
        root[sign]=(root[sign]+(r-l+1)*x)%mod;
        return ;
    }
    pushdown(sign,l,r);
    int mid=(l+r)>>1;
    if(b<=mid)
        update(sign<<1,l,mid,a,b,x);
    else if(a>mid)
        update(sign<<1|1,mid+1,r,a,b,x);
    else
    {
        update(sign<<1,l,mid,a,mid,x);
        update(sign<<1|1,mid+1,r,mid+1,b,x);
    }
    pushup(sign);
}

int query(int sign,int l,int r,int a,int b)
{
    if(l==a&&r==b)
        return root[sign];
    pushdown(sign,l,r);
    int mid=(l+r)>>1;
    if(b<=mid)
        return query(sign<<1,l,mid,a,b);
    else if(a>mid)
        return query(sign<<1|1,mid+1,r,a,b);
    else
        return (query(sign<<1,l,mid,a,mid)+query(sign<<1|1,mid+1,r,mid+1,b))%mod;
}

void update_line(int a,int b,int x)
{
    while(top[a]!=top[b])
    {
        if(depth[top[a]]>depth[top[b]])
            swap(a,b);
        update(1,1,n,id[top[b]],id[b],x);
        b=father[top[b]];
    }
    if(depth[a]>depth[b])
        swap(a,b);
    update(1,1,n,id[a],id[b],x);
}

int find_line(int a,int b)
{
    int ans=0;
    while(top[a]!=top[b])
    {
        if(depth[top[a]]>depth[top[b]])
            swap(a,b);
        ans=(ans+query(1,1,n,id[top[b]],id[b]))%mod;
        b=father[top[b]];
    }
    if(depth[a]>depth[b])
        swap(a,b);
    ans=(ans+query(1,1,n,id[a],id[b]))%mod;
    return ans;
}

int main()
{
    init();
    int s,e,op;
    int a,b,c;
    scanf("%d %d %d %d",&n,&q,&r,&mod);
    for(int i=1;i<=n;i++)
        scanf("%d",&value[i]);
    for(int i=1;i<n;i++)
    {
        scanf("%d %d",&s,&e);
        add_edge(s,e);
        add_edge(e,s);
    }
    dfs1(r,0);
    dfs2(r,r);
    build_root(1,1,n);
    while(q--)
    {
        scanf("%d",&op);
        if(op==1)
        {
            scanf("%d %d %d",&a,&b,&c);
            update_line(a,b,c);
        }
        else if(op==2)
        {
            scanf("%d %d",&a,&b);
            printf("%d\n",find_line(a,b));
        }
        else if(op==3)
        {
            scanf("%d %d",&a,&b);
            update(1,1,n,id[a],id[a]+sizes[a]-1,b);
        }
        else
        {
            scanf("%d",&a);
            printf("%d\n",query(1,1,n,id[a],id[a]+sizes[a]-1));
        }
    }
    return 0;
}