poj 1273 || hdu 1532 Drainage Ditches 最大流
//poj 1273 || hdu 1532 Drainage Ditches 最大流
//普通最大流
//这里给出dinic的递归和非递归代码
//非递归：
//用dfs或bfs寻找一条增广路，并进行分层，比如 i能到 j，
//则 j的层次比 i多 1。如果聚点有在 增广路上(即有对应的
//层次,否则说明已经达到最大流了)，然后顺着层次寻找一条
//到达聚点的路，并记录下来，若某个结点流向下一结点时，流
//用不完，则说明可能有分支，记录最后一个分支，若找到聚点
//时停止查找。如果路径上最后一个结点为聚点时，计算能到达
//聚点的流量，并建立反向边。之后从分支点找另一条能到聚点
//的路。若路径上最后一个结点不是聚点时，跳向分支点前一个
//结点找路，若一直找不到，直到源点时，继续dfs或bfs找增广路
//递归：
//bfs对残余网络分层，若到达不了sink则表示没有增广路了，
//否则sink也分完层后就开始深搜从前一个节点到下
//一个节点要有容量且下一个节点的层次要比前一节点多1才可继续深搜
//非递归：记得保存分支的地方(上条边的流量流了一些到聚点后还有剩时)；
//注意用dinic的话如果用邻接表会tle，用邻接矩阵则不会。
//dinic时，若深搜到的点不能到达sink的点的层次要标为 -1，
//表示不能到达sink
//具体看代码
递归
//递归 #define comein freopen("in.txt", "r", stdin); #include <stdio.h> #include <string.h> #include <queue> #include <algorithm> using namespace std; #define INF 1<<30 #define N 500 int eid, n_point; int map[N][N]; //用邻接表居然tle了 int head[N], to[N], cap[N], next[N]; int level[N]; void add_edge(int from, int t, int f) { to[eid] = t; cap[eid] = f; next[eid] = head[from]; head[from] = eid++; to[eid] = from; //建反向边 cap[eid] = 0; next[eid] = head[t]; head[t] = eid++; } bool bfs(int root) //残余网络分层 { memset(level, -1, sizeof(level)); queue<int>que; que.push(root); level[root] = 0; while(!que.empty()) { root = que.front(); que.pop(); // for(int i = head[root]; i != -1; i = next[i]) for(int i = 1; i <= n_point; ++i) { //边还有残余容量，且下一个点还没分层 if(map[root][i] > 0 && level[i] == -1) { level[i] = level[root] + 1; if(i == n_point) return true; que.push(i); } // if(level[to[i]] == -1 && cap[i]) // { // level[to[i]] = level[root] + 1; // if(to[i] == n_point) // return true; // que.push(to[i]); // } } } return false; } int dfs(int root, int f) { if(root == n_point) return f; int flow, ans = 0; // for(int i = head[root]; i != -1; i = next[i]) for(int i = 1; i <= n_point; ++i) { // int m = min(cap[i], f - ans); //记得这里要 f-ans int m = min(map[root][i], f-ans); if(map[root][i] > 0 && level[root] + 1 == level[i] && ans < f && (flow = dfs(i, m) ) ) { map[root][i] -= flow; map[i][root] += flow; ans += flow; } // if(cap[i] && level[root]+1 == level[to[i]] && ans < f && // (flow = dfs(to[i], m ) ) ) // { //下标从0开始，则正向边为偶数，反向边为基数; // cap[i] -= flow; // cap[i^1] += flow;//下标从1开始则不能用 异或 // ans += flow; // } } if(ans == 0) //若没找到增广路，这时注意要把该点 level[root] = -1; //的层次标为-1，表示不能到达 return ans; } void dinic() { int flow = 0; while(bfs(1)) //分层 { while(1) //每条增广路都有一个瓶颈(增光路上最小容量的边) { //每次分层都要把所有增广路的瓶颈都清除掉，再重新分层 int f = dfs(1, INF);//因此最多层分v次 if(f == 0) break; flow += f; } } printf("%d\n", flow); } int main() { comein eid = 0; int n_edge; while(scanf("%d%d", &n_edge, &n_point) != EOF) { memset(map, 0, sizeof(map)); // memset(head, -1, sizeof(head)); while(n_edge--) { int from, to, f; scanf("%d%d%d", &from, &to, &f); map[from][to] += f; // add_edge(from, to, f); } dinic(); } return 0; }
非递归
//Dinic 非递归 //邻接矩阵 #include <stdio.h> #include <string.h> #define N 205 int n_node, n_edge; int map[N][N], level[N], que[N*N], path[N]; int bfs(int s) { memset(level, -1, sizeof(level)); int head = 0, tail = 0; que[tail++] = s; level[s] = 1; //源点标记为第一层 while(head < tail) { int now = que[head++]; for(int i = 1; i <= n_node; ++i) { if(map[now][i] != 0 && level[i] == -1) { level[i] = level[now] + 1; //标记层数 que[tail++] = i; } } } //如果聚点没有被分层的话，说明已经达到最大流了 return level[n_node] + 1; } int dinic(int s) { int max_flow = 0; while(bfs(s)) //广搜对一条增广路上的点分层 { int pos = 0, cut; path[++pos] = s; //记录增广路 while(1) { int flow = 1 << 30; int find = 1; //若增广路的最后一个结点是聚点，或者流不能流到下一个结点时，结束 while(path[pos] != n_node && find) { find = 0; for(int i = 1; i <= n_node; ++i) { if(level[i] == level[path[pos]] + 1 && map[path[pos]][i] != 0) { find = 1; path[++pos] = i; break; } } } if(path[pos] == n_node) //若有找到增广路 { for(int i = 1; i < pos; ++i) { if(flow > map[path[i]][path[i+1]]) { flow = map[path[i]][path[i+1]]; cut = i; //记录分叉的地方，这个地方的流没全用完 } } max_flow += flow; for(int i = 1; i < pos; ++i) { map[path[i]][path[i+1]] -= flow; map[path[i+1]][path[i]] += flow; //建反向边 } pos = cut; //从流没用完的边，也就是分支处继续找下一条到聚点的路 } else //若没有到达聚点 { if(pos == 1) break; else { level[path[pos]] = -1; //若这个点不能到达聚点，则去掉 pos--; } } } } return max_flow; } int main() { while(scanf("%d%d", &n_edge, &n_node) != EOF) { memset(map, 0, sizeof(map)); for(int i = 0; i < n_edge; ++i) { int from, to, flow; scanf("%d%d%d", &from, &to, &flow); map[from][to] += flow; } printf("%d\n", dinic(1)); } return 0; }
EK算法
//EK算法比较容易理解 //用广搜找到一条增广路，记录路径，找出增广路中最小 //的边为流到汇点的流量，建反向边，一直重复道没增广路为止； #include <iostream> #include <stdio.h> #include <string.h> #include <queue> using namespace std; #define INF (1<<30) #define N 205 int map[N][N], fa[N]; bool vis[N]; bool bfs(int n) //广搜找增广路 { memset(vis, false, sizeof(vis)); memset(fa, -1, sizeof(fa)); queue<int>que; que.push(1); vis[1] = true; while(!que.empty()) { int now = que.front(); que.pop(); vis[now] = true; for(int i = 1; i <= n; ++i) { if(vis[i] == false && map[now][i] > 0) { vis[i] = true; fa[i] = now; //记录路径 if(i == n) return true; que.push(i); } } } return false; } void EK(int n, int m) //找增广路 { int ans = 0; while(bfs(n)) { int min = INF; //找出增广路的瓶颈，即增广路中的最短边 for(int i = n; i != 1; i = fa[i]) min = map[fa[i]][i] < min ? map[fa[i]][i] : min; for(int i = n; i != 1; i = fa[i]) { map[fa[i]][i] -= min; map[i][fa[i]] += min; //增加反向流 } ans += min; } printf("%d\n", ans); } int main() { int n, m; while(scanf("%d%d", &m, &n) != EOF) { memset(map, 0, sizeof(map)); for(int i = 0; i < m; ++i) { int from, to, f; scanf("%d%d%d", &from, &to, &f); map[from][to] += f; } EK(n, m); } return 0; }
