从通用预流推进到先进先出预流推进、HLPP、EXCESS SCALING

于 2023-03-15 20:45:01 发布
阅读量273 收藏
点赞数
文章标签： 算法 c++ 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaopangfeiyu/article/details/129568106
版权

通用预留推进设计

网络流的定义

对于一张网络我们需要将初始容量为 0 0 0 的反向边也在加入边时进行添加，并依据斜对称性在推送后进行修改，对于剩余容量为 0 0 0的边忽略判断连通性。

然后我们定义进入结点的流超过流出结点的流的剩余部分为超额流，即堵上的。

再后我们定义高度限制流动方向。

那么在推送非超额流后对于超额流我们依据高度向低 1 1 1处推送。

无法推送时，则将其高度提升至最低连通点 + 1 +1 +1。

依次规则直到全部没有超额流。

这是最通用的预留推进算法。

#include <iostream>
#include <queue>

using namespace std;

#define int long long

const int inf=1<<30;
int n,m,s,t;
struct edge
{
    int to,val,next;
}e[1000005];
int cnt=1,head[1000005];

void add(int x,int y,int z)
{
    cnt++;
    e[cnt].to=y;
    e[cnt].val=z;
    e[cnt].next=head[x];
    head[x]=cnt;
}

int h[1000005],w[1000005],vis[1000005];
queue<int>q;

int relabel(int x)
{
    int minn=inf;
    for(int i=head[x];i;i=e[i].next)
    {
        int to=e[i].to;
        if(e[i].val)
        {
            minn=min(minn,h[to]);
        }
    }
    if(minn==inf)
    {
        return 0;
    }
    h[x]=minn+1;
    return 1;
}

void push_(int x,int i)
{
    int flow=min(e[i].val,w[x]);
    e[i].val-=flow;
    e[i^1].val+=flow;
    w[x]-=flow;
    w[e[i].to]+=flow;
}

int push_relabel()
{
    h[s]=n;
    for(int i=head[s];i;i=e[i].next)
    {
        int to=e[i].to,val=e[i].val;
        if(val)
        {
            e[i].val-=val;
            e[i^1].val+=val;
            w[s]-=val;
            w[to]+=val;
            if(vis[to]==0&&to!=s&&to!=t&&relabel(to))
            {
                q.push(to);
                vis[to]=1;
            }
        }
    }
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        vis[x]=0;
        for(int i=head[x];i;i=e[i].next)
        {
            int v=e[i].to;
            if(w[x]==0)break;
            if(e[i].val==0)continue;
            if(h[x]==h[v]+1)
            {
                push_(x,i);
            }
            if(w[v]!=0&&v!=s&&v!=t&&vis[v]==0&&relabel(v))
            {
                q.push(v);
                vis[v]=1;
            }
        }
        if(w[x]&&vis[x]==0&&relabel(x))
        {
            vis[x]=1;
            q.push(x);
        }
    }
    return w[t];
}

signed main()
{
    int i,j,k;
    cin>>n>>m>>s>>t;
    for(i=1;i<=m;i++)
    {
        int x,y,z;
        cin>>x>>y>>z;
        add(x,y,z);
        add(y,x,0);
    }
    cout<<push_relabel();
    return 0;
}

LOJ 良好

洛谷 良好

UOJ 不好

但是在大数据下还是远远快于 D i n i c \sf Dinic Dinic 甚至 I S A P \sf ISAP ISAP。

虽然时间复杂度为 O ( n 2 m ) O(n^2m) O(n2m) 但实际有时比 D i n i c \sf Dinic Dinic 快得多。

二分图 洛谷 比较危险

通用预流推进实际运用尝试

我们寻找一些 Dinic 无法轻易通过的题目测试通用预流推进有多强。

看到 P2057，毫无悬念的通过了。

然后我们看到了 P1361。

只有 44 44 44 分，对于最大数据范围需要跑 60 60 60 秒。

从建模角度来看， s s s 到 t t t 最多四步，预处理了层次就是Dinic 在层数较低时更快的原因。

所以我们也需要预处理层次，不过在预流推进中是高度。

BFS优化

我们使用 BFS 将 h u h_u hu​ 初始化为 u u u 到 t t t 的最短距离。

特殊的 h s = n h_s=n hs​=n。

同时也能检查连通性排除无解。

UOJ 效果不是很显著

以下的预流推进算法自带此优化不再赘述。

#include <iostream>
#include <queue>
#include <cstring>

using namespace std;

#define int long long

const int inf=1<<30;
int n,m,s,t;
struct edge
{
    int to,val,next;
}e[1000005];
int cnt=1,head[1000005];

void add(int x,int y,int z)
{
    cnt++;
    e[cnt].to=y;
    e[cnt].val=z;
    e[cnt].next=head[x];
    head[x]=cnt;
}

int h[1000005],w[1000005],vis[1000005],cnth[1000005],book[1000005];
queue<int>q;
queue<int>qq;
void bfs()
{
    memset(h,0x3f,sizeof(h));
    h[t]=0;
    qq.push(t);
    while(!qq.empty())
    {
        int u=qq.front();
        qq.pop();
        for(int i=head[u];i;i=e[i].next)
        {
            int v=e[i].to;
            if(e[i^1].val&&h[u]+1<h[v])
            {
                h[v]=h[u]+1;
                if(book[v]==0)
                {
                    qq.push(v);
                    book[v]=1;
                }
            }
        }
    }
}

int relabel(int x)
{
    int minn=inf;
    for(int i=head[x];i;i=e[i].next)
    {
        int to=e[i].to;
        if(e[i].val)
        {
            minn=min(minn,h[to]);
        }
    }
    if(minn==inf)
    {
        return 0;
    }
    h[x]=minn+1;
    return 1;
}

void push_(int x,int i)
{
    int flow=min(e[i].val,w[x]);
    e[i].val-=flow;
    e[i^1].val+=flow;
    w[x]-=flow;
    w[e[i].to]+=flow;
}

int push_relabel()
{
    bfs();
    h[s]=n;
    for(int i=head[s];i;i=e[i].next)
    {
        int to=e[i].to,val=e[i].val;
        if(val)
        {
            e[i].val-=val;
            e[i^1].val+=val;
            w[s]-=val;
            w[to]+=val;
            if(vis[to]==0&&to!=s&&to!=t&&relabel(to))
            {
                q.push(to);
                vis[to]=1;
            }
        }
    }
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        vis[x]=0;
        for(int i=head[x];i;i=e[i].next)
        {
            int v=e[i].to;
            if(w[x]==0)break;
            if(e[i].val==0)continue;
            if(h[x]==h[v]+1)push_(x,i);
            if(w[v]!=0&&v!=s&&v!=t&&vis[v]==0&&relabel(v))
            {
                q.push(v);
                vis[v]=1;
            }
        }
        if(w[x]&&vis[x]==0&&relabel(x))
        {
            vis[x]=1;
            q.push(x);
        }
    }
    return w[t];
}

signed main()
{
    int i,j,k;
    cin>>n>>m>>s>>t;
    for(i=1;i<=m;i++)
    {
        int x,y,z;
        cin>>x>>y>>z;
        add(x,y,z);
        add(y,x,0);
    }
    cout<<push_relabel();
    return 0;
}

先入先出预流推进算法

还是不够快。

你或许认为我们不得不去面对 HPLL了。

但实际上这中间还夹着一个 O ( n 3 ) O(n^3) O(n3) 的名为 FIFOPP 算法。

非常简单，只需要将上方的通用预流推进算法中的队列改为栈即可跑的飞起。

至于为啥。

自行查看论文。

#include <iostream>
#include <queue>
#include <cstring>
#include <stack>

using namespace std;

#define int long long

const int inf=1<<30;
int n,m,s,t;
struct edge
{
    int to,val,next;
}e[1000005];
int cnt=1,head[1000005];

void add(int x,int y,int z)
{
    cnt++;
    e[cnt].to=y;
    e[cnt].val=z;
    e[cnt].next=head[x];
    head[x]=cnt;
}

int h[1000005],w[1000005],vis[1000005],cnth[1000005],book[1000005];
stack<int>q;
queue<int>qq;
void bfs()
{
    memset(h,0x3f,sizeof(h));
    h[t]=0;
    qq.push(t);
    while(!qq.empty())
    {
        int u=qq.front();
        qq.pop();
        for(int i=head[u];i;i=e[i].next)
        {
            int v=e[i].to;
            if(e[i^1].val&&h[u]+1<h[v])
            {
                h[v]=h[u]+1;
                if(book[v]==0)
                {
                    q.push(v);
                    book[v]=1;
                }
            }
        }
    }
}

int relabel(int x)
{
    int minn=inf;
    for(int i=head[x];i;i=e[i].next)
    {
        int to=e[i].to;
        if(e[i].val)
        {
            minn=min(minn,h[to]);
        }
    }
    if(minn==inf)
    {
        return 0;
    }
    h[x]=minn+1;
    return 1;
}

void push_(int x,int i)
{
    int flow=min(e[i].val,w[x]);
    e[i].val-=flow;
    e[i^1].val+=flow;
    w[x]-=flow;
    w[e[i].to]+=flow;
}

int push_relabel()
{
    h[s]=n;
    for(int i=head[s];i;i=e[i].next)
    {
        int to=e[i].to,val=e[i].val;
        if(val)
        {
            e[i].val-=val;
            e[i^1].val+=val;
            w[s]-=val;
            w[to]+=val;
            if(vis[to]==0&&to!=s&&to!=t&&relabel(to))
            {
                q.push(to);
                vis[to]=1;
            }
        }
    }
    while(!q.empty())
    {
        int x=q.top();
        q.pop();
        vis[x]=0;
        for(int i=head[x];i;i=e[i].next)
        {
            int v=e[i].to;
            if(w[x]==0)break;
            if(e[i].val==0)continue;
            if(h[x]==h[v]+1)push_(x,i);
            if(w[v]!=0&&v!=s&&v!=t&&vis[v]==0&&relabel(v))
            {
                q.push(v);
                vis[v]=1;
            }
        }
        if(w[x]&&vis[x]==0&&relabel(x))
        {
            vis[x]=1;
            q.push(x);
        }
    }
    return w[t];
}

signed main()
{
    int i,j,k;
    cin>>n>>m>>s>>t;
    for(i=1;i<=m;i++)
    {
        int x,y,z;
        cin>>x>>y>>z;
        add(x,y,z);
        add(y,x,0);
    }
    cout<<push_relabel();
    return 0;
}

UOJ 极大的提升

最高标号预流推进算法

这里正式介绍 HLPP 算法。

最高标号预流推进算法，顾名思义用优先队列代替队列每次取超额流最大的点推送。

然后依然是进行通用预流推进。

同时还是带上 BFS优化。

UOJ 效果十分明显 （HLPP）

UOJ 又多过一个点 （HLPP-BFS）

#include <iostream>
#include <queue>
#include <cstring>

using namespace std;

#define int long long

const int inf=1<<30;
int n,m,s,t;
struct edge
{
    int to,val,next;
}e[1000005];
int cnt=1,head[1000005];

void add(int x,int y,int z)
{
    cnt++;
    e[cnt].to=y;
    e[cnt].val=z;
    e[cnt].next=head[x];
    head[x]=cnt;
}

int h[1000005],w[1000005],vis[1000005],cnth[1000005],book[1000005];
struct cmp
{
    inline bool operator ()(int a,int b) const
    {
        return h[a]<h[b];
    }
};
priority_queue<int,vector<int>,cmp>q;
queue<int>qq;
void bfs()
{
    memset(h,0x3f,sizeof(h));
    h[t]=0;
    qq.push(t);
    while(!qq.empty())
    {
        int u=qq.front();
        qq.pop();
        for(int i=head[u];i;i=e[i].next)
        {
            int v=e[i].to;
            if(e[i^1].val&&h[u]+1<h[v])
            {
                h[v]=h[u]+1;
                if(book[v]==0)
                {
                    qq.push(v);
                    book[v]=1;
                }
            }
        }
    }
}

int relabel(int x)
{
    int minn=inf;
    for(int i=head[x];i;i=e[i].next)
    {
        int to=e[i].to;
        if(e[i].val)
        {
            minn=min(minn,h[to]);
        }
    }
    if(minn==inf)
    {
        return 0;
    }
    h[x]=minn+1;
    return 1;
}

void push_(int x,int i)
{
    int flow=min(e[i].val,w[x]);
    e[i].val-=flow;
    e[i^1].val+=flow;
    w[x]-=flow;
    w[e[i].to]+=flow;
}

int push_relabel()
{
    bfs();
    h[s]=n;
    for(int i=head[s];i;i=e[i].next)
    {
        int to=e[i].to,val=e[i].val;
        if(val)
        {
            e[i].val-=val;
            e[i^1].val+=val;
            w[s]-=val;
            w[to]+=val;
            if(vis[to]==0&&to!=s&&to!=t&&relabel(to))
            {
                q.push(to);
                vis[to]=1;
            }
        }
    }
    while(!q.empty())
    {
        int x=q.top();
        q.pop();
        vis[x]=0;
        for(int i=head[x];i;i=e[i].next)
        {
            int v=e[i].to;
            if(w[x]==0)break;
            if(e[i].val==0)continue;
            if(h[x]==h[v]+1)push_(x,i);
            if(w[v]!=0&&v!=s&&v!=t&&vis[v]==0&&relabel(v))
            {
                q.push(v);
                vis[v]=1;
            }
        }
        if(w[x]&&vis[x]==0&&relabel(x))
        {
            vis[x]=1;
            q.push(x);
        }
    }
    return w[t];
}

signed main()
{
    int i,j,k;
    cin>>n>>m>>s>>t;
    for(i=1;i<=m;i++)
    {
        int x,y,z;
        cin>>x>>y>>z;
        add(x,y,z);
        add(y,x,0);
    }
    cout<<push_relabel();
    return 0;
}

虽然快了 20 20 20 秒。

可是我们还是无法通过上题。

GAP 优化 HLPP

g a p    n . \sf gap \ \ n. gap  n. 缺口 缺口 缺口

当不存在 u u u 使 h ( u ) = k h(u)=k h(u)=k 那么使 h ( u ) > k h(u)>k h(u)>k 的 u u u 的 h ( u ) = n + 1 h(u)=n+1 h(u)=n+1

即高度出现缺口，将其迅速推回，节省大量的对高度重定的操作。

同时因为可以迅速推回，所以对每个操作都进行相关的优化，存在大量细节问题，如日报中的HLPP遇到不连通的点会RE。

UOJ HLPP(BFS+GAP)

洛谷 HLPP(BFS+GAP)

应该是完美的模板：

#include <iostream>
#include <queue>
#include <cstring>

using namespace std;

#define int long long

const int inf=1<<30;
int n,m,s,t;
struct edge
{
    int to,val,next;
}e[1000005];
int cnt=1,head[1000005];

void add(int x,int y,int z)
{
    cnt++;
    e[cnt].to=y;
    e[cnt].val=z;
    e[cnt].next=head[x];
    head[x]=cnt;
}

int h[1000005],w[1000005],vis[1000005],cnth[1000005],book[1000005];
struct cmp
{
    inline bool operator ()(int a,int b) const
    {
        return h[a]<h[b];
    }
};
priority_queue<int,vector<int>,cmp>q;
queue<int>qq;
void bfs()
{
    memset(h,0x3f,sizeof(h));
    h[t]=0;
    qq.push(t);
    while(!qq.empty())
    {
        int u=qq.front();
        qq.pop();
        for(int i=head[u];i;i=e[i].next)
        {
            int v=e[i].to;
            if(e[i^1].val&&h[u]+1<h[v])
            {
                h[v]=h[u]+1;
                if(book[v]==0)
                {
                    qq.push(v);
                    book[v]=1;
                }
            }
        }
    }
}

void relabel(int x)
{
    h[x]=inf;
    for(int i=head[x];i;i=e[i].next)
    {
        int to=e[i].to;
        if(e[i].val)
        {
            h[x]=min(h[x],h[to]+1);
        }
    }
}

void push_(int x,int i)
{
    int flow=min(e[i].val,w[x]);
    e[i].val-=flow;
    e[i^1].val+=flow;
    w[x]-=flow;
    w[e[i].to]+=flow;
}

int push_relabel()
{
    bfs();
    if(h[s]==0x3f3f3f)return 0;
    h[s]=n;
    for(int i=1;i<=n;i++)
    {
        if(h[i]<0x3f3f3f)
        {
            cnth[h[i]]++;
        }
    }
    for(int i=head[s];i;i=e[i].next)
    {
        int to=e[i].to,val=e[i].val;
        if(val)
        {
            e[i].val-=val;
            e[i^1].val+=val;
            w[s]-=val;
            w[to]+=val;
            if(vis[to]==0&&to!=s&&to!=t)
            {
                q.push(to);
                vis[to]=1;
            }
        }
    }
    while(!q.empty())
    {
        int x=q.top();
        q.pop();
        vis[x]=0;
        for(int i=head[x];i;i=e[i].next)
        {
            int v=e[i].to;
            if(e[i].val&&h[x]==h[v]+1)
            {
                push_(x,i);
                if(v!=s&&v!=t&&vis[v]==0)
                {
                    q.push(v);
                    vis[v]=1;
                }
            }
            if(w[x]==0)i=0;
        }
        if(w[x]&&h[x]<=n+1)
        {
            cnth[h[x]]--;
            if(cnth[h[x]]==0)
            {
                for(int i=1;i<=n;i++)
                {
                    if(h[i]>h[x]&&i!=s&&i!=t&&h[i]<n+1)
                    {
                        h[i]=n+1;
                    }
                }
            }
            relabel(x);
            cnth[h[x]]++;
            vis[x]=1;
            q.push(x);
        }
    }
    return w[t];
}

signed main()
{
    int i,j,k;
    cin>>n>>m>>s>>t;
    for(i=1;i<=m;i++)
    {
        int x,y,z;
        cin>>x>>y>>z;
        add(x,y,z);
        add(y,x,0);
    }
    cout<<push_relabel();
    return 0;
}

值得注意的是带 GAP 优化的 HLPP 会遍历点，所以在建模后更改 n n n 的数值，其余则不需要。

成功的通过了上题

GAP 优化其它

对于通用预流推进优先队列改回队列即可

洛谷 有用但不多

UOJ 有用但不多

对于 FIFOPP

将上代码中的优先队列改为栈即可。

常数会更优一些，因此具有使用价值

UOJ 只慢一点

洛谷 它甚至更快一些

节点选择改进尝试

对于通用的预流推进算法。

队列存储溢出节点并不是必须的。

可以发现以上两种改进均是对溢出节点的挑选方式进行的调整。

那我们试试挑选超额流最大的节点推进。

UOJ 只慢一点

洛谷 未能通过

我们也可以将优先队列的排列方式改为按照 e i + h i e_i+h_i ei​+hi​ 。

UOJ 还是慢一点

所以各种存储排列方式预流推进实质上是对选择点的改进。

EXCESS SCALING

论文

我的理解：

我们进行 log ⁡ U \log U logU 次 Scaling，每次不断选择 Δ / 2 ≤ e i \Delta/2\leq e_i Δ/2≤ei​ 中 h i h_i hi​ 最小的进行推一次流，更新当前弧，推不了重贴，重置当前弧，保证推到的点的超额流之后仍 < Δ <\Delta <Δ，直到没有 Δ / 2 ≤ e i \Delta/2\leq e_i Δ/2≤ei​，然后 Δ \Delta Δ 减半进入下一轮。

来自CHAT-GPT：

EXCESS SCALING 算法的流程如下：

预流推进初始化：将源点 s s s 的所有边设定为满载流量，源点 s s s 的 h h h 值设定为节点数 n n n，汇点 t t t 的 h h h 值为 0 0 0。同时将 s s s 的所有出边加入到高度为 1 1 1 的桶中。

excess flow scaling：每次推进时限定每条边所能流入的流量为 f ≤ 2 k f \le 2^k f≤2k，其中 k k k 是一个不断减小的指数。初始值为 k = ⌊ log ⁡ C ⌋ k = \lfloor \log C \rfloor k=⌊logC⌋，其中 C C C 是图中边权的最大值。当 k < 0 k < 0 k<0 时，停止算法。

桶排操作：按照节点的高度 h h h，将所有节点放入相应的高度桶中。同时建立超额流桶，将超额流的节点放入其中。

推进流：从高度最大的桶开始，取出其中的节点 u u u。如果节点 u u u 的超额流 e u e_u eu​ 大于 0 0 0，则将其推进至相邻节点 v v v。如果 v v v 的高度 h v < h u h_v < h_u hv​<hu​，则 u u u 将超额流 e u e_u eu​ 推进至 v v v，更新 e u e_u eu​ 和 e v e_v ev​。如果 v v v 的超额流 e v e_v ev​ 大于 0 0 0，则将其加入超额流桶中。

重贴标签：如果 u u u 的超额流 e u e_u eu​ 发生变化，使其超额流不为 0 0 0，则将其高度 h u h_u hu​ 置为最小的与其相邻的节点的高度加 1 1 1。

当高度为 h s > n h_s > n hs​>n 时，停止算法。此时， t t t 的超额流大小即为最大流。

在 EXCESS SCALING 算法中， k k k 的初始值是 ⌊ log ⁡ 2 C ⌋ \lfloor \log_2 C \rfloor ⌊log2​C⌋，其中 C C C 是图中边的最大容量。每次执行 excess flow scaling 阶段时， k k k 的值会减小，一般是 k ← ⌊ k / 2 ⌋ k \leftarrow \lfloor k/2 \rfloor k←⌊k/2⌋，直到 k = 0 k=0 k=0。这样做的原因是随着算法的进行，残量网络中的流量会逐渐减小，因此可以逐步减小 k k k 的值，以加快算法的收敛速度。

#include <iostream>
#include <queue>
#include <cstring>
#include <cmath>
#include <cctype>
#include <cstdio>
#include <cstring>

#define int long long

using namespace std;

inline int read()
{
    int x=0;
    char c=getchar();
    while(!isdigit(c))c=getchar();
    while(isdigit(c))x=x*10+c-'0',c=getchar();
    return x;
}

int K,level;
const int inf=(long long)1<<40;
int n,m,s,t;
struct edge
{
    int to,val,next;
}e[1000005];
int cnt=1,head[1000005],now[1000005];

void add(int x,int y,int z)
{
    cnt++;
    e[cnt].to=y;
    e[cnt].val=z;
    e[cnt].next=head[x];
    now[x]=head[x]=cnt;
}

int h[12005],w[12005],cnth[12005];
queue<int>list[12005];
queue<int>qq;
int book[12005];
void bfs()
{
    memset(h,0x3f,sizeof(h));
    h[t]=0;
    qq.push(t);
    while(!qq.empty())
    {
        int u=qq.front();
        qq.pop();
        for(int i=head[u];i;i=e[i].next)
        {
            int v=e[i].to;
            if(e[i^1].val&&h[u]+1<h[v])
            {
                h[v]=h[u]+1;
                if(book[v]==0)
                {
                    qq.push(v);
                    book[v]=1;
                }
            }
        }
    }
}



void push_relabel(int x,int Delta)
{
    int i;
    int found=0;
    for(i=now[x];i;i=e[i].next)
    {
        int v=e[i].to;
        if(h[x]==h[v]+1&&e[i].val)
        {
            found=1;
            break;
        }
        else
        {
            now[x]=e[i].next;
        }
    }
    if(found==1)
    {
        int v=e[i].to;
        int flow=min(e[i].val,w[x]);
        if(v!=t)flow=min(e[i].val,Delta-w[v]);
        e[i].val-=flow;
        e[i^1].val+=flow;
        w[x]-=flow;
        w[v]+=flow;
        if(w[x]<=Delta/2)list[h[x]].pop();
        if(w[v]>Delta/2&&v!=s&&v!=t)
        {
            list[h[v]].push(v);
            level--;
        }
    }
    else
    {
        list[h[x]].pop();
        cnth[h[x]]--;
        if(cnth[h[x]]==0)
        {
            for(int i=1;i<=n;i++)
            {
                if(h[i]>h[x]&&i!=s&&i!=t&&h[i]<n+1)
                {
                    h[i]=n+1;
                }
            }
        }
        int minn=inf;
        for(int i=head[x];i;i=e[i].next)
        {
            int to=e[i].to;
            if(e[i].val)
            {
                minn=min(minn,h[to]);
            }
        }
        h[x]=minn+1;
        if(minn==inf)h[x]=n+1;
        cnth[h[x]]++;
        list[h[x]].push(x);
        now[x]=head[x];
    }
}

int Excess_Scaling()
{
    bfs();
    if(h[s]==0x3f3f3f)return 0;
    h[s]=n;
    for(int i=1;i<=n;i++)
    {
        if(h[i]<0x3f3f3f)
        {
            cnth[h[i]]++;
        }
    }
    for(int i=head[s];i;i=e[i].next)
    {
        int to=e[i].to,val=e[i].val;
        if(val)
        {
            e[i].val-=val;
            e[i^1].val+=val;
            w[s]-=val;
            w[to]+=val;
        }
    }
    for(int k=1;k<=K;k++)
    {
        int Delta=(long long)1<<(K-k);
        for(int i=1;i<=n;i++)
        {
            if(w[i]>Delta/2)
            {
                list[h[i]].push(i);
            }
        }
        level=1;
        while(level<=n)
        {
            if(list[level].empty())level++;
            else
            {
                int x=list[level].front();
                push_relabel(x,Delta);
            }
        }
        for(int i=1;i<=32;i++)
        {
            while(!list[i].empty())
            {
                list[i].pop();
            }
        }
    }
    return w[t];
}


signed main()
{
    int i,j,k;
    n=read();
    m=read();
    s=read();
    t=read();
    for(i=1;i<=m;i++)
    {
        int x=read(),y=read(),z=read();
        K=max(K,(int)log2(z-1)+1);
        add(x,y,z);
        add(y,x,0);
    }
    K++;
    cout<<Excess_Scaling();
    return 0;
}
xiaopangfeiyu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Bounds Checking on the GPU - Futhark (hlpp20)-计算机科学
04-22
Noname manuscript No. (will be inserted by the editor)Bounds Checking on GPUTroels HenriksenReceived: date / Accepted: dateAbstract We present a simple compilation strategy for safety-checking array ...
ACM 算法模板大全
03-03
HLPP算法是另一种求解最大流问题的方法，它基于预流推进技术。 **最小费用流O(V*E*F)** 最小费用流问题旨在寻找从源点到汇点的最大流，同时使得总的流成本最小。 **最小边割集** 最小边割集是指在图中移除后将图...
预流推进
Dreamer_WishSky的专栏
05-06 2286
预流推进算法 预流推进算法（压入与重标记方法）： 预流推进算法将网络从源点到汇点至于从上到下的高度中。在算法执行过程中，每个节点的存留量（入流-出流）>=0，当一个点的存留量大于零时，则称此结点为活结点。算法从源点开始向下推流，通过不断地寻找活结点，将流量推向以该点为起点的可推流边（可推流边指与该点相连且高度比该点小1的边），该过程即为压入。如果在该点处
小胖来啦！
xiaopangfeiyu的博客
08-06 296
Hello!
从Dinic到ISAP，从余流推进到最高标号的预留推进HLPP（究极最大流算法）
既然弱小，就只顾变强就是了
01-22 1906
题目链接——很好的一道对于网络流提升的题 Dinic 首先，这道题真的将Dinic算法卡到了它的上界，也就是，在这道题中，使用一般的Dinic最后会获得40分。 #include <iostream> #include <cstdio> #include <cmath> #include <string> #include <cst...
HLPP(High Level Preflow Push) Algoritm
C20172809的博客
10-21 1389
怎么说呢，找博客来看真的很难弄清这个神奇的算法的具体过程。 相比找增广路的算法，不找增广路的HLPP被吹捧为“更(chang)高(shu)效(da)”的算法。各种各样的玄学博客看了好久，最后还是抄了一遍代码才大概理解了这个神奇的算法。 一.预流推进 (Preflow Push [abbr. PP]) 假设现在没有学过什么魔鬼增广路，就给出一个网络，怎么手跑最大流？ 把边上的流量看成在点上。 先管他...
网络最大流·预流推进及其衍生
weixin_30550271的博客
03-09 234
原文地址：http://www.orchidany.cf/2019/01/11/HLPP/#more #define \(u\)的伴点集合 与\(u\)相隔一条边的且\(u\)能达到的点的集合 \(0x00~ {}~Preface\) \(HLPP(Highest~Label~Preflow~Push)\)最高标签预流推进算法是处理网络最大流里两种常用方法——增广路&预流推进中，预流...
HLPP1对小鼠脊髓损伤运动功能恢复的实验研究-论文.zip
08-18
这篇论文的标题是“HLPP1对小鼠脊髓损伤运动功能恢复的实验研究”，它主要探讨了HLPP1在小鼠脊髓损伤后恢复运动功能方面的作用。HLPP1可能是一个蛋白质或生物分子，其具体作用机制和效果是本研究的重点。脊髓损伤是...
ACM算法模板和pku代码
11-09
最大流：hlpp算法 最小费用最大流：bellman_ford找增广路 最小费用最大流：ssp算法 字符串 KMP 通配符匹配 最小表示法 后缀数组 倍增算法 基于多串匹配的有限状态自动机 未分类 归并排序 星期几的计算 N...
预流推进算法的最大流模板
08-13
预流推进算法是不同与增广路思想的另一种求最大流的算法，主要思想是把流从源点经过边，并通过调整顶点的标号来把流压入汇点。 该算法需要维护一个装有活跃顶点的标号，所谓活跃定点则是流出量小于流入量的顶点，则具有超额量，欲使该顶点平衡（流出==流入），则需要把该定点积累的流压出，被压入流的顶点只能是距离标号比该点标号小1且这条边未满流的顶点，若不存在这样的顶点但是改点仍未活跃顶点，则需要把该点的距离标号加1. 这只是利用普通的FIFO队列，为了加速算法，可以维护一个优先队列，以顶点的距离标号为优先级，距离标号大的先出列。
网络流理论预流推进算法C++代码实现
10-13
网络流理论预流推进算法C++代码实现 最大流最小割 可进一步改造成类，用于各种应用
最大网络流 预流推进算法
05-20
最大网络流的预流推进算法，预流推进为网络流算法中的一种较为高效的一种算法，是最高标号法的基础
二分图匹配算法总结(phoenixinter)
hqd_acm的专栏
08-22 2386
一、二分图最大匹配<br />    二分图最大匹配的经典匈牙利算法是由Edmonds在1965<br />年提出的，算法的核心就是根据一个初始匹配不停的找增广<br />路，直到没有增广路为止。<br />    匈牙利算法的本质实际上和基于增广路特性的最大流算<br />法还是相似的，只需要注意两点：（一）每个X节点都最多<br />做一次增广路的起点；（二）如果一个Y节点已经匹配了，<br />那么增广路到这儿的时候唯一的路径是走到Y节点的匹配点<br />（可以回忆最大流算法中的后向边，这个时候后向
网络流之预流推进
weixin_45948940的博客
08-08 442
emmmm LOJ这个最大流加强版卡掉了我心爱的Dinic板子 加强版最大流 这这这也太丝滑了吧 LOJ板子题跑了400ms #pragma GCC optimize("Ofast,unroll-loops") #pragma GCC target("avx") #include <bits/stdc++.h> using namespace std; int getint() { char c; while (not isdigit(c = getchar()))
预流推进 HLPP模板
lcl1234567890lcl的博客
11-25 359
P4722 【模板】最大流 加强版 / 预流推进 网络流，最大流算法的最好标算法，时间复杂度上界一般为O(n2m)O(n^2\sqrt{m})O(n2m​) 本模板除了相应的算法，还加入了上界优化，在随机数据下会更优 #include <bits/stdc++.h> #define inf 0x7fffffff #define ll long long //#define int long long //#define double long double #define re register
最大流问题预流推进算法（最基本）
QiaoRuoZhuo的专栏
06-15 2536
/* Name: 最大流问题预流推进算法 Copyright: Author: 巧若拙 Date: 14-06-17 09:26 Description: 最基本的预流推进算法，没有任何优化，每次遍历所有的结点，找出活结点， 寻找可行弧，并预流推进，若没有可以push的顶点,执行relabel操作。 */ #include #include u
网络流算法（Dinic，Ispa，Hlpp）小结
trouble_的博客
05-15 1371
网络流所能解决的问题:   给定一个有向图，有两个特殊的点，源点S，汇点T，每条边有指定的容量，求从S流向T的最大流量是什么？ 求解思路： 解决该问题的算法： Dinic算法：   算法步骤: bfs标记深度，dfs查找增广路，再bfs，dfs，bfs，dfs，…，直到bfs无法进行，遇到断层，算法结束 代码模板（洛谷：P3376）： #include <bits/stdc++.h> #define INF INT_MAX using namespace std; typedef long
网络最大流——最高标号预流推进
aisi8242的博客
09-12 944
0、写在前面 解决最大流问题，最常用的算法是\(Dinic\)和\(ISAP\)，两种算法在实际应用中都相当快速。但是就理论而言，两种算法都属于增广路算法，复杂度上界都达到了\(O(n^2 m)\)，因此在某些题目中或许存在毒瘤出题人构造数据卡这两种算法的情况。因此本文讲解一种复杂度上界在常用最大流算法中最优的最高标号预留推进算法（又叫\(HLPP\)），其上界为\(O(n^2 \sqr...
最大流算法-最高标号预流推进(HLPP)
最新发布
06-08
最高标号预流推进算法（High-Level Preflow Push, HLPP）是一种常用的最大流算法。它的基本思想是将节点按照高度分类，按照高度从高到低进行推进流量，同时维护一个优先队列，以保证高度最高的节点优先处理。该算法...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值