The Accomodation of Students（二分图判断+匈牙利算法）

描述

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.

输入

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.

输出

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.

样例输入

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

样例输出

No
3

1.先要判断能否分成两组，使得每组内的人互不认识，即判断是否为二分图

2.不是二分图输出No，否则就计算两两匹配的对数

判断二分图：采用染色法+bfs（染色法是将一个点先染色，然后把和它相邻的点染成不同的颜色，如果遇到相邻点的颜色相同的情况就不是二分图）

匹配的对数：由于是两个相同的集合进行配对，所以最后将结果除2

这题的来源是hdoj，很多的题解上对于bfs那部分是只做了一次，即默认从1开始可以搜索到所有出现的点，但是这显然是不全面的，还是可能会存在有单独的集合（比如在题目样例2在加上一组：7 8），虽然那样在hdoj也可以ac，但是我觉得还是多次bfs更加合理

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;

const int N=205;
int n,m;
int maps[N][N],num[N],vis[N],flag[N],par[N];
queue<int> que;

int bfs()//多次bfs
{
    memset(vis,0,sizeof(vis));//初始都未访问
    memset(num,-1,sizeof(num));//染色数组，-1为未染，0，1则为两种不同颜色
    for(int i=1;i<=n;i++){
        if(!vis[i]){
            vis[i]=1;
            num[i]=0;
            que.push(i);
            while(!que.empty()){
                int k=que.front();
                que.pop();
                for(int j=1;j<=n;j++){
                    if(maps[k][j]){
                        if(num[j]==-1){
                            num[j]=1-num[k];
                            que.push(j);
                            vis[j]=1;
                        }
                        else if(num[k]==num[j]){
                            return 0;
                        }
                    }
                }
            }
        }
    }
    return 1;
}

int find(int x)//匈牙利算法
{
    for(int i=1;i<=n;i++){
        if(maps[x][i]==1&&!flag[i]){
            flag[i]=1;
            if(!par[i]||find(par[i])){
                par[i]=x;
                return 1;
            }
        }
    }
    return 0;
}

int main()
{
    int x,y;
    while(scanf("%d%d",&n,&m)!=EOF){
        memset(maps,0,sizeof(maps));
        for(int i=0;i<m;i++){
            scanf("%d%d",&x,&y);
            maps[x][y]=maps[y][x]=1;//关系是互相的
        }
        if(!bfs()) printf("No
");
        else{
            int sum=0;
            memset(par,0,sizeof(par));
            for(int i=1;i<=n;i++){
                memset(flag,0,sizeof(flag));
                sum+=find(i);
            }
            printf("%d
",sum/2);//两个相同集合配对结果除2
        }
        while(!que.empty()){
            que.pop();
        }
    }
    return 0;
}