[最大流/Edmonds-karp算法]hiho1369 网络流一

最新推荐文章于 2025-05-11 00:32:21 发布

原创最新推荐文章于 2025-05-11 00:32:21 发布 · 385 阅读

0 ·

CC 4.0 BY-SA版权

网络流专栏收录该内容

2 篇文章

订阅专栏

本文介绍了一种解决最大交通车流量问题的方法——Edmonds-Karp算法，并通过C++代码详细展示了该算法的具体实现过程。

hiho1369 网络流一

题意：

最大交通车流量

思路：

裸的Edmonds_karp算法，请套模板

代码：

/**************************************************************
    Problem: hiho_1369
    User: soundwave
    Language: C++
    Result: Accepted
    Time: 24ms
    Memory: 1MB
****************************************************************/
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <stdio.h>
#include <queue>
#include <vector>
#include <cmath>
#include <string.h>
//注意重边
using namespace std;
const int maxn = 500+5;
const int INF = 1<<29;
int my_min(int x, int y){
    return x<y?x:y;
}
struct Edge{
    int from, to;
    int cap, flow;
    Edge(int u, int v, int c, int f): from(u), to(v), cap(c), flow(f) {}
};
struct Edmonds_karp{
    int n, m;
    vector<Edge> edges;
    vector<int> G[maxn];
    int path[maxn];
    int a[maxn];
    void init(int n){
        for(int i=0; i<n; i++)
            G[i].clear();
        edges.clear();
    }
    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);
    }
    int MaxFlow(int s, int t){
        int re = 0;
        while(1){
            queue<int> Q;
            Q.push(s);
            memset(a,0,sizeof(a));
            a[s] = INF;
            //bfs找增广路
            while(!Q.empty()){
                int u = Q.front();
                Q.pop();
                for(int i=0; i<G[u].size(); i++){
                    Edge &v = edges[G[u][i]];
                    if(!a[v.to] && v.cap>v.flow){
                        path[v.to] = G[u][i];
                        Q.push(v.to);
                        a[v.to] = my_min(a[u], v.cap-v.flow);
                    }
                }
                if(a[t]) break;
            }
            if(!a[t]) break;//找不到增广路，当前的流量就是最大流
            for(int u=t; u!=s; u=edges[path[u]].from){
                edges[path[u]].flow += a[t];
                edges[path[u]^1].flow -= a[t];
            }
            re += a[t];
        }
        return re;
    }
};
int n,m;
Edmonds_karp EK;
int main(){
    int x, y, val;
    while(~scanf("%d%d", &n, &m)){
        EK.init(n);
        while(m-->0){
            scanf("%d%d%d", &x, &y, &val);
            EK.AddEdge(x,y,val);
        }
        x = EK.MaxFlow(1,n);
        printf("%d\n", x);
    }
    return 0;
}