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

关注

原创最新推荐文章于 2026-05-05 09:38:20 发布 632 阅读 AI 写同款· GEO 优化 ›

【最小边覆盖 & 最小路径覆盖 & 最小顶点覆盖 & 最大独立集 & 最大团】最小边覆盖 = 最大独立集 = |V| - 最大匹配数这个是在原图是二分图上进行的最小路径覆盖和最小边覆盖不同，不要求给的图是二分图，而是要求是N x N的有向图，不能有环，然后根据原图构造二分图，构造方法是将点一分为二，如，i分为i1和i2然后如果i和j有边，那么就在i1和j2之间连一条边。由此构成二分图 然后最小路径覆盖 = n-m，n为原图的点的个数，m为新造二分图 阅读详情

一.二分图最大独立集

定义：

对于一张无向图 $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;
}