树链剖分简析

落谷3384

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<queue>
#include<stack>
#include<deque>
#include<map>
#include<iostream>
using namespace std;
typedef long long  LL;
const double pi=acos(-1.0);
const double e=exp(1);
//const int MAXN =2e5+10;
const LL N = 100010*4;

struct node
{
    LL l,r;
    LL mid() {
        return (l + r) / 2;  
    }
}node[N];
LL sum[N];
LL add[N];

LL con[N];
LL head[N];
struct edge{
    LL to;
    LL next;
    LL w;
}edge[N];


LL f[N];  //结点i的父结点
LL d[N];   // 结点i的深度
LL size[N]; // 结点i子树的规模(结点数)
LL son[N];  // 结点i的重结点
LL top[N];  // 结点i所在链的顶端结点
LL id[N];   // 树中结点剖分后对应的数组下标
LL rk[N];   // 剖分后数组下标对应的树上的结点

LL cnt1 = 1, cnt = 0;
LL n,m,r,p;

void PushUp(LL i)
{
    //sum[i] = max(sum[i << 1], sum[i << 1 | 1]);
    sum[i] = sum[i << 1] + sum[i << 1 | 1];
}

void PushDown(LL i,LL L) // LΪÇøŒä³€¶È £šÑÓ³Ù±êŒÇ£©
{
    if(add[i])
    {
        add[i << 1] += add[i] % p;
        add[i << 1 | 1] += add[i] % p;
        sum[i << 1] += add[i] * (L - (L >> 1)) % p; // Ò׎í
        sum[i << 1 | 1] += add[i] * (L >> 1) % p;
        add[i] = 0;
    }
}

void Build(LL l, LL r, LL i)
{
    //cout << " l: " << l << " r: " << r << endl;
    node[i].l = l;
    node[i].r = r;
    sum[i] = 0;
    add[i] = 0;
    if(l == r)
    {
     //   cout << " l: " << l << " r: " << r << " " << rk[cnt1] << endl;
        sum[i] = con[rk[cnt1++]];
        return ;
        //scanf("%d",&sum[i]);
    }
    LL m = node[i].mid();

    Build(l, m, i << 1);
    Build(m+1, r, i << 1 | 1);

    PushUp(i);
}

LL Query(LL l, LL r, LL i)
{
    if(node[i].l == l && node[i].r == r)
    {
        return sum[i];
    }
    PushDown(i, node[i].r - node[i].l + 1);
    LL m = node[i].mid();
    LL ans = 0;
    if(r <= m)
    {
        ans += Query(l, r, i << 1) % p;
    }
    else
    {
        if(l > m)
        {
            ans += Query(l, r, i << 1 | 1) % p;
        }
        else
        {
            ans += Query(l, m, i << 1) % p;
            ans += Query(m+1, r, i << 1 | 1) % p;
        }
    }
    return ans;
}

void Update(LL l, LL r, LL x, LL i)
{
   // cout << " ^^ " << node[i].l << " " << node[i].r << endl;
    if(node[i].l == l && node[i].r == r)
    {
        sum[i] += x * (r - l + 1)  % p;
        add[i] += x % p;
        return ;
    }
    PushDown(i,node[i].r - node[i].l + 1);
    LL m = node[i].mid();
    if(r <= m)
    {
        Update(l, r, x, i << 1);
    }
    else
    {
        if(l > m)
        {
            Update(l, r, x, i << 1 | 1);
        }
        else
        {
            Update(l, m, x, i << 1);
            Update(m+1, r, x, i << 1 | 1);
        }
    }
    PushUp(i);
}



// 处理size,son,f,d数组
void dfs1(LL u, LL fa, LL depth) //当前节点、父节点、层次深度
{
    LL i;
    f[u] = fa;
    d[u] = depth;
    size[u] = 1;   //这个点本身size = 1;

    for( i = head[u]; i != -1; i = edge[i].next)
    {
        LL v = edge[i].to;
        if(v == fa)
            continue;
        dfs1(v, u, depth + 1);
        size[u] += size[v];
        if(size[v] > size[son[u]]) //son[u]数组为u的重儿子
        {
            son[u] = v;  
        }
    }
}
//dfs1(root, 0, 1); // 处理结点子树的规模，每个结点的重儿子，结点所在的深度



// 处理top,id,rk数组
void dfs2(LL u, LL t) //当前结点、重链顶端
{
    top[u] = t;
    id[u] = ++cnt; //标记dfs序
    rk[cnt] = u;    // 序号cnt对应结点u
    if(!son[u])     // 当点u为叶子节点时，代表一条重链剖分完毕。
        return ;    // 返回到倒数第二个结点，从该结点出发，剖分另一条链。
    dfs2(son[u],t);  
    
    for(LL i = head[u]; i != -1; i = edge[i].next)  //从该结点所连接的结点出发，进行剖分
    {
        LL v = edge[i].to;
        if(v != son[u] && v != f[u])  // 链头要求不能是结点u的重儿子(因为该结点已经被重链占用了)
                                      // 也不能是结点u的父结点
            dfs2(v,v);        //每条链都是以轻结点为开头，后面链的都是重儿子。所以结点v的链头是它本身。
    }                           
    
}

void U_xy(LL x, LL y, LL z)
{
    LL ans = 0, fx = top[x], fy = top[y];
    while(fx != fy)
    {
        if(d[fx] >= d[fy])
        {
            if(id[x] <= id[fx])
                Update(id[x], id[fx], z, 1);
            else
            {
                Update(id[fx], id[x], z, 1);
            }
            
            x = f[fx];
            fx = top[x];
        }
        else
        {
            if(id[y] <= id[fy])
                Update(id[y], id[fy], z, 1);
            else
            {
                Update(id[fy], id[y], z, 1);
            }
            
            y = f[fy];
            fy = top[y];
        }
    }

    if(id[x] <= id[y])
    {
        Update(id[x], id[y], z, 1);
    }
    else
    {
        Update(id[y], id[x], z, 1);
    }
        
}

LL Q_xy(LL x, LL y)
{
    LL ans = 0, fx = top[x], fy = top[y]; //fx代表x的链头结点，fy同理。
    while(fx != fy)
    {
       // cout << " ^^ " << "x: " << x << " y: " << y << "fx: " << fx << "fy: " << fy << endl;
       // cout << id[x] << "  " << id[fx] << " ** " << endl;
        if(d[fx] >= d[fy])  // 如果x的深度比y的深度大，所以应让x向上跳
        {
            if(id[x] <= id[fx])
                ans += Query(id[x], id[fx], 1) % p;   // 因为剖分后每条链上的结点都是线性存储的，所以x到x链头的父节点的距离，为两者之间的距离的差。
            else
            {
                ans += Query(id[fx], id[x], 1) % p;
            }
            
            x = f[fx];    // x更新为x链头结点的父节点
            fx = top[x];  // fx更新为新x结点的链头结点， 然后再去和fy比较，判断x，y是否在同一条链上了。
        }
        else
        {
            if(id[y] <= id[fy])
                ans += Query(id[y], id[fy], 1) % p;
            else
            {
                ans += Query(id[fy], id[y], 1) % p;
            }
            
            y = f[fy];
            fy = top[y];
        }
    }

    if(id[x] <= id[y])
    {
        ans += Query(id[x], id[y], 1) % p;
    }
    else
    {
        ans += Query(id[y], id[x], 1) % p;
    }

    return ans % p;
}

void U_x(LL x, LL z)
{
   // cout << "id[x]: " << id[x] << "  size: " << size[x] << endl;
   // cout << " ** " << Query(id[x],id[x] + size[x] - 1,1) << endl;;    
    Update(id[x], id[x] + size[x] - 1, z, 1);
   // cout << " ** " << Query(id[x],id[x] + size[x] - 1,1) << endl;;
    
}

LL Q_x(LL x)
{
    return Query(id[x], id[x] + size[x] - 1, 1) % p;
}


int main()
{
    
    LL i,j,a,b,x,y,z;

    scanf("%lld%lld%lld%lld",&n,&m,&r,&p);
    for(i = 1; i <= n; i ++)
    {
        scanf("%lld",&con[i]);
    }

    memset(head,-1,sizeof(head));
    LL cnt2 = 0;
    for(i = 1; i < n; i++)
    {
        scanf("%lld%lld",&a,&b);
        edge[cnt2].to = b;
        edge[cnt2].next= head[a];
        head[a] = cnt2 ++;


        edge[cnt2].to = a;
        edge[cnt2].next = head[b];
        head[b] = cnt2 ++;
    }
    dfs1(r, 0, 1);
    dfs2(r, r);

    
    Build(1, n, 1);

/* 
    cout << "** ";
    for(i = 1; i <= cnt; i++)
    {
        cout << rk[i] << " " ;
    }
    cout << endl;
*/
    while(m--)
    {
        scanf("%lld",&j);
      //  cout << "j: " << j << endl;
        if(j == 1)
        {
            scanf("%lld%lld%lld",&x,&y,&z);
            U_xy(x,y,z);
        }
        else if(j == 2)
        {
            scanf("%lld%lld",&x,&y);
            printf("%lld
", Q_xy(x,y) % p);
        }
        else if(j == 3)
        {
            scanf("%lld%lld",&x,&z);
            U_x(x,z);
        }
        else if(j == 4)
        {
            scanf("%lld",&x);
            printf("%lld
", Q_x(x) % p);
        }
    }
    return 0;
}








/* 
 888888888888888888888888888 36375  68190  63528 ** 
 888888888888888888888888888 66907  32530  32528 ** 


  888888888888888888888888888 36375  31713  68190  63528 ** 
 888888888888888888888888888 66907  86992  32530  32528 ** 

 */