二分图和匈牙利算法

染色法判断二分图

#include <iostream>

using namespace std;


// http://t.csdn.cn/THM8j




const int N = 100010;
const int M = 200020; // 无向图中存储一条边要占用两个空间

int n, m;

// 邻接表存储边
int h[N], e[M], ne[M], idx;

int color[N]; // 0表示还没染色，1和2表示黑白色

void insert(int a, int b)
{
	e[idx] = b;
	ne[idx] = h[a];
	h[a] = idx;
	idx++;
}

// 深度优先遍历进行染色，可以判断当前点所在连通分支是否为二分图
bool dfs(int u, int c) // 表示将u点染成c色
{
	// 将当前点染成c色
	color[u] = c;

	// 将所有与当前点相连的点染成相反色
	for (int i = h[u]; i != -1; i = ne[i])
	{
		int j = e[i];

		// 如果该点没染色，进行染色；如果染色了，判断是否染色矛盾
		if (!color[j])
		{
			// 递归染色，出现染色矛盾返回false
			if (!dfs(j, 3 - c)) // 3 - c 可以将 1->2 和 2->1
			{
				return false;
			}
		}
		else if (color[j] == c) // 染色矛盾返回false
		{
			return false;
		}
	}

	// 染色成功，返回true
	return true;
}

int main()
{
	// 初始化邻接表表头
	memset(h, -1, sizeof h);

	cin >> n >> m;

	for (int i = 0; i < m; i++)
	{
		int a, b;
		cin >> a >> b;

		insert(a, b);
		insert(b, a);
	}

	bool flag = true;
	// 遍历所有的连通分支，只有所有的连通分支都为二分图，整个图才为二分图
	for (int i = 1; i <= n; i++)
	{
		// 如果没染色的话，进行染色
		if (!color[i])
		{
			// 染色过程中如果出现矛盾（该点所在连通分支不是二分图），标志flag为false并跳出循环
			if (!dfs(i, 1))
			{
				flag = false;
				break;
			}
		}
	}

	if (flag)
	{
		cout << "True" << endl;
	}
	else
	{
		cout << "No" << endl;
	}

	return 0;
}

匈牙利算法

#include <iostream>

using namespace std;

// 匈牙利算法的前提是二分图

/*

给定一个二分图，其中左半部包含 n1 个点(编号1 ~ n1)，右半部包含 n2 个点(编号 1 ~ n2)，二分图共包含 m 条边。
数据保证任意一条边的两个端点都不可能在同一部分中。请你求出二分图的最大匹配数。

给定一个二分图G，在G的一个子图M中，M的边集 {E} 中的任意两条边都不依附于同一个顶点，则称M是一个匹配。
所有匹配中包含边数最多的一组匹配被称为二分图的最大匹配，其边数即为最大匹配数。

输入格式
第一行包含三个整数 n1、 n2和 m。
接下来 m 行，每行包含两个整数 u 和 v，表示 左半部点集中的点u 和 右半部点集中的点v 之间存在一条边。


输出格式
输出一个整数，表示二分图的最大匹配数。

*/

const int N = 510;
const int M = 100010;

int n1, n2, m;

// 邻接表存储图，只需存储左部图到右部图的边
int h[N], e[M], ne[M], idx; // e[1] = 1表示左部图的1与右部图的1点相连

int match[N]; // match[i]存储右部图的i点与左部图匹配的点，如果为0表示还未匹配到
bool st[N];


void insert(int a,int b)
{
	e[idx] = b;
	ne[idx] = h[a];
	h[a] = idx;
	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;
			}
		}
	}

	// 如果都匹配不上，则匹配失败，返回false
	return false;
}

int hungary()
{
	int res = 0; // 记录最大匹配数

	// 遍历左部图每个点
	for (int i = 1; i <= n1; i++)
	{
		// 先清空布尔数组，以便从头开始寻找右部图匹配点
		memset(st, false, sizeof st);

		// 如果找到了，匹配数+1
		if (find(i))
		{
			res++;
		}
	}

	return res;
}


int main()
{
	// 初始化邻接表表头
	memset(h, -1, sizeof h);

	cin >> n1 >> n2 >> m;

	for (int i = 0; i < m; i++)
	{
		int a, b;

		cin >> a >> b;

		insert(a, b);
	}

	cout << hungary() << endl;

	return 0;
}