POJ - 2763 Housewife Wind

传送门
第一次遇到这么有意思的题目。

首先介绍一下dfs序。

dfs顾名思义 是用dfs遍历一棵树时，各节点出现的顺序。这样可以把一个无序的问题转换为有序的。
dfs最大的特点是一个点的子树一定是一段连续的区间。

那么这一题首先要把边权转换为点权，为什么呢？显然dfs序是针对点的，这样转换好处理。其次，怎样转换？假设有一条边的两个顶点为v， u且v的深度大于u的深度。那么我们可以把边权看作是较深点的点权也就是v，这样是可以的，因为每个点只有一个父亲。

之后我们修改值只需要在in[v]处加上val，在out[v]+1处减去val即可。

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

typedef long long ll;
typedef unsigned long long ull;

typedef pair<int, int> PI;
typedef pair<double, double> PD;
 
const int maxn = 100000 + 10;
const int max_log_v = 22;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const double eps = 1e-7;
const ull B = 100000007;

struct edge { int to, cost, next; };
struct nn { int v, u, c; };
struct Node { int l, r; };

edge g[2*maxn]; 
nn e[2*maxn];

int n, q, s;
int tot, etot;
int depth[maxn], parent[max_log_v][maxn];
int in[maxn], out[maxn];
int head[maxn];
int bit[maxn];

void addedge(int v, int u, int c) {
    g[++etot].to = u;
    g[etot].cost = c;
    g[etot].next = head[v];
    head[v] = etot;
}


void add(int i, int c) {
    while(i <= n) {
        bit[i] += c;
        i += i & -i;
    }
}

int sum(int i) {
    int res = 0;
    while(i > 0) {
        res += bit[i];
        i -= i & -i;
    }
    return res; 
}

void dfs(int v, int p, int d) {
    parent[0][v] = p;
    depth[v] = d;
    in[v] = ++tot;
    for(int i = head[v]; i; i = g[i].next) {
        edge e =  g[i];
        if(e.to == p) continue;
        dfs(e.to, v, d+1);
    }
    out[v] = tot;
}

void init() {
    dfs(1, -1, 0);   
    for(int k = 0; k + 1 < max_log_v; k++) {
        for(int v = 1; v <= n; v++) {
            if(parent[k][v] == -1) parent[k+1][v] = -1;
            else parent[k+1][v] = parent[k][parent[k][v]];
        }
    }
    memset(bit, 0, sizeof bit);
    for(int i = 1; i <= n - 1; i++) {
        int v = e[i].v, u = e[i].u, c = e[i].c;
        if(depth[v] < depth[u]) swap(v, u);
        add(in[v], c);
        add(out[v] + 1, -c);
    }
}

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

void solve() {
    while(scanf("%d %d %d", &n, &q, &s) == 3) {
        tot = etot = 0;
        memset(head, 0, sizeof head);
        for(int i = 1; i < n; i++) {
            int v, u, c;
            scanf("%d %d %d", &v, &u, &c);
            addedge(v, u, c);
            addedge(u, v, c);
            e[i].c = c; e[i].v = v; e[i].u = u;
        }
        init();
        while(q--) {
            int op, x, y;
            scanf("%d", &op);
            if(op == 0) {
                scanf("%d", &x);
                printf("%d\n", sum(in[x]) + sum(in[s]) - 2 * sum(in[lca(x, s)]));
                s = x;
            }
            else {
                scanf("%d %d", &x, &y);
                int d = y - e[x].c;
                int v = e[x].v, u = e[x].u;
                e[x].c = y;
                if(depth[v] < depth[u]) swap(v, u);
                add(in[v], d);
                add(out[v]+1, -d);
            }
        }
    }
}

int main() {
    //ios::sync_with_stdio(false);
    int t = 1;
    while(t--) {
        solve();
    }
    return 0;
}