uva 12093 Protecting Zonk 树形dp

题目大意：有n个城市和n-1条路组成了一个树，现在有花费为c1的机器人A和花费为c2的机器人B，两种机器人都是无限量的，如果在城市u放置机器人A，此时与u连接的边都会被覆盖，如果在城市u放置机器人B，那么与u相连的边都会被覆盖，且与u相连的点所相连的边也会被覆盖，现问将所有道路都覆盖所需最小花费

dp[u][0] ：以点u为根的子树下的边全部被覆盖，且没有向u节点上方覆盖

dp[u][1]：以点u为根的子树下的边全部覆盖，且向上覆盖长度为1

dp[u][2]：以点u为根的子树下的边全部覆盖，且向上覆盖长度为2

dp[u][3]：以点u为根的子树的子树里的边都被覆盖，但是u和子树间的边不一定被覆盖

#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;

int n, c1, c2;
const int maxn = 1e4 + 10;
const int INF = 0x3f3f3f3f;
vector<int> G[maxn];
int dp[maxn][4];

void dfs(int u, int fa)
{
    dp[u][0] = dp[u][3] = 0;
    dp[u][1] = c1;
    dp[u][2] = c2;
    int min_A = INF, sum = 0;
    for (int i = 0; i < G[u].size(); i++)
    {
        int v = G[u][i];
        if (v == fa) continue;
        dfs(v, u);
        int min_of_t = min(min(dp[v][0], dp[v][1]), dp[v][2]);
        
        dp[u][0] += dp[v][1];
        dp[u][1] += min_of_t;
        dp[u][2] += min(min_of_t, dp[v][3]);
        dp[u][3] += min_of_t;
        
        sum += min_of_t;
        min_A = min(min_A, dp[v][2] - min_of_t);
    }
    sum += min_A;
    dp[u][1] = min(dp[u][1], sum);
}

int main()
{
    while (scanf("%d%d%d", &n, &c1, &c2) != EOF)
    {
        if (n == 0) break;
        for (int i = 1; i <= n; i++) G[i].clear();
        int u, v;
        for (int i = 1; i < n; i++)
        {
            scanf("%d%d",&u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        dfs(1, -1);
        int res = min(min(dp[1][0], dp[1][1]), dp[1][2]);
        printf("%d\n", res);
    }
    return 0;
}