最大网络流（Ford-Fulkerson算法）(hihicoder)

最新推荐文章于 2024-06-23 18:31:33 发布

_秋鸿

最新推荐文章于 2024-06-23 18:31:33 发布

阅读量573

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/arz74/article/details/52540609

算法同时被 3 个专栏收录

22 篇文章

订阅专栏

JAVA

6 篇文章

订阅专栏

hihocoder

5 篇文章

订阅专栏

本文深入探讨了Ford-Fulkerson算法在网络流问题中的应用，详细解释了其工作原理，并提供了Java和C++的实现示例。

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

Ford-Fulkerson算法

（有向图）

1.寻找一条从远点到终点的路径

2.找出这条路径里的最短边

3.将这条路径上的边减去 2 中求的最短边，其反向的边则加上最短边

4.重复 1 直到无法找到一条从源点到终点的边

至于为什么反向边要加，我是这么理解的：

由于我们找的路径之间可能会交叉，但方向相反，而如果画出实际的网络流图，你会发现这些边会被抵消，从而没有显示。

如图：

在实际中寻找可能会出现这中情况

第一条路径为 1 -> 2 -> 3 -> 4

如果反向边不加的化，就没有路径了，但这是错的；

如果反向边加了的话，

第二条路径就是：1 -> 3 -> 2 -> 4

2 -> 3 和 3 -> 2 正好反向了，实际上也就抵消了；

代码：基于dfs

JAVA代码，下面还有C++的

import java.util.Scanner;
import java.util.ArrayList;

public class Main {
    private static Scanner scan = new Scanner(System.in);
    static final int MAX = 507;
    static int[][] a = new int[MAX][MAX]; 
    static boolean[] b = new boolean[MAX];
    static boolean flag=true;
    static int ans=0;
    public static void dfs(int x,int n,int pre[]){
        if(x == n)flag = true;
    	for(int i=1;i<=n && !flag;++i){
    		if(a[x][i] > 0 && b[i] == false){
    			b[i]=true;
    			pre[i]=x;
    			dfs(i,n,pre);
    		}
    	}
    }
    
    public static void main(String[] args) {
        int n,m;
    	n = scan.nextInt();
    	m = scan.nextInt();
    	int[] pre = new int[n+1];
    	for(int i=0;i<m;++i){
            int x,y,c;
            x = scan.nextInt();
            y = scan.nextInt();
            c = scan.nextInt();
            a[x][y] += c;
    	}
    	
    	while(flag){
    		for(int i=0;i<=n;++i)b[i]=false;
    		b[1]=true;
    		pre[1]=1;
    		flag=false;
    		dfs(1,n,pre);
    		if(flag == false)break;
    		int min=Integer.MAX_VALUE;
    		for(int i=n;pre[i]!=i;){
    		    if(a[pre[i]][i]<min)min=a[pre[i]][i];
    		    i = pre[i];
    		}
    		for(int i=n;pre[i]!=i;){
    			a[pre[i]][i] -= min;
    			a[i][pre[i]] += min;
    			i = pre[i];
    		}
    		ans += min;
    	}
    	
    	System.out.println(ans);
        scan.close();
    }
}

C++代码

#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#include<stack>
using namespace std;
#define MAX 507
typedef long long ll;

int n,m,sum=0,g[MAX][MAX];
vector<int> a[MAX];
bool b[MAX],flag=1;
void dfs(int x,int pre[]){
    if(x == n)flag=1;;
    for(int i=0;i<(int)a[x].size() && !flag;++i)
        if(b[a[x][i]] == false && g[x][a[x][i]] > 0){
             b[a[x][i]] = true;
             pre[a[x][i]] = x;
             dfs(a[x][i],pre);
        }
}

int main(){
    int pre[MAX];
    cin>>n>>m;

    for(int i=0;i<m;++i){
        int x,y,c;
        cin>>x>>y>>c;
        if(g[x][y] == 0)a[x].push_back(y),a[y].push_back(x);
        g[x][y]+=c;
    }

    while(flag){
        memset(b,0,sizeof(b));
        memset(pre,0,sizeof(pre));
        flag=0,b[1]=true,pre[1]=1;
        dfs(1,pre);
        if(flag == 0)break;
        int Min=100000;
        for(int i=n;pre[i]!=i;){
            if(g[pre[i]][i] < Min)Min = g[pre[i]][i];
            i = pre[i];
        }
        for(int i=n;pre[i]!=i;){
            g[pre[i]][i] -= Min;
            g[i][pre[i]] += Min;
            i = pre[i];
        }
        sum += Min;
    }

    cout<<sum<<endl;
    return 0;
}