二分图最大独立集&最小路径点覆盖

最新推荐文章于 2020-04-22 21:42:14 发布

置顶 Modestr-E·X·L

最新推荐文章于 2020-04-22 21:42:14 发布

阅读量546

点赞数

本文链接：https://blog.youkuaiyun.com/Modestr/article/details/105115984

版权

本文介绍了二分图的最大独立集和最小路径点覆盖问题。最大独立集求解方法是通过最大匹配来计算，文章通过[LGOJ]P3355和[LGOJ]P5030题目详细讲解了应用实例。最小路径点覆盖则可以通过转换为最大流问题来解决，以[LGOJ]P2764为例展示了求解过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一.二分图最大独立集

定义：

对于一张无向图 $G (V, E)$ ，选出一个 $V$ 的子集 $S$ ，使得 $S$ 中任意两点之间都没有边，且 $S$ 是最大这样的子集。

求解方法：

二分图的最大独立集的点的数量=总点数N-最大匹配

简单的证明：要使得独立集越大，那么删掉的点就要越少，同时话要保证删掉的点覆盖到所有边，所以删掉的因该是最小点覆盖。

例题：

Example1:[LGOJ]P3355 骑士共存问题:

总结：

能攻击的点，颜色都是不一样的，颜色一0样就意味着不冲突，一定可以放骑士。
这是一张“二分图”，如果我们把冲突的两个格子连边，相当于隔开。
每一个格子都是一个点，而每个格子只能放一个骑士，能选出来多少格子，最大独立集就是骑士的数量
所以答案为 $n * n - m -$ 最大匹配数

注意奇数建图&偶数建图的差距，奇数建图会TLE！！！

代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn=1000005;
const int maxm=5005;
const int dx[8]={-1,-2,-2,-1,1,2,2,1};
const int dy[8]={-2,-1,1,2,2,1,-1,-2};
int n,m,tot,ans;
bool ban[maxm][maxm],vis[maxn];
int match[maxn],head[maxn];
vector<int> nd;
struct node
{
	int from,next,to;
}edge[maxn];
inline int read()
{
	int s=0,f=1;
	char c=getchar();
	while (c<'0'||c>'9')
	{
		if (c=='-')
		{
			f=-1;
		}
		c=getchar();
	}
	while (c>='0'&&c<='9')
	{
		s=s*10+c-48;
		c=getchar();
	}
	return s*f;
}
inline void add(int x,int y)
{
	edge[++tot].next=head[x];
	edge[tot].from=x;
	edge[tot].to=y;
	head[x]=tot;
}
inline bool dfs(int u)
{
	for (int i=head[u];i;i=edge[i].next)
	{
		int v=edge[i].to;
		if (!vis[v])
		{
			vis[v]=1;
			if (match[v]==-1||dfs(match[v]))
			{
				match[v]=u;
				return 1;
			}
		}
	}
	return 0;
}
int main()
{
	n=read(),m=read();
	int x,y;
	for (int i=1;i<=m;i++)
	{
		x=read(),y=read();
		ban[x][y]=1;
	}
	for (int i=1;i<=n;i++)
	{
		for (int j=1;j<=n;j++)
		{
			if (!ban[i][j]&&(i+j)%2)
			{
				nd.push_back(n*(i-1)+j);
				for (int k=0;k<8;k++)
				{
					int cur_x=i+dx[k],cur_y=j+dy[k];
					if (cur_x<1||cur_x>n||cur_y<1||cur_y>n)
					{
						continue;
					}
					if (!ban[cur_x][cur_y])
					{
						add(n*(i-1)+j,n*(cur_x-1)+cur_y);
					}
				}
			}
		}
	}
	memset(match,-1,sizeof(match));
	for (int i=0;i<nd.size();i++)
	{
		memset(vis,0,sizeof(vis));
		ans+=dfs(nd[i]);
	}
	cout<<n*n-m-ans;
	return 0;
}
/*
TLE72pts
#include<bits/stdc++.h>
using namespace std;
const int maxn=1005;
const int maxm=2000005;
int dx[9]={1,1,2,2,-1,-1,-2,-2};
int dy[9]={2,-2,1,-1,2,-2,1,-1};
int n,m,k,tot=-1,cnt,ans;
int head[maxm],match[maxm],num[maxn][maxn];
bool vis[maxm],ban[maxn][maxn];
struct node
{
	int from,to,next;
}edge[maxm];
inline int read()
{
	int s=0,f=1;
	char c=getchar();
	while (c<'0'||c>'9')
	{
		if (c=='-')
		{
			f=-1;
		}
		c=getchar();
	}
	while (c>='0'&&c<='9')
	{
		s=s*10+c-48;
		c=getchar();
	}
	return s*f;
}
void add(int x,int y)
{
	edge[++tot].next=head[x];
	edge[tot].from=x;
	edge[tot].to=y;
	head[x]=tot;
}
bool dfs(int u)
{
	for (int i=head[u];i;i=edge[i].next)
	{
		int v=edge[i].to;
		if (!vis[v])
		{
			vis[v]=1;
			if (!match[v]||dfs(match[v]))
			{
				match[v]=u;
				return true;
			}
		}
	}
	return false;
}
int main()
{
	n=read(),m=read();
	for (int i=1;i<=m;i++)
	{
		int x=read(),y=read();
		ban[x][y]=1;
	}
	for (int i=1;i<=n;i++)
	{
		for (int j=1;j<=n;j++)
		{
			num[i][j]=++cnt;
		}
	}
	for (int i=1;i<=n;i++)
	{
		for (int j=1;j<=n;j++)
		{
			if (ban[i][j])
			{
				continue;
			}
			else
			{
				for (int k=0;k<8;k++)
				{
					int cur_x=i+dx[k],cur_y=j+dy[k];
					if (cur_x>0&&cur_x<=n&&cur_y>0&&cur_y<=n&&!ban[cur_x][cur_y])
					{
						add(num[i][j],num[cur_x][cur_y]);
						add(num[cur_x][cur_y],num[i][j]);
					}
				}
			}
		}
	}
	for (int i=1;i<=cnt;i++)
	{
		memset(vis,0,sizeof(vis));
		if (dfs(i))
		{
			ans++;
		}
	}
	cout<<(n*n)-m-(ans/2)<<endl;
	return 0;
}
*/

Example2: [LGOJ]P5030 长脖子鹿放置

很显然这是一个二分图最大独立子集问题，由题面很容易联想到[LGOJ]P3355 骑士共存问题。但是那题的建图方式显然不能照搬。我们考虑按照行的奇偶性建立二分图。（列的奇偶性也可以）

在这里插入图片描述
因为长脖子鹿只能跳到当前行-3，-1，+1，+3这四行中的任意一行，所以我们可以得出:
长脖子鹿仅能从奇数行跳到偶数行和从偶数行跳到奇数行。
通过这个性质我们对棋盘稍加改造（按照行的奇偶性染色）：
在这里插入图片描述
我们将能互相攻击到的格子进行连边，这样建出来的图显然满足二分图的定义
因为骑士共存问题可以用图的遍历顺序优化+匈牙利水过去，这是我们就可以用图的遍历顺序优化+匈牙利水过去，时间复杂度为O（能过）

代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn=1000005;
const int maxm=1005;
int n,m,e,tot,ans;
int head[maxn],match[maxn],vis[maxn],obstacle[maxm][maxm];
int dx[8]={-3,-3,-1,-1,1,1,3,3};
int dy[8]={-1,1,-3,3,-3,3,-1,1};
struct node
{
	int from,to,next;
}edge[maxn];
inline int get_pos(int x,int y)
{
	return (x-1)*m+y;
}
inline int add(int x,int y)
{
	edge[++tot].next=head[x];
	edge[tot].from=x;
	edge[tot].to=y;
	head[x]=tot;
}
inline int read()
{
	int s=0,f=1;
	char c=getchar();
	while (c<'0'||c>'9')
	{
		if (c=='-')
		{
			f=-1;
		}
		c=getchar();
	}
	while (c>='0'&&c<='9')
	{
		s=s*10+c-48;
		c=getchar();
	}
	return s*f;
}
inline bool dfs(int x)
{
	for (int i=head[x];i;i=edge[i].next)
	{
		int y=edge[i].to;
		if (vis[y]==false)
		{
			vis[y]=true;
			if (match[y]==0||dfs(match[y])==true)
			{
				match[y]=x;
				return true;
			}
		}
	}
}
int main()
{
	n=read(),m=read(),e=read();
	for (int i=1;i<=e;i++)
	{
		int x=read(),y=read();
		obstacle[x][y]=1;
	}
	for (int i=1;i<=n;i+=2)
	{
		for (int j=1;j<=m;j++)
		{
			if (obstacle[i][j])
			{
				continue;
			}
			for (int k=0;k<8;k++)
			{
				int cur_x=i+dx[k],cur_y=j+dy[k];
				if (cur_x<1||cur_y<1||cur_x>n||cur_y>m||obstacle[cur_x][cur_y])
				{
					continue;
				}
				add(get_pos(i,j),get_pos(cur_x,cur_y));
			}
		}
	}
	for (int i=1;i<=n;i+=2)
	{
		for (int j=1;j<=m;j++)
		{
			if (!obstacle[i][j])
			{
				memset(vis,0,sizeof(vis));
				ans+=dfs(get_pos(i,j));
			}
		}
	}
	cout<<n*m-e-ans<<endl;
	return 0;
}
/*
8 7 5
1 1
5 4
2 3
4 7
8 3
*/

二.最小路径点覆盖

定义：

对于一张有向无环图DAG，用最少的简单路径（没有重复经过点的）覆盖所有点。每一个点恰好被覆盖一次。这样的问题就是有向无环图的最小路径点覆盖

解法：

如何求DAG的最小路径点覆盖

首先将原图的每一个点拆成 $x$ 和 $（ x + n ）$ ，这样就可以分成 $1 - n$ 和 $n + 1$ 到 $2 n$ 两个点集
然后，在原图中 $x - > y$ 的这条边，转换成 $x - > (y + n)$ ,得到一张新图 $G^{'}$
原图的最小路径点覆盖== $N - G^{'}$ 的最大匹配

例题：

Example1:[LGOJ]P2764 最小路径覆盖问题

给定有向图 $G = (V, E) G = (V, E)$ 。设 $P$ 是 $G$ 的一个简单路(顶点不相交)的集合。如果 $V$ 中每个定点恰好在PP的一条路上，则称 $P$ 是 $G$ 的一个路径覆盖。 $P$ 中路径可以从 $V$ 的任何一个定点开始，长度也是任意的，特别地，可以为 $0$ 。 $G$ 的最小路径覆盖是 $G$ 所含路径条数最少的路径覆盖。设计一个有效算法求一个 $G A P$ (有向无环图) $G$ 的最小路径覆盖。

提示：设 $V=\{1,2,...,n\}V={1,2,...,n}$ 构造网络 $G_1=\{V_1,E_1\}$ 如下
$V1 ={x 0 ,x 1 ,...,x n }∪{y 0 ,y 1 ,...,y n }$
$E 1 ={(x 0 ,x i ):i∈V}∪{(y i ,y 0 ):i∈V}∪{(x i ,y j ):(i,j)∈E}$
每条边的容量均为 11 ，求网络 $G_1$ 的 $x_0,y_0)$ 最大流。

输入格式
第一行有 $2$ 个正整数 $n$ 和 $m$ 。 $n$ 是给定 $\text{GAP}$ (有向无环图) $G$ 的顶点数， $m$ 是 $G$ 的边数。接下来的 $m$ 行,每行有两个正整数 $i$ 和 $j$ 表示一条有向边 $(i, j)$ 。

输出格式
从第1 行开始，每行输出一条路径。文件的最后一行是最少路径数。

Solution:

一道二分图的题，在网络流上体现为：最小路径覆盖=点的总数-网络最大流。在这里插入图片描述
拆点后源点向 $1 n$ 连接权为1的边， $n + 1 - > 2 n$ 向汇点连权为1的边
对于原图中相连的两个点 $x - > y$ ，二分图中体现为 $x - > y + n$
最后的方案可以利用残量网络用并查集维护
即从 $1$ 到 $n$ 枚举，从每个点向外扫一圈，如果有流从这条边经过，并流向 $y + n$ ，则合并 $x$ 与 $y$
然后 $n^2$ 输出方案即可。

二分图代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn=1005;
const int maxm=1000005;
int n,m,tot,ans;
int head[maxn],match[maxn];
bool vis[maxn];
struct edge
{
	int from,next,to;
}edge[maxm];
inline int read()
{
	int s=0,f=1;
	char c=getchar();
	while (c<'0'||c>'9')
	{
		if (c=='-')
		{
			f=-1;
		}
		c=getchar();
	}
	while (c>='0'&&c<='9')
	{
		s=s*10+c-48;
		c=getchar();
	}
	return s*f;
}
void add(int x,int y)
{
	edge[++tot].next=head[x];
	edge[tot].from=x;
	edge[tot].to=y;
	head[x]=tot;
}
bool dfs(int x)
{
	for (int i=head[x];i;i=edge[i].next)
	{
		int v=edge[i].to;
		if (!vis[v])
		{
			vis[v]=1;
			if (!match[v]||dfs(match[v]))
			{
				match[x]=v;
				match[v]=x;
				return 1;
			}
		}
	}
	return 0;
}
void print(int x)
{
	x+=n;
	do
	{
		x=x-n;
		cout<<x<<" ";
	}while(vis[x]=1,x=match[x]);
	puts("");
}
int main()
{
	n=read(),m=read();
	for (int i=1;i<=m;i++)
	{
		int x=read(),y=read();
		add(x,y+n);
	}
	for (int i=1;i<=n;i++)
	{
		if (!match[i])
		{
			memset(vis,0,sizeof(vis));
			ans+=dfs(i);
		}
	}
	memset(vis,0,sizeof(vis));
	for (int i=1;i<=n;i++)
	{
		if (!vis[i])
		{
			print(i);
		}
	}
	cout<<n-ans<<endl;
	return 0;
}