网络流学习笔记-最大流问题的四种算法

最大流问题

最大流问题满足以下三个条件：

• 容量限制：(f(u,v)≤c(u,v))
• 斜对称性：(f(u,v)=-f(v,u))
• 流量平衡：(sum_ {(u,v)∈E}f(u,v)=0)（除(s),(t)外的图中任意两点）

原图中不存在的边也假设存在，视为容量为0.

残量网络：计算出每条边上容量(c)与流量(f)之差后所得到的图。由于上述的原因，边数可能是原图的两倍。对于原图中一条(c=16,f=11)的单向边，在残量网络中对应边权为(5(16-11))与(11(0-(-11)))的两条边。

增广路算法

当且仅当残量网络中不存在(s→t)的有向道路（增广路）时，此时的流是从(s)到(t)的最大流。

Edmonds-Karp算法

核心流程

• 对图进行(BFS)，直到形成(s->t)的通路（即当找到(t)时），同时维护这条通路上的最小残量(minflow=e[i].cap-e[i].flow)，并保存通路上每一个节点的入边。只要能到达(t)，这条通路就是增广路，否则图中已经没有增广路。
• 形成通路之后，按照先前保留的各节点的入边，从终点(t)开始沿着通路倒退回去，并更新路上每一条边的正向边的流量e[i].flow与反向边的流量e[i^1].flow。
• 整条通路的流量更新完毕后，更新答案(maxflow)。
• 重复以上步骤，直到图中没有增广路。

优化方法

• 重边处理。即将正向边(u→v)的多条管道合并为一条，只需将(cap)属性累加即可。而反向边不需要特殊处理。

（链式前向星+重边处理）

int n, m, s, t;
int num = 1;//让边的编号从2开始
int head[maxn], pre[maxn];
LL flow = 0;
LL d[maxn];
int flag[300][300];
//记录重边，重边的容量累加到一条边上

struct Edge {
    int next, to;
    LL cap;
    LL flow;
}e[maxn*4];

void addedge(int from,int to,LL cap){
    //存正向边
    num++;
    e[num].next = head[from];
    e[num].to = to;
    e[num].cap = cap;
    e[num].flow = 0;
    head[from] = num;
    //存反向边
    num++;
    e[num].next = head[to];
    e[num].to = from;
    e[num].cap = 0;
    e[num].flow = 0;
    head[to] = num;
}

void update() {
    //从终点开始退回去，沿路修改边权
    //通路的最小值m即d[t]
    for (int x = t; x != s; x = e[pre[x]^1].to) {
        e[pre[x]].flow += d[t];
        e[pre[x] ^ 1].flow -= d[t];
    }
    flow += d[t];
}

void ek(int s, int t) {
    for (;;) {
        mem(d, 0);
        //d[i]记录s->i路径上的最小残量
        //由于总是正数，可以同时起到记录是否访问过的作用
        queue<int> q;
        q.push(s);
        d[s] = INF;
        while (q.size()) {
            int u = q.front(); q.pop();
            for (int i = head[u]; i; i = e[i].next) {
                if (!d[e[i].to] && e[i].cap > e[i].flow) {
                    pre[e[i].to] = i;
                    //记录e[[i].to是从哪条边过来的
                    d[e[i].to] = min(d[u], e[i].cap - e[i].flow);
                    q.push(e[i].to);
                }
            }
            if (d[t]) break;
            //已经访问过t，可以跳出了
        }
        if (!d[t]) break;
        //整张图找遍依然到达不了t,说明已经没有增广路了
        update();
    }
}

int main() {
    cin >> n >> m >> s >> t;
    mem(flag, 0);
    f(i, 1, m) {
        int u, v, w;
        cin >> u >> v >> w;
        if (!flag[u][v]) {
            addedge(u, v, w);
            flag[u][v] = num - 1;
            //num是v->u的编号
            //num-1才是u->v的编号
        }
        else e[flag[u][v]].cap += w;
        //如果是重边，容量加到已存在的那条边上
    }
    ek(s,t);
    cout << flow;
    return 0;
}

Dinic算法

EK算法中，每一次BFS都只能找到一条增广路，效率不高。而Dinic算法则能通过BFS同时找到多条最短增广路，再通过DFS对找出的所有最短增广路同时增广。

核心流程

• 对图进行BFS，直到形成(s→ t)的通路（即找到终点(t)）。同时用数组(d[i])记录每个节点(i)所在层级，这类似于经典BFS题目中常记录的步数。BFS的目的在于找到图中的最短增广路。其中最短定义为路上经过的节点数最少。联想到BFS的性质可以知道，当找到终点(t)时，找到的最短增广路有多条。

• 在BFS成功形成(s→ t)通路的基础上，从(s)开始进行DFS。搜索路径所经过的节点层级严格递增，以保证走的是最短增广路。同时维护路径上的最小残量(minflow)。当找到终点(t)时，带着整条通路上的最小残量(minflow)回溯，这相当于(EK)算法中“从终点开始倒退回去沿路更新”的操作。

  • 在回溯过程中，同(EK)算法一样，会更新路上每一条边的正向边的流量e[i].flow与反向边的流量e[i^1].flow。但还要更新额外的变量(nowflow)，表示将当前节点(now)视为起点，以此出发后所经过的所有最短增广路的总流量。以及将当前节点(now)视为终点时的通路最小残量(minflow)。故前者加，后者减。
  • 当节点(now)的各数据更新完毕后，带着以(now)为起点的总流量(nowflow)回溯。

• 一次DFS最终得到的值，即以(s)为起点的多条最短增广路的总流量(nowflow)，用它更新答案(maxflow)。

• 重复以上所有步骤，直到BFS找不到增广路。

优化方法

• 剪枝。注意到当前节点(now)的各数据更新是基于更深一层(DFS)回溯上来的值(k)，当(k)为(0)时，它对节点的更新是无任何贡献的，所以可以把(k)的来源节点(v)从层级网络中剥离，即令d[v]=INF，这样之后的DFS就不会再访问以(v)为起点的最短增广路了。

• 当前弧优化。（这里的弧其实就是边）

  对于一个节点(u)，当它在DFS中走到了第(i)条弧时，前(i-1)条弧到汇点的流一定已经被流满而没有可行的路线了。那么当下一次再访问(u)节点的时候，前(i-1)条弧就可以被删掉而没有任何意义了。所以我们可以在每次枚举节点(now)所连的弧时，改变枚举的起点，这样就可以删除起点以前的所有弧以达到优化的效果。

typedef long long LL;
const long long INF = 2005020600;
const int maxn = 5e4 + 100;

int n, m, s, t;
int num = 1;//让边的编号从2开始
int head[maxn];
bool vis[maxn];
LL d[maxn], Maxflow;
int cur[maxn];
int flag[300][300];
int cnt[maxn];
//记录重边，重边的容量累加到一条边上

struct Edge {
    int next, to;
    LL cap;
    LL flow;

}e[maxn*4];

void addedge(int from,int to,LL cap){
    //存正向边
    num++;
    e[num].next = head[from];
    e[num].to = to;
    e[num].cap = cap;
    e[num].flow = 0;
    head[from] = num;
    //存反向边
    num++;
    e[num].next = head[to];
    e[num].to = from;
    e[num].cap = 0;
    e[num].flow = 0;
    head[to] = num;
}

bool bfs() {
    for (int i = 0; i <= n; i++) d[i] = INF;
    queue<int>q;
    q.push(s);
    d[s] = 0;
    cnt[s] = head[s];
    while (!q.empty()) {
        int u = q.front(); q.pop();
        for (int i = head[u]; i; i = e[i].next) {
            if (d[e[i].to]==INF && e[i].cap > e[i].flow) {
                d[e[i].to] = d[u] + 1;
                cnt[e[i].to] = head[e[i].to];
                q.push(e[i].to);
                if (e[i].to == t) return true;
            }
        }
    }
    return false;
}

//bfs将整张图跑一遍，将所有点分层，这样就可以一次性找出s->t的所有最短增广路
//最短指经过最少的节点

//dfs 从s开始递归搜索残量网络，且递归路线是层级逐渐加深的，这样就能保证走的是最短路
//并且在递归过程中维护通路上的最小残量
LL dfs(int now, LL minflow) {
    if (now == t) return minflow;
    //minflow维护以now为终点的最小残量
    LL nowflow = 0;
    for (int i = cnt[now]; i && minflow; i = e[i].next) {
        cnt[now] = i;
        //当前弧优化
        if (d[e[i].to] == d[now] + 1 && e[i].cap > e[i].flow) {
            LL k = dfs(e[i].to, min(e[i].cap - e[i].flow, minflow));
            if (!k) d[e[i].to] = INF;
            //剪枝
            e[i].flow += k;
            e[i ^ 1].flow -= k;
            nowflow += k;
            minflow -= k;
            //因为通路上的所有路径的残量都少了k
            //所以以now为终点的所有路径的最小残量也要减k
        }
    }
    return nowflow;
}

void dinic(){
    while (bfs()) {
        Maxflow += dfs(s, INF);
    }
}

int main() {
    cin >> n >> m >> s >> t;
    f(i, 1, m) {
        int u, v, w;
        cin >> u >> v >> w;
        addedge(u, v, w);
    }
    dinic();
    cout << Maxflow;
    return 0;
}

注意：通常(cap)和(flow)这两个属性可以简化为一个属性(val)，意为边(i)的残量
这样做的话，在增广处理时，(正向边.val-流量)，(反向边.val+流量)