網絡最大流算法—最高標號預流推動HLPP

吐槽

這個算法。。

怎麼說........

學來也就是裝裝13吧。。。。

長得比EK醜

跑的比EK慢

寫着比EK難

思想

你們先來猜一下這個算法的思想吧:joy:

看看人家的名字——最高標號預留推動

多麼高端大氣上檔次2333333咳咳

從它的名字中咱們能夠看出，它的核心思想是—推動，而不是找增廣路

那麼它是怎麼實現推動的呢？

很簡單，咱們從源點開始，不停的向其餘的點加流量，對於每一個點都如此操做。那麼推到最後，咱們就能夠獲得到達匯點的最大流量

 

不過可能會出現一種狀況，就是$A$送流量給$B$，$B$以爲很差意思不想要，因而又推給$A$，$A$很是熱情便又推給$B$……直到推到TLE爲止。。那怎麼解決這種狀況呢？

咱們對每一個點，引入一個高度$H$，而且規定，一個點$u$能夠向另外一個點$v$送流量，當且僅當$H[u]=H[s]+1$

這樣咱們就能夠保證不會有上面狀況發生了

 

另外還有一種狀況，就是這個點依然有流量，可是迫於高度的限制流不出去，那怎麼辦呢？

很簡單，咱們增長這個點的高度，這樣這個點的流量就能流出去了。

 

優化

預留推動也就是這些內容了

可是它的名字裏的最高標號是啥意思呢？

這個要感謝我們的熟人tarjan，他和他的小夥伴發現，若是每次選的點是高度最高的點，時間複雜度會更優。

能夠優化至$O(n^2\sqrt{m})$

 

另外還有一個比較顯然的優化，若是一個高度$i$是不存在的，即圖中沒有高度爲$i$的點，那麼從比$i$高的點必定不會走到匯點$T$，由於根據咱們的限制條件，必需要通過高度爲$i$的點，因而這些點就沒有用了

代碼

題目在這兒

不是我說，這個算法真的是死慢死慢的，，，，

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
using namespace std;
const int MAXN=2*1e3+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;
}
int N,M,S,T;
int H[MAXN];//每一個節點的高度
int F[MAXN];//每一個節點能夠流出的流量
int gap[MAXN];//每一個高度的數量 
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);//注意這裏別忘了加反向邊 
}
struct comp
{
    int pos,h;
    comp(int pos=0,int h=0):pos(pos),h(h) {}
    inline bool operator < (const comp &a) const {return h<a.h;} 
};
priority_queue<comp>q;
bool Work(int u,int v,int id)
{
    int val=min(F[u],edge[id].flow);
    edge[id].flow-=val;edge[id^1].flow+=val;
    F[u]-=val;F[v]+=val;
    return val;
}
inline int HLPP()
{
    H[S]=N;F[S]=INF;q.push(comp(S,H[S]));
    while(q.size()!=0)
    {
        int p=q.top().pos;q.pop();
        if(!F[p]) continue;
        for(int i=head[p];i!=-1;i=edge[i].nxt)
            if( (p==S||H[edge[i].v]+1==H[p]) && Work(p,edge[i].v,i) && edge[i].v!=S && edge[i].v!=T)
                q.push( comp(edge[i].v,H[edge[i].v]) );
        if(p!=S && p!=T && F[p])
        {
            if( (--gap[ H[p] ])==0 )//該高度不存在 
            {
                for(int i=1;i<=N;i++)
                    if( H[p]<H[i]&&H[i]<=N && p!=S && p!=T ) 
                        H[i]=N+1;//設置爲不可訪問 
            }
            ++gap[ ++H[p] ];//高度+1 
            q.push( comp(p,H[p]) );
        }
    }
    return F[T];
}
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", HLPP() ); 
    return 0;
}