【算法】最大流问题——Ford-Fulkerson算法+Dinic算法

Ford-Fulkerson算法描述：

最大流问题可以看做是无向图搜索，找到一条可以使结果增加的边。不过只有当有流量出去，对应的向回推的流才有容量，二者相加等于该边总容量。不断搜索直到没有可以增加的边，则返回最大值。Ford-Fulkerson算法的复杂度为O(FE)。

添加对应边

struct Stream{//保存终点，流量，反向边编号 
    int to,cap,revNum;
};
vector<Stream>G[Max_Node];
void Add_Stream(int from,int to,int cap){
    G[from].push_back((Stream){to,cap,G[to].size()}); 
    G[to].push_back((Stream){from,0,G[from].size()-1});//由于from刚刚插入了一个，所以为size()-1 
} 

查找一条增广路

每一次查找后，正向路的容量为c-f,反向路径的流量为f。

bool used[Max_Node];
int dfs(int v,int t,int f){//当前点，终点(不变),当前流量 
//  printf("%d %d %d\n",v,t,f);
    if(v==t)return f;
    used[v]=true;
    for(int i=0;i<G[v].size();i++){
        Stream &temp=G[v][i];
        if(!used[temp.to]&&temp.cap>0){
            int d=dfs(temp.to,t,min(f,temp.cap));
            if(d>0){
                temp.cap-=d;
                G[temp.to][temp.revNum].cap+=d;
                return d;
            }
        }
    }
    return 0; 
}

找出最大流

死循环不断调用深度优先搜索，直到没有增广路为止。

int max_flow(int s,int t){
    int flow=0;
    for(;;){
        memset(used,0,sizeof(used));
        int f=dfs(s,t,INF);
        if(f==0)return flow;
        flow+=f; 
    }
}

测试代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<string>
#include<vector>
#include<algorithm>
#define INF 99999999
#define Max_Node 1000
using namespace std;
struct Stream{//保存终点，流量，反向边编号 
    int to,cap,revNum;
};
vector<Stream>G[Max_Node];
bool used[Max_Node];
void Add_Stream(int from,int to,int cap){
    G[from].push_back((Stream){to,cap,G[to].size()}); 
    G[to].push_back((Stream){from,0,G[from].size()-1});//由于from刚刚插入了一个，所以为size()-1 
} 
int dfs(int v,int t,int f){//当前点，终点(不变),当前流量 
//  printf("%d %d %d\n",v,t,f);
    if(v==t)return f;
    used[v]=true;
    for(int i=0;i<G[v].size();i++){
        Stream &temp=G[v][i];
        if(!used[temp.to]&&temp.cap>0){
            int d=dfs(temp.to,t,min(f,temp.cap));
            if(d>0){
                temp.cap-=d;
                G[temp.to][temp.revNum].cap+=d;
                return d;
            }
        }
    }
    return 0; 
}
int max_flow(int s,int t){
    int flow=0;
    for(;;){
        memset(used,0,sizeof(used));
        int f=dfs(s,t,INF);
        if(f==0)return flow;
        flow+=f; 
    }
}
int main(){
    int s=0,t=4;
    Add_Stream(s,1,10);
    Add_Stream(s,2,2);
    Add_Stream(1,2,6);
    Add_Stream(1,3,6);
    Add_Stream(3,2,3);
    Add_Stream(3,t,8);
    Add_Stream(2,t,5);
    printf("%d\n",max_flow(s,t));
    return 0;
}

Dinic算法描述

Dinic算法通过宽度优先搜索产生分层图，然后在上面进行深度优先搜索寻找最短増广路径。如果找不到了，则说明最短增广路变长或不存在增广路了，于是继续重新构造分层图，由于每一次循环后最短增广路长度至少增加1，所以最多重复O(V)步,我们通过iter数组避免对没有用的边进行多次检查，将复杂度降为O(EV)，总复杂度为O(EV^2)。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<string>
#include<vector>
#include<queue>
#include<algorithm>
#define INF 99999999
#define Max_Node 1000
using namespace std;
struct Stream{//保存终点，流量，反向边编号 
    int to,cap,revNum;
};
vector<Stream>G[Max_Node];
int level[Max_Node];//顶点到源点的距离标号 
int iter[Max_Node];//当前弧，在其之前的边就没有用了 

void Add_Stream(int from,int to,int cap){
    G[from].push_back((Stream){to,cap,G[to].size()}); 
    G[to].push_back((Stream){from,0,G[from].size()-1});//由于from刚刚插入了一个，所以为size()-1 
} 
void bfs(int s){
    memset(level,-1,sizeof(level));
    queue<int> que;
    level[s]=0;
    que.push(s);
    while(!que.empty()){
        int v=que.front();que.pop();
        for(int i=0;i<G[v].size();i++){
            Stream &e=G[v][i];
            if(e.cap>0&&level[e.to]<0){
                level[e.to]=level[v]+1;
                que.push(e.to);
            }
        }
    }
} 
int dfs(int v,int t,int f){//当前点，终点(不变),当前流量 
    printf("%d %d %d\n",v,t,f);
    if(v==t)return f;
    for(int &i=iter[v];i<G[v].size();i++){
        Stream &temp=G[v][i];
        if(temp.cap>0&&level[v]<level[temp.to]){
            int d=dfs(temp.to,t,min(f,temp.cap));
            if(d>0){
                temp.cap-=d;
                G[temp.to][temp.revNum].cap+=d;
                return d;
            }
        }
    }
    return 0; 
}
int max_flow(int s,int t){
    int flow=0;
    for(;;){
        bfs(s);
        if(level[t]<0)return flow;
        memset(iter,0,sizeof(iter));
        int f;
        while((f=dfs(s,t,INF))>0)flow+=f; 
    }
}
int main(){
    int s=0,t=4;
    Add_Stream(s,1,10);
    Add_Stream(s,2,2);
    Add_Stream(1,2,6);
    Add_Stream(1,3,6);
    Add_Stream(3,2,3);
    Add_Stream(3,t,8);
    Add_Stream(2,t,5);
    printf("%d\n",max_flow(s,t));
    return 0;
}