【模板】最大流模板（ISAP）

原创于 2018-04-12 23:31:00 发布 · 138 阅读

0 ·

CC 4.0 BY-SA版权

本文介绍了一种高效的最大流算法——ISAP，并通过具体实现展示了如何利用此算法求解给定网络图的最大流问题。适用于网络流问题中寻找最大流的应用场景。

【模板】最大流模板（ISAP）

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

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

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

输出格式：
一行，包含一个正整数，即为该网络的最大流。

输入输出样例
输入样例#1：
4 5 4 3
4 2 30
4 3 20
2 3 20
2 1 30
1 3 40
输出样例#1：
50
说明
时空限制：1000ms,128M

数据规模：

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

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

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

还是最大流，换了个更有效率的算法~
code：

//By Menteur_Hxy
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;

int rd() {
    int x=0,fla=1; char c=' ';
    while(c>'9'|| c<'0') {if(c=='-') fla=-fla; c=getchar();}
    while(c<='9'&&c>='0') x=x*10+c-'0',c=getchar();
    return x*fla;
}

const int MAX=10010;
const int INF=0x3f3f3f3f;
int n,m,s,t,ans,cnt=-1,maxflow;
int gap[MAX],head[MAX],cur[MAX],d[MAX],S[MAX];

struct edges {
    int next,to,cap,flow;
}edge[200010];

void add(int a,int b,int c) {
    edge[++cnt]=(edges) {head[a],b,c,0};
    head[a]=cnt;
}

void bfs() {
    memset(d,-1,sizeof d);
    memset(gap,0,sizeof gap);
    gap[0]=1;d[t]=0;
    queue <int> q;
    q.push(t);
    while(!q.empty()) {
        int u=q.front(); q.pop();
        for(int i=head[u];i!=-1;i=edge[i].next) {
            int v=edge[i].to;
            if(d[v]==-1) {
                d[v]=d[u]+1;
                gap[d[v]]++;
                q.push(v);
            }
        }
    }
}

void ISAP() {
    bfs();
    memcpy(cur,head,sizeof head);
    int u=s,top=0;
    while(d[s]<n) {
        if(u==t) {
            int Min=INF,inser;
            for(int i=0;i<top;i++) {
                if(Min>edge[S[i]].cap-edge[S[i]].flow) {
                    Min=edge[S[i]].cap-edge[S[i]].flow;
                    inser=i;
                }
            }
            for(int i=0;i<top;i++) {
                edge[S[i]].flow+=Min;
                edge[S[i]^1].flow-=Min;
            }
            ans+=Min;
            top=inser;
            u=edge[S[top]^1].to;
            continue;
        }
        bool ok=false;
        int v;
        for(int i=cur[u];i!=-1;i=edge[i].next) {
            v=edge[i].to;
            if(edge[i].cap-edge[i].flow && d[v]+1==d[u]) {
                ok=true;
                cur[u]=i;
                break;
            }
        }
        if(ok) {
            S[top++]=cur[u];
            u=v;
            continue;
        }
        int Min=n;
        for(int i=head[u];i!=-1;i=edge[i].next) {
            if(edge[i].cap-edge[i].flow && d[edge[i].to]<Min) {
                Min=d[edge[i].to];
                cur[u]=i;
            }
        }
        gap[d[u]]--;
        if(!gap[d[u]]) return ;
        d[u]=Min+1;
        gap[d[u]]++;
        if(u!=s) u=edge[S[--top]^1].to;
    }
    return ;
}

int main() {
    n=rd(),m=rd(),s=rd(),t=rd();
    memset(head,-1,sizeof head);
    for(int i=1;i<=m;i++) {
        int a=rd(),b=rd(),c=rd();
        add(a,b,c);
        add(b,a,0);
    }
    ISAP();
    printf("%d",ans);
    return 0;
}