【树形dp】 [POI2014] FAR-FarmCraft

思路：
由于是树形结构，我们直接考虑树形dp。
定义$f[u]$，表示从$u$出发，走完$u$的子树花费的最短时间，也就是子树中每一个点（走到的时间+点权）的最大值。
我们考虑如何转移，用$tim[u]$表示走完$u$的若干子节点所代表的子树，返回$u$，所花费的时间。
那么有$f[u]=max(f[u],f[v]+tim[u]+1)$，我们发现这个转移方式和子节点的遍历顺序有关。
考虑$u$的两个子节点$x$和$y$，假设$x$比$y$先被遍历到。
那么有$x$和$y$对于$f[u]$的贡献为：
$max(tim[u]+1+f[x],tim[u]+tim[x]+2+1+f[y])$
我们把$x,y$交换一下位置，那么贡献变为：
$max(tim[u]+1+f[y],tim[u]+tim[y]+2+1+f[x])$
把上下两式的$tim[u]+1$都去掉之后，得到以下两式子：
$max(f[x],tim[x]+2+f[y])$
$max(f[y],tim[y]+2+f[x])$
假设我们交换之后结果更优，那么有$max(f[x],tim[x]+2+f[y])>max(f[y],tim[y]+2+f[x])$
又因为$f[x]<tim[y]+2+f[x],f[y]<tim[x]+2+f[y]$，那么可以得到$tim[x]+2+f[y]>tim[y]+2+f[x]$，即$tim[x]-f[x]>tim[y]-f[y]$
那么也就是说，只要有相邻的两个孩子$x,y$满足$tim[x]-f[x]>tim[y]-f[y]$，我们就可以将其交换并且结果更优，那么最优解中孩子的遍历顺序就是按照$tim[]-f[]$从小到大排序的顺序。
那么我们就可以用贪心来做，每一次把孩子排个序之后再遍历。
其中，$tim[u]={\sum }_{v}tim[v]+2$

AC代码：

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

typedef long long LL;

const int N = 500005;

int n;
int c[N];
int tim[N];
struct edge
{
	int to, next;
}e[N << 1];
int head[N], cnt;
int w[N];
int tmp[N];
LL f[N];

void add(int u, int v)
{
	e[ ++ cnt ] = {v, head[u]};
	head[u] = cnt;
}

bool cmp(int x, int y)
{
	return tim[x] - f[x] < tim[y] - f[y];	
}

void dfs(int u, int ff)
{
	if (u != 1) f[u] = w[u];
	int cnt = 0;
	for (int i = head[u]; i; i = e[i].next)
	{
		int v = e[i].to;
		if (v == ff ) continue;
		dfs(v, u);
		
	}
	for (int i = head[u]; i; i = e[i].next)
		if (e[i].to != ff) 
			tmp[++ cnt] = e[i].to;
	sort(tmp + 1, tmp + 1 + cnt, cmp);
	
	for (int i = 1; i <= cnt; i ++ )
	{
		int v = tmp[i];
		f[u] = max(f[u], tim[u] + f[v] + 1);
		tim[u] += tim[v] + 2; 	
	}
}

int main()
{
	scanf("%d", &n);
	for (int i = 1; i <= n; i ++ ) scanf("%d", &w[i]);
	for (int i = 0; i < n - 1; i ++ )
	{
		int u, v;
		scanf("%d%d", &u, &v);
		add(u, v); add(v, u);
	}
	
	dfs(1, 0);
	
	printf("%lld\n", max(f[1], 1LL * tim[1] + w[1]));
	
	return 0;
}