POJ 3659 Cell Phone Network【最小支配集】

题意：有以个 有 N 个节点的树形地图，问在这些顶点上最少建多少个电话杆，可以使得所有顶点被覆盖到，一个节点如果建立了电话杆，那么和它直接相连的顶点也会被覆盖到。

分析：用最少的点覆盖所有的点，即为求最少支配集。  可以用树形DP。

       ①  dp[r][0] += min(dp[i][0],dp[i][1],dp[i][2])    dp[r][0]表示在自 r 顶点自身建， 以 r 为根节点的树所需要的最少覆盖数。
       ②  dp[r][1] += min(dp[i][0],dp[i][1])                dp[r][1]表示在r 的子节点建，     以 r 为根节点的树所需要的最少覆盖数。
       ③  dp[r][2] += min(dp[i][0],dp[i][1])                dp[r][2]表示在r 的父节点建，     以 r 为根节点的数所需要的最少覆盖数。

       其中第 ② 个有 特殊情况需要考虑，即如果每次 min () 取得都是dp[i][1]的话，即 r 所有的子节点的都没有建电话杆的话，这样得出的结果就会有误差，可以在其中记录最小

       的dp[i][0]  值和其对应的 dp[i][1] 值，最后在这个 i 上建电话杆，就能保证自己被覆盖到，且用的电话杆最少， 这时dp[r][1]+=dp[i][0]-dp[i][1] 即可。

#include<stdio.h>
#include<string.h>
#define clr(x)memset(x,0,sizeof(x))
int min(int a,int b)
{ return a<b?a:b; }
#define maxn 100005
#define INF 0x1f1f1f1f
struct node
{
    int to;
    int next;
}e[1000000];
int tot;
int head[maxn];
int dp[maxn][3];
void add(int s,int u)
{
    e[tot].to=u;
    e[tot].next=head[s];
    head[s]=tot++;
}
// dp[r][0] = min(dp[i][0],dp[i][1],dp[i][2])自身建
// dp[r][1] = min(dp[i][0],dp[i][1]) 子节点建
// dp[r][2] = min(dp[i][0],dp[i][1]) 父节点建
int n;
int v[maxn];
void dfs(int r)
{
    v[r]=1;
    int i,k;
    int flag=1,ff=1,mi=INF,t;
    dp[r][0]=1;
    for(i=head[r];i;i=e[i].next)
    {
        k=e[i].to;
        if(!v[k])
        {
            flag=0;
            dfs(k);
            dp[r][0]+=min(dp[k][0],min(dp[k][1],dp[k][2]));
            if(dp[k][1]>=dp[k][0])
            {
                ff=0;
                dp[r][1]+=dp[k][0];
            }
            else 
            {
                dp[r][1]+=dp[k][1];
                if(dp[k][0]<mi)
                {
                    mi=dp[k][0];
                    t=dp[k][1];
                }
            }
            dp[r][2]+=min(dp[k][0],dp[k][1]);
        }
    }
    if(ff)
        dp[r][1]+=mi-t;
    if(flag)
    {
        dp[r][0]=1;
        dp[r][1]=INF;
        dp[r][2]=0;
    }
}
int main()
{
    int a,b,i;
    while(scanf("%d",&n)!=EOF)
    {
        tot=1;
        clr(v);
        clr(dp);
        clr(head);
        for(i=1;i<n;i++)
        {
            scanf("%d%d",&a,&b);
            add(a,b);
            add(b,a);
        }
        if(n==1)
        {
            printf("1\n");
            continue;
        }
        dfs(1);
        printf("%d\n",min(dp[1][0],dp[1][1]));
    }
    return 0;
}