POJ 2763 Housewife Wind (树链剖分 有修改单边权)

题目链接：http://poj.org/problem?id=2763

n个节点的树上知道了每条边权，然后有两种操作：0操作是输出 当前节点到 x节点的最短距离，并移动到 x 节点位置；1操作是第i条边的边权变成x。

树链边权剖分的模版题，修改单边权和求和。

//#pragma comment(linker, "/STACK:102400000,102400000")
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int MAXN = 1e5 + 5;
struct EDGE {
    int next, to, cost;
}edge[MAXN << 2];
int head[MAXN], tot;
int from[MAXN], to[MAXN], cost[MAXN];
int par[MAXN], dep[MAXN], son[MAXN], size[MAXN];
int top[MAXN], id[MAXN], cnt;

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

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

void dfs1(int u, int p, int d) {
    dep[u] = d, par[u] = p, size[u] = 1, son[u] = u;
    for(int i = head[u]; ~i; i = edge[i].next) {
        int v = edge[i].to;
        if(v == p)
            continue;
        dfs1(v, u, d + 1);
        if(size[v] >= size[son[u]])
            son[u] = v;
        size[u] += size[v];
    }
}

void dfs2(int u, int p, int t) {
    top[u] = t, id[u] = ++cnt;
    if(son[u] != u)
        dfs2(son[u], u, t);
    for(int i = head[u]; ~i; i = edge[i].next) {
        int v = edge[i].to;
        if(v == son[u] || v == p)
            continue;
        dfs2(v, u, v);
    }
}

struct segtree {
    int l, r, val;
}T[MAXN << 2];

void build(int p, int l, int r) {
    int mid = (l + r) >> 1;
    T[p].l = l , T[p].r = r;
    if(l == r) {
        return ;
    }
    build(p << 1, l, mid);
    build((p << 1)|1, mid + 1, r);
}

void updata(int p, int pos, int num) {
    int mid = (T[p].l + T[p].r) >> 1;
    if(T[p].l == T[p].r && T[p].l == pos) {
        T[p].val = num;
        return ;
    }
    if(pos <= mid) {
        updata(p << 1, pos, num);
    }
    else {
        updata((p << 1)|1, pos, num);
    }
    T[p].val = T[p << 1].val + T[(p << 1)|1].val;
}

int query(int p, int l, int r) {
    int mid = (T[p].l + T[p].r) >> 1;
    if(l == T[p].l && T[p].r == r) {
        return T[p].val;
    }
    if(r <= mid) {
        return query(p << 1, l, r);
    }
    else if(l > mid) {
        return query((p << 1)|1, l, r);
    }
    else {
        return query(p << 1, l, mid) + query((p << 1)|1, mid + 1, r);
    }
}

int find(int u, int v) {
    int fu = top[u], fv = top[v], res = 0;
    while(fv != fu) {
        if(dep[fu] > dep[fv]) {
            res += query(1, id[fu], id[u]);
            u = par[fu];
            fu = top[u];
        }
        else {
            res += query(1, id[fv], id[v]);
            v = par[fv];
            fv = top[v];
        }
    }
    if(v == u)
        return res;
    else if(dep[u] > dep[v])
        return res + query(1, id[son[v]], id[u]);
    else
        return res + query(1, id[son[u]], id[v]);
}

int main()
{
    int n, m, root;
    while(~scanf("%d %d %d", &n, &m, &root)) {
        init();
        for(int i = 1; i < n; ++i) {
            scanf("%d %d %d", from + i, to + i, cost + i);
            add(from[i], to[i], cost[i]);
            add(to[i], from[i], cost[i]);
        }
        dfs1(1, 1, 0);
        dfs2(1, 1, 1);
        build(1, 1, cnt);
        for(int i = 1; i < n; ++i) {
            if(dep[from[i]] < dep[to[i]])
                swap(from[i], to[i]);
            updata(1, id[from[i]], cost[i]);
        }
        int op, pos, num;
        while(m--) {
            scanf("%d", &op);
            if(op) {
                scanf("%d %d", &pos, &num);
                updata(1, id[from[pos]], num);
            }
            else {
                scanf("%d", &pos);
                printf("%d
", find(root, pos));
                root = pos;
            }
        }
    }
}