【POJ 2763】Housewife Wind【LCA】

题目链接：POJ-2763

题目大意：

一棵树，n个点，每条边有权值w[i]，q个操作。
A：求u到v路径上权值之和
B：将第x条边的权值改为t
（1<= n,q<= 10^5）

题解

先考虑图是一条链时，无论是查询还是修改，用BIT（树状数组）的话都可以在O(log n)内完成。
但是对于一棵树怎么搞呢？？
可以将树通过DFS访问的顶点顺序当做一条链。

这样就非常妙了，可以使用BIT做优化了。
令边的权值沿叶子方向为正，沿根方向为负，那么往返部分自然都抵消了。
同时，LCA也可以在通过RMQ的方法求出来。（我是用倍增写的）
这样所有的操作都在O(log n)内。

代码

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;

#define N 100100
#define logv 20
#define lowbit(x) x & -x
#define fill(a,x) memset(a,x,sizeof(a))

struct edge{int id,to;};
vector<edge> g[N];
int tree[N*2],es[N*2],w[N]; //es[i] : the pos of i-th edge
int pos[N*2],depth[N],parent[logv][N]; //pos[i] : where dian i frist exsit
int n;

void add(int x,int add) {
    while(x <= n * 2 - 2) {
        tree[x] += add; x += lowbit(x);
    }
}
int sum(int x) {
    int res = 0;
    while(x > 0) {
        res += tree[x]; x -= lowbit(x);
    }
    return res;
}

int ke = 0,kv = 0;
void dfs(int v,int p,int d) {
    parent[0][v] = p;
    pos[v] = ++ kv;
    depth[v] = d;
    for(int i = 0;i < g[v].size();i++)
    {
        edge e = g[v][i];
        if(e.to != p)
        {
            es[e.id*2-1] = ++ke; add(ke,w[e.id]);
            dfs(e.to,v,d+1);
            kv++;
            es[e.id*2] = ++ke; add(ke,-w[e.id]);
        }
    }
}

void lca_init() {
    fill(parent,-1);
    dfs(n/2,-1,1);
    for(int k = 0;k+1 < logv;k++)
        for(int v = 1;v <= n;v++)
            if(parent[k][v] < 0) parent[k+1][v] = -1;
            else parent[k+1][v] = parent[k][parent[k][v]];
}

int lca(int u,int v)
{
    if(depth[u] > depth[v]) swap(u,v);
    for(int k = 0;k < logv;k++)
        if((depth[v]-depth[u]) >> k & 1) v = parent[k][v];
    if(u == v) return u;
    for(int k = logv-1;k >= 0;k--)
        if(parent[k][u] != parent[k][v])
        {
            u = parent[k][u];
            v = parent[k][v];
        }
    return parent[0][u];
}

int main()
{
    int q,s,u,v,cost,opt;
    scanf("%d%d%d",&n,&q,&s);
    for(int i = 1;i < n;i++)
    {
        scanf("%d%d%d",&u,&v,&w[i]);
        edge e;
        e.id = i;e.to = v; g[u].push_back(e);
        e.to = u; g[v].push_back(e);
    }
    fill(tree,0);
    lca_init();

    while(q--)
    {
        scanf("%d",&opt);
        if(opt == 0)
        {
            scanf("%d",&u);
            int p = lca(s,u);
            printf("%d\n",sum(pos[u]-1)+sum(pos[s]-1)-sum(pos[p]-1)*2);
            s = u;
        }
        else
        {
            scanf("%d%d",&u,&cost);
            add(es[u*2-1],cost-w[u]);
            add(es[u*2],w[u]-cost);
            w[u] = cost;
        }
    }
    return 0;
}