hdu 3987 求割边最少的最小割

题目是求边数最少的最小割集。
网上看到了两种方法，粘一下。
第一种：

建边的时候每条边权 w = w * (E + 1) + 1;

这样得到最大流 maxflow / (E + 1) ，最少割边数 maxflow % (E + 1)

道理很简单，如果原先两类割边都是最小割，那么求出的最大流相等

但边权变换后只有边数小的才是最小割了

乘（E+1）是为了保证边数叠加后依然是余数，不至于影响求最小割的结果

因为假设最小割=k，那么现在新图的最小割为k*（E+1)+p，p为割的边数，本质上是，原来你割一条边，需要代价，

由于你要求边数最小 所以你多割一条边，就多一的代价，但是这个代价不足以影响到原来的代价。
原来割一条边，代价xi，现在割一条边，代价xi*A+1，只要让A>m+1，m为边数，即使割了所有的边，自己加上去的代价也就m

第二种：

建图，得到最大流后，图中边若满流，说明该边是最小割上的边

再建图，原则：满流的边改为容量为 1 的边，未满流的边改为容量 INF 的边，然后最大流即答案

算出那些可以在最小割集中的边，然后变成一个求最小割边的网络流，那些不可能在最小割集中的边，我们就不能割它们，所以cost为inf

另外，最小割边集合增广路没啥关系，一个错误观点：

一条增广路上面只要割一条边就好。例如：

S->1 2

1->2 1

1->3 1

2->T oo

3->T oo

这当然是两条增广路，但是最小割边当然是一条。

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#define maxn 10000
#define inf 1ll<<60
#define mod 100001
#define maxm 500000
int n,m;
int level[maxn],que[maxn];
int head[maxn],lon;
__int64 min(__int64 a,__int64 b)
{
if(a<b) return a;
else return b;
}
struct EDGE
{
int next,to;
__int64 c;
}e[maxm];
void edgeini()
{
memset(head,-1,sizeof(head));
lon=-1;
}
void edgemake(int from,int to,__int64 c)
{
e[++lon].c=c;
e[lon].to=to;
e[lon].next=head[from];
head[from]=lon;
}
void make(int from,int to,__int64 c)
{
edgemake(from,to,c);
edgemake(to,from,0);
}

bool makelevel(int s,int t)
{
memset(level,0,sizeof(level));
int front=1,end=0;
que[++end]=s;
level[s]=1;
while(front<=end)
{
int u=que[front++];
if(u==t) return true;
for(int k=head[u];k!=-1;k=e[k].next)
{
int v=e[k].to;
if(!level[v]&&e[k].c)
{
que[++end]=v;
level[v]=level[u]+1;
}
}
}
return false;
}

__int64 dfs(int now,int t,__int64 maxf)
{
if(now==t||maxf==0) return maxf;
__int64 ret=0;
for(int k=head[now];k!=-1;k=e[k].next)
{
int u=e[k].to;
if(level[u]==level[now]+1&&e[k].c)
{
__int64 f=dfs(u,t,min(e[k].c,maxf-ret));
e[k].c-=f;
e[k^1].c+=f;
ret+=f;
if(ret==maxf) return ret;
}
}
if(ret==0) level[now]=0;
return ret;
}

__int64 maxflow(int s,int t)
{
__int64 ret=0;
while(makelevel(s,t))
{
ret+=dfs(s,t,inf);
}
return ret;
}

int main()
{
int cas;
int sum=0;
scanf("%d",&cas);
while(cas--)
{
sum++;
int i,j;
int u,v,flag;
__int64 w;
scanf("%d%d",&n,&m);
edgeini();
for(i=1;i<=m;i++)
{
scanf("%d%d%I64d%d",&u,&v,&w,&flag);
make(u,v,w*mod+1);
if(flag==1) make(v,u,w*mod+1);
}
printf("Case %d: %d\n",sum,maxflow(0,n-1)%mod);
}
}