POJ - 2763 Housewife Wind （ lca + dfs序 + 树状数组 ）

题意：

给定一棵含n个结点的树，共有q次操作，分为两种

0 c ：求从位置s到c的距离，然后s变成c

1 a b:把第a条边的权值变为b

分析：

 树上两个节点a,b的距离可以转化为

 dis[a] + dis[b] - 2*dis[lca(a,b)]

其中 dis[i] 表示 i 节点到根的距离，

由于每次修改一条边，树中在这条边下方的 dis[] 值全都会受到影响，这样每条边都对应这一段这条边的管辖区，

 可以深搜保存遍历该点的时间戳，l[i] 表示第一次遍历到该点的时间戳， r[i] 表示回溯到该点时的时间戳，这样每次

修改边 i 的时候就可以对区间 [ l[i], r[i] ] 进行成段更新，成段更新的方式可以在 位置 ll[i] 上加一个权值，在位置

r[i]+1 上减去这个权值，求和时，sum(l[i]) 即为该点到根的距离。

/*
 *
 * LCA 在线算法
 */
#include<cstdio>
#include<cstring>
#include<queue>

using namespace std;

const int maxn = 1e5+10;
const int DEG = 20;

struct Edge{
    int to,next,w;
}edge[maxn*2];

int head[maxn],tot;

void addedge(int u,int v,int w){
    edge[tot].to = v;
    edge[tot].w = w;
    edge[tot].next = head[u];
    head[u] = tot++;
}

void init(){
    tot = 0;
    memset(head,-1,sizeof(head));
}

int fa[maxn][DEG];//fa[i][j]表示结点i的第2^j个祖先
int deg[maxn];//深度数组
int dis[maxn];

void bfs(int root){
    queue<int>que;
    deg[root] = 0;
    fa[root][0] = root;
    que.push(root);
    while(!que.empty()){
        int tmp = que.front();
        que.pop();
        for(int i = 1;i < DEG;i++)
            fa[tmp][i] = fa[fa[tmp][i-1]][i-1];
        for(int i = head[tmp]; i != -1;i = edge[i].next){
            int v = edge[i].to,w=edge[i].w;
            if(v == fa[tmp][0])continue;
            dis[v]=dis[tmp]+w;
            deg[v] = deg[tmp] + 1;
            fa[v][0] = tmp;
            que.push(v);
        }

    }
}

int LCA(int u,int v){
    if(deg[u] > deg[v])swap(u,v);
    int hu = deg[u], hv = deg[v];
    int tu = u, tv = v;
    for(int det = hv-hu, i = 0; det ;det>>=1, i++)
        if(det&1)
            tv = fa[tv][i];
    if(tu == tv)return tu;
    for(int i = DEG-1; i >= 0; i--){
        if(fa[tu][i] == fa[tv][i])
            continue;
        tu = fa[tu][i];
        tv = fa[tv][i];
    }
    return fa[tu][0];
}

int l[maxn],r[maxn];
int index;

void dfs(int u,int fa){
    l[u]=++index;
    for(int i=head[u];i!=-1;i=edge[i].next){
        int v=edge[i].to;
        if(v==fa) continue;
        dfs(v,u);
    }
    r[u]=index;
}

int C[maxn];

int n,q,ps;

int lowbit(int x){
    return x&(-x);
}

int getsum(int x){
    int res=0;
    for(;x;x-=lowbit(x)) res+=C[x];
    return res;
}

void change(int x,int c){
    for(;x<maxn;x+=lowbit(x)){
        C[x]+=c;
    }
}

struct node{
    int u,v,w;
    node(int u,int v,int w):u(u),v(v),w(w){}
    node(){}
}g[maxn];

int main(){
    while(scanf("%d%d%d",&n,&q,&ps)!=EOF){
        init();
        memset(dis,0,sizeof dis);
        for(int i=1;i<n;i++){
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            addedge(u,v,w);
            addedge(v,u,w);
            g[i]=node(u,v,w);
        }
        index=0;
        memset(l,0,sizeof l);
        memset(r,0,sizeof r);
        dfs(1,1);
        bfs(1);
        memset(C,0,sizeof C);
        for(int i=1;i<n;i++){
            int u=g[i].u,v=g[i].v,w=g[i].w;
            if(fa[u][0]==v) swap(u,v);      //有可能建图的时候正好反过来了。
            change(l[v],w);
            change(r[v]+1,-w);
        }
        while(q--){
            int k;
            scanf("%d",&k);
            if(k==1){
                int a,b;
                scanf("%d%d",&a,&b);
                int u=g[a].u,v=g[a].v,w=b-g[a].w;
                g[a].w=b;
                if(fa[u][0]==v) swap(u,v);
                change(l[v],w);
                change(r[v]+1,-w);
            }else{
                int v;
                scanf("%d",&v);
                printf("%d\n",getsum(l[ps])+getsum(l[v])-2*getsum(l[LCA(ps,v)]));
                ps=v;
            }
        }
    }
    return 0;
}