网络最大流问题

参考

下面几个博文或视频,是我觉得对网络流入门非常有帮助的。
B站视频：
算法流程（前面几部分是铺垫，有助于理解网络流问题）： 13-3: Edmonds-Karp Algorithm 寻找网络最大流
浅显的理论解释：[算法竞赛入门] 网络流基础：理解最大流/最小割定理 (蒋炎岩)
文字版总结：
Edmonds-karp算法详解

代码部分

根据前面的学习，Edmonds-Karp 算法主要是循环进行以下4步：

1. 找出s->t的最短路径; 2.寻找路径中最小容量a; 3.所有路径减去a; 4. 增加反向弧

代码来自【算法竞赛入门经典 第2版 刘汝佳】368页，我仅仅增加了注释:

#include <iostream>
#include <queue>
#include <vector>
using namespace std;
const int MAXN = 100;
struct Edge
{
    int from, to, cap, flow;
    Edge(int u, int v, int c, int f) : from(u), to(v), cap(c), flow(f) {}
};

struct EdmondsKarp
{
    int n, m;
    vector<Edge> edges;  // 边数的两倍(弧和反向弧)
    vector<int> G[MAXN]; // 邻接表,G[i][j]表示节点i的第j条边在edges中的序号
    int a[MAXN];         // 从起点s到顶点i的可改进量(s到当前点可以通过的最大流量),是逐步取min的
    int preE[MAXN];      // 最短路树上p的入弧编号, previous Edge

    void init(int n)
    {
        for (int i = 0; i < n; i++)
            G[i].clear();
        edges.clear();
    }

    void AddEdges(int from, int to, int cap)
    {
        edges.push_back(Edge(from, to, cap, 0)); // edges的中存放正/反向弧,其中,偶数序号里是正向弧,奇数序号是反向弧
        edges.push_back(Edge(to, from, 0, 0));   // 反向弧
        m = edges.size();
        G[from].push_back(m - 2); // 每个顶点(from/to)的弧和反向弧,都放在同一个G[v]中.
        G[to].push_back(m - 1);
    }

    int MaxFlow(int s, int t)
    {

        int flow = 0;
        while (true)
        {
            fill(a, a + MAXN, 0);
            queue<int> Q;
            Q.push(s);
            a[s] = INT_MAX; // 一开始流入
            while (!Q.empty())
            {
                int x = Q.front(); // 取出队头顶点编号x
                Q.pop();
                for (int i = 0; i < G[x].size(); i++)
                { // 对x所有的相临边(弧和反向弧)进行操作
                    Edge &e = edges[G[x][i]];
                    if (!a[e.to] && e.cap > e.flow) //如果没有计算过a[x的相临边e.to]并且可以加入该边
                    {
                        preE[e.to] = G[x][i];                // 记录x(=e.from)->e.to(也即是edges[G[x][i]]),p记录入弧
                        a[e.to] = min(a[x], e.cap - e.flow); // 2.寻找路径中最小容量,当前点e.to的流量等于已有的x点流量和入弧流量的较小值
                        Q.push(e.to);                        // bfs,同时取多条路来观察,说不定那条先到t点
                    }
                }
                if (a[t]) // 已经找到由s-...->t的路了,这就是最短路
                    break;
            }
            if (!a[t]) // 没有通路,不再进行查找了
                break;
            for (int u = t; u != s; u = edges[preE[u]].from) // 3.所有路径减去x; 4. 增加反向弧
            {
                edges[preE[u]].flow += a[t];     // 入弧流增加了
                edges[preE[u] ^ 1].flow -= a[t]; // 反向弧的流减少了,这样cap-flow就为正了,相当于反向弧容量增加了.
            }
            flow += a[t]; // 网络流计数
        }
        return flow;
    }
};
int main()
{
    int from, to, cap;
    EdmondsKarp ek;
    int n, m; // 顶点数,边数
    cin >> n >> m;
    while (m--)
    {
        cin >> from >> to >> cap;
        ek.AddEdges(from, to, cap);
    }
    cout << "最大流为" << ek.MaxFlow(0, n - 1) << endl;
    return 0;
}

	测试一	测试二
输入	6 8 0 1 4 0 2 2 1 2 1 1 3 2 1 4 4 2 4 2 3 5 3 4 5 3	4 5 0 1 100 0 2 100 1 2 1 1 3 100 2 3 100
输出	最大流为5	最大流为200