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);
    }
}

 

 

转载于:https://www.cnblogs.com/vermouth/p/3832203.html