树链剖分 - poj2763 Housewife Wind

题目：

http://poj.org/problem?id=2763

题意：

给定一棵树，及一个初始位置，然后给出q个操作，每个操作为改变某根树枝权值，或求树上两点之间的距离

思路：

树链剖分的模板题，权值位于边上，剖分完用线段树存储查询即可，注意此时线段上每个单结点K的权值定义为结点K到其父节点的距离

代码：

#include<stdio.h>
#include<iostream>
#include<string>
#include<string.h>
#include<math.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<functional>
#pragma comment(linker, "/STACK:102400000,102400000")//C++
using namespace std;

const double PI = 3.141592653589793238462643383279502884197169399;
const int MAXINT = 0x7fffffff;
const int MAXSIZE = 100000 + 5;

int n,q,now;
//vector<int> e[MAXSIZE];
int len[MAXSIZE][3];
int fa[MAXSIZE], siz[MAXSIZE], son[MAXSIZE], dep[MAXSIZE], top[MAXSIZE], tid[MAXSIZE];
int first[MAXSIZE], next[2*MAXSIZE], to[2*MAXSIZE], edge;
int tsum;
int ans;


//树链剖分第一次深搜，预处理出每个结点的深度，重儿子，结点数，父结点
void dfs_1(int v,int father,int depth){
    siz[v] = 1;
    dep[v] = depth;
    fa[v] = father;
    son[v] = 0;
    int i=first[v];
    while (i){
        int u = to[i];
        if (u!=father){
            dfs_1(u,v,depth+1);
            siz[v]+=siz[u];
            if (siz[u]>siz[son[v]]) son[v] = u;
        }
        i = next[i];
    }
    return;
}

//第二次深搜，标记出每个结点所在重链的顶结点，及剖分完结点对应在线段上的位置
void dfs_2(int v, int tp){
    tid[v] = ++tsum;
    top[v] = tp;
    if (son[v] != 0) dfs_2(son[v], top[v]);  //使重链在线段上连续
    int i=first[v];
    while (i){
        int u = to[i];
        if (u!=fa[v] && u!=son[v]){
             dfs_2(u, u);
        }
        i = next[i];
    }
    return ;
}

struct node{
	int l, r;
	int sum;
	int mid(){
		return (l + r) / 2;
	}
};
node tree[(MAXSIZE << 2) + 5];

//初始状态 BuildTree(0,1,n)
void BuildTree(int root, int l, int r){
	tree[root].l = l; tree[root].r = r;
	tree[root].sum=0;
	if (l != r){
		BuildTree(root * 2 + 1, l, (l + r) / 2);
		BuildTree(root * 2 + 2, (l + r) / 2 + 1, r);
	}
	return;
}

//更新节点 (0,i,w)
void t_insert(int root, int i, int weight){
	if (tree[root].l == tree[root].r){
        tree[root].sum = weight;
        return;
	}
	else{
		if (i <= tree[root].mid())
			t_insert(root * 2 + 1, i, weight);
		else
            t_insert(root * 2 + 2, i, weight);
        tree[root].sum = tree[(root<<1)+1].sum + tree[(root<<1)+2].sum;
	}
}

//查询线段[st,en] (0,st,en)
void t_query(int root, int st, int en){
	if (tree[root].l == st && tree[root].r == en){
		ans+=tree[root].sum;
		return;
	}
	if (st>tree[root].mid()){
		t_query(root * 2 + 2, st, en);
	}
	else if (en <= tree[root].mid()){
		t_query(root * 2 + 1, st, en);
	}
	else{
		t_query(root * 2 + 1, st, tree[root].mid());
		t_query(root * 2 + 2, tree[root].mid() + 1, en);
	}
	return;
}

void g_insert(int a, int b){
    next[++edge] = first[a];
    first[a] = edge;
    to[edge] = b;
}

int main(){
    cin>>n>>q>>now;

    //for (int i=1;i<=n;++i) e[i].clear();
    memset(len,0,sizeof(len));
    memset(siz,0,sizeof(siz));
    memset(son,0,sizeof(son));
    memset(dep,0,sizeof(dep));
    memset(fa,0,sizeof(fa));
    memset(top,0,sizeof(top));
    memset(tid,0,sizeof(tid));
    tsum = 0;
    edge=0;

    for (int i=1;i<n;++i){
        int a,b,c;
        scanf("%d %d %d",&a,&b,&c);
        g_insert(a,b);
        g_insert(b,a);
        len[i][0]=a;
        len[i][1]=b;
        len[i][2]=c;
    }

    dfs_1(1,0,0);
    dfs_2(1,1);

    BuildTree(0,1,tsum);
    for (int i=1;i<n;++i){
        if (dep[len[i][0]] < dep[len[i][1]]) swap(len[i][0],len[i][1]);
        t_insert(0,tid[len[i][0]],len[i][2]);
    }

    for (int i=1;i<=q;++i){
        int a,b,c;
        scanf("%d",&a);
        if (a==1){
            scanf("%d %d",&b,&c);
            t_insert(0,tid[len[b][0]],c);
        }
        else{
            ans=0;
            scanf("%d",&b);
            int u = now, v = b;
            int f1 = top[u], f2 = top[v];

            while (f1 != f2){
                if (dep[f1] < dep[f2]){
                    swap(f1,f2);
                    swap(u,v);
                }
                t_query(0,tid[f1],tid[u]);
                u=fa[f1];
                f1=top[u];
            }
            if (u != v){
                if (dep[u] > dep[v]) swap(u,v);
                t_query(0, tid[son[u]], tid[v]);
            }
            printf("%d\n",ans);
            now = b;
        }
    }
    return 0;
}