bzoj-2502 清理雪道

题意：

给出一个n个点的拓扑图，每次从任意点出发到任意点结束，要求最终每条边都至少经过一次；

求最少要走多少次；

n<=100；

题解：

最近在补一些网络流的姿势，于是就来刷刷上下界的网络流；

这道题网络流的模型比较特殊，对于每条边都有一个下界1，并且要求总流量最小；

所以这是个最小流，建图如下：

建立源S汇T；

每条原图的边(x,y)加入下界为1上界无穷的弧(x,y)；

从S到每个点x连下界为0上界无穷的边(S,x)；

从每个点x到T连下界为0上界无穷的边(x,T)；

这个图中的S->T的最小流即是答案；

而最小流不能用最大流模板直接处理，所以要像其他的上下界模型那样做一些转化；

首先建立超级源汇，将原图转化成无源汇可行流的形式；

因为现在问题变成了找可行的环流，所以要连一条(T,S)流量为正无穷的边；

由于这道题的性质这样一定存在一个可行流，此时所有的流量不一定都在(T,S)边上，也可能在某些直接连接超级源汇的路径上；

但是那些流量显然与最终答案无关，所以答案应该取在(T,S)的流量上；

然而在无源汇图上我们只能找到可行流，并不能保证其最小；

因此还需要将超级源汇干掉，删除(T,S)边，从T向S反向跑一遍最大流，尝试一些流量退掉；

那么最终得到的答案就是刚才的(T,S)流量-这个最大流了；

代码：

 #include<queue>
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define N 110
#define E 30000
using namespace std;
int next[E],to[E],flow[E],head[N],ce=1;
int du[N],dis[N],SS,TT,S,T;
queue<int>q;
void add(int x,int y,int fl)
{
	to[++ce]=y;
	flow[ce]=fl;
	next[ce]=head[x];
	head[x]=ce;
	to[++ce]=x;
	flow[ce]=0;
	next[ce]=head[y];
	head[y]=ce;
}
bool BFS()
{
	int x,i;
	memset(dis,0,sizeof(dis));
	dis[S]=1;
	q.push(S);
	while(!q.empty())
	{
		x=q.front(),q.pop();
		if(x==101)
			i=1;
		for(i=head[x];i;i=next[i])
		{
			if(flow[i]&&!dis[to[i]])
			{
				dis[to[i]]=dis[x]+1;
				q.push(to[i]);
			}
		}
	}
	return dis[T]!=0;
}
int dfs(int x,int lim)
{
	if(x==T)	return lim;
	int i,temp,ret=0;
	for(i=head[x];i;i=next[i])
	{
		if(flow[i]&&dis[to[i]]==dis[x]+1)
		{
			temp=dfs(to[i],min(flow[i],lim-ret));
			ret+=temp;
			flow[i]-=temp,flow[i^1]+=temp;
			if(ret==lim)
				return ret;
		}
	}
	if(!ret)
		dis[x]=0;
	return ret;
}
int main()
{
	int n,m,i,j,k,x,y,ans,mf,sum;
	scanf("%d",&n);
	for(x=1;x<=n;x++)
	{
		scanf("%d",&m);
		for(i=1;i<=m;i++)
		{
			scanf("%d",&y);
			add(x,y,0x3f3f3f3f);
			du[x]--;
			du[y]++;
		}
	}
	SS=n+1,TT=SS+1;
	S=TT+1,T=S+1;
	for(x=1,mf=0;x<=n;x++)
	{
		add(SS,x,0x3f3f3f3f);
		add(x,TT,0x3f3f3f3f);
		if(du[x]>0)
			add(S,x,du[x]),mf+=du[x];
		if(du[x]<0)
			add(x,T,-du[x]);
	}
	add(TT,SS,0x3f3f3f3f);
	ans=0,sum=0;
	while(BFS())
		ans+=dfs(S,0x3f3f3f3f);
	if(mf!=ans)	while(1) puts("fuck");
	sum=flow[ce];
	head[SS]=next[head[SS]];
	head[TT]=next[head[TT]];
	for(i=head[S];i;i=next[i])
		flow[i]=0,flow[i^1]=0;
	for(i=head[T];i;i=next[i])
		flow[i]=0,flow[i^1]=0;
	add(S,TT,0x3f3f3f3f);
	add(SS,T,0x3f3f3f3f);
	ans=0;
	while(BFS())
		ans+=dfs(S,0x3f3f3f3f);
	sum-=ans;
	printf("%d\n",sum);
	return 0;
}