poj 3659 Cell Phone Network 树型DP也是树的最小支配集

题目：poj 3659 Cell Phone Network

题意：农夫给他的每个牛发另一个手机（有点扯），现在要在农场建设信号塔以便所有的牛可以相互联系，每个信号塔可以供和他相连的农场使用，所有农场形成一颗树，问要达到要求最少建塔的数量。也就是给一颗树，每个节点可以覆盖和他相连的所有节点，现在问你用最少的点把所有的点覆盖完。

这个题目和poj1463有点相似，poj1463是用点覆盖边，相对简单很多（poj1463解题报告）；

解题：可以用动态规划，也可以用最小支配集。

一、现在先说用动态规划的思路：

         根据题意知道每个节点有三种状态：

              1、点i建塔，i的所有孩子都覆盖，用dp[i][0]表示；

              2、点i不建塔，i和i的所有孩子都覆盖，用dp[i][1]表示；

              3、点i不建塔，i不覆盖，i的所有孩子都覆盖，用dp[i][2]表示；

         如果这样不好理解那么这样理解可能容易一点（参考别人的）：覆盖i，要么是父节点覆盖，要么是自己，要么是孩子，所以三种状态（和上面的对应）：             

              1、点i自己覆盖自己，i的所有孩子都覆盖，用dp[i][0]表示；

              2、点i被自己的孩子覆盖，i和i的所有孩子都覆盖，用dp[i][1]表示；

              3、点i被父节点覆盖，i的所有孩子都覆盖，用dp[i][2]表示；

         那么动态转移方程就是（v是i的孩子）：

              dp[i][0]+=min(dp[v][0],dp[v][1],dp[v][2]);

              dp[i][2]+=min(dp[v][0],dp[v][1]);

              对于dp[i][1],要考虑全面，也就是说：必须要有一个孩子建塔，才能保证i被覆盖（Min=sum(min(dp[v][0]-dp[i][1]))，也就是当所有孩子的dp[v][0]>dp[v][i]时，Min表示他们差值最小的那个差值）。

              所以方程是dp[i][1]+=min(dp[v][0],dp[1])（至少存在一个孩子的dp[v][0]<=dp[v][1]，否则要dp[i][1]+=Min）；

代码如下：

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <vector>

using namespace std;
#define N 10005
struct Node{
    int v,next;
}node[N<<1];
int headnod[N];
bool vist[N];
int num,ans,k;
int dp[N][3];
void Add(int u,int v)
{
    node[k].v=v;
    node[k].next=headnod[u];
    headnod[u]=k++;
}
void init()
{
    int i,x,y;    k=1;
    memset(headnod,0,sizeof(headnod));
    memset(vist,true,sizeof(vist));
    for(i=1;i<num;i++)
    {
        scanf("%d%d",&x,&y);
        Add(x,y);        Add(y,x);
    }
}
void dfs(int key)
{
    bool flag=true;    vist[key]=false;
    int i,v,Min=(1<<30);
    dp[key][0]=1;    dp[key][1]=dp[key][2]=0;
    for(i=headnod[key];i;i=node[i].next)
    {
        v=node[i].v;
        if(vist[v])
        {
            dfs(v);
            dp[key][0]+=min(dp[v][0],min(dp[v][1],dp[v][2]));
            dp[key][2]+=min(dp[v][0],dp[v][1]);
            if(dp[v][0]<=dp[v][1])
            {
                flag=false;
                dp[key][1]+=dp[v][0];
            }
            else
            {
                dp[key][1]+=dp[v][1];
                Min=min(Min,dp[v][0]-dp[v][1]);
            }
        }
    }
    if(flag)
    {
        dp[key][1]+=Min;
    }
}
int main()
{
    //freopen("/home/acm/JPY/input.txt","r",stdin);
    while(cin>>num)
    {
        init();
        dfs(1);
        cout<<min(dp[1][1],dp[1][0])<<endl;
    }
    return 0;
}

二、贪心，随便找一个根，后续遍历树。每个点，如果它的孩子都没有真正覆盖的，同时他自己和他父亲都没有真正覆盖的，就把它的父亲覆盖，答案加一。

代码：

#include<iostream>
#include<vector>
using namespace std;
int n, ans;
vector<int> v[10001];
bool vst[10001], have[10001];
void jeo(int id, int from)
{
    vst[id] = 1; bool flag = false;
    for(int i = 0; i < v[id].size(); i++)
        if (!vst[v[id][i]])
            jeo(v[id][i], id), flag = flag || have[v[id][i]];
    if (from == -1) ans += !(have[id] || flag);
    else if (!have[from] && !have[id] && !flag)
        have[from] = 1, ans++;
}
int main()
{
    scanf("%d", &n);
    for(int i = 1; i < n; i++)
    {
        int a, b;scanf("%d%d", &a, &b);
        v[a].push_back(b);
        v[b].push_back(a);
    }
    memset(vst, 0, sizeof(bool) * (n + 1));
    memset(have, 0, sizeof(bool) * (n + 1));
    ans = 0; jeo(1, -1);
    printf("%d\n", ans);
    return 0;
}

注：方法二转自 http://blog.sina.com.cn/s/blog_64675f540100l21t.html