洛谷 P3376 【【模板】网络最大流】

题目描述

如题，给出一个网络图，以及其源点和汇点，求出其网络最大流。

输入

第一行包含四个正整数N、M、S、T，分别表示点的个数、有向边的个数、源点序号、汇点序号。

接下来M行每行包含三个正整数ui、vi、wi，表示第i条有向边从ui出发，到达vi，边权为wi（即该边最大流量为wi）

输出

一行，包含一个正整数，即为该网络的最大流。

样例输入

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

样例输出

50

数据规模：

对于30%的数据：N<=10，M<=25

对于70%的数据：N<=200，M<=1000

对于100%的数据：N<=10000，M<=100000

网络流的模板题。汇总一些增广路算法。（Ford-Fulkerson, Edmond-Karp, Dinic, ISAP）

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;

struct edge {
    int to,cap,rev;
};

const int maxn=10001, INF=0x7F7F7F7F;
int n,m;
vector <edge> G[maxn+1];

edge make_edge(int to, int cap, int rev) {
    edge x;
    x.to=to, x.cap=cap, x.rev=rev;
    return x;
}

void add_edge(int from, int to, int cap) {
    G[from].push_back(make_edge(to,cap,G[to].size()));
    G[to].push_back(make_edge(from,0,G[from].size()-1));
}

void init() {
    for (int i=1; i<=m; i++) {
        int u,v,w;
        scanf("%d%d%d",&u,&v,&w);
        add_edge(u,v,w);
    }
}

namespace Ford_Fulkerson {
    bool used[maxn+1];

    int dfs(int x, int t, int f) {
        if (x==t) return f;
        used[x]=true;
        for (int i=0; i<G[x].size(); i++) {
            edge &e=G[x][i];
            if (!used[e.to]&&e.cap>0) {
                int d=dfs(e.to,t,min(f,e.cap));
                if (d>0) {
                    e.cap-=d;
                    G[e.to][e.rev].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;
        }
    }
}

namespace Edmond_Karp {
    bool vis[maxn+1];
    int prev[maxn+1];
    int pree[maxn+1];

    void bfs(int s) {
        memset(vis,0,sizeof(vis));
        memset(prev,-1,sizeof(prev));
        memset(pree,-1,sizeof(pree));
        queue <int> q;
        vis[s]=true;
        q.push(s);

        while(!q.empty()) {
            int x=q.front();
            q.pop();
            for (int i=0; i<G[x].size(); i++) {
                edge &e=G[x][i];
                if (e.cap>0&&!vis[e.to]) {
                    prev[e.to]=x;
                    pree[e.to]=i;
                    vis[e.to]=true;
                    q.push(e.to);
                }
            }
        }
    }

    int max_flow(int s, int t) {
        int flow=0;
        for(;;) {
            bfs(s);
            if (!vis[t]) return flow;
            int d=INF;
            for (int i=t; prev[i]!=-1; i=prev[i])
                d=min(d,G[prev[i]][pree[i]].cap);
            for (int i=t; prev[i]!=-1; i=prev[i]) {
                edge &e=G[prev[i]][pree[i]];
                e.cap-=d;
                G[e.to][e.rev].cap+=d;
            }
            flow+=d;
        }
    }
}

namespace Dinic {
    int level[maxn+1];
    int iter[maxn+1];

    void bfs(int s) {
        memset(level,-1,sizeof(level));
        queue <int> q;
        level[s]=0;
        q.push(s);

        while (!q.empty()) {
            int x=q.front();
            q.pop();
            for (int i=0; i<G[x].size(); i++) {
                edge &e=G[x][i];
                if (e.cap>0&&level[e.to]<0) {
                    level[e.to]=level[x]+1;
                    q.push(e.to);
                }
            }
        }
    }

    int dfs(int x, int t, int f) {
        if (x==t) return f;
        for (int &i=iter[x]; i<G[x].size(); i++) {
            edge &e=G[x][i];
            if (e.cap>0&&level[e.to]>level[x]) {
                int d=dfs(e.to,t,min(f,e.cap));
                if (d>0) {
                    e.cap-=d;
                    G[e.to][e.rev].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;
        }
    }
}

namespace ISAP {
    int gap[maxn+1];
    int iter[maxn+1];
    int level[maxn+1];

    void bfs(int t) {
        memset(gap,0,sizeof(gap));
        memset(level,-1,sizeof(level));
        queue <int> q;
        level[t]=1;
        gap[level[t]]=1;
        q.push(t);

        while (!q.empty()) {
            int x=q.front();
            q.pop();
            for (int i=0; i<G[x].size(); i++) {
                edge &e=G[x][i];
                if (level[e.to]<0) {
                    level[e.to]=level[x]+1;
                    gap[level[e.to]]++;
                    q.push(e.to);
                }
            }
        }
    }

    int dfs(int x, int s, int t, int f) {
        if (x==t) return f;
        int flow=0;
        for (int &i=iter[x]; i<G[x].size(); i++) {
            edge &e=G[x][i];
            if (e.cap>0&&level[x]==level[e.to]+1) {
                int d=dfs(e.to,s,t,min(f-flow,e.cap));
                e.cap-=d;
                G[e.to][e.rev].cap+=d;
                flow+=d;
                if (f==flow) return f;
            }
        }

        gap[level[x]]--;
        if (gap[level[x]]==0)
            level[s]=n+1;
        iter[x]=0;
        gap[++level[x]]++;
        return flow;
    }

    int max_flow(int s, int t) {
        int flow=0;
        bfs(t);
        memset(iter,0,sizeof(iter));
        while (level[s]<=n)
            flow+=dfs(s,s,t,INF);
        return flow;
    }
}

int main() {
    int s,t;
    scanf("%d%d%d%d",&n,&m,&s,&t);
    init();
    printf("%d
",ISAP::max_flow(s,t));
    return 0;
}