初识树链剖分

参考博客：https://www.cnblogs.com/George1994/p/7821357.html

　　模板题：HDU 3966 Aragorn's Story

　　给一棵树每个点有权值，三种操作，一是给两个点和一个值U， V，K，U~V这条路径上所有点+K，二是U~K这条路径上所有点权值-K，三是查询某点U的权值为多少。先写着树链剖分　　

#include <iostream>
#include <string.h>
#include <cstdio>
#include <vector>
#include <queue>
#include <math.h>
#include <string>
#include <algorithm>
#include <time.h>

#define SIGMA_SIZE 26
#define lson rt<<1
#define rson rt<<1|1
#define lowbit(x) (x&-x)
#define foe(i, a, b) for(int i=a; i<=b; i++)
#define fo(i, a, b) for(int i = a; i < b; i++);
#pragma warning ( disable : 4996 )
#pragma comment(linker, "/STACK:1024000000,1024000000")

using namespace std;
typedef long long LL;
inline LL LMax(LL a,LL b)      { return a>b?a:b; }
inline LL LMin(LL a,LL b)      { return a>b?b:a; }
inline LL lgcd( LL a, LL b )   { return b==0?a:lgcd(b,a%b); }
inline LL llcm( LL a, LL b )   { return a/lgcd(a,b)*b; }  //a*b = gcd*lcm
inline int Max(int a,int b)    { return a>b?a:b; }
inline int Min(int a,int b)       { return a>b?b:a; }
inline int gcd( int a, int b ) { return b==0?a:gcd(b,a%b); }
inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
const LL INF = 0x3f3f3f3f3f3f3f3f;
const LL mod  = 1000000007;
const double eps = 1e-8;
const int inf  = 0x3f3f3f3f;
const int maxk = 1e6+5;
const int maxn = 5e4+5;

int N, M, Q, tim;
int cnt;
int linjie[maxn];
int sum[maxn<<2], lazy[maxn<<2];
int siz[maxn]; //以i为根节点 它的子树的节点个数
int top[maxn]; //当前节点所在链的顶端节点编号
int son[maxn]; //重儿子编号
int faz[maxn]; //当前节点的父亲节点
int dep[maxn]; //深度,
int tid[maxn]; //树中每个节点剖分以后的新编号(dfs执行顺序)
int rnk[maxn]; //当前节点在树中的位置
struct node {
    int to, next, val; 
}pp[2*maxn];

void addedge(int u, int v)
{ pp[cnt].to = v; pp[cnt].next = linjie[u]; linjie[u] = cnt++; }

//第一次dfs更新了dep，faz，siz，son数组
void dfs_1(int u, int fa, int d)
{
    dep[u] = d;
    faz[u] = fa;
    siz[u] = 1;
    for ( int i = linjie[u]; ~i; i = pp[i].next)
    {
        int v = pp[i].to;
        if ( v != faz[u] )
        {
            dfs_1(v, u, d+1);
            // 收敛的时候将当前结点的siz加上子结点的siz
            siz[u] += siz[v];
            // 如果没有设置过重结点son或者子结点v的siz大于之前记录的重结点son，则进行更新
            if (son[u] == -1 || siz[v] > siz[son[u]])
                son[u] = v;
        }
    }
}

void dfs_2(int u, int tp)
{
    top[u] = tp;        // 设置当前结点的起点为tP
    tid[u] = ++tim;        // 设置当前结点的dfs执行序号
    rnk[tid[u]] = u;    // 设置dfs序号对应成当前结点

    // 如果当前结点没有处在重链上，则不处理
    if (son[u] == -1) return;
    // 将这条重链上的所有的结点都设置成起始的重结点
    dfs_2(son[u], tp);

    for ( int i = linjie[u]; ~i; i = pp[i].next )
    {
        // 如果连接结点不是当前结点的重子结点并且也不是u的父亲结点，
        // 则将其的top设置成自己，进一步递归
        int v = pp[i].to;
        if (v != son[u] && v != faz[u])
            dfs_2(v, v);
    }
}

void pushUp(int rt)
{ sum[rt] = Max(sum[lson], sum[rson]); }

void pushDown(int rt, int ln, int rn)
{
    if (lazy[rt])
    {
        lazy[lson] += lazy[rt];
        lazy[rson] += lazy[rt];

        sum[lson] += ln*lazy[rt];
        sum[rson] += rn*lazy[rt];

        lazy[rt] = 0;
    }
}

void build(int rt, int L, int R)
{
    lazy[rt] = 0;
    if ( L == R )
    {
        //L是dfs遍历顺序编号，rnk[L]是原来的点的编号
        sum[rt] = pp[rnk[L]].val;
        return;
    }

    int mid = (L+R)>>1;
    build(lson, L, mid);
    build(rson, mid+1, R);
    pushUp(rt);
}

void update(int rt, int L, int R, int lhs, int rhs, int C)
{
    if ( lhs <= L && rhs >= R )
    {
        lazy[rt] += C;
        sum[rt] += C*(R-L+1);
        return;
    }

    int mid = (L+R)>>1;
    pushDown(rt, mid-L+1, R-mid);
    if ( lhs <= mid ) update(lson, L, mid, lhs, rhs, C);
    if ( rhs >  mid ) update(rson, mid+1, R, lhs, rhs, C);
    pushUp(rt);
}

int query(int rt, int L, int R, int V)
{
    if ( L == R )
        return sum[rt];

    int tmp = -1, mid = (L+R)>>1;
    pushDown(rt, mid-L+1, R-mid);
    if ( V <= mid ) tmp = query(lson, L, mid, V);
    else tmp = query(rson, mid+1, R, V);

    pushUp(rt);
    return tmp;
}

void change(int x, int y, int val)
{
    while (top[x] != top[y])
    {
        //x作为找深度深的那一个节点
        if (dep[top[x]] < dep[top[y]]) swap(x, y);
        //将x作为一个区间的结尾，top[x]作为一个区间的起始
        update(1, 1, N, tid[top[x]], tid[x], val);
        //跳到更上层的链
        x = faz[top[x]];        
    }

    //直到x和y是在同一条链上
    if (dep[x] > dep[y]) swap(x, y);
    update(1, 1, N, tid[x], tid[y], val);
}

void init()
{
    tim = cnt = 0;
    memset(linjie, -1, sizeof(linjie));
    memset(son, -1, sizeof(son));

    int x, y;
    foe(i, 1, N)
        scanf("%d", &pp[i].val);
    foe(i, 1, M)
    {
        scanf("%d %d", &x, &y);
        addedge(x, y);
        addedge(y, x);
    }

    //父节点是0， 深度为0
    dfs_1(1, 0, 0);
    dfs_2(1, 1);
    build(1, 1, N);
}


int main()
{
    while ( ~scanf("%d %d %d", &N, &M, &Q) )
    {
        init();

        char str[2];
        int x, y, d;
        while (Q--)
        {
            scanf("%s", str);
            if (str[0] == 'I') {
                scanf("%d %d %d", &x, &y, &d);
                change(x, y, d);
            }
            else if (str[0] == 'D') {
                scanf("%d %d %d", &x, &y, &d);
                change(x, y, -d);
            }
            else {
                scanf("%d", &d);
                printf("%d
", query(1, 1, N, tid[d]));
            }
        }
    }
    return 0;
}