最大流问题-EK算法

最大流问题

解决问题

        最大流的目的是将最多的物品从源点S通过其他点的中转，运送到汇点T，每条边具有能运送物品的上限。从S运送出来的物品数目等于到达T的物品数量。

        针对图a，其中每条边代表运送物品的上上限，图b是其一个可行流(a / b, a是实际运送物品，b是物品上限)， 其结果为9, 但不是最大流11，这样的可行流有多个，而最大流就是可行流中最大的那个。

概念

         容量:对于一条边$(u,v)$, 它的物品上限称为容量，记做$c(u,v)$, 而对于不存在的边$c(u,v)=0$;

        流量:对于一条边$(u,v)$,它的实际运送的物品称为流量，记做 $f(u,v)$，而对于不存在的边$f(u,v)=0$;

        残量:每条边上的容量和流量的差值。

性质

        在最大流问题中，容量$C$和流量$F$满足三个性质：

• 容量限制 ：$f(u,v)\le c(u,v)$

• 斜对称性 ：$f(u,v)=-f(v,u)$

• 流量平衡 ： 对于除了$s$和$t$外的任意结点$u$ , ${\sum }_{(u,v)\in E}f(u,v)=0$(即，流入此结点的流量必定会全部流出)。

增广路算法(EK算法)

残量图

    残量图中边的权修改为残量，$(u,v)$ 的残量我们记做 $r(u,v)$，并引入反向边的残量（其目的是为了可以回退流量）。如下图：

        其中对某条边进行说明：
        $r(S,A)=c(S,A)-f(S,A)=10-2=8$;
        $r(A,S)=c(A,S)-f(A,S)=0-(-2)=2$

增广路

        残量图中任何一条从$S$到$T$的有向道路都对应这一条原图中的增广路，只要求出该道路上的所有残量的最小值$d$，把增广路上的边流量均增加$d$即可，这个过程称为增广。只要残量图中存在增广路，流量就可以增大。如果残量图中不存在增广路，则当前流量就是最大流。

代码实现

        EK算法使用的是BFS的方式在残量图中不断寻找增广路。并用p数组保存记录曾广路上弧，a数组记录可以增加的流。

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10000 + 5;

// 邻接表结构
struct Edge 
{
    int from, to, cap, flow;
    Edge(int fr, int t, int c, int f) : from(fr), to(t), cap(c), flow(f){}    
};
vector<Edge> edges;
vector<int> G[MAXN]; 

int a[MAXN];        /* 起点到aa的可改进量*/
int p[MAXN];        /* 最短路树上的入弧编号*/

// 向邻接表中添加边, 增加一个正向残量，引入一个反向残量
void addEdge(int from, int to, int cap) 
{
    int m = -1;
    edges.push_back(Edge(from, to, cap, 0));
    edges.push_back(Edge(to, from, 0, 0));
    m = edges.size();
    G[from].push_back(m - 2);
    G[to].push_back(m - 1);    
} 

// 最大流算法
int MaxFlow(int s, int t)
{
    int flow = 0;                            /* 结果*/
    for(;;) 
    {
        memset(a, 0, sizeof(a));
        queue<int> Q;
        Q.push(s);
        a[s] = INT_MAX;
        while(!Q.empty())
        {
            int x = Q.front(); Q.pop();

            // 遍历邻街边
            for(int i = 0; i < G[x].size(); i++)
            {
                Edge & e = edges[G[x][i]];
                
                // 此条边可以进行曾广
                if(!a[e.to] && e.cap > e.flow)
                {
                    p[e.to] = G[x][i];
                    a[e.to] = min(a[x], e.cap - e.flow);
                    Q.push(e.to);
                }
            }

            // 找到了增广路
            if(a[t]) break;
        }           

        // 找不到增广路
        if(!a[t]) break;

        // 更新残量图
        for(int u = t; u != s; u = edges[p[u]].from) 
        {
            edges[p[u]].flow += a[t];                /* 正向边增加流量*/
            edges[p[u] ^ 1].flow -= a[t];          /* 反向边减少流量*/
        }
        
        flow += a[t];
    }
    return flow;
}