最大流

含义

网络流,用于求一个源点到一个汇点的最大流量.

方法1 EK

先用bfs求出最短路,并记录下路径,之后找到路径上的流量最小的边的流量路径,并且让每条边都减去这个最小值,让它的反向边加上这个值(给它后悔的机会),当无法再找到到达汇点的路径时结束,此时所有最小流量之和即为答案.

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#define C ch=getchar()
#define INF 0x3f3f3f3f
#define N 10010
#define M 101000
using namespace std;

int n,m,s,t,first[N],bb,ans,vis[N],last[N],wh[N],mn;
queue<int>que;
struct Bn
{
    int next,to,quan;
} bn[M*2];

inline void add(int u,int v,int w)
{
    bn[bb].to=v;
    bn[bb].quan=w;
    bn[bb].next=first[u];
    first[u]=bb;
    bb++;
}

inline void read(int &u)
{
    char C;
    u=0;
    for(;ch<'0';C);
    for(;ch>='0';C) u=u*10+ch-48;
}

int main()
{
    memset(first,-1,sizeof(first));
    register int i,p,q,o;
    read(n),read(m),read(s),read(t);
    for(i=1; i<=m; i++)
    {
        read(p);
        read(q);
        read(o);
        add(p,q,o);
        add(q,p,0);
    }
    last[s]=-1;
    for(;;)
    {
        memset(vis,0,sizeof(vis));
        for(;!que.empty();) que.pop();
        que.push(s),vis[s]=1,mn=INF;
        for(;!que.empty()&&!vis[t];)
        {
            q=que.front(),que.pop();
            for(p=first[q];p!=-1&&!vis[t];p=bn[p].next)
            {
                if(!bn[p].quan||vis[bn[p].to]) continue;
                vis[bn[p].to]=1;
                last[bn[p].to]=q;
                wh[bn[p].to]=p;
                mn=min(mn,bn[p].quan);
                que.push(bn[p].to);
            }
        }
        if(!vis[t]) break;
        ans+=mn;
        for(p=t;p!=s;p=last[p])
        {
            bn[wh[p]].quan-=mn,bn[wh[p]^1].quan+=mn;
        }
    }
    cout<<ans;
}

方法2 dinic

思路基本同上,多路增广,先用bfs记录每一个点的深度,再从源点开始dfs,若下一个点的深度是当前点的深度加一则可以继续搜下去(这样可以防止走错),之后每次加上最小流量,一直到bfs搜不出最短路为止.

代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#define INF 0x3f3f3f3f
#define N 10010
#define M 100100
using namespace std;

int n,m,s,t,bb,first[N],deep[N],ans;
struct Bn
{
    int next,to,quan;
} bn[M*2];
queue<int>que;

inline void add(int u,int v,int w)
{
    bn[bb].next=first[u];
    bn[bb].to=v;
    bn[bb].quan=w;
    first[u]=bb;
    bb++;
}

inline bool bfs()
{
    int p,q;
    memset(deep,0,sizeof(deep));
    for(;!que.empty();que.pop());
    que.push(s);
    deep[s]=1;
    for(; !que.empty();)
    {
        q=que.front();
        que.pop();
        for(p=first[q]; p!=-1; p=bn[p].next)
        {
            if(!bn[p].quan||deep[bn[p].to]) continue;
            deep[bn[p].to]=deep[q]+1;
            que.push(bn[p].to);
        }
    }
    return deep[t];
}

int dfs(int now,int mn)
{
    if(now==t)
    {
        return mn;
    }
    int p=first[now],res=0;
    for(; p!=-1; p=bn[p].next)
    {
        if(deep[now]+1!=deep[bn[p].to]||!bn[p].quan) continue;
        res=dfs(bn[p].to,min(bn[p].quan,mn));
        if(res)
        {
            bn[p].quan-=res;
            bn[p^1].quan+=res;
            return res;
        }
    }
    return 0;
}

int main()
{
    memset(first,-1,sizeof(first));
    int i,j,p,q,o;
    cin>>n>>m>>s>>t;
    for(i=1; i<=m; i++)
    {
        scanf("%d%d%d",&p,&q,&o);
        add(p,q,o);
        add(q,p,0);
    }
    for(; bfs();)
    {
        for(p=dfs(s,INF);p;ans+=p,p=dfs(s,INF));
    }
    cout<<ans;
}

当前弧优化

dinic在后来不断dfs时,可以发现扫过的边不会再扫第二边,因而在扫时可以记录一下上次扫到了哪里,下次从这个地方继续扫即可,可以大大优化.

代码

// luogu-judger-enable-o2
#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
#define INF 0x3f3f3f3f
#define N 10100
using namespace std;

int n,m,bb,need[30][30],val[30][30],first[N],deep[N],tmp,s,t,dir[4][2]= {1,0,-1,0,0,-1,0,1},sum,ans,cur[N];
struct Bn
{
    int next,to,quan;
} bn[200100];
queue<int>que;

inline void add(int u,int v,int w)
{
    bn[bb].to=v;
    bn[bb].quan=w;
    bn[bb].next=first[u];
    first[u]=bb;
    bb++;
}

inline void adt(int u,int v,int w)
{
    add(u,v,w);
    add(v,u,0);
}

inline bool bfs()
{
    int p,q;
    for(;!que.empty();que.pop());
    memset(deep,0,sizeof(deep));
    deep[s]=1;
    que.push(s);
    for(;!que.empty();)
    {
        q=que.front();
        que.pop();
        for(p=first[q];p!=-1&&!deep[t];p=bn[p].next)
        {
            if(deep[bn[p].to]||!bn[p].quan) continue;
            deep[bn[p].to]=deep[q]+1;
            que.push(bn[p].to);
        }
    }
    return deep[t];
}

int dfs(int now,int mn)
{
    if(now==t)
    {
        return mn;
    }
    int res;
    for(int &p=cur[now];p!=-1;p=bn[p].next)
    {
        if(deep[bn[p].to]!=deep[now]+1||!bn[p].quan) continue;
        res=dfs(bn[p].to,min(bn[p].quan,mn));
        if(res)
        {
            bn[p].quan-=res;
            bn[p^1].quan+=res;
            return res;
        }
    }
    return 0;
}

int main()
{
    memset(first,-1,sizeof(first));
    register int i,j,p,q,k;
    cin>>n>>m>>s>>t;
    for(i=1;i<=m;i++)
    {
        scanf("%d%d%d",&p,&q,&k);
        adt(p,q,k);
    }
    for(;bfs();)
    {
        for(i=1;i<=n;i++) cur[i]=first[i];
        for(k=dfs(s,INF);k;ans+=k,k=dfs(s,INF));
    }
    cout<<ans;
}