最小费用最大流模板

笔者在写作这篇笔记之前做了整整两天的最大流,然后。。。发现网络流24题里有很多怎么看都是不可做的题目,于是solution了一把,发现要去切一下费用流这个东东,于是借鉴各种blog和题解,现在勉强搞懂了这个东西,所以作一篇笔记聊以记录和日后复习。

如果您还没有学习网络流的基本概念,请出门左转百度吧。。(事实是笔者太懒只整理了题目而没有详解)。

首先,先明白费用流是什么:

费用流建立在网络最大流的基础上,一张图中最大流有且仅有一个,但是最大流条数往往不止一条,这时候对于我们来说,可能要找出这些最大流中最小(或者最大)的那一条路径,这就是最小(最大)费用最大流 。

实现的基本思想:给出一张网络,那么这个网络的最大流一定是个定值(即使它有多种方法实现这个最大值),我们只要从当前可行流开始增广的时候,选择费用最少的一条路径就可以了。

我们有多种方法实现最小费用的计算:

其一:最原始的E-K算法+spfa。

这个自然没什么说的(如果您会了最大流却不知道spfa,那我也只能说您666),将弧的费用看做是路径长度,即可转化为求最短路的问题了。只需要所走的最短路满足两个条件即可:一个是残量不为0,一个是最短路的那个条件。建图的方法依题来建,不过大体建出来和DINIC差不多。

以洛谷P3381的模板题为例:

  1 #include<iostream>
  2 #include<cstdio>
  3 #include<cstring>
  4 #include<algorithm>
  5 #include<cmath>
  6 #include<queue>
  7 #define ll long long
  8 #define inf 50000000
  9 #define re register
 10 using namespace std;
 11 struct po
 12 {
 13     int from,to,dis,nxt,w;
 14 }edge[250001];
 15 int head[250001],cur[1000001],dep[60001],n,m,s,t,u,num=-1,x,y,l,tot,sum,k,fa[10001];
 16 int dis[5001],b[5001],xb[5001],flow[5001];
 17 inline int read()
 18 {
 19     int x=0,c=1;
 20     char ch=' ';
 21     while((ch>'9'||ch<'0')&&ch!='-')ch=getchar();
 22     while(ch=='-')c*=-1,ch=getchar();
 23     while(ch<='9'&&ch>='0')x=x*10+ch-'0',ch=getchar();
 24     return x*c;
 25 }
 26 inline void add_edge(int from,int to,int w,int dis)
 27 {
 28     edge[++num].nxt=head[from];
 29     edge[num].from=from;
 30     edge[num].to=to;
 31     edge[num].w=w;
 32     edge[num].dis=dis;
 33     head[from]=num;
 34 }
 35 inline void add(int from,int to,int w,int dis)
 36 {
 37     add_edge(from,to,w,dis);
 38     add_edge(to,from,0,-dis);
 39 }
 40 inline bool bfs()
 41 {
 42     memset(dis,100,sizeof(dis));
 43     memset(b,0,sizeof(b));
 44     queue<int> q;
 45     while(!q.empty())
 46     q.pop();
 47     for(re int i=1;i<=n;i++)
 48     {
 49         fa[i]=-1;
 50     }
 51     b[s]=1;dis[s]=0;fa[s]=0;
 52     flow[s]=inf;q.push(s);
 53     while(!q.empty())
 54     {
 55         int u=q.front();
 56         q.pop();
 57         b[u]=0;
 58         for(re int i=head[u];i!=-1;i=edge[i].nxt)
 59         {
 60             int v=edge[i].to;
 61             if(edge[i].w>0&&dis[v]>dis[u]+edge[i].dis)
 62             {
 63                 dis[v]=dis[u]+edge[i].dis;
 64                 fa[v]=u;
 65                 xb[v]=i;
 66                 flow[v]=min(flow[u],edge[i].w);
 67                 if(!b[v]){b[v]=1,q.push(v);}
 68             }
 69         }
 70     }
 71     return dis[t]<inf;
 72 }
 73 inline void max_flow()
 74 {
 75     while(bfs())
 76     {
 77         int k=t;
 78         while(k!=s)
 79         {
 80             edge[xb[k]].w-=flow[t];
 81             edge[xb[k]^1].w+=flow[t];
 82             k=fa[k];
 83         }
 84         tot+=flow[t];
 85         sum+=flow[t]*dis[t];
 86     }
 87 }
 88 int main()
 89 {
 90     memset(head,-1,sizeof(head));
 91     n=read();m=read();s=read();t=read();
 92     for(re int i=1;i<=m;i++)
 93     {
 94         x=read();y=read();l=read();
 95         int d=read();
 96         add(x,y,l,d);
 97     }
 98     max_flow();
 99     cout<<tot<<" "<<sum;
100 }

可以看出,虽然笔者的常数优化比较优秀,然而还是卡着时间跑过最后两个点。

其二:zkw费用流

这个方法笔者没有深究,仔细阅读之后发现要使zkw费用流算法达到最好的效率,那么必须使用KM算法。然而不会KM算法怎么办,您可以跳过这个部分,直接看第三种实现方式。

原始的EK算法虽然在做题的时候不会出很大的问题——因为现在的费用流的题目数据都不是很大。它的缺点比较明显:在增广的时候单路增广,导致速度减慢。zkw大神于是乎发明了一种可以直接多路增广的算法,并用KM算法节省了spfa或者迪杰斯特拉的时间,然而悲催的是,笔者自己也对KM算法不是很理解,抱歉无法写出程序比较一下时空复杂度。不过为了保持博文的完整性,还是放上方法发明者zkw的钦定标程:

#include <cstdio>
#include <cstring>
using namespace std;
const int maxint=~0U>>1;

int n,m,pi1,cost=0;
bool v[550];
struct etype
{
    int t,c,u;
    etype *next,*pair;
    etype(){}
    etype(int t_,int c_,int u_,etype* next_):
        t(t_),c(c_),u(u_),next(next_){}
    void* operator new(unsigned,void* p){return p;}
} *e[550];

int aug(int no,int m)
{
    if(no==n)return cost+=pi1*m,m;
    v[no]=true;
    int l=m;
    for(etype *i=e[no];i;i=i->next)
        if(i->u && !i->c && !v[i->t])
        {
            int d=aug(i->t,l<i->u?l:i->u);
            i->u-=d,i->pair->u+=d,l-=d;
            if(!l)return m;
        }
    return m-l;
}

bool modlabel()
{
    int d=maxint;
    for(int i=1;i<=n;++i)if(v[i])
        for(etype *j=e[i];j;j=j->next)
            if(j->u && !v[j->t] && j->c<d)d=j->c;
    if(d==maxint)return false;
    for(int i=1;i<=n;++i)if(v[i])
        for(etype *j=e[i];j;j=j->next)
            j->c-=d,j->pair->c+=d;
    pi1 += d;
    return true;
}

int main()
{
    freopen("costflow.in","r",stdin);
    freopen("costflow.out","w",stdout);
    scanf("%d %d",&n,&m);
    etype *Pe=new etype[m+m];
    while(m--)
    {
        int s,t,c,u;
        scanf("%d%d%d%d",&s,&t,&u,&c);
        e[s]=new(Pe++)etype(t, c,u,e[s]);
        e[t]=new(Pe++)etype(s,-c,0,e[t]);
        e[s]->pair=e[t];
        e[t]->pair=e[s];
    }
    do do memset(v,0,sizeof(v));
    while(aug(1,maxint));
    while(modlabel());
    printf("%d\n",cost);
    return 0;
}

有兴趣深究的朋友可以从博文最后访问zkw大神的博客。

其三:原始对偶算法

讲这个算法之前先说一下zkw费用流的一些不适用性,zkw大神原话:在某一些图上, 算法速度非常快, 另一些图上却比纯 SPFA 增广的算法慢. 不少同学经过实测总结的结果是稠密图上比较快, 稀疏图上比较慢。其实也不完全是因为这样。我们比较一下原始的EK和zkw算法,可以发现原始EK主要慢在spfa一遍一遍的队列操作和重复访问节点,以及只能进行单路增广的限制。而zkw算法只是一个对边的扫描操作,并且重标号后可以多路增广。然而缺点也显而易见,如果这个图是出题者别有用心制造的,那么流量不大, 费用不小, 增广路还较长,每次添加一条边,然后尝试增广,凑不成最短路,再添重标号,继续尝试。造成了大量的时间浪费。

那么有没有一种方式结合了这两种算法的优点呢?有的,我们可以用一种和dinic很相似的思路(至少笔者是这么认为)。

费用流的算法大致分为两种, 一种是经典的解法, 如消圈, 增广路, 原始对偶等等, 特点是步步为营, 维持可行性或者最优性其中之一, 再不断对另一方面作出改进. 另一种就比较现代一些, 典型的例子是松弛算法和网络单纯形, 由于放松了对求解过程中解的限制条件, 使得其速度远远超过经典解法, 同时也增加了编程难度和理解障碍. 下面要说的原始对偶算法, 速度自然不可能比松弛和网络单纯形快, 但应该是经典解法中的佼佼者了。                                                                                       ——zkw

我们在spfa的时候使用SLF优化来维护距离编号,然后利用多路增广,达到一个比较好的效果。下面放上笔者弱弱的代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<queue>
#define ll long long
#define inf 50000000
#define re register
using namespace std;
struct po
{
    int from,to,dis,nxt,w;
}edge[250001];
int head[250001],cur[1000001],dep[60001],n,m,s,t,u,num=-1,x,y,l,tot,sum,k,fa[10001];
int dis[5001],b[5001],xb[5001],flow[5001];
inline int read()
{
    int x=0,c=1;
    char ch=' ';
    while((ch>'9'||ch<'0')&&ch!='-')ch=getchar();
    while(ch=='-')c*=-1,ch=getchar();
    while(ch<='9'&&ch>='0')x=x*10+ch-'0',ch=getchar();
    return x*c;
}
inline void add_edge(int from,int to,int w,int dis)
{
    edge[++num].nxt=head[from];
    edge[num].to=to;
    edge[num].w=w;
    edge[num].dis=dis;
    head[from]=num;
}
inline void add(int from,int to,int w,int dis)
{
    add_edge(from,to,w,dis);
    add_edge(to,from,0,-dis);
}
inline bool spfa()
{
    memset(b,0,sizeof(b));
    for(re int i=0;i<=n;i++) dis[i]=inf;
    dis[t]=0;b[t]=1;
    deque<int> q;
    q.push_back(t);
    while(!q.empty())
    {
        int u=q.front();
        b[u]=0;
        q.pop_front();
        for(re int i=head[u];i!=-1;i=edge[i].nxt)
        {
            int v=edge[i].to;
            if(edge[i^1].w>0&&dis[v]>dis[u]-edge[i].dis)
            {
                dis[v]=dis[u]-edge[i].dis;
                if(!b[v])
                {
                    b[v]=1;
                    if(!q.empty()&&dis[v]<dis[q.front()])
                    q.push_front(v);
                    else
                    q.push_back(v);
                }
            }
        }
    }
    return dis[s]<inf;
}
inline int dfs(int u,int low)
{
    if(u==t)
    {
        b[t]=1;
        return low;
    }
    int diss=0;
    b[u]=1;
    for(re int i=head[u];i!=-1;i=edge[i].nxt)
    {
        int v=edge[i].to;
        if(!b[v]&&edge[i].w!=0&&dis[u]-edge[i].dis==dis[v])
        {
            int check=dfs(v,min(edge[i].w,low));
            if(check>0)
            {
                tot+=check*edge[i].dis;
                edge[i].w-=check;
                edge[i^1].w+=check;
                low-=check;
                diss+=check;
                if(low==0) break;
            }
        }
    }
    return diss;
}
inline int max_flow()
{
    int ans=0;
    while(spfa())
    {
        b[t]=1;
        while(b[t])
        {
            memset(b,0,sizeof(b));
            ans+=dfs(s,inf);
        }
    }
    return ans;
}
int main()
{
    memset(head,-1,sizeof(head));
    n=read();m=read();s=read();t=read();
    for(re int i=1;i<=m;i++)
    {
        x=read();y=read();l=read();int d=read();
        add(x,y,l,d);
    }
    cout<<max_flow()<<" ";
    cout<<tot;
}
View Code

 

  

直接快了50%,可以看出多路增广的优势还是显然的。

然而如果并没有看明白,可以访问以下这位大神的博客:一种更高效的费用流

部分内容或有重复冲突请神犇们谅解,可能是想到一起去了。

zkw大神的博客

posted @ 2018-02-07 14:21  ~victorique~  阅读(1597)  评论(1编辑  收藏
Live2D