Dinic算法

递归邻接表

#include <iostream>
#include <string.h>
#include <queue>
using namespace std;

const int INF = 0x3f3f3f3f;
const int MAX_N=100;     //顶点数上限
const int MAX_M=10000;    //总的边数上限

struct edge{
    int v,c,next;       //v指另一个顶点，c表示容量。
}e[MAX_M];

int p[MAX_N],eid;

void init(){
	memset(p,-1,sizeof(p));
    eid=0;
}

void insert(int u,int v,int c){ //插入一条从u向v，容量为c的弧。
    e[eid].v=v;
    e[eid].next=p[u];
    e[eid].c=c;
    p[u]=eid++;
}

void addedge(int u,int v,int c){ //用insert插入网络中的弧
    insert(u,v,c);
    insert(v,u,0);                  //插入一条反方向，当前容量为0的弧
}

int S,T;                             //S是源点，T是汇点。
int d[MAX_N];                        //存储每个顶点的层次
bool bfs(){
    memset(d,-1,sizeof(d));
    queue<int> q;
    q.push(S);
    d[S]=0;
    while(!q.empty()){
        int u=q.front();
        q.pop();
        for(int i=p[u];i!=-1;i=e[i].next){
            int v=e[i].v;
            if(e[i].c>0&&d[v]==-1){
                q.push(v);
                d[v]=d[u]+1;
            }
        }
    }
    return (d[T]!=-1);
}

int dfs(int u,int flow){        //flow表示当前搜索分支的流量上限
    if(u==T){
        return flow;
    }
    int res=0;
    for(int i=p[u];i!=-1;i=e[i].next){
        int v=e[i].v;
        if(e[i].c>0&&d[u]+1==d[v]){
            int tmp=dfs(v,min(flow,e[i].c));    // 递归计算顶点 v，用 c(u, v) 来更新当前流量上限
            flow-=tmp;
            e[i].c-=tmp;
            res+=tmp;
            e[i^1].c+=tmp;      // 修改反向弧的容量
            if(flow==0){        // 流量达到上限，不必继续搜索了
                break;
            }
        }
    }
    if(res==0){     // 当前没有经过顶点 u 的可行流，不再搜索顶点 u
          d[u]=-1;
    }
    return res;
}

int dinic(){        // 函数返回值就是最大流的结果
    int res=0;
    while(bfs()){
        res+=dfs(S,INF);    // 初始流量上限为 INF
    }
    return res;
}

int main() {
	int n,m;
    init();
    cin>>m>>n;
    for(int i=0;i<m;i++){
        int u,v,flow;
        cin>>u>>v>>flow;
        addedge(u,v,flow);
    }
    cin>>S>>T;
    cout<<dinic()<<endl;
    return 0;
}

递归邻接矩阵

#include <iostream>
#include <string.h>
#include <queue>
using namespace std;

#define INF 0x3f3f3f3f
#define N 110

int e[N][N];

int S,T;
int n,np,nc,m;
int d[N];

bool bfs(){
    memset(d,-1,sizeof(d));
    queue<int> q;
    q.push(S);
    d[S]=0;
    while(!q.empty()){
        int u=q.front();
        q.pop();
        for(int i=0;i<n;i++){
            if(e[u][i]&&d[i]==-1){
                d[i]=d[u]+1;
                q.push(i);
            }
        }
    }
    return d[T]!=-1;
}

int dfs(int u,int flow){
    if(u==T){
        return flow;
    }
    int res=0;
    for(int i=0;i<n;i++){
        if(e[u][i]&&d[i]==d[u]+1){
            int tmp=dfs(i,min(flow,e[u][i]));
            flow-=tmp;
            e[u][i]-=tmp;
            res+=tmp;
            e[i][u]+=tmp;
            if(flow==0) break;
        }
    }
    if(res==0) d[u]=-1;
    return res;
}

int dinic(){
    int res=0;
    while(bfs()){
        res+=dfs(S,INF);
    }
    return res;
}

//#define debug

int main(){
    #ifdef debug
    freopen("in.txt","r",stdin);
//    freopen("out.txt","w",stdout);
    #endif // debug
    int x,y,z;
    char s[10];
    while(scanf("%d%d",&n,&m)!=EOF){
        while(m--){
            scanf("%d%d%d",&x,&y,&z);
            if(x==y) continue;
            e[x][y]+=z;
        }
        scanf("%d%d",&S,&T);
        printf("%d\n",dinic());
    }
    return 0;
}

非递归

#include <iostream>
#include <string.h>
#include <queue>
using namespace std;

const int INF = 0x3f3f3f3f;
const int MAX_N=205;     //顶点数上限
const int MAX_M=1000;    //总的边数上限

struct Edge{
    int v,f,next;       //v指另一个顶点，c表示容量。
}edge[MAX_M];

int first[MAX_N],eid;

void init(){
	memset(first,-1,sizeof(first));
    eid=0;
}

void insert(int u,int v,int c){ //插入一条从u向v，容量为c的弧。
    edge[eid].v=v;
    edge[eid].next=first[u];
    edge[eid].f=c;
    first[u]=eid++;
}

void addedge(int u,int v,int c){ //用insert插入网络中的弧
    insert(u,v,c);
    insert(v,u,0);                  //插入一条反方向，当前容量为0的弧
}

int level[MAX_N];                        //存储每个顶点的层次

int q[MAX_M];

int bfs(int s, int t) //构建层次网络
{
    memset(level, 0, sizeof(level));
    level[s] = 1;
    int front = 0, rear = 1;
    q[front] = s;
    while(front < rear)
    {
        int x = q[front++];
        if(x == t) return 1;
        for(int e = first[x]; e != -1; e = edge[e].next)
        {
            int v = edge[e].v, f = edge[e].f;
            if(!level[v] && f)
            {
                level[v] = level[x] + 1;
                q[rear++] = v;
            }
        }
    }
    return 0;
}

int Dinic(int s, int t){
    int ans = 0;
    while(bfs(s, t)){
        int e, x, y, back, iter = 1;
        while(iter){
            x = (iter==1)?s:edge[q[iter-1]].v;
            if (x == t){
                int minCap = INF;
                for (int i = 1; i < iter; i++){
                    e = q[i];
                    if (edge[e].f < minCap){
                        minCap = edge[e].f;
                        back = i;
                    }
                }
                for (int i = 1; i < iter; i++){
                    e = q[i];
                    edge[e].f -= minCap;
                    edge[e^1].f += minCap;
                }
                ans += minCap;
                iter = back;
            }else{
                for (e = first[x]; e != -1; e = edge[e].next){
                    y = edge[e].v;
                    if (edge[e].f && level[y] == level[x]+1){
                        break;
                    }
                }
                if (e != -1){
                    q[iter++] = e;
                }
                else{
                    level[x] = -1;
                    iter--;
                }
            }
        }
    }
    return ans;
}

int main() {
	int n,m;
    while(cin>>m>>n){
        init();
        for(int i=0;i<m;i++){
            int u,v,flow;
            cin>>u>>v>>flow;
            addedge(u,v,flow);
        }
        cout<<Dinic(1,n)<<endl;
    }
    return 0;
}

猜你喜欢