洛谷 P3574 FAR-FarmCraft

原题：
在一个叫做比特村的小村庄中，有n−1条路连接着这个村庄中的全部n个房子。

每两个房子之间都有一条唯一的通路。这些房子的编号为1至nnn。

1号房子属于村庄的管理员比特安萨尔。

为了提升村庄的科技使用水平，n台电脑被快递到了比特安萨尔的房子。每个房子都应该有一台电脑，且分发电脑的任务就落在了比特安萨尔的肩上。

比特村的居民一致同意去玩农场物语这个游戏的最新快照版，而且好消息是他们很快就要得到他们最新的高配置电脑了。

比特安萨尔将所有电脑都装在了他的卡车上，而且他准备好完成这个艰巨的任务了。

他的汽油恰好够走每条路两遍。

在每个房子边，比特安萨尔把电脑贴心的配送给居民，且立即前往下一个房子。（配送过程不花费任何时间）

只要每间房子的居民拿到了他们的新电脑，它们就会立即开始安装农场物语。安装农场物语所用的时间根据居民的科技素养而定。幸运的是，每间房子中居民的科技素养都是已知的。

在比特安萨尔配送完所有电脑后，他会回到他自己的1号房子去安装他自己的农场物语。

用卡车开过每条路的时间恰好是1分钟，而居民开电脑箱的时间可以忽略不计。（因为他们太想玩农场物语了）

请你帮助比特安萨尔算出从开始配送到所有居民都玩上了农场物语的最少时间。

输入格式：

第一行包含一个整数n(2≤n≤500000)n(2 <= n <= 500000)n(2≤n≤500000)，代表比特村中有多少房子。

第二行包含nnn个整数c1,c2,⋯,cn(1≤ci≤10^ 9)c_1, c_2, ⋯, c_n(1 <= c_i <= 10^9)c1​,c2​,⋯,cn​(1≤ci​≤10 ^9)，每个数都被单个空格隔开。ci​是第i号房间中居民安装农场物语所用的时间。

接下来的n−1行代表了每一条路的两个顶点。两个顶点a和b满足(1≤a<b≤n)(1 <= a < b <= n)(1≤a<b≤n)，两个数之间有一个空格。
输出格式：

一行，包含一个整数，代表题目中所说的最小时间。

感谢@deadpool123 提供的翻译
输入输出样例
输入 #1

6
1 8 9 6 3 2
1 3
2 3
3 4
4 5
4 6

输出 #1

11

说明/提示

给一棵树，走过每条边需要花费一个时间，安装软件又需要花费一个时间，需要遍历整棵树并回到起点，想让所有点中到达时间+安装时间的最大值最小，问这个值是多少

代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn = 500000 + 5;
const int inf = 9999999;
typedef long long ll;
typedef pair<ll,ll> value;

ll f1[maxn], f2[maxn]; // 遍历时间, 剩余时间
ll wei[maxn];
ll sum[maxn];
int n;
vector<int> G[maxn];
int cmp(const pair<value,int>& v1, const pair<value,int>& v2) {
    if (v1.first.second != v2.first.second) {
        return v1.first.second > v2.first.second;
    }
    return v1.first.first < v2.first.first;
}

value dfs(int cur, int pre) {
    vector<pair<value,int>> V;

    int tot = 0;

    for (int i=0;i<G[cur].size();i++) {
        if (G[cur][i] == pre) {
            continue;
        }

        value val = dfs(G[cur][i], cur);
        V.push_back(make_pair(val,G[cur][i]));
        tot += val.first;
    }
    sort(V.begin(), V.end(), cmp);

    ll v1 = V.size() * 2 + tot, v2 = 0;

    sum[V.size()] = 0; // do not use memset, it will be tle!
    for (int i=V.size()-1;i>=0;i--) {
        sum[i] = sum[i+1] + V[i].first.first;
    }

    for (int i=0;i<V.size();i++) {
        ll p_time = (V.size() - i - 1) * 2 + 1 + sum[i+1];
        ll tmp = f2[V[i].second] > p_time ? f2[V[i].second] - p_time : 0;
        v2 = max(v2, tmp);
    }

    ll root_v = wei[cur] - v1 > 0 ? wei[cur] - v1 : 0;
    value res = make_pair(v1, max(v2, root_v));
    f1[cur] = res.first;
    f2[cur] = res.second;

    return res;
}

//ifstream in("in");
//ofstream out("out");
int main()
{
    ios::sync_with_stdio(false);
    while(cin>>n) {
        memset(f1, 0, sizeof(f1));
        memset(f2, 0, sizeof(f2));
        for (int i=1;i<=n;i++) {
            cin >> wei[i];
            G[i].clear();
        }
        int a, b;
        for (int i=1;i<n;i++) {
            cin >> a >> b;
            G[a].push_back(b);
            G[b].push_back(a);
        }
        ll val = wei[1];
        wei[1] = 0;
        dfs(1, -1);
        cout << f1[1] + max(f2[1], val) << endl;
    return 0;
}


/*
7
1 10 8 6 10 8 9
1 2
2 3
2 4
3 5
4 6
6 7

17
*/

解答：

比较明显的树形dp题目，洛谷上和bzoj上的神仙们将的都比较粗糙，我的做法和多数人都有点区别，感觉更好理解一些，说的详细一点。

满足树形dp的计算特性，那么就要求每个节点作为根节点时能够得到当前的最优值。
这里设定两个状态$f1[x]$与$f2[x]$，其中$f1[x]$表示遍历以x节点为根节点并回到x节点所需要的时间；
$f2[x]$表示以x为根节点，在x遍历所有其子孙节点并回到x节点后，以x节点为根节点的子树中所有节点安装游戏的最大剩余时间。
假设，某节点x，子节点有3个，分别为$ch[1],ch[2],ch[3]$，其子节点分别包含对应的子树，对应的f1与f2值如下：
(2, 3), (4,2), (6,5) 如下图：
那么，考虑x节点的f1与f2的计算，其中$f1[x]$的计算很简单，按照树遍历的定义，从x点出发再回到x点，那么每个边都会走两遍，所以$f1[x]=f1[ch[1]]+f1[ch[2]]+f1[ch[3]]+3\times 2$，最后的3×2表示x有三个子节点，连接子节点的边会走来回各一次。

关键在于$f2[x]$的计算方式
题目中的要求时计算所有安装时间最小，那么最后肯定是希望遍历完x的所有子节点在回到x时，安装的剩余时间最小。
如何使得剩余时间最小？从上面的图上看，子节点剩余时间最多的是ch3，如果从x节点出发，先遍历ch3，那么ch3节点剩余的计算时间会被遍历ch2加上ch1的时间所掩盖上。
即，$p\_time=f1[ch[1]]+f1[ch[2]]+2\times 2+1$ p_time可以用来掩盖ch3为根节点的剩余时间，其中2×2表示x节点与ch1和ch2连接的边来回的时间，后面的+1表示从ch3节点回到x节点的时间。

如上面的例子，ch3节点的剩余时间是5，如果先遍历ch3，那么可以用于掩盖ch3安装时间的数值根据上面的公式得到的是11，也就是在回到x节点的时候，ch3节点的及其ch3子树的节点早就安装完成了。

根据上面的计算例子，可以得知，我们把x节点的子节点，按照f2时间进行排序，优先遍历剩余时间最大的，保证剩余时间最大的子节点可以在其余子节点的遍历过程中被掩盖掉。

这样，根据上面贪心的计算方法，计算所有x的子节点在x子节点全部遍历完并回到x节点后，其对应剩余时间减去被其余子节点遍历时间掩盖的部分，并保留其最大值（在程序中记作v2)

考虑完x的子节点的安装时间的最优选择，接下考虑回到x节点的安装时间。
因为是先遍历x节点，后遍历x的子节点，再回到x节点。所以x节点的安装时间应该是可以被$f1[x]$所掩盖的，如果$f1[x]$的值大于x节点的安装时间，那说明遍历完所有x节点并回到x节点时，节点x已经安装完了，否则x仍然没有安装完成。
那么$f2[x]$的计算方式，就应该取其子节点中被遍历掩盖后的最大剩余时间（即v2）与节点x被遍历掩盖后的剩余时间的二者最大值。

最后得到的结果，就是
$f1[1]+max(f2[1],val)$
因为1号节点是遍历完所有节点后最后安装的，所以在程序中先把1号节点在dfs时安装时间设置成0，并保存在val中。

题目中样例计算的f1与f2如下图：