HDU 3966 Aragorn's Story 树链剖分

题目大意：

就是现在给出一棵树节点个数不超过50000, 每个节点初始有个权值

接下来最多10万次操作, 每次操作对于节点u和v之间路径上的所有点的权值加上一个值或者减去一个值

或者询问某个节点当前的权值是多少

大致思路：

学习树链剖分的第一个题目....

首先将树剖分之后映射到线段树维护的区间中, 然后就是区间修改单点查询的线段树问题了

代码如下：

Result  :  Accepted     Memory  :  6708 KB     Time  :  1716 ms

/*
 * Author: Gatevin
 * Created Time:  2015/9/7 11:32:17
 * File Name: Heavy_Light_Decomposition.cpp
 */
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;

/*
 * Heavy_Light_Decompostion (HLD)
 * 利用树链剖分将树切分成多条链放在线段树上
 * 完成树链剖分预处理时间复杂度是O(n), n为树的结点个数
 * 使用其他算法套在上面的复杂度是O(logn * ? ) ?为其它操作的复杂度
 */

#define maxn 50010

int top[maxn];//top[k]表示编号为k的链的顶点编号
int grandson[maxn];//grandson[k]编号为k的路径最下面的叶子(深度最大的)
int dep[maxn];//结点深度
int siz[maxn];//siz[u]为以u为根的子树的结点个数
int belong[maxn];//belong[u]为结点u所属的路径的编号
int father[maxn];//father[u]为u的父亲节点
int Q[maxn];//队列, 深度小的在前
int cnt;//链的编号总数
int hson[maxn];//hson[u]是u的重儿子, 等于-1说明u是叶子节点

vector<int> son[maxn];//son[u]表示结点u的儿子们
int n, m, q;

bool vis[maxn];
int id[maxn];//id[u]是u在线段树中对应的区间位置
int antiID[maxn];//antiID[k]是线段树中k位置对应的树上的点的编号

void split()//以1作为根节点进行树链剖分
{
    cnt = 0;
    int l = 0, r = 1;
    dep[Q[r] = 1] = 1;
    father[r] = -1;
    while(l < r)//第一遍bfs求出dep, father
    {
        int x = Q[++l];
        if(son[x].empty()) continue;
        for(int j = son[x].size() - 1; j >= 0; j--)
        {
            int y = son[x][j];
            if(y == father[x]) continue;
            dep[Q[++r] = y] = dep[x] + 1;
            father[y] = x;
        }
    }
    for(int i = n; i; i--)//n为结点总个数, 倒序遍历
    {
        int x = Q[i], p = -1;
        siz[x] = 1;
        if(son[x].empty()) continue;
        for(int j = son[x].size() - 1; j >= 0; j--)
        {
            int y = son[x][j];
            if(y == father[x]) continue;
            siz[x] += siz[y];
            if(p == -1 || (p > 0 && siz[y] > siz[p]))
                p = y;//找出重儿子
        }
        if(p == -1)//x是叶子节点
        {
            hson[x] = -1;//x没有重儿子
            grandson[++cnt] = x;//第cnt条链以x结尾
            belong[top[cnt] = x] = cnt;
        }
        else
        {
            hson[x] = p;//x的重儿子是p
            belong[x] = belong[p];
            top[belong[x]] = x;
        }   
    }
    
    int idx = 0;
    memset(vis, 0, sizeof(vis));
    for(int i = n; i; i--)//接下来将所有的点映射到线段树中, 重链是连续的, 注意倒序
    {
        int x = Q[i];
        if(vis[x]) continue;
        vis[x] = 1;
        id[x] = ++idx;
        antiID[idx] = x;
        while(father[x] != -1 && belong[father[x]] == belong[x] && !vis[father[x]])
        {
            x = father[x];
            id[x] = ++idx;
            antiID[idx] = x;
            vis[x] = 1;
        }
    }
    return;
}

int w[maxn];

#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
int val[maxn << 2];
int flag[maxn << 2];

void pushDown(int l, int r, int rt, int mid)
{
    if(flag[rt])
    {
        flag[rt << 1] += flag[rt];
        flag[rt << 1 | 1] += flag[rt];
        val[rt << 1] += flag[rt];
        val[rt << 1 | 1] += flag[rt];
        flag[rt] = 0;
    }
    return;
}

void build(int l, int r, int rt)
{
    flag[rt] = 0, val[rt] = 0;
    if(l == r)
    {
        val[rt] = w[antiID[l]];
        return;
    }
    int mid = (l + r) >> 1;
    build(lson);
    build(rson);
    return;
}

void update(int l, int r, int rt, int L, int R, int value)
{
    if(l >= L && r <= R)
    {
        val[rt] += value;
        flag[rt] += value;
        return;
    }
    int mid = (l + r) >> 1;
    pushDown(l, r, rt, mid);
    if(mid >= L) update(lson, L, R, value);
    if(mid + 1 <= R) update(rson, L, R, value);
    return;
}

int query(int l, int r, int rt, int pos)
{
   if(l == r)
      return val[rt];
   int mid = (l + r) >> 1;
   pushDown(l, r, rt, mid);
   if(mid >= pos) return query(lson, pos);
   else return query(rson, pos);
}

void change(int l, int r, int x)
{
  //  cout<<l<<" "<<r<<" "<<top[l]<<" "<<top[r]<<endl;
    while(top[belong[l]] != top[belong[r]])
    {
        if(dep[top[belong[l]]] < dep[top[belong[r]]])
            swap(l, r);
        //top[l]深度更大
        update(1, n, 1, id[l], id[top[belong[l]]], x);//l到top[l]之间
        l = father[top[belong[l]]];
    }
    if(dep[l] < dep[r])
        swap(l, r);//深度大的对应区间更前面的区间位置
    update(1, n, 1, id[l], id[r], x);
    return;
}

int main()
{
    while(scanf("%d %d %d", &n, &m, &q) != EOF)
    {
        for(int i = 1; i <= n; i++) son[i].clear();
        for(int i = 1; i <= n; i++)
            scanf("%d", w + i);
        int u, v;
        for(int i = 1; i < n; i++)
        {
            scanf("%d %d", &u, &v);
            son[u].push_back(v);
            son[v].push_back(u);
        }
        split();
        build(1, n, 1);
        char op[4];
        int l, r, x;
        while(q--)
        {
            scanf("%s", op);
            switch(op[0])
            {
                case 'I': scanf("%d %d %d", &l, &r, &x);
                          change(l, r, x);
                          break;
                case 'D': scanf("%d %d %d", &l, &r, &x);
                          change(l, r, -x);
                          break;
                case 'Q': scanf("%d", &x);
                          printf("%d\n", query(1, n, 1, id[x]));
                          break;
            }
        }
    }
    return 0;
}