前言

EK算法是求網絡最大流的最基礎的算法，也是比較好理解的一種算法，利用它可以解決絕大多數最大流問題。

但是受到時間復雜度的限制，這種算法常常有TLE的風險

思想

還記得我們在介紹最大流的時候提到的求解思路麽？

對一張網絡流圖，每次找出它的最小的殘量（能增廣的量），對其進行增廣。

沒錯，EK算法就是利用這種思想來解決問題的

實現

EK算法在實現時，需要對整張圖遍歷一邊。

那我們如何進行遍歷呢？BFS還是DFS？

因為DFS的搜索順序的原因，所以某些毒瘤出題人會構造數據卡你，具體怎麽卡應該比較簡單，不過為了防止大家成為這種人我就不說啦(#^.^#)

所以我們選用BFS

在對圖進行遍歷的時候，記錄下能進行增廣的最大值，同時記錄下這個最大值經過了哪些邊。

我們遍歷完之後對這條增廣路上的邊進行增廣就好啦

代碼

題目在這兒

代碼裏面我對一些重點的地方加了一些註釋，如果我沒寫明白的話歡迎在下方評論:blush:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
using namespace std;
const int MAXN=2*1e6+10;
const
 
 int INF=1e8+10;
inline char nc()
{
    static char buf[MAXN],*p1=buf,*p2=buf;
    return p1==p2&&(p2=(p1=buf)+fread(buf,1,MAXN,stdin),p1==p2)?EOF:*p1++;
}
inline int read()
{
    char c=nc();int x=0,f=1;
    while(c<‘0‘||c>‘9‘){if(c==‘-‘)f=-1;c=nc();}
    while(c>=‘0‘&&c<=‘
 
9‘){x=x*10+c-‘0‘;c=nc();}
    return x*f;
}
struct node
{
    int u,v,flow,nxt;
}edge[MAXN];
int head[MAXN];
int num=0;//註意這裏num必須從0開始 
inline void add_edge(int x,int y,int z)
{
    edge[num].u=x;
    edge[num].v=y;
    edge[num].flow=z;
    edge[num].nxt=head[x];
    head[x]=num++;
}
inline void AddEdge(int x,int y,int z)
{
    add_edge(x,y,z);
    add_edge(y,x,0);//註意這裏別忘了加反向邊 
}
int N,M,S,T;
int path[MAXN];//經過的路徑
int A[MAXN];//S到該節點的最小流量
inline int EK()
{
    int ans=0;//最大流 
    while(true)//不停的找增廣路
    {
        memset(A,0,sizeof(A)); 
        queue<int>q;//懶得手寫隊列了。。。 
        q.push(S);
        A[S]=INF;
        while(q.size()!=0)
        {
            int p=q.front();q.pop();
            for(int i=head[p];i!=-1;i=edge[i].nxt)
            {
                if(!A[edge[i].v]&&edge[i].flow)
                {
                    path[ edge[i].v ]=i;//記錄下經過的路徑，方便後期增廣 
                    A[edge[i].v]=min(A[p],edge[i].flow);//記錄下最小流量 
                    q.push(edge[i].v);
                }
            }
            if(A[T]) break;//一個小優化 
        }
        if(!A[T]) break;//沒有可以增廣的路徑，直接退出
        for(int i=T;i!=S;i=edge[path[i]].u)//倒著回去增廣 
        {
            edge[path[i]].flow-=A[T];
            edge[path[i]^1].flow+=A[T];//利用異或運算符尋找反向邊，0^1=1 1^1=0 
        }
        ans+=A[T]; 
    }
    return ans;
}
int main()
{
    #ifdef WIN32
    freopen("a.in","r",stdin);
    #else
    #endif 
    memset(head,-1,sizeof(head));
    N=read(),M=read(),S=read(),T=read();
    for(int i=1;i<=M;i++)
    {
        int x=read(),y=read(),z=read();
        AddEdge(x,y,z); 
    } 
    printf("%d", EK() ); 
    return 0;
}

性能分析

通過上圖不難看出，這種算法的性能還算是不錯，

不過你可以到這裏提交一下就知道這種算法究竟有多快(man)了

可以證明，這種算法的時間復雜度為$O(n*m^2)$

大體證一下：

我們最壞情況下每次只增廣一條邊，則需要增廣$m-1$次。

在BFS的時候，由於反向弧的存在，最壞情況為$n*m$

總的時間復雜度為$O(n*m^2)$

後記

EK算法到這裏就結束了。

不過loj那道題怎麽才能過掉呢？

這就要用到我們接下來要講的其他算法

網絡最大流算法—EK算法