题意
给出一个 N N N个点 M M M条边的无向连通图,每个点的标号为 1 1 1到 n n n, 且有两个权值 A i , B i A_i,B_i Ai,Bi.第 i i i条边连接了点 u i u_i ui和 v i v_i vi.
最开始时你拥有一定数量的钱,并且可以选择这张图上的任意一个点作为起始点,之后你从这个点开始沿着给定的边遍历这张图。每当你到达一个点 v v v时,你必须拥有至少 A v A_v Av元。而当你到达了这个点后,你可以选择向它捐献 B v B_v Bv元(当然也可以选择不捐献),当然,你需要保证在每次捐献之后自己剩余的钱 ≥ 0 \geq 0 ≥0。
你需要对所有的 n n n个点都捐献一次,求你一开始至少需要携带多少钱。
数据范围
- 1 ≤ N ≤ 1 0 5 1\leq N\leq 10^5 1≤N≤105
- N − 1 ≤ M ≤ 1 0 5 N-1\leq M\le 10^5 N−1≤M≤105
- 1 ≤ A i , B i ≤ 1 0 9 1\leq A_i,B_i\leq 10^9 1≤Ai,Bi≤109
- 1 ≤ u i < v i ≤ N 1\leq u_i<v_i\leq N 1≤ui<vi≤N
- 保证题目给出的图联通
输入格式
第一行两个正整数 N , M N,M N,M.
接下来 N N N行每行两个正整数 A i , B i A_i,B_i Ai,Bi.
接下来 M M M行每行两个正整数 u i , v i u_i,v_i ui,vi
输出格式
一行一个整数,表示一开始你需要携带的最少钱数。
思路
正着做搞了半天没懂,从反着做的角度来搞好做多了。
反着做的题意:假设你经过 u u u点后可以领取 B u B_u Bu,要求离开此点时身上金额不小于 A u A_u Au,要求对于所有点都领取一次,问最后身上金钱的最小值。
因为领取的总金额是一个定值,所以我们也可以认为是一开始携带金钱的最小值。
显然第一次到达 u u u点就领取一定不劣。于是就变成了:第一次到达点 u u u时你的金额不能小于 A u − B u A_u-B_u Au−Bu,而你身上的钱是单调不降的,所以我们也可以说你到达点 u u u时你的金额不能小于 A u − B u A_u-B_u Au−Bu。
现在你要从点 u u u走到点 v v v,则你身上的金钱既不可能小于 A u − B u A_u-B_u Au−Bu,也不会小于 A v − B v A_v-B_v Av−Bv;并且,显然当你的金钱 ≥ m a x ( A u − B u , A v − B v ) \geq max(A_u-B_u,A_v-B_v) ≥max(Au−Bu,Av−Bv)时,这次移动必定成立,于是我们可以认为点 u u u和点 v v v之间的边权为 m a x ( A u − B u , A v − B v ) max(A_u-B_u,A_v-B_v) max(Au−Bu,Av−Bv),记 C i = A i − B i C_i=A_i-B_i Ci=Ai−Bi,则边权等价于 m a x ( C u , C v ) max(C_u,C_v) max(Cu,Cv)
从边权的角度考量,如果我们已经走过了边权为 w w w的边,则边权 < w \lt w <w的边也一定能走;贪心地说,如果我们走过了边权为 w w w的边,那我们可以先将边权 ≤ w \leq w ≤w的所有边都走了,之后再去走边权 > w \gt w >w的边,显然这个策略一定不劣。
因此,我们可以将边权从小往大排序后按顺序拿钱,也就是按顺序激活边权 ≤ w \leq w ≤w的所有边,但有时两个连通块之间存在 > w \gt w >w的边,此时我们必须先把一个连通块拿完再过去。
这种瓶颈路的设定引导我们建立
K
r
u
s
k
a
l
Kruskal
Kruskal重构树,然后再做一个
d
p
dp
dp。具体地,设
d
p
[
u
]
dp[u]
dp[u]表示将
u
u
u所在的子树全部拿走所需要的最少金钱,则有状态转移方程:
d
p
[
u
]
=
m
i
n
v
∈
s
o
n
[
u
]
(
m
a
x
(
d
p
[
v
]
,
v
a
l
u
)
+
s
u
m
[
u
]
−
s
u
m
[
v
]
)
dp[u] = min_{v \in son[u]}(max(dp[v],val_u)+sum[u]-sum[v])
dp[u]=minv∈son[u](max(dp[v],valu)+sum[u]−sum[v])
其中
m
a
x
(
d
p
[
v
]
,
v
a
l
u
)
max(dp[v],val_u)
max(dp[v],valu)是指先拿完
v
v
v所在的子树的钱和该边权
v
a
l
u
val_u
valu取个
m
a
x
max
max;后者是指我们可以通过边权为
v
a
l
u
val_u
valu的边来到另一个连通块,此时我们可以大拿特拿,因为
v
a
l
u
val_u
valu从根往叶是单调不增的。
最后答案就是这棵树中根节点的 d p dp dp值。
代码
#include<bits/stdc++.h>
using LL = long long;
const LL inf = 1e16;
struct DSU{
std::vector<int> fa;
DSU(int n) {
fa.assign(n,0);
std::iota(fa.begin(),fa.end(),0);
}
int find (int x) {
while (fa[x] != x) {
x = fa[x] = fa[fa[x]];
}
return x;
}
void merge(int x,int y) {
fa[y] = x;
}
};
void OuO() {
int n,m;std::cin >> n >> m;
std::vector<LL> A(n),B(n),C(n);
std::vector<LL> val(n*2-1),sum(n*2-1),fa(n*2-1),dp(n*2-1);
std::vector eg(n*2,std::vector<LL>());
for (int i = 0; i < n; ++i) {
std::cin >> A[i] >> B[i];
C[i] = std::max(A[i] - B[i],0ll);
sum[i] = B[i];
dp[i] = std::max(A[i],B[i]);
}
{
std::vector<std::array<LL, 3>> edge(m);
DSU dsu = DSU(n * 2 - 1);
for (int i = 0, x, y; i < m; ++i) {
std::cin >> x >> y;
x--, y--;
edge[i] = {x, y, std::max(C[x], C[y])};
}
std::sort(edge.begin(),edge.end(),[&](std::array<LL,3> x,std::array<LL,3> y) {
return x[2] < y[2];
});
int ecnt = n;
for (auto [u,v,w] : edge) {
u = dsu.find(u),v = dsu.find(v);
if (u == v) continue;
val[ecnt] = w;
eg[ecnt].emplace_back(u),eg[ecnt].emplace_back(v);
fa[u] = fa[v] = ecnt;
sum[ecnt] = sum[u] + sum[v];
dsu.merge(ecnt,u),dsu.merge(ecnt,v);
ecnt ++;
}
}
std::function<void(int)> dfs = [&](int u) {
if (!eg[u].empty())dp[u] = inf;
for (auto v : eg[u]) {
dfs(v);
dp[u] = std::min(dp[u],sum[u]-sum[v]+std::max(val[u],dp[v]));
}
// std::cout << u << " " << sum[u] << " " << dp[u] << '\n';
};
dfs(n*2-2);
std::cout << dp[n*2-2];
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
// clock_t st = clock();
// std::cout << std::fixed << std::setprecision(12);
// freopen("test.in", "r", stdin);
// freopen("test.out", "w", stdout);
int T = 1;
// std::cin >> T;
while (T --) {
OuO();
}
// std::cout << (double)(clock()-st)/CLOCKS_PER_SEC;
return 0;
}