graph | Max flow

最大流算法，解决的是从一个起点到一个终点，通过任何条路径能够得到的最大流量。

有个Edmond-Karp算法：

1. BFS找到一条增广路径；算出这条路径的最小流量（所有边的最小值）increase；

2. 然后更新路径上的权重（流量），正向边加上increase，反向边减去increase;

3. 重复1，直到没有增广路径；

可以证明的是在使用最短路增广时增广过程不超过V*E次，每次BFS的时间都是O(E)，所以Edmonds-Karp的时间复杂度就是O(V*E^2)。

图的BFS和DFS的时间复杂度都是O(n+e)，这里指用邻接表的方式。每次出栈或者出队列，都要扫一遍该点的所有边，所有点的边集加起来就是O(e)了。

至于为什么要用反向边，这里讲得挺清楚；

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <limits.h>
#include <vector>
using namespace std;

class Maxflow {
    public:

        Maxflow() {}
        ~Maxflow() {
            if (pre) delete[] pre;
            if (flow) delete[] flow;
            if (weight) {
                for (int i = 0; i < vertices; ++i) {
                    delete[] weight[i];
                }
                delete[] weight;
            }
        }
        void readGraph(string filename) {
            freopen(filename.c_str(), "r", stdin);
            int edges;
            scanf("%d %d", &vertices, &edges);
            pre = new int[vertices];
            flow = new int[vertices];
            memset(flow, 0, vertices * sizeof(int));
            weight = new int*[vertices];
            for (int i = 0; i < vertices; ++i) {
                weight[i] = new int[vertices];
                memset(weight[i], 0, vertices * sizeof(int));
            }

            for (int i = 0; i < edges; ++i) {
                int v1, v2, w;
                scanf("%d %d %d", &v1, &v2, &w);
                weight[v1 - 1][v2 - 1] = w;
            }
        }

        int maxFlow() {
            int start = 0, end = vertices - 1;
            int max = 0;
            int increase = 0;
            while ((increase = bfs(start, end)) != 0) {
                int p = end;
                while (p != start) {
                    int b = pre[p];
                    weight[b][p] -= increase;
                    weight[p][b] += increase;
                    p = b;
                }
                max += increase;
            }
            return max;
        }
    private:
        int bfs(int start, int end) {
            memset(pre, -1, vertices * sizeof(int));
            vector<vector<int> > layers(2);
            int cur = 0, next = 1;
            layers[cur].push_back(start);
            flow[start] = INT_MAX;

            while (!layers[cur].empty()) {
                layers[next].clear();
                for (int i = 0; i < layers[cur].size(); ++i) {
                    int v1 = layers[cur][i];
                    for (int v2 = 0; v2 < vertices; ++v2) {
                        if (weight[v1][v2] <= 0 || pre[v2] != -1) continue;
                        pre[v2] = v1;
                        layers[next].push_back(v2);
                        flow[v2] = min(flow[v1], weight[v1][v2]);
                        if (v2 == end) return flow[v2];
                    }
                }

                cur = !cur;
                next = !next;
            }
            return 0;
        }
        int* pre;
        int** weight;
        int* flow;
        int vertices;
};

int main() {
    Maxflow maxflow;
    maxflow.readGraph("input.txt");
    cout<< maxflow.maxFlow() << endl;
    return 0;
}

sample input:

4 5
1 2 40
1 4 20
2 4 20
2 3 30
3 4 10