二分图多重匹配与二分图多重最优匹配(知识点整理+板子整理)(二分图多重最优匹配板子待整理)

思路来源

https://blog.csdn.net/luozhong11/article/details/52430572

https://blog.csdn.net/qq_37352710/article/details/88037456

知识点整理

1.二分图多重匹配

二分图匹配，但规定一些点可以和多个点匹配，

不妨设这条边的最大匹配量为L

 

法一：网络流

建网络流图，二分图左端点和右端点的边仍存在，

源点S连二分图左端点，流量为最大匹配量L，

汇点T连二分图右端点，流量为最大匹配量L

二分图匹配，Dinic的复杂度能跑到，很稳

 

求最大流即答案

以 HihoCoder - 1393 网络流三·二分图多重匹配 为例

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#include<map> 
using namespace std;
typedef long long ll;
const int INF=0x3f3f3f3f;
const int maxn=210;
const int maxm=maxn*maxn*2;
int level[maxn];
int head[maxn],cnt;
int t,n,m,u,v,x,y;
int S,T,ans,sum;
struct edge{int v,nex;ll w;}e[maxm];
void init()
{
	sum=cnt=0;
	memset(head,-1,sizeof head);
}
void add(int u,int v,ll w)
{
	e[cnt].v=v;
	e[cnt].w=w;
	e[cnt].nex=head[u];
	head[u]=cnt++;
}
void add2(int u,int v,ll w,bool op)//是否为有向图 
{
	add(u,v,w);
	add(v,u,op?0:w);
}
bool bfs(int s,int t)
{
	queue<int>q;
	memset(level,0,sizeof level);
	level[s]=1;
	q.push(s);
	while(!q.empty())
	{
		int x=q.front();
		q.pop();
		if(x==t)return 1;
		for(int u=head[x];~u;u=e[u].nex)
		{
			int v=e[u].v;ll w=e[u].w;
			if(!level[v]&&w)
			{
				level[v]=level[x]+1;
				q.push(v);
			}
		}
	}
	return 0;
}
ll dfs(int u,ll maxf,int t)
{
	if(u==t)return maxf;
	ll ret=0;
	for(int i=head[u];~i;i=e[i].nex)
	{
		int v=e[i].v;ll w=e[i].w;
		if(level[u]+1==level[v]&&w)
		{
			ll MIN=min(maxf-ret,w);
			w=dfs(v,MIN,t);
			e[i].w-=w;
			e[i^1].w+=w;
			ret+=w;
			if(ret==maxf)break;
		}
	}
	if(!ret)level[u]=-1;//优化,防止重搜,说明u这一路不可能有流量了 
	return ret;
}
ll Dinic(int s,int t)
{
	ll ans=0;
	while(bfs(s,t))
	ans+=dfs(s,INF,t);
	return ans;
}
int main()
{ 
    scanf("%d",&t);
    //n个点 m条边 
    while(t--)
    {
    	init();
    	scanf("%d%d",&n,&m);
    	S=n+m+1;T=n+m+2;
		for(int i=1;i<=m;++i)
    	{
    		//v为右点i的流量限制 
    		scanf("%d",&v);
    		sum+=v;
    		add2(i+n,T,v,1);
    	}
    	for(int i=1;i<=n;++i)
    	{
    		//x为左点i的流量限制 y为左点与右点相连边数 
    		scanf("%d%d",&x,&y);
    		add2(S,i,x,1);
    		for(int j=1;j<=y;++j)
    		{
    			scanf("%d",&v);
    			add2(i,v+n,1,1);
    		}
    	}
    	ans=Dinic(S,T);
    	if(ans==sum)puts("Yes");
    	else puts("No");
    }
	return 0;
}

法二：二分图匹配拆点(不常用)

把最大匹配量为L的点，拆成L个二分图匹配的点，分别连边

跑一遍二分图匹配，考虑到L很大的时候建图会爆炸，所以一般不考虑

 

法三：魔改二分图匹配

模拟匈牙利增广过程，

如果对于当前点，匹配量不满L，直接返回可匹配

否则去check当前已匹配的一个点，观察其是否可增广，可增广再返回可匹配

也就是对于右集合的每个点，都有一个sz限制，

局限性也就在，左边集合和右边集合无法同时有L的限制

只能解决一边有L限制的情况

以POJ - 3189 Steady Cow Assignment为例，二分+二分图多重匹配

#include<iostream>
#include<cstdio> 
#include<cstring>
#include<vector>
using namespace std;
const int N=1e3+5;
bool vis[N];
int mp[N][22],mx[22];//mx:右yi节点流量限制 
int head[N],cnt,ans;
int t,n,m,u,v;
struct edge{int to,next,w;}e[N*N*2];
struct node
{
	int cnt;//右yi节点的匹配个数
	int k[N];//与右yi匹配的左节点xi的集合 
}link[N];
void init()
{
	memset(head,0,sizeof head);
	cnt=0;
}
void add(int u,int v)
{
	e[++cnt].to=v;
	e[cnt].next=head[u];
	head[u]=cnt;
}
//mx为u对应的流量 可以先建图再跑 
bool dfs(int u)
{
	for(int i=head[u];i;i=e[i].next)
	{
		int v=e[i].to;
		if(!vis[v])
		{
			vis[v]=1;
			if(link[v].cnt<mx[v])
			{
				link[v].k[link[v].cnt++]=u;
				return 1;
			}
			for(int j=0;j<link[v].cnt;++j)
			{
				if(dfs(link[v].k[j]))
				{
					link[v].k[j]=u;
					return 1;
				}
			}
		}
	}
	return 0;
}
bool hungary(int n)
{
	memset(link,0,sizeof link);
	for(int u=1;u<=n;++u)
	{
		memset(vis,0,sizeof vis);
		if(!dfs(u))return 0;
	}
	return 1;
}
bool ok(int len)
{
	for(int l=1;l+len-1<=m;++l)//建[l,l+len-1]的图 
	{
		init();
		int r=l+len-1;
		for(int i=1;i<=n;++i)
		{
			for(int j=l;j<=r;++j)
			add(i,mp[i][j]);
		}
		if(hungary(n))return 1;
	}
	return 0;
}
int main()
{
	while(~scanf("%d%d",&n,&m))
	{
		for(int i=1;i<=n;++i)
		{
			for(int j=1;j<=m;++j)
			{
				scanf("%d",&mp[i][j]);
			}
		}
		for(int i=1;i<=m;++i)
		scanf("%d",&mx[i]);
		int L=0,R=m;//二分最大rank和最小rank的差值 
		while(L<=R)
		{
			int mid=(L+R)/2;
			if(ok(mid))R=mid-1;
			else L=mid+1;
		}
		printf("%d\n",L);
	}
	return 0;
}

2.二分图多重最优匹配

即二分图最大权匹配，但允许一个点匹配多个点

 

法一：最大费用最大流

建网络流图，二分图左端点和右端点的边仍存在，流量为1，费用为边权

源点S连二分图左端点，流量为最大匹配量L，费用为0，

汇点T连二分图右端点，流量为最大匹配量L，费用为0

求该图的最大费用最大流，即为原图的最大权