HDU5044【LCA+差分】

思路：
树以1为根节点，然后向下DFS
两个差分

ADD1 操作，对节点 (u, v) 就是 他们的两个各自节点+w， 然后节点LCA(u, v) - w，LCA(u, v)的父节点-w，然后DFS一遍就能求出来

ADD2 操作就更简单了，边的权值都放在节点上，然后直接在LCA(u, v)上 - 2*w，另外u, v都+w.

但是很卡常数。

---

//#pragma comment(linker, "/STACK:102400000,102400000")
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;
typedef long long LL;
#define mem(a, b) memset(a, b, sizeof(a))

const int Maxn = 1e5 + 10;
const int N = 1e5 + 10;

struct Edge{
    int w, v, nex;
    int id;
}edge[Maxn<<1];
int head[Maxn], tol;
int n, m;
int to[Maxn], pre[Maxn];

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

inline void Add(int u, int v, int id){
//    edge[tol].w = w;
    edge[tol].id = id;

    edge[tol].v = v;
    edge[tol].nex = head[u];
    head[u] = tol++;

    u = u ^ v; v = u ^ v; u = u ^ v;
//    edge[tol].w = w;
    edge[tol].id = id;

    edge[tol].v = v;
    edge[tol].nex = head[u];
    head[u] = tol++;
}

// 注意 Maxn 和 25  !!!
int deep[Maxn<<1], first[Maxn], tot, id[Maxn<<1];
int dp[Maxn<<1][25];
void _DFS(int u, int dep, int fa){
    pre[u] = fa;
    int v;
    id[++tot] = u;
    deep[tot] = dep;
    first[u] = tot;
    for(int i=head[u]; ~i; i = edge[i].nex){
        v = edge[i].v;
        if(v == fa) continue;
        _DFS(v, dep+1, u);
        to[edge[i].id] = v;

        id[++tot] = u;
        deep[tot] = dep;
    }
}
void ST(){
    for(int i=1;i<=tot;i++) dp[i][0] = i;
    for(int j=1;(1<<j) <= tot;j++){
        for(int i=1;i+(1<<j)-1<=tot;i++){
            int a = dp[i][j-1], b = dp[i+(1<<(j-1))][j-1];
            dp[i][j] = deep[a] < deep[b] ? a : b;
        }
    }
}
int RMQ(int Left, int Right){
    int k = 0;
    while(1<<(k+1) <= (Right - Left + 1)) k++;
    int a = dp[Left][k], b = dp[Right-(1<<k)+1][k];
    return deep[a] < deep[b] ? a : b;
}
int LCA(int u, int v){
    int x = first[u], y = first[v];
    if(x > y){
        x = x ^ y;
        y = x ^ y;
        x = x ^ y;
    }
    int res = RMQ(x, y);
    return id[res];
}
void solve(){
    tot = 0;
    _DFS(1, 1, -1);
    ST();
}
LL nodeval[Maxn], edgeval[Maxn];
void DFS(int u, int fa){
    int v;
    for(int i=head[u]; ~i; i=edge[i].nex){
        v = edge[i].v;
        if(v == fa) continue;
        DFS(v, u);
        nodeval[u] = nodeval[u] + nodeval[v];
        edgeval[u] = edgeval[u] + edgeval[v];
    }
}

void solve1(int u, int v, LL w){
    int fa = LCA(u, v);
//    printf("%d %d: %d\n", u, v, fa);
    if(fa == u){
        if(pre[fa] != -1) nodeval[pre[fa]] = nodeval[pre[fa]] - w;
        nodeval[v] = nodeval[v] + w;
    }
    else if(fa == v){
        if(pre[fa] != -1) nodeval[pre[fa]] = nodeval[pre[fa]] - w;
        nodeval[u] = nodeval[u] + w;
    }
    else{
        if(pre[fa] != -1) nodeval[pre[fa]] = nodeval[pre[fa]] - w;
        nodeval[fa] = nodeval[fa] - w;
        nodeval[u] = nodeval[u] + w;
        nodeval[v] = nodeval[v] + w;
    }
}

void solve2(int u, int v, int w){
    int fa = LCA(u, v);
    if(fa == u){
        edgeval[fa] = edgeval[fa] - w;
        edgeval[v] = edgeval[v] + w;
    }
    else if(fa == v){
        edgeval[fa] = edgeval[fa] - w;
        edgeval[u] = edgeval[u] + w;
    }
    else{
        edgeval[fa] = edgeval[fa] - w*2;
        edgeval[u] = edgeval[u] + w;
        edgeval[v] = edgeval[v] + w;
    }
}

int main(){
    int T, cas = 1;
    int u, v, w;
    scanf("%d", &T);
    while(T--){
        scanf("%d%d", &n, &m);

        init();

        for(int i=0;i<n-1;i++){
            scanf("%d%d", &u, &v);
            Add(u, v, i);
        }
        solve();

        for(int i=0;i<=n;i++) nodeval[i] = edgeval[i] = 0;
        char op[6];
        while(m--){
            scanf("%s%d%d%d",op, &u, &v, &w);
            if(op[3] == '1') solve1(u, v, w);
            else solve2(u, v, w);
        }
        DFS(1, -1);
        printf("Case #%d:\n", cas++);
        for(int i=1;i<=n;i++)
        {
            if(i != 1) printf(" ");
            printf("%I64d", nodeval[i]);
        }
        puts("");
        for(int i=0;i<n-1;i++){
            if(i) printf(" ");
            printf("%I64d", edgeval[to[i]]);
        }
        puts("");
    }
    return 0;
}