【二分图】【二分图最大匹配】LCP 04. 覆盖

作者推荐

视频算法专题

本文涉及知识点

二分图 二分图最大匹配

LeetCode LCP 04. 覆盖

你有一块棋盘，棋盘上有一些格子已经坏掉了。你还有无穷块大小为1 * 2的多米诺骨牌，你想把这些骨牌不重叠地覆盖在完好的格子上，请找出你最多能在棋盘上放多少块骨牌？这些骨牌可以横着或者竖着放。
输入：n, m代表棋盘的大小；broken是一个b * 2的二维数组，其中每个元素代表棋盘上每一个坏掉的格子的位置。
输出：一个整数，代表最多能在棋盘上放的骨牌数。
示例 1：
输入：n = 2, m = 3, broken = [[1, 0], [1, 1]]
输出：2
解释：我们最多可以放两块骨牌：[[0, 0], [0, 1]]以及[[0, 2], [1, 2]]。（见下图）

示例 2：
输入：n = 3, m = 3, broken = []
输出：4
解释：下图是其中一种可行的摆放方式

限制：
1 <= n <= 8
1 <= m <= 8
0 <= b <= n * m

二分图

图G所有点可以分为两个子集X,Y。子集合X内部的点没有边相连,子集Y内部也是。X$\in$[0,n)
二分图的判断方法：
染色法，任何一点开始染成红色，邻接点染成黑色，看是否冲突。
可以用： 深度优先或广度优先或并集查找

二分图的最大匹配

保证任何点最多选取一次的情况下，选取最多的边。
典型用例：一组老师，一组学生，如果老师x和学生y互相有好感，则可以组队教学。任何老师只能参加一个队伍，学生也是。
交叉路径：选取边和未选取边交叉出现。
增广路径：以非选取边开始，非选取边结束的交叉路径。由于边数是奇数，所以一定x起点，y终点或y起点,x终点。不失一般性，我们以x为起点。
增广路径的选择边和非选择边互换，选择边增加。
用匈牙利算法来实现Find：
枚举x in X，如果x是一个增广路径的起点，则x匹配此路径的第二个节点。
枚举y， y 是x的临接点，且不在此路径中。如果y没有匹配，则x$\to$y 是增广路径，vMath[y]=x。
如果已经匹配，看Find(vMath[y]) 是否成功 ，如果成功，也是增广路径。vMath[y] = x。
如果所有临接点都匹配失败，则x匹配失败。
性质一：无论是手动调用，还是递归调用。都只会Find(子集X的节点)。
性质二：用变量used记录，那些Y节点在本次路径。我们从小到大枚举x，则Find(x)开始事，vMath[y]$\in$ [0,x) ;Find(x)结束后，vMath[y]$\in$ [0,x]。所有无需记录那些x已经使用。
长度为3的增广路径：x1->y1 同时 x2和y1连通 x1和y2连通
则find(x2)调用find(x1)时： x1->y2连通,且y2没有匹配，于是vMath[y2]=x1
find(x2)本体中：vMath[y1]=x2 $$\underline{x2\to y1}\to \underline{x1\to y2}$$

证明：
如果找不到以x为起点的增广路径，则选择几条边，就需要删除几条边。边数不变。

代码

核心代码

class CNeiBo
{
public:	
	static vector<vector<int>> Two(int n, vector<vector<int>>& edges, bool bDirect, int iBase = 0) 
	{
		vector<vector<int>>  vNeiBo(n);
		for (const auto& v : edges)
		{
			vNeiBo[v[0] - iBase].emplace_back(v[1] - iBase);
			if (!bDirect)
			{
				vNeiBo[v[1] - iBase].emplace_back(v[0] - iBase);
			}
		}
		return vNeiBo;
	}	
	static vector<vector<std::pair<int, int>>> Three(int n, vector<vector<int>>& edges, bool bDirect, int iBase = 0)
	{
		vector<vector<std::pair<int, int>>> vNeiBo(n);
		for (const auto& v : edges)
		{
			vNeiBo[v[0] - iBase].emplace_back(v[1] - iBase, v[2]);
			if (!bDirect)
			{
				vNeiBo[v[1] - iBase].emplace_back(v[0] - iBase, v[2]);
			}
		}
		return vNeiBo;
	}
	static vector<vector<int>> Grid(int rCount, int cCount, std::function<bool(int, int)> funVilidCur, std::function<bool(int, int)> funVilidNext)
	{
		vector<vector<int>> vNeiBo(rCount * cCount);
		auto Move = [&](int preR, int preC, int r, int c)
		{
			if ((r < 0) || (r >= rCount))
			{
				return;
			}
			if ((c < 0) || (c >= cCount))

			{
				return;
			}
			if (funVilidCur(preR, preC) && funVilidNext(r, c))
			{
				vNeiBo[cCount * preR + preC].emplace_back(r * cCount + c);
			}
		};

		for (int r = 0; r < rCount; r++)
		{
			for (int c = 0; c < cCount; c++)
			{
				Move(r, c, r + 1, c);
				Move(r, c, r - 1, c);
				Move(r, c, r, c + 1);
				Move(r, c, r, c - 1);
			}
		}
		return vNeiBo;
	}
	static vector<vector<int>> Mat(vector<vector<int>>& neiBoMat)
	{
		vector<vector<int>> neiBo(neiBoMat.size());
		for (int i = 0; i < neiBoMat.size(); i++)
		{
			for (int j = i + 1; j < neiBoMat.size(); j++)
			{
				if (neiBoMat[i][j])
				{
					neiBo[i].emplace_back(j);
					neiBo[j].emplace_back(i);
				}
			}
		}
		return neiBo;
	}
};

class CBipartiteGraph
{
public:
	int MaxMatch()
	{
		m_vYToX.assign(m_vY.size() + m_vX.size(),-1);
		int ans = 0;
		for (const auto& x : m_vX)
		{
			m_vUsed.assign(m_vY.size() + m_vX.size(),false);
			ans += Find(x);
		}
		return ans;
	}
	bool Find(int x)
	{		
		for (const auto& y : m_vNeiBo[x])
		{
			if (m_vUsed[y])
			{
				continue;
			}
			m_vUsed[y] = true;
			if ((-1 == m_vYToX[y]) || (Find(m_vYToX[y])))
			{
				m_vYToX[y] = x;
				return true;
			}
		}
		return false;
	}
	vector<int> m_vX, m_vY;
	vector<vector<int>> m_vNeiBo;
	vector<int> m_vYToX;
	vector<bool> m_vUsed;
};
class Solution {
public:
	int domino(int n, int m, vector<vector<int>>& broken) {
		vector<vector<int>> grid(n, vector<int>(m));
		for (const auto& v : broken)
		{
			grid[v[0]][v[1]] = 1;
		}
		auto vilidFun = [&grid](int r, int c) {return 0 == grid[r][c]; };
		CBipartiteGraph bg;
		for (int r = 0; r < n; r++)
		{
			for (int c = 0; c < m; c++)
			{
				const int mask = m * r + c;
				if ((r + c) & 1)
				{
					bg.m_vY.emplace_back(mask);
				}
				else
				{
					bg.m_vX.emplace_back(mask);
				}
			}
		}
		bg.m_vNeiBo = CNeiBo::Grid(n, m, vilidFun, vilidFun);		
		return bg.MaxMatch();
	}
};

测试用例

template<class T, class T2>
void Assert(const T& t1, const T2& t2)
{
	assert(t1 == t2);
}

template<class T>
void Assert(const vector<T>& v1, const vector<T>& v2)
{
	if (v1.size() != v2.size())
	{
		assert(false);
		return;
	}
	for (int i = 0; i < v1.size(); i++)
	{
		Assert(v1[i], v2[i]);
	}

}

int main()
{
	int m, n;
	vector<vector<int>> broken;
	{
		Solution sln;
		n = 3, m = 3, broken = {  };
		auto res = sln.domino(n, m, broken);
		Assert(4, res);
	}
	{
		Solution sln;
		n = 2, m = 3, broken = { {0, 0},{0, 1} };
		auto res = sln.domino(n, m, broken);
		Assert(2, res);
	}
	{
		Solution sln;
		n = 2, m = 3, broken = { {1, 0},{1, 1} };
		auto res = sln.domino(n, m, broken);
		Assert(2, res);
	}
	
	{
		Solution sln;
		n = 4, m = 3, broken = { {1,0},{1,1} };
		auto res = sln.domino(n, m, broken);
		Assert(5, res);
	}
	{
		Solution sln;
		n = 3, m = 4, broken = { {2,2},{2,3} };
		auto res = sln.domino(n, m, broken);
		Assert(5, res);
	}

}

扩展阅读

视频课程

有效学习：明确的目标 及时的反馈 拉伸区（难度合适），可以先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快
速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

相关下载

想高屋建瓴的学习算法，请下载《喜缺全书算法册》doc版
https://download.csdn.net/download/he_zhidan/88348653

我想对大家说的话
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛

测试环境

操作系统：win7 开发环境： VS2019 C++17
或者 操作系统：win10 开发环境： VS2022 C++17
如无特殊说明，本算法用**C++**实现。