题目大意
给定一颗 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]);
}