Relief grain HDU - 5029 (万人皆知的套路题，树链剖分 + 线段树)

题目大意：

给定一棵树，然后每次修改是对u -> v路径上的点，增加一个新的权值，然后查询每个节点的权值数量最多的权值，如果有相同最大的，取权值小的。

思路

为啥说这是道万人皆知的题目呢？因为这是一个十足的套路，如果简化模型，把树换成一个segment，那么对一个区间[L, R]增加一个权值X，那可以用差分打标记的策略，先在L处打一个X的标记，可以用vector存一下，然后在R + 1存一个-X的标记，分别代表区间开始与结束，最后，遍历每个点，同时维护一棵权值线段树，代表每个权值的个数，最后查询最大值即可所在权值即可，可以在update的时候同时更新这个权值，然后直接查根的这个值就行。

同时这道题我又学到一个新的东西，是fp这个数组，之前用树剖从来没用过这个，这次用了一下发现还挺好用。

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

typedef long long ll;
const int maxn = 1e5 + 100;
int n, m;
struct Edge {
    int to, nxt;
}edge[maxn << 1];
int head[maxn], tot;
vector<int> up[maxn];
int deep[maxn], fa[maxn], sz[maxn], son[maxn];
int pos, top[maxn], p[maxn], fp[maxn];
void init() {
    tot = 0; memset(head, -1, sizeof(head));
    pos = 1; memset(son, -1, sizeof(son));
    for(int i = 1; i <= n; i++) up[i].clear();
}
void addedge(int u, int v) {
    edge[tot].to = v; edge[tot].nxt = head[u]; head[u] = tot++;
}
void dfs1(int u, int pre, int d) {
    deep[u] = d;
    fa[u] = pre;
    sz[u] = 1;
    for(int i = head[u]; i != -1; i = edge[i].nxt) {
        int v = edge[i].to;
        if(v != pre) {
            dfs1(v, u, d + 1);
            sz[u] += sz[v];
            if(son[u] == -1 || sz[v] > sz[son[u]]) {
                son[u] = v;
            }
        }
    }
}
void dfs2(int u, int sp) {
    top[u] = sp;
    p[u] = pos++;
    fp[p[u]] = u;
    if(son[u] == -1) return ;
    dfs2(son[u], sp);
    for(int i = head[u]; i != -1; i = edge[i].nxt) {
        int v = edge[i].to;
        if(v != son[u] && v != fa[u]) {
            dfs2(v,v);
        }
    }
}
void Change(int u, int v, int c) {
    int f1 = top[u], f2 = top[v];
    while(f1 != f2) {
        if(deep[f1] < deep[f2]) {
            swap(f1,f2);
            swap(u,v);
        }
        up[p[f1]].push_back(c);
        up[p[u] + 1].push_back(-c);
        u = fa[f1];
        f1 = top[u];
    }
    if(deep[u] > deep[v]) swap(u,v);
    up[p[u] ].push_back(c);
    up[p[v] + 1 ].push_back(-c);
}
struct Tree {
    int id, m, l, r;
}tr[maxn << 2];
void build(int o, int l, int r) {
    tr[o].l = l;  tr[o].r = r;
    tr[o].m = 0;
    tr[o].id = l;
    if(l == r)  {
        return ;
    }
    int mid = (l + r) >> 1;
    build(o<<1, l, mid);
    build(o<<1|1, mid+1, r);
}
void push_up(int o) {
    if(tr[o<<1].m >= tr[o<<1|1].m) tr[o].id = tr[o<<1].id;
    else tr[o].id = tr[o<<1|1].id;
    tr[o].m = max(tr[o<<1].m, tr[o<<1|1].m);
}
void update(int o, int l, int r, int k, int d) {
    int L = tr[o].l, R = tr[o].r;
    if(L == R && L == k) {
        tr[o].m += d;
        return ;
    }
    int mid = (L + R) >> 1;
    if(mid >= k) update(o<<1, l, r, k, d);
    else if(mid < k) update(o<<1|1, l, r, k, d);
    push_up(o);
}
int ans[maxn];
int main()
{
    //freopen("/Users/maoxiangsun/MyRepertory/acm/code/i.txt", "r", stdin);
    while(~scanf("%d%d", &n, &m) && (n || m) ) {
        init();
        for(int i = 0; i < n - 1; i++) {
            int u, v;
            scanf("%d%d", &u, &v);
            addedge(u, v);
            addedge(v, u);
        }
        dfs1(1, 0, 0);
        dfs2(1, 1);
        for(int i = 0; i < m; i++) {
            int u, v, c;
            scanf("%d%d%d", &u, &v, &c);
            Change(u, v, c);
        }
        build(1, 0, maxn);
        for(int i = 1; i <= n; i++) {
            for(auto & v : up[i]) {
                if(v < 0) {
                    update(1, 1, maxn, -v, -1);
                }
                else update(1, 1, maxn, v, 1);
            }
            ans[fp[i]] = tr[1].id;
        }
        for(int i = 1; i <= n; i++) {
            printf("%d\n", ans[i]);
        }
    }
    return 0;
}
/*
2 4
1 2
1 1 1
1 2 2
2 2 2
2 2 1
5 3
1 2
3 1
3 4
5 3
2 3 3
1 5 2
3 3 3
0 0
*/