2. 程式人生 > >網路最大流-ISAP演算法詳解與模板

網路最大流-ISAP演算法詳解與模板

阿新 • • 發佈：2018-12-24
ISAP演算法
ISAP（Improved Shortest Augumenting Path）演算法是改進版的SAP演算法，如果對效率要求很高的時候，可以用該演算法。
（1）概述：演算法基於這樣的一個事實：每次增廣之後，任意結點到匯點（在殘餘網路中）的最短距離都不會減小。這樣，我們可以利用d[i[表示結點i到匯點的距離的下界。然後再增廣過程當中不斷地修改這個下界。增廣的時候和Dinic演算法類似，只允許沿著d[i]==d[j]+1的弧(i,j)走。

不難證明，d[i[滿足兩個條件：(1)d[t]=0;(2)對任意的弧(i,j) d[i]≤d[j]+1。因為最壞的情況就是s到t是一條鏈，此時等號成立。因此，當d[s]≥n時，殘餘網路中不存在s-t路。

那麼與Dinic演算法類似，事先逆向bfs，找增廣的過程就是沿著“允許弧”（即滿足f< c且d[i]==d[j]+1的弧）往前走。（稱為“前進”）。如果向前走不動了，那麼就要考慮原路返回（稱為“撤退”）。此時把d[i]修改為min{d[j]}+1即可。因為要滿足d函式的條件(2)。修改後，原來的i值的個數就減少一個，而新i值的個數多一個。在程式中，用num陣列來儲存所有距離的個數，當把距離值從x修改為y時，num[x]–,num[y]++即可，然後檢查num[x]是否為0，如果是0，那麼s-t不連通，演算法終止。原因顯而易見：比如s-t的距離是3，如果距離為2的情況都已經沒了，更別提走到距離為1的點了。這就是所謂的“gap優化”。

通過之前的分析，在資料結構方面，該演算法只比Dinic演算法的資料結構多了兩個陣列：用於記錄父邊以便於撤退的陣列p，以及標記距離個數的陣列num。增廣的時候分為兩步，第一步逆推求出可改進量a（即殘餘量的最小值）；第二步再逆推一遍，進行增廣。主過程中，x走到匯點時增廣。

在下面程式碼中，由於我們是連續存的正向邊和反向邊，如0和1,2和3，等等。而他們分別與1異或後可以得到對方（二進位制最後一位變反，其他位不變），所以我們在更新反向邊時用到了這一點。

程式碼模板：
版本一

（紫書）：

#include<bits/stdc++.h>
using namespace std;

#define N 1000
#define INF 100000000
struct Edge
{
    int from,to,cap,flow;
    Edge(int u,int v,int c,int f):from(u),to(v),cap(c),flow(f){}
};

struct ISAP
{
    int n,m,s,t;
    vector<Edge>edges;
    vector<int>G[N];
    bool vis[N];
    int d[N],cur[N];
    int p[N],num[N];//比Dinic演算法多了這兩個陣列，p陣列標記父親結點，num陣列標記距離d[i]存在幾個
    void addedge(int from,int to,int cap)
    {
        edges.push_back(Edge(from,to,cap,0));
        edges.push_back(Edge(to,from,0,0));
        int m=edges.size();
        G[from].push_back(m-2);
        G[to].push_back(m-1);
    }

    int Augumemt()
    {
        int x=t,a=INF;
        while(x!=s)//找最小的殘量值
        {
            Edge&e=edges[p[x]];
            a=min(a,e.cap-e.flow);
            x=edges[p[x]].from;
        }
        x=t;
        while(x!=s)//增廣
        {
            edges[p[x]].flow+=a;
            edges[p[x]^1].flow-=a;//更新反向邊。
            x=edges[p[x]].from;
        }
        return a;
    }
    void bfs()//逆向進行bfs
    {
        memset(vis,0,sizeof(vis));
        queue<int>q;
        q.push(t);
        d[t]=0;
        vis[t]=1;
        while(!q.empty())
        {
            int x=q.front();q.pop();
            int len=G[x].size();
            for(int i=0;i<len;i++)
            {
                Edge&e=edges[G[x][i]];
                if(!vis[e.from]&&e.cap>e.flow)
                {
                    vis[e.from]=1;
                    d[e.from]=d[x]+1;
                    q.push(e.from);
                }
            }
        }
    }

    int Maxflow(int s,int t)//根據情況前進或者後退，走到匯點時增廣
    {
        this->s=s;
        this->t=t;
        int flow=0;
        bfs();
        memset(num,0,sizeof(num));
        for(int i=0;i<n;i++)
            num[d[i]]++;
        int x=s;
        memset(cur,0,sizeof(cur));
        while(d[s]<n)
        {
            if(x==t)//走到了匯點，進行增廣
            {
                flow+=Augumemt();
                x=s;//增廣後回到源點
            }
            int ok=0;
            for(int i=cur[x];i<G[x].size();i++)
            {
                Edge&e=edges[G[x][i]];
                if(e.cap>e.flow&&d[x]==d[e.to]+1)
                {
                    ok=1;
                    p[e.to]=G[x][i];//記錄來的時候走的邊，即父邊
                    cur[x]=i;
                    x=e.to;//前進
                    break;
                }
            }
            if(!ok)//走不動了，撤退
            {
                int m=n-1;//如果沒有弧，那麼m+1就是n，即d[i]=n
                for(int i=0;i<G[x].size();i++)
                {
                    Edge&e=edges[G[x][i]];
                    if(e.cap>e.flow)
                        m=min(m,d[e.to]);
                }
                if(--num[d[x]]==0)break;//如果走不動了，且這個距離值原來只有一個，那麼s-t不連通，這就是所謂的“gap優化”
                num[d[x]=m+1]++;
                cur[x]=0;
                if(x!=s)
                    x=edges[p[x]].from;//退一步，沿著父邊返回
            }
        }
        return flow;
    }
};

int main()
{
    ISAP isap;
    while(scanf("%d%d",&isap.n,&isap.m)!=EOF)
    {
        for(int i=0;i<isap.m;i++)
        {
            int from,to,cap;
            scanf("%d%d%d",&from,&to,&cap);
            isap.addedge(from,to,cap);
        }
        scanf("%d%d",&isap.s,&isap.t);
        printf("%d\n",isap.Maxflow(isap.s,isap.t);)
    }
    return 0;
}
版本二：
/*ISAP鄰接表形式
*/
const int maxn=100010;//點數的最大值
const int maxm=400010;//邊數的最大值
const int inf=0x3f3f3f3f;
struct Edge {
  int to,next,cap,flow;
}edge[maxm];//注意是maxm
int tol;
int head[maxn];
int cur[maxn],d[maxn];// 當前弧下標   結點到匯點距離下界
int p[maxn],gap[maxn];//可增廣路上的上一條弧   gap優化  //比dinic多的兩個陣列
void init() {
  tol=0;
  memset(head,-1,sizeof(head));
}

//加邊，單向圖三個引數，雙向圖四個引數
void addedge(int u,int v,int w,int rw=0) {
  edge[tol].to=v; edge[tol].cap=w; edge[tol].next=head[u];
  edge[tol].flow=0; head[u]=tol++;
  edge[tol].to=u; edge[tol].cap=rw; edge[tol].next=head[v];
  edge[tol].flow=0; head[v]=tol++;
}

//輸入引數：起點、終點、點的總數
//點的編號沒有影響，只要輸入點的總數
int sap(int s,int t,int N){
  memset(gap, 0, sizeof(gap));
  memset(d, 0, sizeof(d));
  memcpy(cur, head, sizeof(head));
  int u=s;
  p[u]=-1;
  gap[0]=N;
  int ans=0;
  while(d[s]<N){
    if(u == t){
      int Min=inf;
      for(int i=p[u]; i!=-1; i=p[edge[i^1].to])//找最小殘量值
        if(Min>edge[i].cap-edge[i].flow)
          Min=edge[i].cap-edge[i].flow;
      for(int i = p[u]; i!=-1; i=p[edge[i^1].to]){//增廣
        edge[i].flow+=Min;
        edge[i^1].flow-=Min;
      }
      u=s;
      ans+=Min;
      continue;
    }
    bool ok=false;
    int v;
    for(int i=cur[u]; i!=-1; i=edge[i].next){
        v=edge[i].to;
        if(edge[i].cap-edge[i].flow && d[v]+1==d[u]){//Advance前進
          ok=true;
          cur[u]=p[v]=i;
          break;
        }
    }
    if(ok){
      u=v;
      continue;
    }
    //Retreat走不動了，撤退
    int Min=N;
    for(int i=head[u]; i!=-1; i=edge[i].next)
      if(edge[i].cap-edge[i].flow && d[edge[i].to] < Min){
        Min=d[edge[i].to];
        cur[u]=i;
      }
    gap[d[u]]--;
    if(!gap[d[u]])return ans;
    d[u] = Min+1;
    gap[d[u]]++;
    if(u!=s) u=edge[p[u]^1].to;//退一步，沿父邊返回
  }
  return ans;
}
版本三：
/*ISAP+bfs初始化+棧優化
*/
const int maxn=100010;//點數的最大值
const int maxm=400010;//邊數的最大值
const int inf=0x3f3f3f3f;
struct Edge {
  int to,next,cap,flow;
}edge[maxm];//注意是maxm
int tol;
int head[maxn];
int cur[maxn],d[maxn];// 當前弧下標   結點到匯點距離下界
int p[maxn],gap[maxn];//可增廣路上的上一條弧   gap優化  //比dinic多的兩個陣列
void init(){
  tol=0;
  memset(head, -1, sizeof(head));
}

void addedge(int u,int v,int w,int rw = 0){
  edge[tol].to=v; edge[tol].cap=w; edge[tol].flow=0;
  edge[tol].next=head[u]; head[u]=tol++;
  edge[tol].to=u; edge[tol].cap=rw; edge[tol].flow=0;
  edge[tol].next=head[v]; head[v]=tol++;
}

int Q[maxn];
void bfs(int s,int t){//逆向進行bfs
  memset(d, -1, sizeof(d));
  memset(gap, 0, sizeof(gap));
  gap[0]=1;
  int front=0, rear=0;
  d[t]=0;
  Q[rear++]=t;
  while(front!=rear){
  int u=Q[front++];
    for(int i=head[u]; i!=-1; i=edge[i].next){
      int v=edge[i].to;
      if(d[v]!=-1)continue;
      Q[rear++]=v;
      d[v]=d[u]+1;
      gap[d[v]]++;
    }
  }
}

int S[maxn];
int sap(int s,int t,int N){
  bfs(s, t);
  memcpy(cur, head, sizeof(head));
  int top=0;
  int u=s;
  int ans=0;
  while(d[s]<N){
    if(u==t){
      int Min=inf;
      int inser;
      for(int i=0; i<top; i++)//找最小殘量值
        if(Min>edge[S[i]].cap-edge[S[i]].flow){
          Min=edge[S[i]].cap-edge[S[i]].flow;
          inser=i;
        }
      for(int i=0; i<top; i++){//增廣
        edge[S[i]].flow+=Min;
        edge[S[i]^1].flow-=Min;
      }
      ans+=Min;
      top=inser;
      u=edge[S[top]^1].to;
      continue;
    }
    bool ok=false;
    int v;
    for(int i=cur[u]; i!=-1; i=edge[i].next){
      v=edge[i].to;
      if(edge[i].cap-edge[i].flow && d[v]+1==d[u]){////Advance前進
        ok=true;
        cur[u]=i;
        break;
      }
    }
    if(ok){
      S[top++]=cur[u];
      u=v;
      continue;
    }
    //Retreat走不動了，撤退
    int Min=N;
    for(int i=head[u]; i!=-1; i=edge[i].next)
      if(edge[i].cap-edge[i].flow && d[edge[i].to]<Min){
        Min=d[edge[i].to];
        cur[u]=i;
      }
    gap[d[u]]--;
    if(!gap[d[u]])return ans;
    d[u]=Min+1;
    gap[d[u]]++;
    if(u!=s)u=edge[S[--top]^1].to;//退一步，沿父邊返回
  }
  return ans;
}




相關推薦

網路最大流-ISAP演算法詳解與模板

ISAP演算法 ISAP（Improved Shortest Augumenting Path）演算法是改進版的SAP演算法，如果對效率要求很高的時候，可以用該演算法。 （1）概述：演算法基於這樣的一個事實：每次增廣之後，任意結點到匯點（在殘餘網路中）的最短距離都不會

網路流-Dinic演算法詳解與模板

Dinic演算法詳解： 我們已經學過了求最大網路流的EK演算法，EK演算法的思想是每次用bfs找增廣路，然後利用記錄的路徑回退到原點的過程更新網路。 （1）Dinic演算法的思路是這樣的：每次都不停地用BFS來構造“層次圖”，然後用“阻塞流”來增廣。這裡我特

網路最大流 Dinic演算法

# 前言 看到網上好多都用的鏈式前向星，就我在用 $vector$ 鄰接表…… # 定義 先來介紹一些相關的定義。（個人理解） ## 網路 一個網路是一張帶權的有向圖 $G=(V,E)$ ，其中每任意一條邊 $(u,v)$ 的權值稱為這條邊的容量 $c(u,v)$ 。若這條邊不存在，對應的容量就為 $0$ 。

HDU 3549 Flow Problem 網路最大流問題 EK、Dinic、ISAP三種演算法

Flow Problem Time Limit: 5000/5000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others) Total Submission(s): 8218    Accepted

網路最大流 - 從入門開始，詳細講到實用易懂的 Dinic 演算法

2019-01-02 更新 理解網路 一張網路，是一張帶權有向圖。比喻成輸水系統可能好理解—— 源頭是大水庫，想輸出多少就輸出多少。 但是，想要輸出到目的地，需要經過中轉點。中轉點不產生新流量、也不私吞；接受多少流量，就同時輸出多少流量。 點與點之間管道的容量（可以理解為水流量限制；注意“流量”指單

網路最大流演算法—最高標號預流推進HLPP

#include<iostream> #include<cstdio> #include<cstring> #include<cmath> #include<queue> using namespace std; const int

網路最大流演算法—EK演算法

#include<iostream> #include<cstdio> #include<cstring> #include<cmath> #include<queue> using namespace std; const int

網路最大流中一般增廣路演算法（標號法）

網路最大流主要有兩大類求解方法：增廣路演算法和預流推進演算法 一般增廣路演算法：主要分為初始流為零流和初始流為非零流的情況！後者在標號的時候注意一條邊是正向連線還是反向連線；若是反向的連線，那麼在調整的時候是減去，若為正向那麼在調整的時候是加上！   這裡就poj1149

網路最大流演算法之Ford_Fullkerson方法，EK演算法c++模板

該演算法最精華的部分是反向邊的理解， 即修改容量的時候為什麼反向邊加上該值，     c[pre[i]][i]-=_min;     c[i][pre[i]]+=_min;              在演算法導論中對求解最大流問題給出了一般性的解決方法，但並沒有涉

（通俗易懂小白入門）網路流最大流——EK演算法

網路流 網路流是模仿水流解決生活中類似問題的一種方法策略，來看這麼一個問題，有一個自來水廠S，它要向目標T提供水量，從S出發有不確定數量和方向的水管，它可能直接到達T或者經過更多的節點的中轉，目前確定的是每條水管中水流的流向是確定的（單向），且每個水管單位時間內都有屬於自己的水流量的上限（超過會爆水管），問

BZOJ.3698.XWW的難題(有源匯上下界最大流ISAP)

部分 stdin 要求 難題 down 題目 什麽 Go bfs 題目鏈接 按套路行列作為兩部分，連邊 \(S->row->column->T\)。 S向代表行的元素連邊cap(A[i][n])(容量上下界為上下取整)，代表列的元素向T連邊cap(A[n]

LOJ 101 最大流(ISAP 模板）

span ins bfs 最大流 spa nbsp space end pan 開long long的最大流 #include<bits/stdc++.h> using namespace std; const long long MAXN = 4000010

圖的最小生成樹prim演算法詳解

prim演算法是求圖的最小生成樹的一種演算法，它是根據圖中的節點來進行求解，具體思想大概如下： 首先，將圖的所有節點（我們假定總共有n個節點）分成兩個集合，V和U。其中，集合V儲存的是我們已經訪問過的節點，集合U儲存的是我們未曾訪問的節點。prim演算法第一步就是選定第一個節點放入集合

最大流DINIC演算法JAVA板子

推薦一條部落格： https://www.cnblogs.com/SYCstudio/p/7260613.html 講解得比較細緻。 然後自己理解了一下寫了個JAVA得板子，和哪個差不多，去把HDU一道板子題A了： http://acm.hdu.edu.cn/showproble

【模板】網路最大流

題目描述 如題，給出一個網路圖，以及其源點和匯點，求出其網路最大流。 輸入輸出格式 輸入格式： 第一行包含四個正整數N、M、S、T，分別表示點的個數、有向邊的個數、源點序號、匯點序號。 接下來M行每行包含三個正整數ui、vi、wi，表示第i條有向邊從ui出發，到達vi，邊權為wi

求最大流dinic演算法模板

//最短增廣路，Dinic演算法 struct Edge { int from,to,cap,flow; };//弧度 void AddEdge(int from,int to,int cap) //增弧 { edges.push_back((Edge){from,to,cap

最大流 Dinic演算法

Dinic演算法模板   鄰接矩陣形式 #include<iostream> #include<cstring> #include<algorithm> #include<queue> #include<vector>

FF最大流問題演算法

一、最大流問題 最大流問題(maximum flow problem)，一種組合最優化問題，就是要討論如何充分利用裝置的能力，使得運輸的流量最大，以取得最好的效果。 實際來源： 有一個自來水管道運輸系統，起點是 s，終點是 t，途中經過的管道都有一個最大的容量，可以想象每條管道不

Drainage Ditches(網路最大流)

Every time it rains on Farmer John's fields, a pond forms over Bessie's favorite clover patch. This means that the clover is covered by water for awhi

流問題Flow Problem（網路最大流）- HDU 3549

        網路最大流問題屬於演算法 裡面較難的問題，因為牽涉的概念比較多，這一篇可能需要你花比較多的時間去理解，除了看這個，最好能多參考別的書籍或者文章進行比較學習，不然可能容易產生理解的偏差。 &n