[网络流24题]最小路径覆盖问题

最小路径覆盖问题

题目描述 ：

给定有向图G=(V,E)。设P 是G 的一个简单路（顶点不相交）的集合。如果V 中每个

顶点恰好在P 的一条路上，则称P是G 的一个路径覆盖。P 中路径可以从V 的任何一个顶

点开始，长度也是任意的，特别地，可以为0。G 的最小路径覆盖是G 的所含路径条数最少

的路径覆盖。

设计一个有效算法求一个有向无环图G 的最小路径覆盖。

对于给定的给定有向无环图G，编程找出G的一个最小路径覆盖。

输入格式：

件第1 行有2个正整数n和m。n是给定有向无环图G 的顶点数，m是G 的边数。接下来的m行，每行有2 个正整数i和j，表示一条有向边(i,j)。

输出格式：

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

输入样例#1：

11 12

1 2

1 3

1 4

2 5

3 6

4 7

5 8

6 9

7 10

8 11

9 11

10 11

输出样例#1：

1 4 7 10 11

2 5 8

3 6 9

3

说明：

1<=n<=150,1<=m<=6000

1<=n<=150,1<=m<=6000

题解：

在网络流24题中应该算是比较简单的题了，根据每个点只能覆盖一次的性质，将每个点拆成左右两份，分别向s，t连上一条容量为1的边(保证最多流过一次)，然后对在原图中连通的点两两连边，最后结果ans=点数-最大流。

建图如图所示：

代码：

#include<cstdio>
#include<iostream>
#include<cstring>
#include<queue>
using namespace std;

const int max_m = 13001;
const int max_n = 301;

bool b[max_n];
int point[max_m],nxt[max_m],v[max_m],remain[max_m];
int cur[max_m],deep[max_n];
int n,m,s,t,inf=1e9,tot,x,y;

inline void clear()
{
	memset(point,-1,sizeof(point));
	memset(nxt,-1,sizeof(nxt));
	tot=-1;
}

inline void addedge(int x,int y,int val)
{
	++tot; nxt[tot]=point[x]; point[x]=tot; v[tot]=y; remain[tot]=val;
	++tot; nxt[tot]=point[y]; point[y]=tot; v[tot]=x; remain[tot]=0;
}

inline bool bfs(int s,int t)
{
	memset(deep,0x7f,sizeof(deep));
	for(int i=s; i<=t; ++i)
	  cur[i]=point[i];
	queue<int> q;
	deep[s]=0;
	q.push(s);
	
	while(!q.empty())
	{
		int now=q.front(); q.pop();
		for(int i=point[now]; i!=-1; i=nxt[i])
		  if(deep[v[i]]>inf && remain[i])
		  {
		  	deep[v[i]]=deep[now]+1;
		  	q.push(v[i]);
		  }
	}
	
	return deep[t]<inf;
}

inline int dfs(int now,int t,int limit)
{
	if(now==t || limit==0) return limit;
	int flow=0,f;
	
	for(int i=cur[now]; i!=-1; i=nxt[i])
	{
		cur[now]=i;
		if(deep[now]+1==deep[v[i]] && (f=dfs(v[i],t,min(limit,remain[i]))))
	    {
	  	  flow+=f;
	  	  limit-=f;
	  	  remain[i]-=f;
	  	  remain[i^1]+=f;
	  	  if(!limit) break;
	    }
	}
	
	return flow;
}

inline int dinic(int s,int t)
{
	int ans;
	
	while(bfs(s,t))
	  ans+=dfs(s,t,inf);
	return ans;
}

inline void output()
{
	int ans=dinic(s,t);
	
	for(int i=1; i<=n; ++i)//输出方案 
	  if(!b[i])
	  {
	  	printf("%d ",i);
	  	b[i]=true;
		int j=point[i];
		
		while(j!=-1)
		{
			if(!remain[j] && v[j]!=s && v[j]!=t)
			{
				b[v[j]-n]=true;
				printf("%d ",v[j]-n);
	  	  	    j=point[v[j]-n];
	  	  	    continue;
			}
			else j=nxt[j];
		}
		printf("\n");
	  }
	  
	printf("%d\n",n-ans);
}

int main()
{
	scanf("%d%d",&n,&m);
	clear();
	s=0; t=2*n+1;
	
	for(int i=1; i<=n; ++i)
	{
		addedge(s,i,1);
		addedge(i+n,t,1);
	}
	
	for(int i=1; i<=m; ++i)
	{
		scanf("%d%d",&x,&y);//在原图中所连的点进行连边 
		addedge(x,y+n,1);
	}
	
	output();
	return 0;
}