《数据结构与算法分析：C语言描述》复习——第九章“图论”——最大流问题

  1 // My first practice on maximum flow problem. This is an implementation using Edmonds-Karp Algorithm.
  2 #include <algorithm>
  3 #include <iostream>
  4 #include <queue>
  5 #include <vector>
  6 using namespace std;
  7 
  8 const int INFINITY = 1000000000;
  9 
 10 bool findAugmentPath(const vector<vector<int> > &rg, vector<int> &path, 
 11     const int start, const int end)
 12 {
 13     // Find an augment path with BFS.
 14     queue<int> q;
 15     vector<int> back_trace;
 16     int n;
 17     int i;
 18     
 19     n = rg.size();
 20     back_trace.resize(n, -1);
 21     
 22     int tmp;
 23     
 24     back_trace[start] = start;
 25     q.push(start);
 26     while (!q.empty()) {
 27         if (back_trace[end] >= 0) {
 28             // An augment path is found.
 29             break;
 30         }
 31         tmp = q.front();
 32         q.pop();
 33         for (i = 0; i < n; ++i) {
 34             if (rg[tmp][i] == INFINITY) {
 35                 continue;
 36             }
 37             if (i == tmp || back_trace[i] >= 0) {
 38                 continue;
 39             }
 40             back_trace[i] = tmp;
 41             q.push(i);
 42         }
 43     }
 44     
 45     if (q.empty()) {
 46         return false;
 47     }
 48     
 49     path.clear();
 50     tmp = end;
 51     while (tmp != start) {
 52         path.push_back(tmp);
 53         tmp = back_trace[tmp];
 54     }
 55     path.push_back(tmp);
 56     reverse(path.begin(), path.end());
 57     
 58     while (!q.empty()) {
 59         q.pop();
 60     }
 61     back_trace.clear();
 62     
 63     return true;
 64 }
 65 
 66 void addFlow(vector<vector<int> > &rg, const vector<int> &path, const int flow)
 67 {
 68     int i;
 69     
 70     for (i = 0; i < (int)path.size() - 1; ++i) {
 71         if (rg[path[i]][path[i + 1]] == flow) {
 72             rg[path[i]][path[i + 1]] = INFINITY;
 73         } else {
 74             rg[path[i]][path[i + 1]] -= flow;
 75         }
 76         
 77         if (rg[path[i + 1]][path[i]] == INFINITY) {
 78             rg[path[i + 1]][path[i]] = flow;
 79         } else {
 80             rg[path[i + 1]][path[i]] += flow;
 81         }
 82     }
 83 }
 84 
 85 int maximumFlow(const vector<vector<int> > &graph, int start, int end)
 86 {
 87     // The residual graph
 88     vector<vector<int> > rg;
 89     vector<int> path;
 90     int flow, maximum_flow;
 91     int i;
 92     
 93     if (graph.size() < 2 || start == end) {
 94         return 0;
 95     }
 96     
 97     rg = graph;
 98     maximum_flow = 0;
 99     while (findAugmentPath(rg, path, start, end)) {
100         flow = rg[path[0]][path[1]];
101         for (i = 1; i < (int)path.size() - 1; ++i) {
102             flow = min(flow, rg[path[i]][path[i + 1]]);
103         }
104         addFlow(rg, path, flow);
105         maximum_flow += flow;
106     }
107     
108     return maximum_flow;
109 }
110 
111 int main()
112 {
113     vector<vector<int> > graph;
114     vector<int> dist;
115     vector<bool> reachable;
116     int n;
117     int nk;
118     int i, j;
119     int tmp, tmp_dist;
120     int maximum_flow;
121     int start, end;
122     
123     while (cin >> n && n > 0) {
124         graph.resize(n);
125         for (i = 0; i < n; ++i) {
126             graph[i].resize(n, INFINITY);
127         }
128         
129         for (i = 0; i < n; ++i) {
130             cin >> nk;
131             for (j = 0; j < nk; ++j) {
132                 cin >> tmp >> tmp_dist;
133                 graph[i][tmp] = tmp_dist;
134             }
135         }
136         
137         cin >> start >> end;
138         maximum_flow = maximumFlow(graph, start, end);
139         
140         cout << "Maximum flow is " << maximum_flow << "." << endl;
141         
142         for (i = 0; i < n; ++i) {
143             graph[i].clear();
144         }
145         graph.clear();
146     }
147     
148     return 0;
149 }