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


展开阅读全文

没有更多推荐了,返回首页