HDU——2444The Accomodation of Students（BFS判二分图+最大匹配裸题）

The Accomodation of Students

Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 4915    Accepted Submission(s): 2260

Problem Description

There are a group of students. Some of them may know each other, while others don't. For example, A and B know each other, B and C know each other. But this may not imply that A and C know each other.

Now you are given all pairs of students who know each other. Your task is to divide the students into two groups so that any two students in the same group don't know each other.If this goal can be achieved, then arrange them into double rooms. Remember, only
paris appearing in the previous given set can live in the same room, which means only known students can live in the same room.

Calculate the maximum number of pairs that can be arranged into these double rooms.

 

Input

For each data set:
The first line gives two integers, n and m(1<n<=200), indicating there are n students and m pairs of students who know each other. The next m lines give such pairs.

Proceed to the end of file.

 

Output

If these students cannot be divided into two groups, print "No". Otherwise, print the maximum number of pairs that can be arranged in those rooms.

 

Sample Input

4 4
1 2
1 3
1 4
2 3
6 5
1 2
1 3
1 4
2 5
3 6

 

Sample Output

No
3

 

边数是个坑点，加到2W才过，WA好几次，题目本身比较水，就是拿来熟悉一下最大匹配的hungary算法，做了几道题发现这个算法主要思想就是不停地尝试匹配，比如A匹配B，如果B没被匹配过那就最好，匹配数+1；若B被匹配过，那就尝试看看匹配B的那个人（匹配B的此时肯定不是A）把B换掉，比如匹配B的是C，而C又可以匹配D，因此把C匹配的对象变成D，那B就空出来了，就可以被A匹配了。

代码：

#include<iostream>
#include<algorithm>
#include<cstdlib>
#include<sstream>
#include<cstring>
#include<cstdio>
#include<string>
#include<deque>
#include<stack>
#include<cmath>
#include<queue>
#include<set>
#include<map>
using namespace std;
#define INF 0x3f3f3f3f
#define MM(x,y) memset(x,y,sizeof(x))
typedef pair<int,int> pii;
typedef long long LL;
const double PI=acos(-1.0);
const int N=1010;
const int M=20010;
struct info
{
	int to;
	int pre;
}E[M];
int head[M],cnt,n,m;
int vis[N],match[N],color[N];
queue<int>Q;
void add(int s,int t)
{
	E[cnt].to=t;
	E[cnt].pre=head[s];
	head[s]=cnt++;
}
void init()
{
	MM(head,-1);
	MM(match,-1);
	MM(color,0);
	cnt=0;
	while (!Q.empty())
		Q.pop();
}
bool canmatch(int s)
{
	int i;
	color[s]=1;
	Q.push(s);
	while (!Q.empty())
	{
		int now=Q.front();
		Q.pop();
		for (i=head[now]; ~i; i=E[i].pre)
		{
			int v=E[i].to;
			if(!color[v])
			{
				color[v]=(color[now]==1?2:1);
				Q.push(v);
			}
			else if(color[v]==color[now])
				return false;
		}
	}
	return true;
}
bool dfs(int now)
{
	int i;
	for (i=head[now]; ~i; i=E[i].pre)
	{
		int v=E[i].to;
		if(!vis[v])
		{
			vis[v]=1;
			if(match[v]==-1||dfs(match[v]))
			{
				match[v]=now;
				match[now]=v;
				return true;
			}
		}
	}
	return false;
}
int hung()
{
	int r=0,i;
	for (i=1; i<=n; i++)
	{
		MM(vis,0);
		if(dfs(i))
			r++;
	}
	return r;
}
int main(void)
{
	int a,b,i;
	while (~scanf("%d%d",&n,&m))
	{
		init();
		for (i=0; i<m; i++)
		{
			scanf("%d%d",&a,&b);
			add(a,b);
		}
		!canmatch(1)?puts("No"):printf("%d\n",hung());
	}
	return 0;
}