UVA - 12093 Protecting Zonk （较难树形DP）

题目链接：https://vjudge.net/problem/UVA-12093

题意：

有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和子树间的边不一定被覆盖。

AC代码：

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