最大流poj1273（三大算法解析）

模板题：（poj1273）

 

Drainage Ditches

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions:87924		Accepted: 34130

Description

Every time it rains on Farmer John's fields, a pond forms over Bessie's favorite clover patch. This means that the clover is covered by water for awhile and takes quite a long time to regrow. Thus, Farmer John has built a set of drainage ditches so that Bessie's clover patch is never covered in water. Instead, the water is drained to a nearby stream. Being an ace engineer, Farmer John has also installed regulators at the beginning of each ditch, so he can control at what rate water flows into that ditch. 
Farmer John knows not only how many gallons of water each ditch can transport per minute but also the exact layout of the ditches, which feed out of the pond and into each other and stream in a potentially complex network. 
Given all this information, determine the maximum rate at which water can be transported out of the pond and into the stream. For any given ditch, water flows in only one direction, but there might be a way that water can flow in a circle. 

Input

The input includes several cases. For each case, the first line contains two space-separated integers, N (0 <= N <= 200) and M (2 <= M <= 200). N is the number of ditches that Farmer John has dug. M is the number of intersections points for those ditches. Intersection 1 is the pond. Intersection point M is the stream. Each of the following N lines contains three integers, Si, Ei, and Ci. Si and Ei (1 <= Si, Ei <= M) designate the intersections between which this ditch flows. Water will flow through this ditch from Si to Ei. Ci (0 <= Ci <= 10,000,000) is the maximum rate at which water will flow through the ditch.

Output

For each case, output a single integer, the maximum rate at which water may emptied from the pond.

Sample Input

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

Sample Output

50

Source

USACO 93

题意：从1流到m的最大流。

思路：最大流模板题。

最大流详解：https://blog.csdn.net/x_y_q_/article/details/51999466

最大流EK算法

#include<iostream>
#include<cstdio>
#include<string.h>
#include<queue>
using namespace std;
int n,m;
int map[210][210];//存图 
int flow[210];//一条可行流中的最小流（因为一条路径中流量是由最小的那个决定的） 
int pre[210];//记录每个点的前驱 
queue<int>Q;
int bfs(int start,int ed){//查找可行流
    while(!Q.empty()) Q.pop();
    for(int i=1;i<=m;i++){
        pre[i]=-1;//将每个点的前驱赋值为-1 
    }
    pre[start]=0;//起点前驱为0 
    Q.push(start);
    flow[start]=0x3f3f3f3f;//初始化，方便找流量最小的那个路径 
    while(!Q.empty()){
        int index=Q.front();
        Q.pop();
        for(int i=1;i<=m;i++){
            if(pre[i]==-1&&map[index][i]>0){//没有被走过，且index->i的流量大于0 
                pre[i]=index;//记录前驱（i的前驱是index） 
                flow[i]=min(flow[index],map[index][i]);//更新flow 
                Q.push(i);
            }
        }
    }
    if(pre[ed]==-1) return -1;//如果终点前驱是-1即代表没有路能到达终点即无增广路径 
    else return flow[ed];
}
int Max_flow(int start,int ed){
    int ans=0; 
    int cnt=0;
    while((cnt=bfs(start,ed))!=-1){
        int k=ed;
        while(k!=start){//迭代，查找需改变流量路径 
            int last=pre[k];
            map[last][k]-=cnt;//改变正向流量 
            map[k][last]+=cnt;//改变反向流量 
            k=last;
        }
        ans+=cnt;
    }
    return ans;
}
int main(){
    while(cin>>n>>m){
        memset(map,0,sizeof(map));
        memset(flow,0,sizeof(flow));
        int start,ed,flo;
        for(int i=0;i<n;i++){
            cin>>start>>ed>>flo;
            if(start==ed) continue;
            map[start][ed]+=flo;//可能输入有重边 
        }
        cout<<Max_flow(1,m)<<endl;
    }
    return 0;
}

 最大流Ford-Fulkerson算法

#include<iostream>
#include<string.h>
#include<queue>
using namespace std;
int map[300][300];
int n,m;
bool vis[300];//标记该点有没有用过 
int dfs(int start,int ed,int cnt){//cnt是查找到的增广路中流量最小的边 
    if(start==ed) return cnt;//起点等于终点，即已经查到一条可行增广路 
    for(int i=1;i<=m;i++){//以起点start遍历与它相连的每一条边 
        if(map[start][i]>0&&!vis[i]){//这条边是否可行 
            vis[i]=true;//标记已经走过 
            int d=dfs(i,ed,min(cnt,map[start][i]));//递归查找 
            if(d>0){//回溯时更行map，这和EK的迭代更行差不多 
                map[start][i]-=d;
                map[i][start]+=d;
                return d; 
            }
        }
    }
    return 0;//没找到 
}
int Max_flow(int start,int ed){
    int ans=0;
    while(true){
        memset(vis,false,sizeof(vis));
        int f=dfs(start,ed,0x3f3f3f3f);//查找增广路 
        //cout<<f<<endl;
        if(f==0) return ans;//没有增广路了 
        ans+=f;
    }
}
int main(){
    int start,ed,w;
    while(cin>>n>>m){
        memset(map,0,sizeof(map));
        for(int i=0;i<n;i++){
            cin>>start>>ed>>w;
            if(start==ed) continue;
            map[start][ed]+=w;
        }
        cout<<Max_flow(1,m)<<endl;
    }
    return 0;
}

前面两个算法不同的是一个是用dfs查找增广路，一个是用bfs查找。

观察前面的dfs算法，对于层次相同的边，会经过多次重复运算，很浪费时间（如有这么一组数据，(1 2 2）（1 3 2） （2 4 1） （3 4 1）那么【1】【2，3】【4】就是他们的层次，所以2->3就是没必要走的 ），那么，可以考虑先对原图分好层产生新的层次图，即保存了每个点的层次，注意，很多人会把这里的边的最大容量跟以前算最短路时的那个权值混淆，其实这里每个点之间的距离都可以看作单位距离，然后对新图进行dfs，这时的dfs就非常有层次感，有筛选感了，同层次的点不可能在同一跳路径中，直接排除。那么运行速度就会快很多了。

这就是dinic算法的思想

最大流dinic算法

#include<iostream>
#include<queue>
#include<string.h>
using namespace std;
int dep[300];//dep是层次 
int map[300][300];
int n,m;
bool bfs(int start,int ed){//图分层 
    if(start==ed) return false;//防止输入的起点与终点相等 
    queue<int>Q;
    while(!Q.empty()) Q.pop();
    Q.push(start);
    memset(dep,-1,sizeof(dep));//先将所有点的层次变为-1 
    dep[start]=0;//第一层定义为0 
    while(!Q.empty()){
        int index=Q.front();//起点 
        Q.pop();
        for(int i=1;i<=m;i++){//与index相连的边（index->i） 
            if(map[index][i]>0&&dep[i]==-1){//没被分过成且map>0 
                dep[i]=dep[index]+1;//i的层是index层+1 
                Q.push(i);
            }
        }
    }
    return dep[ed]!=-1;//如果终点层等于-1，即是图已经无法进行分层 
}
int bt=0;
int dfs(int start,int ed,int cnt){//寻找增广路 （与Ford-Fulkerson算法差不多） 
    if(start==ed) return cnt;
    int d;
    for(int i=1;i<=m;i++){
        if(dep[i]==dep[start]+1&&map[start][i]>0){//用层次去查询，排除了走相同层 
            cout<<bt++<<":"<<start<<"  ,  "<<i<<"               "<<dep[i]<<"   ,"<<dep[start]<<endl;
                d = dfs(i,ed, min(cnt, map[start][i]));
                if(d>0){
                    map[start][i]-=d;
                    map[i][start]+=d;
                    return d;
                }
            }
        }
    return 0;
}
int Max_flow(int start,int ed){
    int ans=0;
    while(bfs(start,ed)){//将图进行分层 
        while(true){
            int d=dfs(start,ed,0x3f3f3f3f);
            if(d==0) break;//该分层图已经无法找到增广路 
            ans+=d;
        }
    }
    return ans;//所有增广路已经查找完毕 
}
int main(){
    int start,ed,w;
    while(cin>>n>>m){
        memset(map,0,sizeof(map));
        for(int i=0;i<n;i++){
            cin>>start>>ed>>w;
            map[start][ed]+=w;
        }
        cout<<Max_flow(1,m)<<endl;
    }
    return 0;
}