LA 4597 Inspection 网络流路径覆盖

LA 4597

题意：给一个有向图，求最小路径覆盖并且输出路径，不过走过的路径可以重复走。

思想是借鉴这位大佬：UVA1440 有下界的最小流，这位大佬写的相当详细，赞，首先设d[ i ]为节点 i 的入度-出度的值，如果路径不可重复走，那么最小路径覆盖就是所有d[ i ]为负数的和sum，不过路径是可以重复走的，那么有些边在不可重复走中只能走一次，但是在这题中可以走多次，这些边满足性质：起点u的d[ i ]>0，终点v的d[ i ]<0，那么就连接s-->u，v-->t，再求一次最大流flow，那么答案就是sum-flow。贴个刘汝佳风格的Dinic算法代码。

#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
const int maxn=105;
const int inf=1e8;
struct Edge{
	int from,to,cap,flow;
}; 	
vector<Edge>edges;
vector<int>G[maxn];
struct Dinic{
	int n,m,s,t;
	bool vis[maxn];
	int d[maxn];
	int cur[maxn];
	void init(int n)
	{
		edges.clear();
		for(int i=0;i<n;i++)
		G[i].clear();
	}
	void AddEdge(int from,int to,int cap)
	{
		edges.push_back((Edge){from,to,cap,0});
		edges.push_back((Edge){to,from,0,0});
		m=edges.size();
		G[from].push_back(m-2);
		G[to].push_back(m-1);
	}
	bool bfs()
	{
		memset(vis,0,sizeof(vis));
		queue<int>Q;
		Q.push(s);
		d[s]=0;
		vis[s]=1;
		while(!Q.empty())
		{
			int x=Q.front();Q.pop();
			for(int i=0;i<G[x].size();i++)
			{
				Edge& e=edges[G[x][i]];
				if(!vis[e.to]&&e.cap>e.flow)
				{
					vis[e.to]=1;
					d[e.to]=d[x]+1;
					Q.push(e.to); 
				}
			}
		}
		return vis[t];
	}
	int dfs(int x,int a){
		if(x==t||a==0)return a;
		int flow=0,f;
		for(int& i=cur[x];i<G[x].size();i++){
			Edge& e=edges[G[x][i]];
			if(d[x]+1==d[e.to]&&(f=dfs(e.to,min(a,e.cap-e.flow)))>0){
				e.flow+=f;
				edges[G[x][i]^1].flow-=f;
				flow+=f;
				a-=f;
				if(!a)break;
			}
		}
		return flow;
	}
	int maxflow(int s,int t)
	{
		this->s=s,this->t=t;
		int flow=0;
		while(bfs()){
			memset(cur,0,sizeof(cur));
			flow+=dfs(s,inf);
		}
		return flow;
	}
}solver; 
int n,m,u,s,t,ans,d[maxn];
vector<int>V;
void dfs(int u)
{
	V.push_back(u);
	for(int i=0;i<G[u].size();i++)
	{
		Edge e=edges[G[u][i]];
		if(e.cap==0||e.to==s||e.to==t)
		continue;
		G[u].erase(find(G[u].begin(),G[u].end(),G[u][i]));//走完这条边就删掉这条边 
		dfs(e.to);
		break;
	}
}
void print()
{
	for(int u=1;u<=n;u++)
	{
		int len=G[u].size();
		for(int i=0;i<len;i++)
		{
			Edge e=edges[G[u][i]];
			if(e.flow<=0||e.to==t||e.to==s||e.cap==0)
			continue;
			for(int j=0;j<e.flow;j++)
			solver.AddEdge(u,e.to,1);//补边 
			d[u]-=e.flow;//补边之后要改变度数 
			d[e.to]+=e.flow;
		}	
	}
	for(int i=1;i<=n;i++)
	while(d[i]<0)
	{
		d[i]++;
		dfs(i);
		int len=V.size();
		for(int j=0;j<len-1;j++)
		printf("%d ",V[j]);
		printf("%d\n",V[len-1]);
		V.clear();
	}
}
int main()
{
	while(~scanf("%d",&n))
	{
		solver.init(maxn);
		s=0,t=n+1,ans=0;
		memset(d,0,sizeof(d));
		for(int i=1;i<=n;i++)
		{
			scanf("%d",&m);
			while(m--)
			{
				scanf("%d",&u);
				solver.AddEdge(i,u,inf);
				d[i]--,d[u]++;
			}
		}
		for(int i=1;i<=n;i++)
		if(d[i]<0)
		ans-=d[i],solver.AddEdge(i,t,-d[i]);
		else if(d[i]>0)
		solver.AddEdge(s,i,d[i]);
		printf("%d\n",ans-=solver.maxflow(s,t));
		print();
	}
}