网络流dinic与EK

原创于 2025-11-11 16:00:41 发布 · 564 阅读

25 ·

CC 4.0 BY-SA版权

文章标签：

#网络流 #dinic #EK #最大流

题目链接：网络流

EK算法核心思想

EK算法是Ford-Fulkerson方法的一种实现，使用BFS来寻找增广路径，用于求解最大流问题。

算法步骤：

初始化
- 构建残量网络，初始时正向边容量为原容量，反向边容量为0
- 最大流初始为0
循环寻找增广路径
- 使用BFS在残量网络中寻找从源点s到汇点t的路径
- 记录路径上的最小容量（瓶颈容量）
更新残量网络
- 沿着找到的增广路径，正向边减去流量，反向边加上流量
- 将瓶颈容量加到最大流中
重复直到找不到增广路径

核心代码：

bool E_K_bfs(){
    memset(vis,-1,sizeof(vis));pre[s]=-1;
    vis[s]=1;
    myline.push(s); minroad[s]=INT_MAX;
    
    while(!myline.empty()){
        int u=myline.front();myline.pop();vis[u]=0;
        for(int i=head[u];i;i=q[i].link){
            int v=q[i].v,w=q[i].w;
            if(w){  // 只有残量>0的边才考虑
                if(~vis[v]) continue;  // 已访问过则跳过
                minroad[v]=min(minroad[u],w);  // 记录路径最小容量
                pre[v]=i;  // 记录到达v的边
                myline.push(v);
                vis[v]=u;  // 标记已访问            
            }
        }
    }
    if(vis[t]!=-1) return true;  // 找到增广路径
    return false;
}

void update(){
    int now=t;
    while(now!=s){
        int id=pre[now];
        q[id].w -= minroad[t];  // 正向边减去流量
        q[id^1].w += minroad[t];  // 反向边增加流量
        now = q[id^1].v;  // 回溯到前一个节点
    }
    maxflow += minroad[t];  // 增加总流量
}

关键特点：

链式前向星存图：cnt从1开始，方便用^1获取反向边
残量网络：正向边存剩余容量，反向边存已用容量
BFS寻路：保证找到的是最短增广路径
反向边机制：允许"反悔"，这是最大流算法的核心

时间复杂度：

O(VE²)，其中V是节点数，E是边数
每次BFS：O(E)
最多进行O(VE)次BFS

算法正确性保证：

增广路定理：当且仅当残量网络中不存在s-t路径时，当前流是最大流
最短路径增长：每次找到最短增广路，保证算法终止
反向边：确保能找到全局最优解

与相关算法对比：

算法	时间复杂度	特点
EK	O(VE²)	实现简单，适合稀疏图
Dinic	O(V²E)	分层图+多路增广，效率更高
ISAP	O(V²E)	改进的Dinic，常数更小

总结：EK算法通过不断在残量网络中寻找增广路径并更新流量，最终得到最大流。

#include<bits/stdc++.h>
#include<queue>
using namespace std;

const int N=1000101;
int n,m,s,t,cnt=1;int head[N];
int vis[N];
//int vis[N];
int pre[N],minroad[N];
queue <int> myline;
struct edge{
	int v,w,link,u;
}q[N<<2];

void put(int x,int y,int z){
	q[++cnt].v=y,q[cnt].u=x,q[cnt].w=z,q[cnt].link=head[x],head[x]=cnt;
	q[++cnt].v=x,q[cnt].u=y,q[cnt].w=0,q[cnt].link=head[y],head[y]=cnt;
}

bool E_K_bfs(){
	memset(vis,-1,sizeof(vis));pre[s]=-1;
	vis[s]=1;
	myline.push(s);	minroad[s]=INT_MAX;
	while(!myline.empty()){
		int u=myline.front();myline.pop();vis[u]=0;
		for(int i=head[u];i;i=q[i].link){//	puts("check");
			int v=q[i].v,w=q[i].w;
			if(w){
			if(~vis[v]) continue;	
			minroad[v]=min(minroad[u],w);
			pre[v]=i;
			myline.push(v);
			vis[v]=u;			
		//	printf("v:%dminroad:%d",v,minroad[v]);
		}
		}
	}//puts("check");
	if(vis[t]!=-1){	return true;}
	return false;
}

int maxflow=0;
void update()
{
//	puts("checkgood");
	int now=t;
	while(now!=s){
		int id=pre[now];
		q[id].w-=minroad[t];
		q[id^1].w+=minroad[t];
		now=q[id^1].v;
	}
	maxflow+=minroad[t];
}
int main(){
    //freopen("tt.txt","r",stdin);
    //freopen("tt.out","w",stdout);
	scanf("%d%d%d%d",&n,&m,&s,&t);
	for(int i=1;i<=m;i++){
		int u,v,w;
		scanf("%d%d%d",&u,&v,&w);
		put(u,v,w);
	}
	while(E_K_bfs()) update();
	printf("%d",maxflow);
}

Dinic算法核心思想

Dinic算法是分层图+多路增广的网络流算法，比EK算法效率更高。

算法步骤：

BFS构建分层图
- 从源点s开始进行BFS
- 记录每个节点到源点的最短距离（层数）
- 只考虑残量>0的边
DFS多路增广
- 在分层图上进行DFS
- 只向下一层的节点推进
- 一次DFS可以找到多条增广路
重复直到无法构建分层图

核心代码：

bool bfs(){
    for(int i=1;i<=n;i++) deep[i]=MAX+5,vis[i]=0,cur[i]=head[i];
    deep[s]=0;
    while(!myline.empty()) myline.pop();
    myline.push(s);vis[s]=1;
    
    while(!myline.empty()){
        int u=myline.front();myline.pop();
        for(int i=head[u];i;i=q[i].link){
            int v=q[i].v;ll w=q[i].w;
            if(vis[v]||(!w)) continue;  // 已访问或残量为0
            if(deep[v]>MAX){  // 未访问过
                deep[v]=deep[u]+1;  // 记录层数
                myline.push(v);
                vis[v]=1;
            }
        }
    }
    if(deep[t]<MAX) return true;  // 能到达汇点
    return false; 
}

BFS作用：构建分层图，deep[i]表示节点i的层数

int dfs(ll limit,int st){
    if(!limit||st==t) return limit;  // 无流量或到达汇点
    ll flow=0,f;
    for(int i=cur[st];i;i=q[i].link){
        cur[st]=i;  // 当前弧优化
        int v=q[i].v;ll w=q[i].w;
        if(deep[v]==deep[st]+1&&(f=dfs(min(limit,w),v))){
            flow+=f;
            limit-=f;
            q[i].w-=f;
            q[i^1].w+=f;
            if(limit<0) return limit;
        }
    }
    return flow;
}

DFS特点：

多路增广：一次DFS可能找到多条路径
当前弧优化：cur[st]避免重复检查无效边
分层限制：deep[v]==deep[st]+1确保向下一层推进

Dinic算法的关键优化：

分层图：避免DFS绕远路
多路增广：一次DFS找到多条增广路
当前弧优化：避免重复检查已经"榨干"的边

时间复杂度：

O(V²E)，比EK的O(VE²)更优
对于单位容量图： $O(min(V^{2/3}, E^{1/2}) × E)$

与EK算法对比：

特性	EK算法	Dinic算法
寻路方式	BFS单路增广	BFS分层 + DFS多路增广
时间复杂度	O(VE²)	O(V²E)
实际效率	较慢	快很多
代码复杂度	简单	中等

代码中的关键点：

链式前向星：cnt从1开始，方便反向边操作
当前弧优化：cur[i]数组，避免重复检查
分层图：deep[i]记录节点层数
多路增广：DFS中flow+=f累计多条路径

算法正确性保证：

分层图性质：确保找到的增广路是最短的
多路增广：充分利用每次BFS构建的分层图
当前弧优化：不影响正确性，只提升效率

总结：Dinic算法通过分层图限制DFS方向，配合多路增广和当前弧优化，大幅提升了网络流算法的效率

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
const int N=1e4+5,M=1e5+5;
const ll MAX=123456789000;
int n,m,s,t;ll w;
queue<int > myline;
int head[N],cur[N],cnt=1;
ll deep[N];
struct edge{
	int link,v,u;
	ll w;
}q[M<<1];
bool vis[N];
void put(int u,int v,ll w){q[++cnt].v=v,q[cnt].u=u,q[cnt].w=w;q[cnt].link=head[u],head[u]=cnt;}
bool bfs(){
	for(int i=1;i<=n;i++) deep[i]=MAX+5,vis[i]=0,cur[i]=head[i];
	deep[s]=0;
	while(!myline.empty()) myline.pop();
	myline.push(s);vis[s]=1;
	while(!myline.empty()){
         int u=myline.front();myline.pop();
   		for(int i=head[u];i;i=q[i].link){
   			int v=q[i].v;ll w=q[i].w;
   			if(vis[v]||(!w)) continue;
   			if(deep[v]>MAX){
   				deep[v]=deep[u]+1;
   				myline.push(v);
   				vis[v]=1;
   			}
   		}
	}
	if(deep[t]<MAX) return true;
	return false; 
}
int dfs(ll limit,int st){
	if(!limit||st==t) return limit;
	ll flow=0,f;
	for(int i=cur[st];i;i=q[i].link){
		cur[st]=i;
		int v=q[i].v;ll w=q[i].w;
		if(deep[v]==deep[st]+1&&(f=dfs(min(limit,w),v))){
			flow+=f;
			limit-=f;
			q[i].w-=f;
			q[i^1].w+=f;
			if(limit<0) return limit;
		}
	}
	return flow;
}
void Dinic(){
	ll ff=0;
	while(bfs()){
//		for(int i=1;i<=n;i++){
//			printf("deep[%d]=%lld ",i,deep[i]);
//		}
//		puts("");
		ff=ff+dfs(MAX,s);
	} 
	printf("%lld",ff);
}
int main(){
	scanf("%d%d%d%d",&n,&m,&s,&t);
	for(int i=1;i<=m;i++){
		int u,v;ll w;
		scanf("%d%d%lld",&u,&v,&w);
		put(u,v,w),put(v,u,0);
	}
	Dinic();
}