ACM/ICPC World Finals 2010 D Castles

题目大意

给定一棵无根树，树的每一个节点上有一个城市，现在要从任意一个城市开始攻打，攻下每个城市需要$a_i$个士兵，会死去$m_i$个士兵，之后要留下$h_i$个士兵。每一条路只能一来一去，攻打一个城市必须要占领与它相邻的一个城市，求最少需要多少士兵才可以攻下所有的城市。

解答

很容易就可以想到，应该先攻打$max\{a_i-m_i-h_i,m_i+h_i\}$尽可能大的城市，这样剩下的兵力就会更多一些，在这个贪心策略下，我们可以枚举每一个起点，用DFS搜索，对每个城市，我们定义$f_i$为攻打以其为根的子树后剩余兵力，$g_i$为损耗的兵力，则：

$$g_i=\sum_{j\in Son_i}g_j$$
然后再一重循环算出 $f_i$的值，对 $i$的第$j$个子节点：
$$f'_j=\left\{ \begin{array}{lcl} f'_{j-1}-a_j+f_j &(f'_{j-1}>a_j)\\ f_j&(f'_{j-1}\le a_j) \end{array} \right.$$

参考代码

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <algorithm>

using namespace std;

const int MAXN = 200;
const int MAXM = 400;

class Edge
{
    public:
        int to;
        int next;
};

Edge es[MAXM];
int head[MAXN];
int et = 0;
int f[MAXN], g[MAXN];
int a[MAXN], m[MAXN], h[MAXN];
int n;

void addEdge(int u, int v)
{
    et++;
    es[et].to = v;
    es[et].next = head[u];
    head[u] = et;
    et++;
    es[et].to = u;
    es[et].next = head[v];
    head[v] = et;
}

bool cmp(int i, int j)
{
    return f[i] > f[j];
}

void dfs(int now, int fa)
{
    int tmp[MAXN];
    int p = 0;
    f[now] = 0;
    g[now] = m[now]+h[now];
    for (int i = head[now]; i; i = es[i].next) {
        if (es[i].to == fa)
            continue;
        dfs(es[i].to, now);
        tmp[p++] = es[i].to;
        g[now] += g[es[i].to];
    }
    sort(tmp, tmp+p, cmp);
    f[now] = max(a[now]-m[now]-h[now], 0);
    for (int i = 0; i < p; i++) {
        if (f[now] < a[tmp[i]])
            f[now] = f[tmp[i]];
        else
            f[now] += f[tmp[i]]-a[tmp[i]];
    }
}

void readin()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
        scanf("%d %d %d", &a[i], &m[i], &h[i]);
    int x, y;
    for (int i = 1; i < n; i++) {
        scanf("%d %d", &x, &y);
        addEdge(x, y);
    }
}

int ans = 2147483647;;

void work()
{
    for (int i = 1; i <= n; i++) {
        dfs(i, 0);
        ans = min(ans, f[i]+g[i]);
    }
    printf("%d\n", ans);
}

int main()
{
    readin();
    work();
    return 0;
}