网络最大流--Dinic

前置概念
增广路：若一条从源点s到汇点t的路径上各边的剩余容量都大于0，则该路径成为一条增广路
残量网络：原图中所有点和所有剩余容量大于0的边组成的图

dinic求最大流分为两步
bfs构造层次图，dfs寻找增广路

BFS构造层次图

字面理解，其实就是给图分层
设源点为第0层
从源点出发最少只要一步可以到达的就是第1层
最少两步到达的是第二层，依次类推直到汇点
如下图所示

Dinic算法中层次图在残量网络上构造
即求取层次图需要先判断该边是否有剩余容量

若层次图可以延伸到汇点，则说明最大流还可以增加

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

    while(!q.empty())
    {
        int u=q.front(); q.pop();
        for(int i=head[u];i;i=E[i].nxt)
        {
            int v=E[i].v;
            if(lev[v]==-1&&E[i].f)
            {
                lev[v]=lev[u]+1;
                if(v==t)return true;
                q.push(v);
            }
        }
    }
    return false;
}

DFS寻找增广路

沿着层次图的层次顺序
在残量网络上dfs找到一条增广路

int dfs(int u,int cap)
{
    if(u==t) return cap;//若到达汇点，直接返回路径上的最大流量
    int flow=cap;
    for(int i=head[u];i;i=E[i].nxt)
    {
        int v=E[i].v;
        if( lev[v]==lev[u]+1&&flow&&E[i].f>0)//增广
        {
            int f=dfs(v,min(flow,E[i].f));//选取路径上的最小容量
            E[i].f-=f; E[i^1].f+=f; //构造残量网络
            flow-=f;
        }
    }
    return cap-flow;//返回这一层的流量
}

---

我们要做的就是不断构造层次图、寻找增广路、得到新的残量网络，直到汇点不可达
一次完整的过程如下图

第四次增广后，红色边上的容量都-4
层次图不能再延伸到汇点，算法结束

---

完整的代码
洛谷P3376 【模板】网络最大流

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

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

const int inf=1000000000;
int n,m;
int s,t;
struct node{int v,f,nxt;}E[1000010];
int head[1000010],tot=1;
int lev[1000010];
int maxf;

void add(int u,int v,int f)
{
    E[++tot].nxt=head[u];
    E[tot].v=v;
    E[tot].f=f;
    head[u]=tot;
}

bool bfs()
{
    queue<int> q; q.push(s);
    memset(lev,-1,sizeof(lev)); lev[s]=0;
    
    while(!q.empty())
    {
        int u=q.front(); q.pop();
        for(int i=head[u];i;i=E[i].nxt)
        {
            int v=E[i].v;
            if(lev[v]==-1&&E[i].f)
            {
                
                lev[v]=lev[u]+1;
                if(v==t)return true;
                q.push(v);
            }
        }
    }
    return false;
}

int dfs(int u,int cap)
{
    if(u==t) return cap;
    
    int flow=cap;
    for(int i=head[u];i;i=E[i].nxt)
    {
        int v=E[i].v;
        if( lev[v]==lev[u]+1&&flow && E[i].f>0 )
        {
            int f=dfs(v,min(flow,E[i].f));
            E[i].f-=f; E[i^1].f+=f; 
            flow-=f;
        }
    }
    return cap-flow;
}

int main()
{
    n=read();m=read();s=read();t=read();
    for(int i=1;i<=m;i++)
    {
        int u=read(),v=read(),w=read();
        add(u,v,w);add(v,u,0);
    }
    
    while(bfs())
    maxf+=dfs(s,inf);
    
    cout<<maxf;
    return 0;
}