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)了。

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

 1 #include <iostream>
 2 #include <stdio.h>
 3 #include <string.h>
 4 #include <limits.h>
 5 #include <vector>
 6 using namespace std;
 7 
 8 class Maxflow {
 9     public:
10 
11         Maxflow() {}
12         ~Maxflow() {
13             if (pre) delete[] pre;
14             if (flow) delete[] flow;
15             if (weight) {
16                 for (int i = 0; i < vertices; ++i) {
17                     delete[] weight[i];
18                 }
19                 delete[] weight;
20             }
21         }
22         void readGraph(string filename) {
23             freopen(filename.c_str(), "r", stdin);
24             int edges;
25             scanf("%d %d", &vertices, &edges);
26             pre = new int[vertices];
27             flow = new int[vertices];
28             memset(flow, 0, vertices * sizeof(int));
29             weight = new int*[vertices];
30             for (int i = 0; i < vertices; ++i) {
31                 weight[i] = new int[vertices];
32                 memset(weight[i], 0, vertices * sizeof(int));
33             }
34 
35             for (int i = 0; i < edges; ++i) {
36                 int v1, v2, w;
37                 scanf("%d %d %d", &v1, &v2, &w);
38                 weight[v1 - 1][v2 - 1] = w;
39             }
40         }
41 
42         int maxFlow() {
43             int start = 0, end = vertices - 1;
44             int max = 0;
45             int increase = 0;
46             while ((increase = bfs(start, end)) != 0) {
47                 int p = end;
48                 while (p != start) {
49                     int b = pre[p];
50                     weight[b][p] -= increase;
51                     weight[p][b] += increase;
52                     p = b;
53                 }
54                 max += increase;
55             }
56             return max;
57         }
58     private:
59         int bfs(int start, int end) {
60             memset(pre, -1, vertices * sizeof(int));
61             vector<vector<int> > layers(2);
62             int cur = 0, next = 1;
63             layers[cur].push_back(start);
64             flow[start] = INT_MAX;
65 
66             while (!layers[cur].empty()) {
67                 layers[next].clear();
68                 for (int i = 0; i < layers[cur].size(); ++i) {
69                     int v1 = layers[cur][i];
70                     for (int v2 = 0; v2 < vertices; ++v2) {
71                         if (weight[v1][v2] <= 0 || pre[v2] != -1) continue;
72                         pre[v2] = v1;
73                         layers[next].push_back(v2);
74                         flow[v2] = min(flow[v1], weight[v1][v2]);
75                         if (v2 == end) return flow[v2];
76                     }
77                 }
78 
79                 cur = !cur;
80                 next = !next;
81             }
82             return 0;
83         }
84         int* pre;
85         int** weight;
86         int* flow;
87         int vertices;
88 };
89 
90 int main() {
91     Maxflow maxflow;
92     maxflow.readGraph("input.txt");
93     cout<< maxflow.maxFlow() << endl;
94     return 0;
95 }

sample input:

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

转载于:https://www.cnblogs.com/linyx/p/3989369.html