hdu 5556 Land of Farms(最大独立集）

最新推荐文章于 2018-11-14 20:40:44 发布
最新推荐文章于 2018-11-14 20:40:44 发布
阅读量885 收藏
点赞数
分类专栏： acm 图论 二分图 最大独立集
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/carryheart/article/details/51137081
版权
acm 同时被 3 个专栏收录
47 篇文章 0 订阅
订阅专栏
图论
11 篇文章 0 订阅
订阅专栏
二分图
1 篇文章 0 订阅
订阅专栏

这题很明显可以用最大独立集来做，但是写代码很麻烦，是本人目前碰到的建图最麻烦的一道题，思路懒得写了，但是为代码应该很好懂。。。这里贴的代码的枚举没有优化所以更好懂。。。。需要卡两次时间才能过可能。上代码：
（时隔半年再次碰到这题，感觉还是比较棘手，底下贴一个稍微优化过的代码）
1.

#include<iostream>
#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;
const int maxn = 110;
int n,m;
int dir[4][2]={{0,-1},{0,1},{1,0},{-1,0}};
      int mmax;
      int kn;
int bmap[maxn][maxn];
int bmask[maxn];
int nx,ny;
int cx[maxn];
int cy[maxn];
char g[12][12];
int id[12][12];
int vis[12][12];
int lianvis[12][12];
int bx[maxn];
int by[maxn];
vector<pair<int,int> > af[11];
int used[11];
int ans;
int findpath(int u )
{
      int i;
      for(i=1; i<=ny; i++)
      {
          if(by[i]==1)
            if(bmap[u][i] && ! bmask[i])
            {

                  bmask[i] = 1;
                  if(cy[i] == -1 || findpath(cy[i]))
                  {
                        cy[i] = u;
                        cx[u] = i;
                        return 1;
                  }
            }
      }
      return 0;
}

int maxmatch()
{
      int res(0);
      int i,j;
      for(i=1; i<=nx; i++)
      {
            cx[i]=-1;
      }
      for(j=1; j<=ny; j++)
      {
            cy[j]=-1;
      }
      for( i = 1; i <= nx ; i++ )
      {
          if(bx[i]==1)
            if ( cx [ i ] == -1)
            {
                  for(j = 1; j <= ny ;  j++ )
                  {
                        bmask[j] = 0;
                  }
                  res+=findpath(i);
            }
      }
      return res;
}

void dfs(int cnt)
{
    if(cnt>=mmax+1)
    {
        memset(vis,0,sizeof(vis));
        memset(lianvis,0,sizeof(lianvis));
        int num=0,jian=0;
        for(int i=0;i<=mmax;i++)
        {
            if(used[i]!=0)
            {
                if(af[i].size()>0)
                    num++;
                for(int j=0;j<af[i].size();j++)
                {
                    int xx=af[i][j].first,yy=af[i][j].second;
                    for(int kk=0;kk<4;kk++)
                    {
                        int x=xx+dir[kk][0],y=yy+dir[kk][1];
                        if(x<0||x>=n||y<0||y>=m)continue;
                        if(id[x][y]==0&&used[g[x][y]-'0']&&(g[x][y]-'0')!=i)
                        {
                            if(lianvis[g[x][y]-'0'][i]==0)
                            {
                                num--;
                                lianvis[g[x][y]-'0'][i]=lianvis[i][g[x][y]-'0']=1;
                            }

                        }
                        if(x<0||x>=n||y<0||y>=m||id[x][y]==0||vis[x][y])continue;
                        vis[x][y]=1;
                        jian++;
                        for(int k=0;k<4;k++)
                    {
                        int X=x+dir[k][0],Y=y+dir[k][1];
                        if(X<0||X>=n||Y<0||Y>=m||id[X][Y]==0)continue;

                        bmap[id[X][Y]][id[x][y]]=bmap[id[x][y]][id[X][Y]]=0;
                    }
                    }
                }
            }
        }
        int res=kn-jian-maxmatch()+num;
        ans=max(ans,res);
        for(int i=0;i<=mmax;i++)
        {
            if(used[i]!=0)
            {

                for(int j=0;j<af[i].size();j++)
                {
                    int xx=af[i][j].first,yy=af[i][j].second;
                    for(int kk=0;kk<4;kk++)
                    {
                        int x=xx+dir[kk][0],y=yy+dir[kk][1];
                        if(x<0||x>=n||y<0||y>=m||id[x][y]==0)continue;

                        for(int k=0;k<4;k++)
                    {
                        int X=x+dir[k][0],Y=y+dir[k][1];
                        if(X<0||X>=n||Y<0||Y>=m||id[X][Y]==0)continue;

                        bmap[id[X][Y]][id[x][y]]=bmap[id[x][y]][id[X][Y]]=1;
                    }}
                }
            }
        }
        return;
    }
    else
    {
        used[cnt]=1;
        dfs(cnt+1);
        used[cnt]=0;
        dfs(cnt+1);
    }
}


int main()
{

      int T;
      int cns=0;
      scanf("%d",&T);
      while(T--)
      {
          mmax=-1;
          memset(id,0,sizeof(id));
          memset(used,0,sizeof(used));
          memset(bx,0,sizeof(bx));
          memset(by,0,sizeof(by));
          for(int i=0;i<11;i++)
              af[i].clear();
          kn=0;

          scanf("%d%d",&n,&m);
          for(int i=0;i<n;i++)
          {
              scanf("%s",g[i]);
              for(int j=0;j<m;j++)
              {
                  if(g[i][j]=='.')
                  {
                      id[i][j]=++kn;
                      if((i+j)%2==0)
                          bx[kn]=1;
                          else
                              by[kn]=1;
                  }
                  else
                  {
                      mmax=max(mmax,g[i][j]-'0');
                      af[g[i][j]-'0'].push_back(make_pair(i,j));
                  }
              }
          }
          nx=kn;
          ny=kn;
          for(int i=0;i<n;i++)
              for(int j=0;j<m;j++)
              {
                  if(id[i][j]!=0)
                  {
                      for(int k=0;k<4;k++)
                      {
                          int X=i+dir[k][0];
                          int Y=j+dir[k][1];
                          if(X<0||X>=n||Y<0||Y>=m||id[X][Y]==0)continue;
                          bmap[id[i][j]][id[X][Y]]=1;
                      }
                  }
              }
              ans=-1;
              dfs(0);
              cout<<"Case #"<<++cns<<": "<<ans<<endl;


          for(int j=0; j<=nx; j++)
            {
                  for(int k=0; k<=ny; k++)
                  {
                        bmap[j][k]=0;
                  }
            }
      }


}

2.

#include<iostream>
#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;
const int maxn = 110;
int n,m;
int dir[4][2]={{0,-1},{0,1},{1,0},{-1,0}};
int mmax;
int kn;
int bmap[maxn][maxn];
int bmask[maxn];
int nx,ny;
char g[12][12];
int id[12][12];
int vis[12][12];
int lianvis[12][12];
int bx[maxn];
int by[maxn];
vector<pair<int,int> > af[11];
int used[11];
int ans;
int linker[maxn];
int used1[maxn];
bool dfs1(int u)
{
    int v;
    for(v=1;v<=ny;v++)
        if(bmap[u][v]&&!used1[v])
        {
            used1[v]=true;
            if(linker[v]==-1||dfs1(linker[v]))
            {
                linker[v]=u;
                return true;
            }
        }
    return false;
}
int hungary()
{
    int res=0;
    int u;
    memset(linker,-1,sizeof(linker));
    for(u=1;u<=nx;u++)
    {
        if(bx[u]==1)
        {memset(used1,0,sizeof(used1));
        if(dfs1(u))  res++;}
    }
    return res;
}
void dfs(int cnt)
{
    if(cnt>=mmax+1)
    {
        memset(vis,0,sizeof(vis));
        memset(lianvis,0,sizeof(lianvis));
        int num=0,jian=0;
        for(int i=0;i<=mmax;i++)
        {
            if(used[i]!=0)
            {
                if(af[i].size()>0)
                    num++;
                for(int j=0;j<af[i].size();j++)
                {
                    int xx=af[i][j].first,yy=af[i][j].second;
                    for(int kk=0;kk<4;kk++)
                    {
                        int x=xx+dir[kk][0],y=yy+dir[kk][1];
                        if(x<0||x>=n||y<0||y>=m)continue;
                        if(id[x][y]==0&&used[g[x][y]-'0']&&(g[x][y]-'0')!=i)
                        {
                            if(lianvis[g[x][y]-'0'][i]==0)
                            {
                                num--;
                                lianvis[g[x][y]-'0'][i]=lianvis[i][g[x][y]-'0']=1;
                            }
                        }
                        if(x<0||x>=n||y<0||y>=m||id[x][y]==0||vis[x][y])continue;
                        vis[x][y]=1;
                        jian++;
                        for(int k=0;k<4;k++)
                    {
                        int X=x+dir[k][0],Y=y+dir[k][1];
                        if(X<0||X>=n||Y<0||Y>=m||id[X][Y]==0)continue;
                        bmap[id[X][Y]][id[x][y]]=bmap[id[x][y]][id[X][Y]]=0;
                    }
                    }
                }
            }
        }
        int res=kn-jian-hungary()+num;
        ans=max(ans,res);
        for(int i=0;i<=mmax;i++)
        {
            if(used[i]!=0)
            {
                for(int j=0;j<af[i].size();j++)
                {
                    int xx=af[i][j].first,yy=af[i][j].second;
                    for(int kk=0;kk<4;kk++)
                    {
                        int x=xx+dir[kk][0],y=yy+dir[kk][1];
                        if(x<0||x>=n||y<0||y>=m||id[x][y]==0)continue;

                        for(int k=0;k<4;k++)
                    {
                        int X=x+dir[k][0],Y=y+dir[k][1];
                        if(X<0||X>=n||Y<0||Y>=m||id[X][Y]==0)continue;
                        bmap[id[X][Y]][id[x][y]]=bmap[id[x][y]][id[X][Y]]=1;
                    }}
                }
            }
        }
        return;
    }
    else
    {
        used[cnt]=1;
        dfs(cnt+1);
        used[cnt]=0;
        dfs(cnt+1);
    }
}
int main()
{
      int T;
      int cns=0;
      scanf("%d",&T);
      while(T--)
      {
          mmax=-1;
          memset(id,0,sizeof(id));
          memset(used,0,sizeof(used));
          memset(bx,0,sizeof(bx));
          memset(by,0,sizeof(by));
          for(int i=0;i<11;i++)
              af[i].clear();
          kn=0;
          scanf("%d%d",&n,&m);
          for(int i=0;i<n;i++)
          {
              scanf("%s",g[i]);
              for(int j=0;j<m;j++)
              {
                  if(g[i][j]=='.')
                  {
                      id[i][j]=++kn;
                      if((i+j)%2==0)
                          bx[kn]=1;
                          else
                              by[kn]=1;
                  }
                  else
                  {
                      mmax=max(mmax,g[i][j]-'0');
                      af[g[i][j]-'0'].push_back(make_pair(i,j));
                  }
              }
          }
          nx=kn;
          ny=kn;
          for(int i=0;i<n;i++)
              for(int j=0;j<m;j++)
              {
                  if(id[i][j]!=0)
                  {
                      for(int k=0;k<4;k++)
                      {
                          int X=i+dir[k][0];
                          int Y=j+dir[k][1];
                          if(X<0||X>=n||Y<0||Y>=m||id[X][Y]==0)continue;
                          bmap[id[i][j]][id[X][Y]]=1;
                      }
                  }
              }
              ans=-1;
              dfs(0);
              cout<<"Case #"<<++cns<<": "<<ans<<endl;
          for(int j=0; j<=nx; j++)
            {
                  for(int k=0; k<=ny; k++)
                  {
                        bmap[j][k]=0;
                  }
            }
      }
}
Kblacksmith
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HDU5556 Land of Farms 最大独立集
HandsomeHow的博客
10-05 424
链接：http://acm.hdu.edu.cn/showproblem.php?pid=5556 思路:直接枚举祖先的选不选,然后把选上的附近的删掉,然后剩下的点按做最大独立集. 祖先那边选了x个,剩下的没被删掉的点共n个,把x+y是奇数的放一边,偶数的放另一边,匹配数是m,那么结果就是x+n-m。 代码： #include #include #include #inclu
HDU5556Land of Farms 【二分匹配+最大独立集+奇偶分类】
LuRiCheng的博客
03-10 487
Land of FarmsTime Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 622 Accepted Submission(s): 201 Problem Description Farmer John and his brothers
HDU5556 Land of Farms(最大独立集)
Rain
09-28 579
题目大意： 一个N*M的矩阵，其中“.”代表空地，“0-9”代表古代建筑，我们如果选择了一个编号的古代建筑想要建立，那么对应就要将全部该编号的建筑建立起来，如果在空地上建筑，只建立当前点。问最多能够建立多少种建筑，并且每两种建筑之间没有公共边。 题目意识比较难懂，我们来分析一下第一组样例： [cpp] view plain copy
HDU 5556 Land of Farms 【最大独立点集】
hxh的博客
07-03 297
题目链接 题意：N*M的图中有一些旧农场，现在要建立一些新的农场，如果新的农场覆盖了某一个旧的农场中的一个点，它就必须覆盖整个这个旧农场。现在要建立尽可能多的新农场，使得每个新农场之间都不相邻，求最多能建立多少个新农场。 很容易想到最大独立点集这东西，把每个旧农场看成一个点，不是农场的点看成一个点，在相邻的之间建边，求最大独立点集即可。 最大独立点集=补图的最大独立团，因此求出补图的最大独立...
hdu 5556 Land of Farms【思维+暴力枚举+最大独立集】好题！
mengxiang000000
09-30 1135
Land of Farms Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 526    Accepted Submission(s): 174 Problem Description Farmer John and hi
Land of Farms HDU - 5556最大独立集
CURRYWANG97的博客
11-14 244
题目大意： 分析： 首先，由于古老的东西数目比较少，可以枚举选择了哪些古老的东西，然后删除古老的东西和选择的古老的东西四周的点，对于剩下的点跑匈牙利匹配。 ans=选择的古老的种类+剩下的点-二分图匹配/2 #include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;cstring&gt; #include &lt;cstdi...
HDU 5556 Land of Farms（枚举+二分图匹配）
yasolx的博客
10-01 384
Land of FarmsTime Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 526 Accepted Submission(s): 174 Problem Description Farmer John and his broth
hdu 5556 Land of Farms 最大团+暴力
weixin_30779691的博客
10-05 99
Land of Farms Time Limit: 2000/1000 MS (Java/Others)Memory Limit: 65536/65536 K (Java/Others)Total Submission(s): 539Accepted Submission(s): 177 Problem Description Farmer John and his brot...
HDU 5556 Land of Farms（枚举 匈牙利）
CillyB的博客
09-27 354
题意：N*M的矩阵，'.'代表空地，'0-9'代表古代建筑，我们如果选择了一个编号的古代建筑想要建立，那么对应就要 将该编号全部建筑建立起来，如果在空地上建筑，只建立当前点。问最多能够建立多少种建筑，并且每两种建筑之间 没有公共边。 思路:如果没有古代建筑，匈牙利就行，相邻的点建边，最后答案就是最大独立集=点数-匹配数(因为是双向边 所以/2). 这题有古代建筑，但是建筑数最多才1
HDU 6187 Destroy Walls（并查集）
01-03
使用并查集+贪心：先将已有边的权值从大到小排序，又n个点只需n-1条边，这时再遍历一遍，将有边的两点合并为一个队伍，当边的数量达到n-1时退出循环，因为此时已达到最小生成树。 边的权值由大到小排序是因为要将大...
HDU 3038 How Many Answers Are Wrong 带权并查集
01-06
一、内容 TT and FF are ... friends. Uh... very very good friends -________-b ... To begin with, TT should write down a sequence of integers-_-!!(bored). Then, FF can choose a continuous subsequence fro
hdu.rar_hdu
09-23
HDU（杭州电子科技大学在线评测系统）是一个深受程序员喜爱的在线编程练习平台，它提供了丰富的算法题目供用户挑战，帮助他们提升编程技能和算法理解能力。"hdu.rar_hdu"这个压缩包文件很可能是某位程序员整理的他在...
hdu ACM 高级程序设计习题集——全文
11-08
本篇内容主要围绕ACM（国际大学生程序设计竞赛）的高级程序设计习题集展开，介绍了如何解决一些基础的编程问题。习题集涵盖了各种类型的题目，旨在提升参赛者的算法设计和编程能力。 首题是"Sum Problem"，这是一个...
poj 1729 Jack and Jill （比较有特色的bfs）
Kblacksmith的博客
08-30 2229
Description Ever since the incident on the hill, Jack and Jill dislike each other and wish to remain as distant as possible. Jack and Jill must attend school each day; Jack attends a boys’ school whil
区间dp一般模板
Kblacksmith的博客
08-04 1658
区间dp一般由小区间推出大的区间： #include  #include  #include  #include  using namespace std; int dp[1010][1010]; int main() { for(int i=0;i  dp[i][i]=........       for(int len=1;len区间长度     {        
单调队列 例子：hdu3401 trade(dp加单调队列)
Kblacksmith的博客
09-05 1260
单调队列指的是指队列中的元素是单调的。如：{a1,a2,a3,a4……an}满足a1<=a2<=a3……<=an,a序列便是单调递增序列。同理递减队列也是存在的。单调队列出现的机会不多，而且最常和dp一起出现。单调队列是一种工具而不是解题的方法。 单调队列的出现可以简化问题，队首元素便是最大（小）值，这样，选取最大（小）值的复杂度便为o（1），由于队列的性质，每个元素入队一次，出队一次，维护队列
hdu 5929 Basic Data Structure 双端队列
Kblacksmith的博客
10-06 1203
Basic Data Structure Time Limit: 7000/3500 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 260    Accepted Submission(s): 62 Problem Description Mr. Frog
hihoCoder 1387 A Research on "The Hundred Family Surnames" 2016 ICPC 北京网络赛E题
Kblacksmith的博客
09-25 1103
#1387 : A Research on "The Hundred Family Surnames" 时间限制:3000ms 单点时限:3000ms 内存限制:256MB 描述 The Hundred Family Surnames is a classic Chinese text composed of common Chinese surn
hdu-1569(网络流)-最大点权独立集
最新发布
05-30
这是一道经典的网络流问题，可以使用最小割模型进行建模。 首先，将所有点拆成两个点，分别表示该点被选中和不被选中两种状态...具体来说，最小割的值等于被选中的点的点权之和，而最小割对应的割就是最大点权独立集。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值