最小费用最大流之 zkw费用流与普通费用流

最新推荐文章于 2020-07-15 18:49:26 发布
最新推荐文章于 2020-07-15 18:49:26 发布
阅读量233 收藏
点赞数

http://www.artofproblemsolving.com/blog/54262

这个是原作者的博文地址

这是今天刚学的，不过理解上还是很浅薄。最近发现算法不能融会贯通还是因为自己太死板了。

奉上一个基础版本的模板， POJ 2195 的代码。

本模板是不能直接用于任何有负权的图，更不能用于有负圈的情况

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <cstdio>
#include <cmath>
#include <queue>
#include <map>
#include <set>
#define eps 1e-5
#define MAXN 222
#define MAXM 55555
#define INF 1000000007
using namespace std;
struct EDGE
{
    int cost, cap, v;
    int next, re;
}edge[MAXM];
int head[MAXN], e;
int vis[MAXN];
int ans, cost, src, des, n;
void init()
{
    memset(head, -1, sizeof(head));
    e = 0;
    ans = cost = 0;
}
void add(int u, int v, int cap, int cost)
{
    edge[e].v = v;
    edge[e].cap = cap;
    edge[e].cost = cost;
    edge[e].re = e + 1;
    edge[e].next = head[u];
    head[u] = e++;
    edge[e].v = u;
    edge[e].cap = 0;
    edge[e].cost = -cost;
    edge[e].re = e - 1;
    edge[e].next = head[v];
    head[v] = e++;
}
int aug(int u, int f)
{
    if(u == des)
    {
        ans += cost * f;
        return f;
    }
    vis[u] = 1;
    int tmp = f;
    for(int i = head[u]; i != -1; i = edge[i].next)
        if(edge[i].cap && !edge[i].cost && !vis[edge[i].v])
        {
            int delta = aug(edge[i].v, tmp < edge[i].cap ? tmp : edge[i].cap);
            edge[i].cap -= delta;
            edge[edge[i].re].cap += delta;
            tmp -= delta;
            if(!tmp) return f;
        }
    return f - tmp;
}
bool modlabel()
{
    int delta = INF;
    for(int u = 1; u <= n; u++)
        if(vis[u])
            for(int i = head[u]; i != -1; i = edge[i].next)
                if(edge[i].cap && !vis[edge[i].v] && edge[i].cost < delta) delta = edge[i].cost;
    if(delta == INF) return false;
    for(int u = 1; u <= n; u++)
        if(vis[u])
            for(int i = head[u]; i != -1; i = edge[i].next)
                edge[i].cost -= delta, edge[edge[i].re].cost += delta;
    cost += delta;
    return true;
}
void costflow()
{
    do
    {
        do
        {
            memset(vis, 0, sizeof(vis));
        }while(aug(src, INF));
    }while(modlabel());
}
int nt, m;
struct point
{
    int x, y;
}p[MAXN], h[MAXN];
int d[MAXN][MAXN];
char s[MAXN][MAXN];
int main()
{
    while(scanf("%d%d", &m, &nt) != EOF)
    {
        if(m == 0 && nt == 0) break;
        for(int i = 0; i < m; i++)
            scanf("%s", s[i]);
        int hcnt = 0, pcnt = 0;
        for(int i = 0; i < m; i++)
            for(int j = 0; j < nt; j++)
            {
                if(s[i][j] == 'H')
                {
                    hcnt++;
                    h[hcnt].x = i;
                    h[hcnt].y = j;
                }
                else if(s[i][j] == 'm')
                {
                    pcnt++;
                    p[pcnt].x = i;
                    p[pcnt].y = j;
                }
            }
        for(int i = 1; i <= pcnt; i++)
            for(int j = 1; j <= hcnt; j++)
                d[i][j] = abs(p[i].x - h[j].x) + abs(p[i].y - h[j].y);
        init();
        n = hcnt + pcnt + 2;
        src = hcnt + pcnt + 1;
        des = n;
        for(int i = 1; i <= pcnt; i++)
            for(int j = 1; j <= hcnt; j++)
                add(i, j + pcnt, 1, d[i][j]);
        for(int i = 1; i <= pcnt; i++)
            add(src, i, 1, 0);
        for(int i = 1; i <= hcnt; i++)
            add(i + pcnt, des, 1, 0);
        costflow();
        printf("%d\n", ans);
    }
    return 0;
}

然后再来一个最基础的模板

这个模板呢，跟上一个一样的地方就是初始化，src代表起点，des是终点,n是顶点的个数


#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <cstdio>
#include <cmath>
#include <queue>
#include <map>
#include <set>
#define eps 1e-5
#define MAXN 555
#define MAXM 55555
#define INF 100000007
using namespace std;
struct EDGE
{
    int v, cap, cost, next, re;    //  re记录逆边的下标。
}edge[MAXM];
int n, m, ans, flow, src, des;
int e, head[MAXN];
int que[MAXN], pre[MAXN], dis[MAXN];
bool vis[MAXN];
void init()
{
    e = ans = flow = 0;
    memset(head, -1, sizeof(head));
}
void addEdge(int u, int v, int cap, int cost)
{
    edge[e].v = v;
    edge[e].cap = cap;
    edge[e].cost = cost;
    edge[e].next = head[u];
    edge[e].re = e + 1;
    head[u] = e++;
    edge[e].v = u;
    edge[e].cap = 0;
    edge[e].cost = -cost;
    edge[e].next = head[v];
    edge[e].re = e - 1;
    head[v] = e++;
}
bool spfa()
{
    int i, h = 0, t = 1;
    for(i = 0; i < MAXN; i ++)
    {
        dis[i] = INF;
        vis[i] = false;
    }
    dis[src] = 0;
    que[0] = src;
    vis[src] = true;
    while(t > h)
    {
        int u = que[h++];
        for(i = head[u]; i != -1; i = edge[i].next)
        {
            int v = edge[i].v;
            if(edge[i].cap && dis[v] > dis[u] + edge[i].cost)
            {
                dis[v] = dis[u] + edge[i].cost;
                pre[v] = i;
                if(!vis[v])
                {
                    vis[v] = true;
                    que[t++] = v;
                }
            }
        }
        vis[u] = false;
    }
    if(dis[des] == INF) return false;
    return true;
}
void end()
{
    int u, p, mi = INF;
    for(u = des; u != src; u = edge[edge[p].re].v)
    {
        p = pre[u];
        mi = min(mi, edge[p].cap);
    }
    for(u = des; u != src; u = edge[edge[p].re].v)
    {
        p = pre[u];
        edge[p].cap -= mi;
        edge[edge[p].re].cap += mi;
        ans += mi * edge[p].cost;     //  cost记录的为单位流量费用，必须得乘以流量。
    }
    flow += mi;
}
void build()
{

}
void MCMF()
{
    init();
    build();
    while(spfa()) end();
}
int main()
{

    return 0;
}


最后来一个使用 Small Label First 优化

的 SPFA 来维护 zkw 算法中的距离标号, 保留多路增广

这也是根据原作者的程序改的，这个貌似就可以用负的边权了

#include <iostream>
#include <algorithm>
#include <cstring>
#include <string>
#include <cstdio>
#include <cmath>
#include <queue>
#include <deque>
#include <map>
#include <set>
#define eps 1e-5
#define MAXN 555
#define MAXM 55555
#define INF 100000007
using namespace std;
struct EDGE
{
    int cost, cap, v;
    int next, re;
}edge[MAXM];
int head[MAXN], e;
int vis[MAXN], d[MAXN];
int ans, cost, src, des, n;
void init()
{
    memset(head, -1, sizeof(head));
    e = 0;
    ans = cost = 0;
}
void add(int u, int v, int cap, int cost)
{
    edge[e].v = v;
    edge[e].cap = cap;
    edge[e].cost = cost;
    edge[e].re = e + 1;
    edge[e].next = head[u];
    head[u] = e++;
    edge[e].v = u;
    edge[e].cap = 0;
    edge[e].cost = -cost;
    edge[e].re = e - 1;
    edge[e].next = head[v];
    head[v] = e++;
}
int aug(int u, int f)
{
    if(u == des)
    {
        ans += cost * f;
        return f;
    }
    vis[u] = 1;
    int tmp = f;
    for(int i = head[u]; i != -1; i = edge[i].next)
        if(edge[i].cap && !edge[i].cost && !vis[edge[i].v])
        {
            int delta = aug(edge[i].v, tmp < edge[i].cap ? tmp : edge[i].cap);
            edge[i].cap -= delta;
            edge[edge[i].re].cap += delta;
            tmp -= delta;
            if(!tmp) return f;
        }
    return f - tmp;
}
bool modlabel()
{
    for(int i = 0; i <= n; i++) d[i] = INF;
    d[des] = 0;
    deque<int>Q;
    Q.push_back(des);
    while(!Q.empty())
    {
        int u = Q.front(), tmp;
        Q.pop_front();
        for(int i = head[u]; i != -1; i = edge[i].next)
            if(edge[edge[i].re].cap && (tmp = d[u] - edge[i].cost) < d[edge[i].v])
                (d[edge[i].v] = tmp) <= d[Q.empty() ? src : Q.front()] ? Q.push_front(edge[i].v) : Q.push_back(edge[i].v);
    }
    for(int u = 1; u <= n; u++)
        for(int i = head[u]; i != -1; i = edge[i].next)
            edge[i].cost += d[edge[i].v] - d[u];
    cost += d[src];
    return d[src] < INF;
}
void costflow()
{
    while(modlabel())
    {
        do
        {
            memset(vis, 0, sizeof(vis));
        }while(aug(src, INF));
    }
}
int nt, m;
struct point
{
    int x, y;
}p[MAXN], h[MAXN];
int dis[MAXN][MAXN];
char s[MAXN][MAXN];
int main()
{
    while(scanf("%d%d", &m, &nt) != EOF)
    {
        if(m == 0 && nt == 0) break;
        for(int i = 0; i < m; i++)
            scanf("%s", s[i]);
        int hcnt = 0, pcnt = 0;
        for(int i = 0; i < m; i++)
            for(int j = 0; j < nt; j++)
            {
                if(s[i][j] == 'H')
                {
                    hcnt++;
                    h[hcnt].x = i;
                    h[hcnt].y = j;
                }
                else if(s[i][j] == 'm')
                {
                    pcnt++;
                    p[pcnt].x = i;
                    p[pcnt].y = j;
                }
            }
        for(int i = 1; i <= pcnt; i++)
            for(int j = 1; j <= hcnt; j++)
                dis[i][j] = abs(p[i].x - h[j].x) + abs(p[i].y - h[j].y);
        init();
        n = hcnt + pcnt + 2;
        src = hcnt + pcnt + 1;
        des = n;
        for(int i = 1; i <= pcnt; i++)
            for(int j = 1; j <= hcnt; j++)
                add(i, j + pcnt, 1, dis[i][j]);
        for(int i = 1; i <= pcnt; i++)
            add(src, i, 1, 0);
        for(int i = 1; i <= hcnt; i++)
            add(i + pcnt, des, 1, 0);
        costflow();
        printf("%d\n", ans);
    }
    return 0;
}


iteye_10993
关注
luogu3381【模板】最小费用最大流（zkw费用流板子）
Icefox的博客
12-09 638
%%%xtx的代码了好久，又翻了很多文章，终于算是差不多看懂了？？？ 费用流问题，是建立在最大流问题基础之上的，也就是说，现在流要钱了，我们要求出最大流，可能有很多个最大流，我们还要费用最小的那个。比较直观的一个想法便是：把原来的bfs分层变成spfa等最短路算法，求出从s到t费用最小的一条路径来增广。然而这样我们就失去了Dinic的一个优势，即多路增广。因为每次我们进行增广后，最短路都不一定再满
网络流重制版：最小费用最大流以及其正确性，还有各种算法的个人SB分析
蒟蒻QMQ
11-25 766
文章目录费用流的定义大概做法算法讲解MCMF算法ZKW费用流原始对偶算法参考资料 费用流的定义 有没有考虑过，如果一条边还有费用呢？？？ 就像带权二分图匹配那样子。 给出定义，cost(i,j)cost(i,j)cost(i,j)为这条弧的花费。 那么不仅要在最大化流量的同时（优先级最高），最小化cost(i,j)∗f(i,j)cost(i,j)*f(i,j)cost(i,j)∗f(i,j)。 可以发现，如果图外面存在一个负环，那么这个负环会有流量，且会影响答案。 大概做法 首先，依旧是找增广路，但是呢，挑
最小费用最大流——ZKW
A1847225889的博客
07-18 646
对于最小费用最大流，我们的通常做法是EK+SPFA。 然而，卡常界大佬ZKW发明了一个求解最小费用最大流的方法，很强啊。 在学ZKW费用流前，先说说KM算法。 KM算法 为啥要先提这个呢？因为ZKW费用流用了一个和它非常类似的做法。 KM算法求的是二分图最大权完美匹配。 在此，我来口胡一下（这个算法其实我并未打过，只懂思想）。 和匈牙利算法差不多，区别在于标号。 对于左右两边的点各...
学习笔记 --- 最小费用最大流
weixin_30347335的博客
01-17 388
最小费用最大流，本人一只三种算法，MCMF、zkw（张昆玮）、Primal-Daul。然而基本没见人用过PD，多数都是MCMF和zkw。 对比起来，MCMF是基于spfa的一种算法，在稀疏图上十分高效；zkw算法是用spfa和KM重标号来进行计算的，在稠密图很高效，不过有一种图能够使zkw变慢：费用不小，容量不大，增广路比较长； zkw最小费用最大流： bool sp...
最小费用最大流模版(zkw)洛谷3381
wondove
03-01 666
zkw费用流模版 洛谷上可以测. 其实就是把dinic里的bfs换成了spfa,建图的时候把反向边的容量设为0，费用设为-c[i]. 然后跑一边模版。。 #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;queue&gt; #include&lt;algorithm&gt; using namespace std; #de...
最小费用最大流 zkw算法
天空の行者
09-21 4402
最小费用最大流的算法有很多种，经典的就是EK+SPFA。但是时间效率确实令人不敢恭维~最近小小的学习了一下传说中的费用流的神算法——zkw算法。(P.s. 以其发明者zkw神牛的名字命名) 该算法可以有效地通过修改距离标号的方法避免反复进行最短路运算的部分省去，基本算法类似KM算法的顶标修改。基本思想就是：采用距离标号法，若能增广则无限增广，反之更新距离标号，直到无法更新为止。本人
华为软件大赛： 最小费用流(zkw)+遗传算法。 zkw比sfa的费用流快好多啊，10倍左右，牛逼~.zip
最新发布
02-19
【项目资源】： 包含前端、后端、移动开发、操作系统、人工智能、物联网、信息化管理、数据库、硬件开发...有任何使用上的问题，欢迎随时与博主沟通，博主会及时解答。 鼓励下载和使用，并欢迎大家互相学习，共同进步。
图论-zkw费用流
KonnyWen的博客
02-10 2429
图论-zkw费用流 这是一个求最小费用最大流的算法，因为发明者是神仙zkw，所以叫zkw费用流（就是zkw线段树那个zkw）。有些时候比EK快，有些时候慢一些，没有比普通费用流算法更难，所以学zkw费用流之前，不需要先掌握普通费用流。 前置知识：网络最大流\color{8888cc}\texttt{网络最大流}网络最大流。 在学了网络最大流后，如果在没条边上加个限制，就是 costcostcost...
Zkw费用流
cj1064789374的博客
01-02 507
V#include &lt;bits/stdc++.h&gt; using namespace std; bool vis[200001];int dist[200001];//vis是spfa访问标记及増广访问标记,dist是每个点距离标号 int n,m,s,t,ans=0;//s是起点，t是终点，ans是费用答案 int nedge=-1,p[200001],c[200001],cc[20...
图论-网络流⑤-最大流解题②
KonnyWen的博客
02-16 688
图论-网络流⑤-最大流解题②
最小费用最大流之ZKW算法。
Harris-H的博客
07-15 657
最小费用最大流之ZKWZKWZKW算法。 主要思想：是类比KMKMKM算法，虽然我不是很了解KMKMKM，通过不断修改可行标号，扩大可行子图，同时多路增广，避免了spfaspfaspfa维护较为复杂的标号的队列操作。 实现的流程： 1.找增广路与dinicdinicdinic一样。 2.找不到增广路时，进行修改可行标号，通过对费用进行修改，使得产生可行增广路径。 时间复杂度与spfaspfaspfa几乎相同，但是在某些图常数更小。 适用范围：较为稠密的图，二分图，最终流量较大，费用取值范围较小，增广路径较短
zkw最小费用流
新博客：https://aping-dev.com/
05-13 614
http://blog.csdn.net/zhulei19931019/article/details/69390750
最小费用最大流/费用流zkw算法模板（洛谷3381）
Welcome to yjjr's blog!
12-12 695
#include<iostream> #include<cstdio> #include<cstdlib> #include<cstring> #include<cmath> #include<algorithm> #define rep(i,a,b) for(int i=a;i<=b;i++) #define dep(i,a,b) for(int i=a;i>=b;i--) #define ll
HDU 4744 Starloop System（ZKW最小费用最大流）
围巾的ACM博客
05-03 1143
思路：建图是显而易见的不过用普通的最小费用最大流超时了...改用ZKW才过了 #include using namespace std; const int maxn = 210; const int maxm = 210*210*2; #define INF 1e9 struct ZKW_flow{ int st,ed,ecnt,n; int head[maxn]; int ca
UVA 12534 - Binary Matrix 2 (网络流‘最小费用最大流’ZKW)
Halo
10-04 728
题目： http://acm.hust.edu.cn/vjudge/contest/view.action?cid=93745#problem/A 题意： 给出r*c的01矩阵，可以翻转格子使得0表成1,1变成0，求出最小的步数使得每一行中1的个数相等，每一列中1的个数相等。 思路： 网络流。容量可以保证每一行和每一列的1的个数相等，费用可以算出最小步数。 行向列建边，如果该格子是
最小费用流的zkw算法
Tcorpion的博客
04-07 1094
最小费用最大流ZKW算法
最小费用流模板（zkw与spfa）
Ark
09-26 628
“zkw” 费用流算法在哪些图上慢（摘自https://www.cnblogs.com/ECJTUACM-873284962/p/7744943.html） 实践中, 上面的这个算法非常奇怪. 在某一些图上, 算法速度非常快, 另一些图上却比纯 SPFA 增广的算法慢. 不少同学经过实测总结的结果是稠密图上比较快, 稀疏图上比较慢, 但也不尽然. 这里我从理论上分析一下, 究竟这个算法用于哪...
网络流--最小费用最大流MCMF算法
yxpandjay的博客
09-12 1470
转载：http://www.cnblogs.com/Missa/archive/2013/04/19/3030512.html 在一个网络中每段路径都有“容量”和“费用”两个限制的条件下，此类问题的研究试图寻找出：流量从A到B，如何选择路径、分配经过路径的流量，可以达到所用的费用最小的要求。如n辆卡车要运送物品，从A地到B地。由于每条路段都有不同的路费要缴纳，每条路能容纳的车的数量有
详解zkw算法解决最小费用流问题
weixin_34318272的博客
10-27 682
网络流的一些基本概念 很多同学建立过网络流模型做题目, 也学过了各种算法, 但是对于基本的概念反而说不清楚. 虽然不同的模型在具体叫法上可能不相同, 但是不同叫法对应的思想是一致的. 下面的讨论力求规范, 个别地方可能需要对通常的叫法加以澄清. 　　求解可行流: 给定一个网络流图, 初始时每个节点不一定平衡 (每个节点可以有盈余或不足), 每条边的流量可...
掌握zkw算法：高效求解最小成本流问题
资源摘要信息:"最小成本流算法...总之，该文件为计算机科学领域的最小成本流问题提供了一种可能的解决方案，无论“zkw”所指为何，文件都可能包含有特色的算法思想和实现，对于算法学习和实际应用都是一份宝贵的资源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值