网络流初步

最新推荐文章于 2022-09-12 17:11:50 发布
原创 最新推荐文章于 2022-09-12 17:11:50 发布 · 515 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#网络流

POJ1273

参考：http://www.cnblogs.com/jackge/archive/2013/04/10/3012182.html

裸的最大流题目，要注意重边。

int map[][] ,记录容量

int flow[][]记录流量

int res[]记录残余流量

int pre[]记录父亲节点，更新flow数组是用到

从流量为0开始找增广路，清空flow数组开始。

每次将残余流量数组清空，只有src源点的残余容量是无穷大。

用BFS寻找随机路径，并且同时更新res（残余流量数组）取最小值。

如果能更新到des，也就是 res[des]不等于0 ，则 说明找到了一条增广路，把它加到max_flow里；

然后更新整个网络，也就是flow数组。正流量增加 res[des],反向流量减少res[des];

不断重复上述过程，直到res[des] == 0,找不到增广路，也就是当前已经达到了最大流。（增广路定理）

Edmond-Karp算法

#include <iostream>
#include <queue>
#include <string.h>
#include <cstdio>
#define N 250
#define INF 0x3f3f3f3f
using namespace std;
int map[N][N]; // 容量
int flow[N][N] ; //流量
int res[N];//每条边的残余流量
int pre[N]; //记录父亲节点的数组 //更新汇点的流量之后回溯时用到
int n,m,max_flow;
int EK(int src,int des){
    memset(flow,0,sizeof(flow)); // start from zero_flow;
    max_flow = 0; //set max_flow to zero
    queue<int>Q;
    while(1){
        memset(res,0,sizeof(res)); // set remains  to zero;
        res[src] = INF; // start point has infinite flow;
        Q.push(src);
        while(!Q.empty()){
            int u = Q.front(); Q.pop();
            for(int v=1;v<=m;v++){
                if(!res[v] && map[u][v] > flow[u][v]){
                    pre[v] = u;
                    Q.push(v);
                    res[v] = min(res[u],map[u][v] - flow[u][v]); //如果res[u]不足，就将所有res
                    //都流入res[v] ,否则 ，将res[v]流满，map[u][v] - flow[u][v];
                }
            }
        }
        if(res[des] == 0) return max_flow; //找不到增广路
        for(int v=des;v!=src;v=pre[v]){
            flow[pre[v]][v] += res[des];
            flow[v][pre[v]] -= res[des]; //更新反向弧
        }
        max_flow += res[des];
    }
}
int main(){
    while(scanf("%d%d",&n,&m)!=EOF){
        int from,to,w;
        memset(map,0,sizeof(map));
        for(int i=0;i<n;i++){
            scanf("%d%d%d",&from,&to,&w);
            map[from][to] += w; //重边
        }
        int ans = EK(1,m);
        printf("%d\n",ans);
    }
    return 0;
}

POJ1459 多源点，多汇点

EK

处理多个源点可以通过增加一个超级源点，连接到多个源点。

同理增加一个超级汇点，让所有汇点连接到超级汇点。 可以参照算法竞赛入门经典。

#include <iostream>
#include <queue>
#include <string.h>
#include <cstdio>
#define N 110
#define INF 0x3f3f3f3f
using namespace std;
int map[N][N]; // 容量
int flow[N][N] ; //流量
int res[N];//每条边的残余流量
int pre[N]; //记录父亲节点的数组 //更新汇点的流量之后回溯时用到
int n,np,nc,m,max_flow;
int src = 101,des=102;
int EK(int src,int des){
    memset(flow,0,sizeof(flow)); // start from zero_flow;
    max_flow = 0; //set max_flow to zero
    queue<int>Q;
    while(1){
        memset(res,0,sizeof(res)); // set remains  to zero;
        res[src] = INF; // start point has infinite flow;
        Q.push(src);
        while(!Q.empty()){
            int u = Q.front(); Q.pop();
            for(int v=0;v<=n+1;v++){ // 加入超级源点 汇点 n,n+1
                if(!res[v] && map[u][v] > flow[u][v]){
                    pre[v] = u;
                    Q.push(v);
                    res[v] = min(res[u],map[u][v] - flow[u][v]); //如果res[u]不足，就将所有res
                    //都流入res[v] ,否则 ，将res[v]流满，map[u][v] - flow[u][v];
                }
            }
        }
        if(res[des] == 0) return max_flow; //找不到增广路
        for(int v=des;v!=src;v=pre[v]){
            flow[pre[v]][v] += res[des];
            flow[v][pre[v]] -= res[des]; //更新反向弧
        }
        max_flow += res[des];
    }
}
int main(){
    while(scanf("%d%d%d%d",&n,&np,&nc,&m)!=EOF){
        char s[10];
        memset(map,0,sizeof(map));
        src = n,des = n+1;
        int from,to,w; char ch;
        for(int i=0;i<m;i++){
            scanf(" %c%d%c%d%c%d",&ch,&from,&ch,&to,&ch,&w);
            map[from][to] = w;
        }
        for(int i=0;i<np;i++){
            scanf(" %c%d%c%d",&ch,&from,&ch,&w);
            map[src][from] = w; //连接超级源点
        }
         for(int i=0;i<nc;i++){
            scanf(" %c%d%c%d",&ch,&from,&ch,&w);
            map[from][des] = w; //连接超级汇点
        }
        int ans = EK(src,des);
        printf("%d\n",ans);
    }
    return 0;
}

贴一个Dinic的模板
POJ的数据测出来，Dinic比EK还是快了好多。




而之外的两个题的数据反而测出Dinic更慢 - -
【Dinic poj1459】 
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
#include <queue>
#define mem(a,x) memset(a,x,sizeof(a))
#define INF 0x3f3f3f3f
#define N 111
#define M 111*100
typedef long long ll;
using namespace std;
struct Edge{
    int from,to,cap,flow;
};
struct Dinic{
    int n,m,s,t; //节点数，边数（包括反向弧）,源点，汇点
    vector<Edge>edges;
    vector<int>G[N];//表示节点i 的第j条边在e数组的编号
    bool vis[N]; // bfs中
    int d[N];//起点到i的距离
    int cur[M]; //当前弧下标

    bool BFS(){
        mem(vis,0);
        queue<int >Q;
        Q.push(s); d[s] = 0;vis[s] = 1;
        while(!Q.empty()){
            int x = Q.front();Q.pop();
            for(int i=0;i<G[x].size();i++){
                Edge &e = edges[G[x][i]];
                if(!vis[e.to] && e.cap > e.flow){//只考虑残量网络中的弧
                    vis[e.to] = 1;
                    d[e.to] = d[x] + 1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }
    int DFS(int x,int a){
        if(x == t || a == 0) return a;
        int flow = 0,f;
        for(int &i = cur[x];i<G[x].size();i++){
            Edge&e = edges[G[x][i]];
            if(d[x] + 1 ==d[e.to] && (f = DFS(e.to,min(a,e.cap - e.flow))) > 0){
                e.flow += f;
                edges[G[x][i]^1].flow -= f;// 反向弧
                flow += f;
                a-=f;
                if(a == 0) break;
            }
        }
        return flow;
    }
    ll MaxFlow(int s,int t){
        this->s = s;this->t = t;
        ll flow = 0;
        while(BFS()){
            mem(cur,0);
            flow += DFS(s,INF);
        }
        return flow;
    }
    void addEdge(int from,int to,int cap){
        edges.push_back((Edge){from,to,cap,0});
        edges.push_back((Edge){to,from,0,0});
        m = edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }
    void init(){
        edges.clear();
        for(int i=0;i<=N;i++){
            G[i].clear();d[i] =0; vis[i] = 0;
        }
        mem(cur,0);
    }
}solve;
int main(){
    int n,np,nc,m;
    while(scanf("%d%d%d%d",&n,&np,&nc,&m)!=EOF){
        char s[10];
        solve.init();
        int src = n,des = n+1;
        int from,to,w; char ch;
        for(int i=0;i<m;i++){
            scanf(" %c%d%c%d%c%d",&ch,&from,&ch,&to,&ch,&w);
            solve.addEdge(from,to,w);
        }
        for(int i=0;i<np;i++){
            scanf(" %c%d%c%d",&ch,&from,&ch,&w);
            solve.addEdge(src,from,w); //连接超级源点
        }
         for(int i=0;i<nc;i++){
            scanf(" %c%d%c%d",&ch,&from,&ch,&w);
            solve.addEdge(from,des,w); //连接超级汇点
        }
        printf("%I64d\n",solve.MaxFlow(src,des));
    }
    return 0;
}


NYOJ677

做了这个题才知道最大流最小割定理是多么神奇，这个题就是裸求图的最小割，然后我们直接转化为最大流问题处理就行了。

关键在于构图，增添一个超级源点0，将超级源点与间谍所在节点连接，汇点是n。其余的结点相连的权值都设置为1。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <set>
#include <vector>
#include <queue>
#define INF 0x3f3f3f3f
using namespace std;
int spy[222];
int map[222][222];
int n,m,q;
int res[222];
int flow[222][222];
int p[222];
int EK(int src,int des){
    int max_flow = 0;
    memset(flow,0,sizeof(flow));
    queue<int>Q;
    while(1){
        memset(res,0,sizeof(res));
        res[src] = INF;
        Q.push(src);
        while(!Q.empty()){
            int u = Q.front();Q.pop();
            for(int v = 0;v<=n;v++){
                if(!res[v] && map[u][v] > flow[u][v]){
                    p[v] = u;
                    res[v] = min(res[u] , map[u][v] - flow[u][v]);
                    Q.push(v);
                }
            }
        }
       // cout<<res[des]<<endl;
        if(res[des] == 0) return max_flow;
        max_flow += res[des];
        for(int v=des;v!=src;v=p[v]){
            flow[p[v]][v] += res[des];
            flow[v][p[v]] -= res[des];
        }
    }
}
int main()
{
    int T ; scanf("%d",&T);
    for(int cas=1;cas<=T;cas++){
        scanf("%d%d%d",&n,&m,&q);
        int po;
        memset(map,0,sizeof(map));
        for(int i=0;i<q;i++){
            scanf("%d",&po);
            map[0][po] = INF; //超级源点
        }
        int a,b;
        for(int i=0;i<m;i++){
            scanf("%d%d",&a,&b);
            map[a][b] = map[b][a] = 1;
        }
        int ans = EK(0,n);
        printf("Case #%d: %d\n",cas,ans);
    }
    return 0;
}

HDU3987
求图的最小割，并且要求割去的边数最少。
通过最小割最大流定理转化成最大流问题。
设置N为大于节点数的一个数。
加权的时候直接将 （新权值） = （权值*N + 1）添入节点中。（注意加的1代表一条边，这样就可以通过取余来算边数了）
这样用原来的方法算出来ans。ans/N 就是最大流， ans%N就是最大流经过的边了。（神构造啊！） 
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
#include <queue>
#define mem(a,x) memset(a,x,sizeof(a))
#define INF 0x3f3f3f3f
#define N 1110
#define M 111*100
typedef long long ll;
using namespace std;
struct Edge{
    int from,to,cap,flow;
};
struct Dinic{
    int n,m,s,t; //节点数，边数（包括反向弧）,源点，汇点
    vector<Edge>edges;
    vector<int>G[N];//表示节点i 的第j条边在e数组的编号
    bool vis[N]; // bfs中
    int d[N];//起点到i的距离
    int cur[M]; //当前弧下标

    bool BFS(){
        mem(vis,0);
        queue<int >Q;
        Q.push(s); d[s] = 0;vis[s] = 1;
        while(!Q.empty()){
            int x = Q.front();Q.pop();
            for(int i=0;i<G[x].size();i++){
                Edge &e = edges[G[x][i]];
                if(!vis[e.to] && e.cap > e.flow){//只考虑残量网络中的弧
                    vis[e.to] = 1;
                    d[e.to] = d[x] + 1;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }
    int DFS(int x,int a){
        if(x == t || a == 0) return a;
        int flow = 0,f;
        for(int &i = cur[x];i<G[x].size();i++){
            Edge&e = edges[G[x][i]];
            if(d[x] + 1 ==d[e.to] && (f = DFS(e.to,min(a,e.cap - e.flow))) > 0){
                e.flow += f;
                edges[G[x][i]^1].flow -= f;// 反向弧
                flow += f;
                a-=f;
                if(a == 0) break;
            }
        }
        return flow;
    }
    ll MaxFlow(int s,int t){
        this->s = s;this->t = t;
        ll flow = 0;
        while(BFS()){
            mem(cur,0);
            flow += DFS(s,INF);
        }
        return flow;
    }
    void addEdge(int from,int to,int cap){
        edges.push_back((Edge){from,to,cap,0});
        edges.push_back((Edge){to,from,0,0});
        m = edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }
    void init(){
        edges.clear();
        for(int i=0;i<=N;i++){
            G[i].clear();d[i] =0; vis[i] = 0;
        }
        mem(cur,0);
    }
}solve;
int main(){
    int t;
    scanf("%d",&t);
    for(int cas=1;cas<=t;cas++){
        int n,m;scanf("%d%d",&n,&m);
        int u,v,c,d;
        solve.init();
        for(int i=0;i<m;i++){
        scanf("%d%d%d%d",&u,&v,&c,&d);
        solve.addEdge(u,v,c * N + 1);
        if(d)
            solve.addEdge(v,u,c*N+1);
        }
        ll ans = solve.MaxFlow(0,n-1);
        printf("Case %d: %I64d\n",cas,ans%(N));
    }
    return 0;
}




计算机网络基础：系列教程汇总
优快云博客专家，系统架构师，有合作、疑惑请私信博主。
04-07 15万+
计算机网络基础：系列教程汇总，从《计算机网络基础：揭开网络世界的神秘面纱》、《计算机网络基础：剖析网络的构成要素》、《计算机网络基础：认识网络拓扑结构》、《计算机网络基础：解析网络协议》、《计算机网络基础：了解网络类型》、《计算机网络基础：探秘网络数据传输》、《计算机网络基础：网络安全基础》等文章描述计算机网络，计算机网络基础系列教程构建了完整的知识体系，各部分相互关联，从理论基础到实践应用，为学习者深入理解计算机网络、从事相关技术工作及进一步探索网络前沿领域奠定坚实基础。
网络流初步总结
free斩
07-18 1879
查看资料：lrj 《算法竞赛入门经典》 相关概念： 最大流：（Maximum-Flow Problem）       从源点　S  中间经过一些点，一些的物品运送到汇点 t 。               中途每两点间都有个最大运送物品数。               求从 s 到 t 最多能运送多少物品。
网络流初步详解
weixin_34019144的博客
02-17 301
众所周知，网络流是探究网络上运输的一种图论分支。但是大多数人在第一次接触这个题时都有些畏惧感（比如说我），大佬可以自信跳过.. 本文包括: 1.网络流的概念及基本性质 2.略谈 Edmonds-Karp增广路算法 3.详谈 Dinic 算法 4.网络流的应用以及ISAP算法引入 1 . 网络流的概念及基本性质 网络流是图论的一种重要分支，我们可以将网络流初步理解为一种 水道 一样的网络。 基本...
网络流最大流初步-Push–relabel maximum flow algorithm
Razhme的博客
07-25 2194
简介 做网络流最大流的题，常用的算法就是Dinic's algorithm。时间复杂度为,通常由于出题人水平较低，几乎能过所有的题。功利地看，这样就没问题了。但是，站在追求真（zhuang）理（B）的角度上。我们有理由去了解更多的算法。 事实上网络流最大流算法，（在具有正确性的前提下，）大体分两类：增广路（augmenting path）算法和推进-重标号（push-relabel）算法（又称...
初步网络最大流的算法及详解
weixin_30770783的博客
08-02 2740
　　　　　　　　　　　　　　　　　　网络最大流 　　众所周知，网络流是图论的一个很重要的内容，也很有难度（主要难在建模）。 　　网络流的基础概念这里提一下： 　　容量网络:设G(V,E),是一个有向网络,在V中指定了一个顶点,称为源点(记为Vs),以及另一个顶点,称为汇点(记为Vt);对于每一条弧<u,v>属于E,对应有一个权值c(u,v)>0,称为弧的容量.通常...
网络流初步:最大流（Dinic算法）
大青蛙的boooooooo客
01-26 700
网络流初步：最大流 标签： 网络流 最大流 Dinic 最大流 例题 POJ****（USACO4.2.1） 在农夫约翰的农场上，每逢下雨，Bessie最喜欢的三叶草地就积聚了一潭水。这意味着草地被水淹没了，并且小草要继续生长还要花相当长一段时间。因此，农夫约翰修建了一套排水系统来使贝茜的草地免除被大水淹没的烦恼（不用担心，雨水会流向附近的一条小溪）。作为一名一流的技师，农
网络流初步之最大流(增广路算法)
weixin_30460489的博客
02-10 235
网络流是一个联通图； 网络流有如下三个性质： 1.一条边上容量恒大于流量，即c(i,j)>=f(i,j) 2.斜对称性，f(u,v)=-f(v,u)； 3.对于非源点和汇点有∑{f(i,j)}{i,j属于E}=0; 为了更方便算法的实现，一般根据原网络定义一个残量网络。其中r(u,v)为残量网络的容量。 r(u,v) = c(u,v) – f(u,v) *反向边也有r！...
11.4 网络流初步
weixin_55835175的博客
10-02 292
11.4 网络流初步 网络流是一个适用范围相当广的模型，相关的算法也非常多。这里我们开始初步(注意是初步)了解这类问题。 百度百科的介绍如下hhhh： 网络流(network-flows)是一种类比水流的解决问题方法，与线性规划密切相关。网络流的理论和应用在不断发展，出现了具有增益的流、多终端流、多商品流以及网络流的分解与合成等新课题。网络流的应用已遍及通讯、运输、电力、工程规划、任务分派、设备更新以及计算机辅助设计等众多领域。 还是直接看问题吧hhhh。 11.4.1 最大流问题 假设需要把一些物体从结
网络流初步 增广路算法求最大流 hdoj3549
AngelBeats!
06-29 1372
内容详见刘汝佳《算法竞赛ru》
最大网络流问题
weixin_34001430的博客
05-27 520
之前参加阿里巴巴的笔试碰到一最大网络流的题目。因为之前没有看过这类算法，所以还是自然没做出。今天抽空看了看。了解了下基本概念和求解流程。这里简单总结下。 主要内容来自百度文库某ppt。在每幅图片的下面我会给出一些说明性文字。 本图示最大流的一个实例。由此，可以引出最大流的一些基本的定义和概念 可以这样看，图就是一种管道，管道有最大通过流量的限制，图中边的权值就是所谓的“容量”。同时，...
算法学习笔记 - 网络流初步
haobowen的博客
09-12 716
网络流是图论中一个博大精深的分支。本篇博客只希望让大家建立对网络流的初步认识，内容会比较浅显。一个网络 G = (V, E) 是一张有向图，图中每条有向边 (x, y)∈E 都有一个给定的权值 c(x, y)，称为遍的容量。特别地，若 (x, y) 不属于 E，则 c(x, y) = 0。图中还有两个指定的特殊节点 S∈V 和 T∈V(S≠T)，分别称为源点和汇点。设 f(x, y) 是定义在节点二元组 (x∈V, y∈V) 上的实数函数，且满足：1. f(x, y) ≤ c(x, y)2. f(x, y)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值