UVA 1218 Perfect Service（树形dp)

题目大意：
有n个点
要求在一些点安装服务器，使不是服务器的点恰好与一台服务器计算机相邻
最少要装多少个点

思路：
树形dp
d[u][0]表示u是服务器，子节点是服务器或者不是服务器的状态
d[u][1]表示u不是服务器，u的父亲是服务器，u的子节点都不是服务器的状态
（如果有一个子节点是服务器那u久相邻两台服务器了）
d[u][2]表示u和u的父亲不是服务器，u的一个子节点是服务器的状态
然后就写状态转移方程(v是u的子节点)
d[u][0]=sum(min(d[v][1],d[v][2])+1
d[u][1]=sum(d[v][2])
而d[u][2]方程就可能比较难想
因为d[u][1]子节点都不是服务器的，而dp[u][2]有一个节点是服务器
差别就在这里
那么我们可以利用容斥原理，dp[u][1]是包含dp[u][2]的
我们就枚举每个子节点，看子节点剩下来的情况是咋样的
d[u][2]=min(d[u][1]-d[v][2]+d[v][0])
这里dp[u][1]就表示子节点全部不是服务器的状态
而-dp[v][2]+d[v][0]表示这个子节点是服务器的状态

AC代码：

#include <bits/stdc++.h>

using namespace std;
const int N=100010;
int n;
int dp[N][4];
vector<int>e[N];
void dfs(int x,int fa)
{
    dp[x][0]=1;
    dp[x][1]=0;
    dp[x][2]=N;
    for(int i=0; i<e[x].size(); i++)
    {
        int y=e[x][i];
        if(y!=fa)
        {
            dfs(y,x);
            dp[x][0]+=min(dp[y][0],dp[y][1]);
            dp[x][1]+=dp[y][2];
        }
    }
    for(int i=0; i<e[x].size(); i++)
    {
        int y=e[x][i];
        if(y!=fa)
        {
            dp[x][2]=min(dp[x][1]-dp[y][2]+dp[y][0],dp[x][2]);
        }
    }
    return;
}

int main()
{
    while(cin>>n)
    {
        int a,b;
        for(int i=1; i<n; i++)
        {
            cin>>a>>b;
            e[a].push_back(b);
            e[b].push_back(a);
        }
        dfs(1,-1);
        cout<<min(dp[1][0],dp[1][2])<<endl;
        cin>>a;
        if(a==-1)break;
        for(int i=1; i<=n; i++)e[i].clear();
    }
    return 0;
}