CF 671D Roads in Yusland 线段树维护代价合并的思想 ★ ★ ★ ★

题目大意

给定一颗 N 个节点的树，现在有 M 个工人，每个工人有三个属性 ui,vi,Ci ，表示这名工人可以维修节点 ui 到节点 vi 的所有路径，花费为 Ci ，并且保证 vi 是 ui 的祖先。问最少花费多少使得树上的每条边都有人维修。

N,M≤300000
Ci≤109

解题思路

这题有个特殊的性质，就是每个工人只会修一条指向祖先的路径。我们设 vi 为一开始工人所处的位置，那么我们就可以从下往上做，设 Fi 表示修完 i 这棵子树以及 i 连向父亲的这条边的最小花费。但是我们发现，当前结点可能有很多儿子，而且不同儿子子树中的工人是互不影响的，而且每个工人都有个修路的最小深度，也就是说我们单独的考虑一个工人的话 Fi 并求不出来，因为做到第 i 个节点是我们不能判断出每个工人对当前点祖先的影响，那么我们要考虑换种思想来维护这个 Fi 。

我们考虑把一些工人的属性叠加到一个工人上，那么我们最后查询时只要查询某些能维修完整棵树的最小值。还是用上面的思想，我们做到节点 i ，它有儿子 p1,p2,p3 。因为我们已经的到了这几棵子树的最优答案，并且子树之间互不影响，那么我们考虑把 Fp2 和 Fp3 的最有费用叠加到子树 p1 的所有工人中。类似这样，同样把 Fp1 和 Fp3 的最有费用叠加到子树 p2 的所有工人中……那么现在每个工人身上都存有其他子树维修完的最小花费。并且这种做法对 i 的祖先不会有后效性，因为在每个工人上都存有当前把含这个工人下的最有解，每次更新 Fi 也只需在所有工人中找到一个最小花费就可以了。

因为我们要要实现对于一些工人的花费都加上某个值得操作，那么可以先把工人按 Dfs 序编号，用线段树维护。复杂度是 O(NlogN) 的。

#include <cstring>
#include <cstdio>
#include <algorithm>
#include <vector>

using namespace std;
typedef long long LL;

const int MAXN = 3e5 + 5;
const LL Inf = 1e15 + 7;

struct Tree {
    LL Val, add;
} Tr[MAXN * 4];

LL F[MAXN];
int N, M, time, Val[MAXN], Ord[MAXN], L[MAXN], R[MAXN];
int tot, Last[MAXN], Out[MAXN], In[MAXN], Next[MAXN * 4], Go[MAXN * 4];

void Link(int u, int v, int *Lst) {
    Next[++ tot] = Lst[u], Lst[u] = tot, Go[tot] = v; 
}

void Dfs(int Now, int Pre) {
    L[Now] = time + 1;
    for (int p = In[Now]; p; p = Next[p]) 
        Ord[Go[p]] = ++ time;
    for (int p = Last[Now]; p; p = Next[p]) {
        int v = Go[p];
        if (v == Pre) continue;
        Dfs(v, Now);
    }
    R[Now] = time;
}

void Build(int Now, int l, int r) {
    Tr[Now].Val = Inf;
    if (l == r) return;
    int Mid = (l + r) >> 1;
    Build(Now * 2, l, Mid), Build(Now * 2 + 1, Mid + 1, r);
}

void Modify(int Now, int l, int r, int Side, LL Val) {
    if (l == r) {
        Tr[Now].Val = Val;
        return;
    }
    int Mid = (l + r) >> 1;
    if (Side <= Mid) Modify(Now * 2, l, Mid, Side, Val); else 
        Modify(Now * 2 + 1, Mid + 1, r, Side, Val);
    Tr[Now].Val = min(Inf, min(Tr[Now * 2].Val, Tr[Now * 2 + 1].Val) + Tr[Now].add);
}

void Add(int Now, int l, int r, int lx, int rx, LL add) {
    if (lx > rx) return;
    if (l == lx && r == rx) {
        Tr[Now].Val = min(Tr[Now].Val + add, Inf);
        Tr[Now].add = min(Tr[Now].add + add, Inf);
        return;
    }
    int Mid = (l + r) >> 1;
    if (rx <= Mid) Add(Now * 2, l, Mid, lx, rx, add); else
    if (lx > Mid) Add(Now * 2 + 1, Mid + 1, r, lx, rx, add); else {
        Add(Now * 2, l, Mid, lx, Mid, add);
        Add(Now * 2 + 1, Mid + 1, r, Mid + 1, rx, add);
    }
    Tr[Now].Val = min(Inf, min(Tr[Now * 2].Val, Tr[Now * 2 + 1].Val) + Tr[Now].add);
}

LL Query(int Now, int l, int r, int lx, int rx) {
    if (lx > rx) return Inf;
    if (l == lx && r == rx) return Tr[Now].Val;
    int Mid = (l + r) >> 1;
    if (rx <= Mid) return min(Inf, Query(Now * 2, l, Mid, lx, rx) + Tr[Now].add); else
    if (lx > Mid) return min(Inf, Query(Now * 2 + 1, Mid + 1, r, lx, rx) + Tr[Now].add); else 
        return min(Inf, min(Query(Now * 2, l, Mid, lx, Mid), Query(Now * 2 + 1, Mid + 1, r, Mid + 1, rx)) + Tr[Now].add);
}

void Solve(int Now, int Pre) {
    LL Ans = 0;
    for (int p = Last[Now]; p; p = Next[p]) {
        int v = Go[p];
        if (v == Pre) continue;
        Solve(v, Now);
        Ans = min(Ans + F[v], Inf);
    }
    if (Now == 1) {
        F[1] = Ans;
        return;
    }

    for (int p = In[Now]; p; p = Next[p])
        Modify(1, 1, M, Ord[Go[p]], Ans + Val[Go[p]]);
    for (int p = Out[Now]; p; p = Next[p])
        Modify(1, 1, M, Ord[Go[p]], Inf);
    for (int p = Last[Now]; p; p = Next[p]) 
        if (Go[p] != Pre)
            Add(1, 1, M, L[Go[p]], R[Go[p]], Ans - F[Go[p]]);
    F[Now] = Query(1, 1, M, L[Now], R[Now]);
}

int main() {
    scanf("%d %d", &N, &M);
    for (int i = 1; i < N; i ++) {
        int u, v;
        scanf("%d%d", &u, &v);
        Link(u, v, Last), Link(v, u, Last);
    }

    for (int i = 1; i <= M; i ++) {
        int l, r, t;
        scanf("%d%d%d", &l, &r, &Val[i]);
        Link(l, i, In), Link(r, i, Out);
    }

    Dfs(1, 0);
    Build(1, 1, M);
    Solve(1, 0);
    printf("%I64d", (F[1] == Inf) ? -1 : F[1]);
}