2020牛客多校9：B. Groundhog and Apple Tree（树形DP + 分类讨论 + 贪心）

---

题目大意：有一棵苹果树，每个节点有一个苹果，吃掉 $u$ 点的苹果能获得 $a_u$点 HP，经过第 $i$ 条边需要消耗 $w_i$ HP，在原地等待一秒可以获得 $1$ HP，每条边只能经过两次，问从1号节点出发吃掉所有苹果最少需要等待多少秒。

分析：首先在某个点一次性把所需要的HP等够是显然正确的，根据每条边只能经过两次，解的形式一定是先吃掉某棵子树，再回到根，再吃其它子树，最优解是一个吃的顺序的问题，而吃掉子树是一个子问题，考虑用树形 dp。

设 $dp[u]$ 表示以 $u$ 为根的答案， $sum[u]$ 表示吃完 $u$ 的子树后 HP 的变化。

$sum[u]$ 转移方程：$sum[u]={\sum }_{v\in son(u)}(sum[v]-2\ast w_v)$
$dp[u]$ 的转移要考虑子树的遍历顺序。

对于第 $i$ 棵子树，进入到这棵子树需要 $a_i=dp[i]+w_i$，从他回到 $u$ 后 得到的 HP 为 $b_i=dp[i]+sum[i]-w_i$

对遍历顺序进行分类讨论，简化问题，考虑只有两棵子树时的遍历顺序：

先遍历 $b_i\ge a_i$ 的子树更优：

设有 $a_i\le b_i,a_j>b_j$，分别讨论先 $i$ 和先 $j$ 的答案：
1、若 $a_i\ge a_j$，则两种情况答案分别为：$a_i$, $a_j+a_i-b_j$
2、若 $a_i<a_j$，则两种情况答案分别为：$a_i+max(a_j-b_i,0)$ ， $a_j+max(a_i-b_j,0$,画一下发现先 $i$ 答案至多为 $a_j$，而先 $j$ 答案至少为 $a_j$

若均满足 $a<b$：
设有 $a_i\le b_i,a_j\le b_j$，设 $a_i<a_j$
两种情况答案分别为：$a_i+max(a_j-b_i,0)$，$a_j$，由于 $b_i\ge a_i$，显然有 $a_i+max(a_j-b_i,0)\le a_j$

若均满足 $a>b$：
设有 $a_i>b_i,a_j>b_j$
两种情况分别为：$a_i+max(a_j-b_i,0)$，$a_j+max(a_i-b_j,0)$，在纸上画一下可以发现先遍历 $b$ 更大的子树更优。

---

代码：

#include<bits/stdc++.h>
using namespace std;
#define pii pair<int,int>
#define fir first
#define sec second
typedef long long ll;
const int maxn = 1e5 + 10;
vector<pii> g[maxn];
int t, n, a[maxn];
ll dp[maxn], sum[maxn];
struct node {
    
    
	ll in, out;
	node() {
    
    }
	node(ll i,ll j) {
    
    
		in = i, out = j;
	}
};
bool cmp1(node x,node y) {
    
    
	return x.in < y.in;
}
bool cmp2(node x,node y) {
    
    
	return x.out > y.out;
}
void dfs(int u,int fa) {
    
    
	dp[u] = 0, sum[u] = a[u];
	vector<node> x, y;
	for (auto it : g[u]) {
    
    
		int v = it.fir, w = it.sec;
		if (v == fa) continue;
		dfs(v,u);
		sum[u] += sum[v] - 2ll * w;
		node t;
		if (w <= dp[v] + sum[v])
			t = node(w + dp[v],dp[v] + sum[v] - w);
		else
			t = node(2ll * w - sum[v],0);
		if (t.in <= t.out)
			x.push_back(t);
		else
			y.push_back(t);
	}
	sort(x.begin(),x.end(),cmp1);
	sort(y.begin(),y.end(),cmp2);
	ll cur = a[u];
	for (auto it : x) {
    
    
		if (it.in > cur) {
    
    
			dp[u] += it.in - cur;
			cur = it.in;
		}
		cur = cur - it.in + it.out;
	}
	for (auto it : y) {
    
    
		if (it.in > cur) {
    
    
			dp[u] += it.in - cur;
			cur = it.in;
		}
		cur = cur - it.in + it.out;
	}
}
int main() {
    
    
	scanf("%d",&t);
	while (t--) {
    
    
		scanf("%d",&n);
		for (int i = 1; i <= n; i++)
			g[i].clear();
		for (int i = 1; i <= n; i++)
			scanf("%d",&a[i]);
		for (int i = 1; i < n; i++) {
    
    
			int u, v, w;
			scanf("%d%d%d",&u,&v,&w);
			g[u].push_back(pii(v,w));
			g[v].push_back(pii(u,w));
		}
		dfs(1,0);
		printf("%lld\n",dp[1]);
	}
	return 0;
}