网络流DINIC 递归版模版

最新推荐文章于 2020-10-12 18:19:49 发布

九野的博客

最新推荐文章于 2020-10-12 18:19:49 发布

阅读量2.5k

点赞数

分类专栏：网络流

本文链接：https://blog.csdn.net/acmmmm/article/details/20659275

版权

网络流专栏收录该内容

54 篇文章

订阅专栏

本文介绍了如何使用Dinic算法解决网络流问题，包括有向图的表示、边的残余流量概念以及如何构建反向弧。网络流问题旨在确定在给定的流量限制下，从源点到汇点的最大流量。提供的Dinic算法实现具有O(nm)的时间复杂度。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

给定一个有向图（若是无向图，那么可以用两条有向边表示一条无向边），边有一个权值表示这条边上的流量，

形象一点：我们有n个城市，告诉你某些路以及路上最多分分钟的车流量。

然后我们求从 1 点压入无限多的车，问从n点分分钟能跑出多少车量的问题称为网络流（最大流）。

我们称无限多进入车辆的点为：源点

车辆的出口的点为：汇点

数据结构：用以下这样的结构体来表示边

struct Edge{
	int from, to, cap, flow, nex; //一条边有起点，终点，最大车流量，当前车流量，下一个节点的指针
}edge[M];

对于每条边，当我们给这条边流过的车流量 = 最大车流量时，称这条边为：满流

对于每条边，cap - flow 就是残余流量（就是还能有多少量车可以从这条路上通过）

加边的函数：

int head[N], edgenum;//邻接表的形式，head为表头，每个点都有一个表头
void addedge(int from, int to, int cap){
	Edge E = {from, to, cap, 0, head[from]};
	edge[edgenum] = E;
	head[from] = edgenum++;

	Edge E2= {from, to, 0, cap, head[to]};
	edge[edgenum] = E2;
	head[to] = edgenum++;
}

网络流的复杂度为点数*边数：O(nm)

注意每条边都有一个反向弧（可以认为是反悔弧）

网络流的主要代码：

int dis[N],cur[N];//距离起点的距离 cur[i]表示i点正在考虑的边 优化不再考虑已经用过的点 初始化为head   
bool vis[N];  
bool BFS(int Start,int End){ 
//我们从残余网络找一条从Start->End的路径 （就是最短路的代码，每条边的边权为最大流量-当前流量，当这条边满流时最大流量=当前流量，边权为0） 
//显然当找不到这样的路径时说明不能继续增加流量 则返回false 算法结束
    memset(vis,0,sizeof(vis));   
    memset(dis,-1,sizeof(dis));  
    queue<int>Q;  while(!Q.empty())Q.pop();  
    Q.push(Start);  dis[Start]=0;   vis[Start]=1;  
    while(!Q.empty())  
    {  
        int u = Q.front(); Q.pop();  
        for(int i=head[u];i!=-1;i=edge[i].nex){  
            Edge E =edge[i];  
            if(!vis[E.to] && E.cap>E.flow)  
            {  
                vis[E.to]=1;  
                dis[E.to]=dis[u]+1;  
                if(E.to==End)return true;  
                Q.push(E.to);  
            }  
        }  
    }  
    return false;  
}  
int DFS(int x, int a,int End){//我们把找到的这个路径上所有的边的当前流量都增加a（注意a是整个路径上的边中 残余流量的最小值）
    if(x==End || a==0)return a;  
    int flow = 0, f;  
    for(int& i=cur[x];i!=-1;i=edge[i].nex)  
    {  
        Edge& E = edge[i];  
        if(dis[x]+1 == dis[E.to] && (f = DFS(E.to , Min(a, E.cap-E.flow), End))>0 )  
        {  
            E.flow += f;  
            edge[ i^1 ].flow -= f;//反向边要减掉   
            flow += f;  
            a -= f;  
            if(a==0)break;  
        }  
    }  
    return flow;  
}  
int Maxflow(int Start,int End){  
    int flow=0;   
    while(BFS(Start,End)){  //重复找路，增加路径上的流量的过程
        memcpy(cur,head,sizeof(head));//把head的数组复制过去   
        flow += DFS(Start, inf, End);  
    }  
    return flow;  
}

给出网络流完整代码：

#include <iostream>   
#include <string>   
#include <cstring>   
#include <algorithm>   
#include <cstdio>   
#include <cctype>   
#include <queue>   
#include <stdlib.h>   
#include <cstdlib>   
#include <math.h>   
#include <set>   
#include <vector>   
#define inf 100000000   
#define eps 1e-8   
#define N 205   
#define M 1050   
#define ll int   
using namespace std;  
inline ll Max(ll a,ll b){return a>b?a:b;}  
inline ll Min(ll a,ll b){return a<b?a:b;}  
//M为边数 N为点数 点标从1-n   
 
struct Edge{  
    int from,to,flow,cap, nex;  
}edge[M*2];//双向边，注意RE的情况 注意这个模版是 相同起末点的边 合并流量
int head[N],edgenum;//2个要初始化-1和0   
void addedge(int u,int v,int cap){//网络流要加反向弧   
    Edge E={u,v,0,cap,head[u]};  
    edge[edgenum]=E;  
    head[u]=edgenum++;  
    Edge E2={v,u,0,0,head[v]}; //这里的cap若是单向边要为0   
    edge[edgenum]=E2;  
    head[v]=edgenum++;  
}  
  
  
int dis[N],cur[N];//距离起点的距离 cur[i]表示i点正在考虑的边 优化不再考虑已经用过的点 初始化为head   
bool vis[N];  
bool BFS(int Start,int End){  
    memset(vis,0,sizeof(vis));   
    memset(dis,-1,sizeof(dis));  
    queue<int>Q;  while(!Q.empty())Q.pop();  
    Q.push(Start);  dis[Start]=0;   vis[Start]=1;  
    while(!Q.empty())  
    {  
        int u = Q.front(); Q.pop();  
        for(int i=head[u];i!=-1;i=edge[i].nex){  
            Edge E =edge[i];  
            if(!vis[E.to] && E.cap>E.flow)  
            {  
                vis[E.to]=1;  
                dis[E.to]=dis[u]+1;  
                if(E.to==End)return true;  
                Q.push(E.to);  
            }  
        }  
    }  
    return false;  
}  
int DFS(int x, int a,int End){//流入x 的流量是a   
    if(x==End || a==0)return a;  
    int flow = 0, f;  
    for(int& i=cur[x];i!=-1;i=edge[i].nex)  
    {  
        Edge& E = edge[i];  
        if(dis[x]+1 == dis[E.to] && (f = DFS(E.to , Min(a, E.cap-E.flow), End))>0 )  
        {  
            E.flow += f;  
            edge[ i^1 ].flow -= f;//反向边要减掉   
            flow += f;  
            a -= f;  
            if(a==0)break;  
        }  
    }  
    return flow;  
}  
int Maxflow(int Start,int End){  
    int flow=0;   
    while(BFS(Start,End)){  
        memcpy(cur,head,sizeof(head));//把head的数组复制过去   
        flow += DFS(Start, inf, End);  
    }  
    return flow;  
}  
void init(){
	memset(head, -1, sizeof(head)); edgenum = 0;
}

若不理解网络流的原理，可以暂且学会套用模版理解网络流的用法。