染色法
一个图是二分图 当且仅当 她可以被2染色（不含有奇数环）
流程如下，先找到一个不在集合中的点 把他放在左边
然后遍历这个点有连接的点，把这些点放到右边，再依次遍历放到右边的点的邻点
模板
int n; // n表示点数
int h[N], e[M], ne[M], idx; // 邻接表存储图
int color[N]; // 表示每个点的颜色，-1表示未染色，0表示白色，1表示黑色
// 参数：u表示当前节点，c表示当前点的颜色
bool dfs(int u, int c)
{
color[u] = c;
for (int i = h[u]; i != -1; i = ne[i])
{
int j = e[i];
if (color[j] == -1)
{
if (!dfs(j, !c)) return false;
}
else if (color[j] == c) return false;
}
return true;
}
bool check()
{
memset(color, -1, sizeof color);
bool flag = true;
for (int i = 1; i <= n; i ++ )
if (color[i] == -1)
if (!dfs(i, 0))
{
flag = false;
break;
}
return flag;
}
例题
给定一个 n 个点 m 条边的无向图，图中可能存在重边和自环。
请你判断这个图是否是二分图。
输入格式
第一行包含两个整数 n 和 m。
接下来 m 行，每行包含两个整数 u 和 v，表示点 u 和点 v 之间存在一条边。
输出格式
如果给定图是二分图，则输出
Yes，否则输出No。数据范围
1≤n,m≤105
输入样例：
4 4 1 3 1 4 2 3 2 4输出样例：
Yes
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 100010,M = 200010;
int n,m;
bool flag = true;
int h[N],e[M],ne[M],idx;
int color[N];
void add(int a,int b)
{
e[idx] = b;
ne[idx] = h[a];
h[a] = idx++;
}
bool dfs(int u,int c)
{
color[u] = c;
for (int i = h[u]; i != -1 ; i = ne[i]) {
int j = e[i];
if (!color[j])
{
if (!dfs(j,3-c)) return false;
}else if(color[j] == c){
return false;
}
}
return true;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
memset(h,-1,sizeof h);
while(m--)
{
int a,b;
cin >> a >> b;
add(a,b);
add(b,a);
}
for (int i = 1; i <= n ; ++i) {
if (!color[i])
{
if (!dfs(i,1))
{
flag = false;
break;
}
}
}
if (flag)
{
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
}
匈牙利算法
可以求出，左边和右边匹配成功的最大数量是多少，成功是指不存在两条边是共用的两个点
例如如下图
我们从左一开始找，找到右二进行尝试，此时右二并没有配对，所以右二和左一配对成功
依次类推左二可以和右一配对
但是左三只能和右二配对但是右二已经和左一配对
这个时候我们找到右二配对的左一 是否有其他边，显然左一还可以和右四配对
这样最终匹配的数量就是 4
模板
int n1, n2; // n1表示第一个集合中的点数，n2表示第二个集合中的点数
int h[N], e[M], ne[M], idx; // 邻接表存储所有边，匈牙利算法中只会用到从第一个集合指向第二个集合的边，所以这里只用存一个方向的边
int match[N]; // 存储第二个集合中的每个点当前匹配的第一个集合中的点是哪个
bool st[N]; // 表示第二个集合中的每个点是否已经被遍历过
bool find(int x)
{
for (int i = h[x]; i != -1; i = ne[i])
{
int j = e[i];
if (!st[j])
{
st[j] = true;
if (match[j] == 0 || find(match[j]))
{
match[j] = x;
return true;
}
}
}
return false;
}
// 求最大匹配数，依次枚举第一个集合中的每个点能否匹配第二个集合中的点
int res = 0;
for (int i = 1; i <= n1; i ++ )
{
memset(st, false, sizeof st);
if (find(i)) res ++ ;
}
例题
给定一个二分图，其中左半部包含 n1 个点（编号 1∼n1），右半部包含 n2 个点（编号 1∼n2），二分图共包含 m 条边。
数据保证任意一条边的两个端点都不可能在同一部分中。
请你求出二分图的最大匹配数。
二分图的匹配：给定一个二分图 G，在 G 的一个子图 M 中，M 的边集 {E} 中的任意两条边都不依附于同一个顶点，则称 M 是一个匹配。
二分图的最大匹配：所有匹配中包含边数最多的一组匹配被称为二分图的最大匹配，其边数即为最大匹配数。
输入格式
第一行包含三个整数 n1、 n2 和 m。
接下来 m 行，每行包含两个整数 u 和 v，表示左半部点集中的点 u 和右半部点集中的点 v 之间存在一条边。
输出格式
输出一个整数，表示二分图的最大匹配数。
数据范围
1≤n1,n2≤500,
1≤u≤n1,
1≤v≤n2,
1≤m≤105输入样例：
2 2 4 1 1 1 2 2 1 2 2输出样例：
2
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 100010,M = 200010;
int n1,n2,m;
int h[N],e[M],ne[M],idx;
int match[N]; // 右边的点对应的点
bool st[N]; //判重，每次不要重复搜一个点
void add(int a,int b)
{
e[idx] = b;
ne[idx] = h[a];
h[a] = idx++;
}
bool find(int x)
{
// 枚举这个点所有可能的点
for (int i = h[x]; i != -1 ; i = ne[i]) {
int j = e[i];
if (!st[j])
{
st[j] = true;
if (match[j] == 0 || find(match[j]))
{
match[j] = x;
return true;
}
}
}
return false;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n1 >> n2 >> m;
memset(h,-1,sizeof h);
while(m--)
{
int a,b;
cin >> a >> b;
add(a,b);
}
int res = 0;
for (int i = 1; i <= n1; ++i) {
memset(st,false,sizeof st);
if (find(i))
{
res++;
}
}
cout << res << endl;
return 0;
}