【HDU5556 2015合肥赛区E】【最大团or二分图匹配】Land of Farms 不同编号不相邻条件下的最大农场数

最新推荐文章于 2019-07-27 22:38:58 发布
最新推荐文章于 2019-07-27 22:38:58 发布
阅读量2.1k 收藏 1
点赞数 1
分类专栏： 图论-二分图匹配(匈牙利算法) 图论-最大团 题库-HDU 文章标签： ACM HDU 最大团 匈牙利算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/snowy_smile/article/details/49866239
版权


Land of Farms

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 68    Accepted Submission(s): 34


Problem Description
Farmer John and his brothers have found a new land. They are so excited and decide to build new farms on the land. The land is a rectangle and consists of   N×M grids. A farm consists of one or more connected grids. Two grids are adjacent if they share a common border, i.e. their Manhattan distance is exactly 1. In a farm, two grids are considered connected if there exist a series of adjacent grids, which also belong to that farm, between them.

Farmer John wants to build as many farms as possible on the new land. It is required that any two farms should not be adjacent. Otherwise, sheep from different farms would fight on the border. This should be an easy task until several ancient farms are discovered.

Each of the ancient farms also consists of one or more connected grids. Due to the respect to the ancient farmers, Farmer John do not want to divide any ancient farm. If a grid from an ancient farm is selected in a new farm, other grids from the ancient farm should also be selected in the new farm. Note that the ancient farms may be adjacent, because ancient sheep do not fight each other.

The problem is a little complicated now. Can you help Farmer John to find a plan with the maximum number of farms?
 

Input
The first line of input contains a number   T  indicating the number of test cases ( T≤200 ).

Each test case starts with a line containing two integers   N  and   M , indicating the size of the land. Each of the following   N  lines contains   M  characters, describing the map of the land ( 1≤N,M≤10 ). A grid of an ancient farm is indicated by a single digit (0-9). Grids with the same digit belong to the same ancient farm. Other grids are denoted with a single character “ .”. It is guaranteed that all test cases are valid.
 

Output
For each test case, output a single line consisting of “ Case #X: Y”.   X  is the test case number starting from 1.   Y  is the maximum number of new farms.
 

Sample Input 
      
      

       
       3
3 4
..3.
023.
.211
2 3
...
...
4 4
1111
1..1
1991
1111
 

Sample Output 
      
      

       
       Case #1: 4
Case #2: 3
Case #3: 1
 

Source
2015ACM/ICPC亚洲区合肥站-重现赛（感谢中科大）
 


【HDU5556 2015合肥赛区E】【最大团or二分图匹配】Land of Farms 不同编号不相邻条件下的最大农场数 最大团做法

#include<stdio.h> 
#include<iostream>
#include<string.h>
#include<ctype.h>
#include<math.h>
#include<map>
#include<set>
#include<vector>
#include<queue>
#include<string>
#include<algorithm>
#include<time.h>
#include<bitset>
using namespace std;
void fre(){freopen("c://test//input.in","r",stdin);freopen("c://test//output.out","w",stdout);}
#define MS(x,y) memset(x,y,sizeof(x))
#define MC(x,y) memcpy(x,y,sizeof(x))
#define MP(x,y) make_pair(x,y)
#define ls o<<1
#define rs o<<1|1
typedef long long LL;
typedef unsigned long long UL;
typedef unsigned int UI;
template <class T> inline void gmax(T &a,T b){if(b>a)a=b;}
template <class T> inline void gmin(T &a,T b){if(b<a)a=b;}
const int N=12,M=0,Z=1e9+7,ms63=1061109567;
const int dy[4]={-1,0,0,1};
const int dx[4]={0,-1,1,0};
int casenum,casei;
int n,m,id;
char a[N][N];		//原始地图
int o[N][N];		//节点标号
bool e[105][105];	//表示最大团关系，e[i][j]==1表示i与j之间没有排斥关系
int f[105][105];	//把存边方式从邻接矩阵边转化为邻接链表，以此来加快速度
int mx[105];		//mx[i]表示最大团中编号最小的点的编号>=i时的最大团答案
int ans;			//全局变量，最后得到的ans就是全局最大团
void color(int y,int x,char ch)
{
    if(y<0||y==n||x<0||x==m||a[y][x]!=ch)return;
    if(~o[y][x])return;o[y][x]=id;
    for(int i=0;i<4;++i)color(y+dy[i],x+dx[i],ch);
}
void disable(int y1,int x1,int y2,int x2)
{
    if(y2<0||y2==n||x2<0||x2==m)return;
    int o1=o[y1][x1];
    int o2=o[y2][x2];
    if(o1==o2)return;
    e[o1][o2]=e[o2][o1]=0;
}
void COLOR()
{
    id=0;MS(o,-1);
    for(int i=0;i<n;++i)
    {
        for(int j=0;j<m;++j)
        {
            if(a[i][j]=='.')
			{
				o[i][j]=id++;
			}
            else if(o[i][j]==-1)
            {
                color(i,j,a[i][j]);
                id++;
            }
        }
    }
}
void build_graph()
{
    MS(e,1);
    for(int i=0;i<n;++i)
    {
        for(int j=0;j<m;++j)
        {
            for(int k=0;k<4;k++)
            {
                disable(i,j,i+dy[k],j+dx[k]);
            }
        }
    }
}
int mcp(int num,int p)
{
    if(!p)//没有边则直接更新答案
    {
        if(num>ans){ans=num;return 1;}
        else return 0;
    }
    for(int i=0;i<p;++i)//枚举当前节点可以延展的所有节点
    {
		//如果把接下来的所有点都加入最大团中，还无法更新答案的话，返回no
        if(num+p-i<=ans)return 0;
		//如果把目前编号最小的节点所能延展的所有点都加进最大团中，还无法更新答案的话，返回no
        int u=f[num][i];if(mx[u]+num<=ans)return 0;
        int k=0;
        for(int j=i+1;j<p;++j)if(e[u][f[num][j]])f[num+1][k++]=f[num][j];
        if(mcp(num+1,k))return 1;
    }
    return 0;
}
void MCP()
{
    MS(f,0);
	MS(mx,0);
	ans=0;
	//从后向前，枚举每个点i为最大团中编号最小的点，以此为起点展开搜索
    for(int i=id-1;~i;--i)
    {
		int k=0;
		for(int j=i+1;j<id;++j)if(e[i][j])f[1][k++]=j;
		mcp(1,k);
		mx[i]=ans;
    }
}
int main()
{
    scanf("%d",&casenum);
    for(casei=1;casei<=casenum;++casei)
    {
        scanf("%d%d",&n,&m);
        for(int i=0;i<n;++i)scanf("%s",a[i]);
		COLOR();
		build_graph();
		MCP();
        printf("Case #%d: %d\n",casei,ans);
    }
}
/*
【trick&&吐槽】
题意说不清，题意有毒……这时需要枚举题意，猜解样例Orz

【题意】
给你一个n（10）*m（10）的棋盘。
格子上的'.'代表可以建造新式农场的点，每个新建的农场是独立的，拥有独立的编号。
格子上的'1'~'9'代表可以建造上古农场的点，相同的数字构成的联通块代表相同的上古农场，相同的上古农场共享一个编号。
如果我们要建造一个上古农场，就必须建立其整个联通块。
对于一个编号的农场，其上下左右相邻处不能有其他编号的农场。
基于以上原则，我们希望建造尽可能多数量的农场。
让你输出这个最大数量。

【类型】
最大团or二分图匹配

【分析】
首先看到这道题点数很少，最大供选择农场数才不过100，而且涉及到"我选了你就不能选"这样的限制条件，于是我们考虑到最大团。
于是——
第一步：求出所有联通块，也就是可能的不同编号的农场数量，并进行编号、染色。
第二步：然后初始化一个全为1的bool矩阵,e[i][j]==1的话表示i和j编号的农场可以同时选。
之后我们对于每个点，向上下左右四个方向走，如果编号不同，那么不同这2个农场不能同时选，在e[][]中标记。
之后对e[][]跑个最大团即可。
本代码里的最大团模板是0base，就是节点编号从0开始，速度很快哦~~啦啦啦！

然而，这道题的正解是二分图匹配，其时间复杂度为O(10^2 * nm * VE)。
O(VE)是匈牙利算法的时间复杂度，最坏情况下是100*200，也就是可以控制使得单组时间复杂度为2e7。

【数据】
1
10 10
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........

*/

【HDU5556 2015合肥赛区E】【最大团or二分图匹配】Land of Farms 不同编号不相邻条件下的最大农场数 匈牙利做法

#include<stdio.h> 
#include<iostream>
#include<string.h>
#include<ctype.h>
#include<math.h>
#include<map>
#include<set>
#include<vector>
#include<queue>
#include<string>
#include<algorithm>
#include<time.h>
#include<bitset>
using namespace std;
void fre(){freopen("c://test//input.in","r",stdin);freopen("c://test//output.out","w",stdout);}
#define MS(x,y) memset(x,y,sizeof(x))
#define MC(x,y) memcpy(x,y,sizeof(x))
#define MP(x,y) make_pair(x,y)
#define ls o<<1
#define rs o<<1|1
typedef long long LL;
typedef unsigned long long UL;
typedef unsigned int UI;
template <class T> inline void gmax(T &a,T b){if(b>a)a=b;}
template <class T> inline void gmin(T &a,T b){if(b<a)a=b;}
const int N=12,M=0,Z=1e9+7,ms63=1061109567;
const int dy[4]={-1,0,0,1};
const int dx[4]={0,-1,1,0};
int casenum,casei;
int n,m,num,ans;
char a[N][N];
bool e[N][N];		//e[i][j]==1表示(i,j)这个'.'是可以通过二分匹配的方式选取的
bool u[10];			//u[i]==1表示'0'+i这个数字是被我们枚举选取的
vector<int>b[105];	//b[i]存放i号点（i号点为偶点）可以匹配的点的编号
int p[105];			//p[j]表示j号点（j号点为奇点）实现匹配的点的编号
bool vis[105];		//vis[i]表示i号点（i号点是偶点）是否匹配访问过
map<int,int>mop;
bool color()
{
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)if(isdigit(a[i][j])&&u[a[i][j]-'0'])
		{
			for(int d=0;d<4;d++)
			{
				int y=i+dy[d];
				int x=j+dx[d];
				if(y<0||y==n||x<0||x==m)continue;
				if(a[y][x]=='.')e[y][x]=0;
				else if(a[y][x]!=a[i][j]&&u[a[y][x]-'0'])return 0;
			}
		}
	}
	return 1;
}
void build_graph()
{
	for(int i=0;i<n*m;i++)b[i].clear();
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)if(a[i][j]=='.'&&e[i][j]&&(i+j)%2==0)
		{

			for(int d=0;d<4;d++)
			{
				int y=i+dy[d];
				int x=j+dx[d];
				if(y<0||y==n||x<0||x==m||a[y][x]!='.'||!e[y][x]||(y+x)%2==0)continue;
				int o1=i*m+j;
				int o2=y*m+x;
				b[o1].push_back(o2);
			}
		}
	}
}
int hungary(int x)
{
	vis[x]=1;
	for(int i=b[x].size()-1;~i;i--)
	{
		int y=b[x][i];
		if(p[y]==-1){p[y]=x;return 1;}
	}
	for(int i=b[x].size()-1;~i;i--)
	{
		int y=b[x][i];
		if(!vis[p[y]]&&hungary(p[y])){p[y]=x;return 1;}
	}
	return 0;
}
void HUNGARY()
{
	MS(p,-1);
	int sum=0;
	int tmp=0;
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)if(a[i][j]=='.'&&e[i][j])
		{
			++sum;
			MS(vis,0);
			if(hungary(i*m+j))++tmp;
		}
	}
	gmax(ans,sum-tmp+num);
}
int main()
{
    scanf("%d",&casenum);
    for(casei=1;casei<=casenum;++casei)
    {
        scanf("%d%d",&n,&m);
		ans=0;
        for(int i=0;i<n;++i)scanf("%s",a[i]);
		mop.clear();int id=0;
		for(int i=0;i<n;i++)
		{
			for(int j=0;j<m;j++)if(isdigit(a[i][j]))
			{
				if(mop.find(a[i][j])==mop.end())mop[a[i][j]]=id++;
				a[i][j]=mop[a[i][j]]+'0';
			}
		}
		int top=1<<id;
		for(int i=0;i<top;i++)
		{
			MS(e,1);
			MS(u,0);
			int p=0;
			int x=i;
			num=0;
			while(x)
			{
				if(x&1)u[p]=1,++num;
				x>>=1;
				++p;
			}
			if(color())
			{
				build_graph();
				HUNGARY();
			}
		}
        printf("Case #%d: %d\n",casei,ans);
    }
}
/*
【trick&&吐槽】
题意说不清，题意有毒……这时需要枚举题意，猜解样例Orz

【题意】
给你一个n（10）*m（10）的棋盘。
格子上的'.'代表可以建造新式农场的点，每个新建的农场是独立的，拥有独立的编号。
格子上的'1'~'9'代表可以建造上古农场的点，相同的数字构成的联通块代表相同的上古农场，相同的上古农场共享一个编号。
如果我们要建造一个上古农场，就必须建立其整个联通块。
对于一个编号的农场，其上下左右相邻处不能有其他编号的农场。
基于以上原则，我们希望建造尽可能多数量的农场。
让你输出这个最大数量。

【类型】
最大团or二分图匹配

【分析】
2^10枚举选取的远古农场，
然后把选取的远古农场周围的'.'标记为不可选取。
对于剩余的可以选取的'.'，从奇点向相邻的偶点连边，
然后跑二分图最大匹配，
用"可以选取的'.'总数-最大匹配数+枚举选取的远古农场数"更新答案

【数据】
input
1
10 10
..........
..........
..........
..........
..........
..........
..........
..........
..........
..........
output
50

*/


snowy_smile
关注
专栏目录
HDU 2063 过山车 【匈牙利算法，二分图最大匹配】
AC_Dreameng
10-06 1426
二分图最大匹配入门题，话不多说，看代码。
二分图匹配
Edward The Bunny 的博客
10-20 2827
定义： 二分图：一个图被分成了两部分，相同的部分没有边 匹配：二分图G的子图M中，M的边集{E}中的任意两条边都不指向同一个顶点 极大匹配：在当前已完成的匹配下,无法再通过增加未完成匹配的边的方式来增加匹配的边数 最大匹配：是所有极大匹配当中边数最大的一个匹配 完全匹配（完备匹配）：一个匹配中，图中的每个顶点都和图中某条边相关联 有什么用： 定理1：最小点覆盖数 = 最大匹配数 点覆盖：点集合使得任意一条边至少有一个端点在集合中 定理2：最大独立集 = 顶点数 - 最大匹配数
hdu5556 Land of Farms
diankeng5481的博客
09-21 130
我对于题目的一种理解 改造农场 1.建新农场 在空的点选 2.重建旧农场 选一个点属于这个农场的地方都要选 最后的农场都不能相连 所以枚举旧农场的个数并进行二分图匹配 #include<bits/stdc++.h> using namespace std; int N,M; char mp[12][12]; vector<pair...
HDU5556 Land of Farms(二分图 2015 合肥区域赛)
Nobel7889的专栏
09-23 151
容易想到将问题转化为求图的独立数问题 ，但求一般图的独立集是一个NPC问题，需要一些转化。 状态压缩，枚举每个上古农场是否选择，然后将剩下的新农场根据i + j奇偶性分为x , y集。 结果为 max(tot + nx + ny - 二分图匹配数) #include<cstdio> #include<iostream> #include...
HDU5556：Land of Farms（图的最大独立集 & 最大团）
junior19的博客
10-18 535
Farmer John and his brothers have found a new land. They are so excited and decide to build new farms on the land. The land is a rectangle and consists of N×MN×Mgrids. A farm consists of one or more
『HDU 5556』Land of Farms
Gavinjou大笨象的博客
10-02 437
题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=5556 转载链接:http://blog.csdn.net/mengxiang000000/article/details/52712864题意:（题意特别难理解）有个农夫,想在发现的新大陆中开荒养羊, ‘.’代表没开荒的地, ‘数字’代表已经开荒过的旧农场. 农夫呢想做新农场尽可能多,而且新农场和新农
HDU5556 Land of Farms(最大独立集)
Rain
09-28 593
题目大意： 一个N*M的矩阵，其中“.”代表空地，“0-9”代表古代建筑，我们如果选择了一个编号的古代建筑想要建立，那么对应就要将全部该编号的建筑建立起来，如果在空地上建筑，只建立当前点。问最多能够建立多少种建筑，并且每两种建筑之间没有公共边。 题目意识比较难懂，我们来分析一下第一组样例： [cpp] view plain copy
二分图匹配实例代码及整理
12-26
二分图匹配实例代码及整理 1、匈牙利算法 HDU 1150 #include #include #include using namespace std; int m,n,k; int vis[105]; int mpt[105][105]; int use[105]; int hungary(int x) { for(int i=1;i<m;i++)...
算法讲解：二分图匹配
热门推荐
thunderMrbird的博客
08-23 5万+
二分图匹配，自然要先从定义入手，那么二分图是什么呢？ 二分图： 二分图又称作二部图，是图论中的一种特殊模型。 设G=(V,E)是一个无向图，如果顶点V可分割为两个互不相交的子集(A,B)，并且图中的每条边（i，j）所关联的两个顶点i和j分别属于这两个不同的顶点集(i in A,j in B)，则称图G为一个二分图。 简单的说，一个图被分成了两部分，相同的部分没有边，那这个图就是二分图，二
(二分图最大权匹配，KM算法）+【详细注释】（算法详解+我要上非诚勿扰~~）+【例题HDU 2255】
超逸の学习技术博客
07-27 643
现在有N男N女，它们来到了非诚勿扰！这次是女生牵手男生环节哦！ 有些男生和女生之间互相有好感，我们将其好感程度定义为好感度，我们希望把他们两两配对，并且最后希望好感度和最大。 ①怎么选择最优的配对方法呢？ 首先，每个女生会有一个期望值，就是与她有好感度的男生中最大的好感度。男生呢，期望值为0，就是……只要有一个妹子就可以啦，不挑~~ 这样，我们把每个人的期望值标出来。 ②接下来，开始配对。 配...
HDU-5556 Land of Farms(无向图的最大独立集)
yo_bc的博客
09-29 627
2015ACM/ICPC亚洲区合肥站 Farmer John and his brothers have found a new land. They are so excited and decide to build new farms on the land. The land is a rectangle and consists of N×MN×M grids. A farm consists of one or more connected grids. Two grids are adjace
HDU 5556 Land of Farms 【最大独立点集】
hxh的博客
07-03 298
题目链接 题意：N*M的图中有一些旧农场，现在要建立一些新的农场，如果新的农场覆盖了某一个旧的农场中的一个点，它就必须覆盖整个这个旧农场。现在要建立尽可能多的新农场，使得每个新农场之间都不相邻，求最多能建立多少个新农场。 很容易想到最大独立点集这东西，把每个旧农场看成一个点，不是农场的点看成一个点，在相邻的之间建边，求最大独立点集即可。 最大独立点集=补图的最大独立团，因此求出补图的最大独立...
hdu 5556 Land of Farms（二分图匹配）
不慌不忙、不急不躁
11-14 1674
题目链接：hdu 5556 Land of Farms解题思路枚举哪些位置是重建的，重建的周围位置不能用，其他空地用做二分图匹配最大独立集。代码#include <cstdio> #include <cstring> #include <cstdlib> #include <vector> #include <algorithm>using namespace std; typedef pair<i
hdu 5556 Land of Farms【思维+暴力枚举+最大独立集】好题！
mengxiang000000
09-30 1145
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
HDU - 5556 Land of Farms 枚举 + 无向二分图最大独立集
WA是一笔财富
10-02 266
题意：有一个农场大小为n*m  里面有一些古老的农田，你现在需要新建一些农田，要求新建的农田之间不能相连，古老的农田不可拆分，如果你选择了一块土地（原为古老的农田）建立新农田则该新农田需要把一整块连通的古老的农田全部包含。问最多能新建多少个农田。 思路：由于古老的农田只有10个，因此我们可以枚举选哪几个古老的农田，然后对于剩下的空地，相邻空地之间建边，求一个二分图的最大独立集就是剩下的空地中最多
HDU 5556 Land of Farms 最大团
とある黄鱼のOIブログ
04-18 960
一个N*M的矩阵，一个农场会覆盖一片连通的区域，新农场与其他农场不可相邻，新农场可以建在空地上，也可以完全地占据一个旧农场，旧农场(不超过10个)已给定，问最多能安排多少个农场？考虑将将旧农场的所有格子缩成1点，空地保持1格1点，那么问题就变成求图的最大独立点集，求补图的最大团即可。#include <cstdio> #include <cstring> using namespace std; #
hdoj 5556 Land of Farms 【DFS + 最大独立集->补图最大团】
世界很大
11-14 1045
Land of Farms Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 19    Accepted Submission(s): 13 Problem Description Farmer John and
HDU 5556
u012896700的专栏
12-08 820
题意：  有一个农场大小为n*m  里面有一些古老的农田，你现在需要新建一些农田，要求新建的农田之间不能相连，古老的农田不可拆分，如果你选择了一块土地（原为古老的农田）建立新农田则需要把该块古老的农田全部包含。 解法： 如果没有古老的农田只要对所有空地和它相邻的空地建边，然后求一遍最大独立集即可。     所以我们需要移除古老的农田的影响，因为古老的农田最多只有10块，所以我们只需要枚举
HDU5556 Land of Farms 最大独立集
HandsomeHow的博客
10-05 452
链接：http://acm.hdu.edu.cn/showproblem.php?pid=5556 思路:直接枚举祖先的选不选,然后把选上的附近的删掉,然后剩下的点按做最大独立集. 祖先那边选了x个,剩下的没被删掉的点共n个,把x+y是奇数的放一边,偶数的放另一边,匹配数是m,那么结果就是x+n-m。 代码： #include #include #include #inclu
匈牙利算法求解二分图最大匹配
匈牙利算法是求解二分图最大匹配的一种经典方法，其核心思想是利用Hall定理，该定理指出存在一个使所有顶点饱和的匹配的充分必要条件是：对于集合X的任何子集A，与A相邻的点集T(A)的大小至少等于A的大小。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值