UVALIVE 5061 - Lightning Energy Report(LCA)

The city of Thunder has many houses and they are powered by lightning. Two houses may be interconnected by a wire. The wires connect the houses such that there is exactly one path from one house to any other house in the city. Each house has a large battery that can store infinite electrical energy.

Everyday, several lightnings strike several houses. These lightnings are very unusual, when it strikes, it strikes two houses simultaneously: one house (A) with a red lightning and the other house (B) with a blue lightning. After the strikes, every house along the path from A to B (inclusive) will receive a certain amount of electrical energy which is then added to the house's battery.

The mayor of Thunder city wants a report on the stored electrical energy for every house at the end of the month and the owner of each house has to pay taxes for that. To prevent the owners report invalid energy stored in their house battery (because they want less tax to pay), you are asked to produce a correct report based on the observed lightnings of the current month. At the beginning of the month, the energy reading on the battery of each house is 0.

Input 

The first line of input contains an integer T (T<=10), the number of cases. Each case begins with an integer N (2<=N<=50, 000), the number of houses in the Thunder city. The next N - 1 lines contain the wire connections where each line will consist of two integers X and Y which means house X is connected with house Y. The house number is from 0 to N - 1. The next line will contain a number Q (1<=Q<=50, 000) which denotes the number of observed lightning strikes. The next Q lines describe the unusual lightnings happened during the month. Each line will consist of three integers A, B, C which tells that a red lightning strikes house A and a blue lightning strikes house B and the power transferred is C (at most 100) based on the reading of a special lightning instrument.

Output 

For each case, output ``Case #X:" (without quote) where X is the case number and N lines where each line is the electrical energy reading on the battery of each house from house 0 to house N - 1 at the end of the month.

Sample Input 

1 
9 
0 1
1 2
2 3
2 4
2 7
7 8
7 6
6 5
5 
1 4 10 
3 5 3 
0 8 5 
1 6 10 
4 4 100

Sample Output 

Case #1: 
5 
25 
28 
3 
110 
3 
13 
18 
5

树上的区间问题， 可以转换成LCA问题求解。

举个例子， 假设查询a, b,c d = lca(a, b) 则 [a - d] += c , [b - d] += c, d -= c; 

这样在查询时只用a += c, b += c, d -= c, parter(d) -= c (这里指这个点上的值，初始化为0)既可， 复杂度为lca(a, b)的复杂度。

这样在最后只用一次对树的遍历，就可得到答案了。

如果不是树上的区间问题， 比如是图上的， 可以求图的双连通分量， 把图变成树， 然后就和这题一样了。

还有其他区间问题，可以考虑怎么建树， 然后用LCA求解问题。 当然RMQ还是有很多优秀的算法可以直接用，不过有时候问题较复杂，可以考虑把问题转换。

const int MAXN = 50001;
 const int MAXLOGN = 20;
vector<vector<int> >g;
 int p[MAXN][MAXLOGN], L[MAXN];
 int val[MAXN];

 void dfs(int u, int pa, int d) {
    p[u][0] = pa; L[u] = d;
    for (int i = 0; i < g[u].size(); ++i) {
        if (g[u][i] != pa) {
            dfs(g[u][i], u, d + 1);
        }
    }
}

 void process(int N) {
    for (int i = 0; i < N; ++i) {
        for (int j = 0; (1 << j) < N; ++j) {
            p[i][j] = -1;
        }
    }
    dfs(0, 0, 0);
    for (int j = 1; (1 << j) < N; ++j) {
        for (int i = 0; i < N; ++i) {
            if (p[i][j-1] != -1) {
                p[i][j] = p[p[i][j-1]][j-1];
            }
        }
    }
}

 int query(int a, int b) {
    if (L[a] < L[b]) swap(a, b);
    int tmp = 1;
    for (; (1 << tmp) <= L[a]; ++tmp);
    --tmp;
    for (int i = tmp; i >= 0; --i)
        if (L[a] - (1 << i) >= L[b])
            a = p[a][i];
    if (a == b) return a;
    for (int i = tmp; i >= 0; --i) 
        if (p[a][i] != -1 && p[a][i] != p[b][i])
            a = p[a][i], b = p[b][i];
    return p[a][0];
}

void add(int u, int v, int c) {
    int lca = query(u, v);
    val[u] += c, val[v] += c;
    val[lca] -= c;
    if (p[lca][0] != lca) {
        val[p[lca][0]] -= c;
    }
}

int cal(int u, int pa) {
    for (int i = 0; i < g[u].size(); ++i) {
        if (g[u][i] != pa)
            val[u] += cal(g[u][i], u);
    }
    return val[u];
}

int main () {
    int T = nextInt();
    for (int nCase = 1; nCase <= T; ++nCase) {
        int N = nextInt();
        g.clear(); g.resize(N);
        for (int i = 0; i < N - 1; ++i) {
            int u = nextInt();
            int v = nextInt();
            g[u].push_back(v);
            g[v].push_back(u);
        }
        process(N);
        memset(val, 0, N << 2);
        int Q = nextInt();
        for (int i = 0; i < Q; ++i) {
            int u = nextInt();
            int v = nextInt();
            int c = nextInt();
            add(u, v, c);
        }
        cal(0, 0);
        printf("Case #%d:\n", nCase);
        for (int i = 0; i < N; ++i) {
            printf("%d\n", val[i]);
        }
    }
    return 0;
}