例题9-14 UVA 1218 Perfect Service 完美的服务（树形dp）

大体题意：

给你一个n 个结点的树状结构，要求把一些结点变成服务器，使得每个非服务器结点恰好和一个服务器结点相连，求最少的服务器结点？

思路：

树形dp思想

看了分析才懂的！简单记录一下吧：

令dp[i][0] 表示 i 结点是服务器的话，最小的服务器数量！

令dp[i][1] 表示 i 结点不是服务器，但是i的父亲是服务器的 最小服务器数量！

令dp[i][2] 表示i 结点不是服务器，i 的父亲也不是服务器的最小的服务器的数量！

那么很容易知道   :

对于第一种状态，如果i 是服务器，那么它的儿子 既可以是服务器 又可以不是服务器！

dp[i][0] = sum{ min (dp[i][0], dp[i][1])} + 1

对于第二种状态， 如果i 不是服务器，但i 的父亲是服务器的话，i 的儿子肯定都不是 服务器，否则i 就连了两个

dp[i][1] = sum{ dp[i][2] }

对于第三种状态，如果i 不是服务器，并且i 的父亲也不是服务器的话，那么i 的儿子肯定有一个是服务器，否则i 没有与任何一个服务器相连！

dp[i][2] = sum{ dp[i][2] } - dp[v][2] + dp[v][0];

这个题虽然知道了转移方程，但是边界上和转移上还是很容易出错的！

虽然有三个状态，但对于一些边界点 ，有些状态是不合法的，既然这个题是取min 最小值，那不妨设不合法的情况为无穷大inf = 0x3f3f3f3f即可！

比如说叶子节点u  dp[u][2]就是不合法的，因为如果叶子不存在服务器，父亲也不存在服务器，那么肯定不合法了！设为inf 就好！

这个题目我给自己挖了个坑，设置的inf 太大了， 假如存在一种数据，一个根节点连了9999个 子结点，那么

dp[u][2] = inf * 9999  爆了int了 ，我最后改的long long 就好了！

 

详细见代码：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 10000 + 7;
const int inf = 0x3f3f3f3f;
struct Node{
    int v, next;
}p[maxn << 1];
int head[maxn], cnt;
void addedge(int u,int v){
    p[cnt].v = v;
    p[cnt].next = head[u];
    head[u] = cnt++;
}
long long dp[maxn][3];

void dfs(int k,int pre){
    int flag = 0;
    dp[k][0] = 1;
    dp[k][1] = 0;
    dp[k][2] = inf;
    for (int i = head[k]; ~i; i = p[i].next){
        int v = p[i].v;
        if (v == pre)continue;
        dfs(v,k);
        dp[k][0] += min(dp[v][0],dp[v][1]);
        dp[k][1] += dp[v][2];
        flag = 1;
    }
    if (!flag) return;

    for (int i = head[k]; ~i; i = p[i].next){
        int v = p[i].v;
        if (v == pre) continue;
        dp[k][2] = min(dp[k][2], dp[k][1] - dp[v][2] + dp[v][0]);
    }
//    printf("^^^  %d %d\n",k,dp[k][0]);
}
int main(){
    int n;
    while(scanf("%d",&n) == 1 && n != -1){
        if (!n)continue;
        memset(head,-1,sizeof head);
        cnt = 0;
        for (int i = 0; i < n-1; ++i){
            int u, v;
            scanf("%d %d",&u, &v);
            addedge(u,v);
            addedge(v,u);
        }
        dfs(1,-1);
//        for (int i = 1; i <= n; ++i)printf("%d %d %d\n",dp[i][0],dp[i][1],dp[i][2]);
        long long ans = min(dp[1][0],dp[1][2]);
        printf("%lld\n",ans);
    }
    return 0;
}