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;
}