[网络流]最大流算法 Dinic

最近做了几道题，发现用Ek算法会超时，而事实上，Ek算法使用的机会并不多，更多的是用Dinic和ISAP算法。所以特地找了一段时间来学习、理解和编Dinic算法。

类似之前的储存方法，但稍作修改，代码如下：

struct Edge {
    int from, to, cap, flow;
};

这样储存的是一条边。在做题的过程中，发现一个技巧（也算是技巧吧），出现无向边时，不需要加两条边，而是直接将反向边的容量也改为cap，会减少很多多余的时间和空间。

插入边的过程与之前相同：

void AddEdge(int from, int to, int cap) {
    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);
}

Dinic算法中，主要的操作过程如下：通过BFS构造层次图，然后DFS一次增广。

首先先来看看层次图。

在残量网络中，s到节点v的距离为d，那么d就是节点v的层次。只保留每个点到下一个层次的弧，也就是d(u) + 1 = d(v)，的图，就是层次图。

层次图上的任意一条路径都是从s到层次1到层次2……直到t，可以发现，每一条这样的路径都是一条s-t最短路，这样求，不会出现走多余的边的情况。

如图，这样的一个图就是一个层次图。

从1开始，2和3都是层次1,4和5是层次2,6是层次3

在层次图上DFS求最大流自然很简单，就是不考虑反向边时能得到的最大流，多次增广后，重新计算层次图，发现s和t不连通，就退出。

它的时间复杂度不会很高，相对Ek会快很多，最多只会跑n-1次DFS，因为每次DFS之后s到t的路径至少会少一条，也就是最大距离至少会增加1，而每一次跑DFS最多会用nm的时间，每一次最多遍历每一个节点，每一个节点遍历它所链接的所有边，所以最终时间复杂度为O(N^2*M)，相对Ek来说会快很多。

实际上，理论数值所对应的数据几乎不会出现，通常并不会想理论值说的这么慢，只会更快。

而且，对于它，还有一个很重要的优化，对于DFS来说，要保存一个“当前所有弧的最小残量”，如果等于0，必然是不能增广的，找到一条路径直接返回它的值即可，不然会出现多路增广不会退出的情况，还需要多加一次再算增广量，必然会很慢。

还有，当前弧优化，对于一次DFS中，可能会重复访问一个节点，虽然可能性比较小，这时候，已经走过的边自然是不需要再走，那么用一个数组记录上一次这个点走了哪些连接它的边，再次访问时不再重复走，那么就会更快。

下面为代码：

struct Dinic {
    int n, m, s, t;
    vector < Edge > edges;
    vector < int > G[MAXN];
    bool vis[MAXN];
    int d[MAXN];
    int cur[MAXN];

    void AddEdge(int from, int to, int cap) {
        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);
    }

    bool BFS() {
        memset(vis, 0, sizeof vis);
        queue < int > Q;
        Q.push(s);
        d[s] = 0;
        vis[s] = 1;

        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(!vis[e.to] && e.cap > e.flow) { //如果未曾访问过，而且这一条边处于残量网络中，那么计算层次
                    vis[e.to] = 1;
                    d[e.to] = d[x] + 1;
                    Q.push(e.to);
                }
            }
        }

        return vis[t];
    }

    int DFS(int x, int a) {
        if(x == t || a == 0) { // 如果找到一条增广的路或无法继续增广，返回当前流量
            return a;
        }

        int flow = 0, f;

        for(int& i = cur[x]; i < G[x].size(); ++i) {
            Edge& e = edges[G[x][i]];

            if(d[x] + 1 == d[e.to] && (f = DFS(e.to, min(a, e.cap - e.flow))) > 0) { // 如果处于同一个层次且这一条路径还能增广
                e.flow += f;
                edges[G[x][i] ^ 1].flow -= f;
                flow += f;
                a -= f;//增广 注意当前流量a要减f

                if(a == 0) {//如果a=0，那么不能继续增广，返回上一条路
                    break;
                }
            }
        }

        return flow;
    }

    int Maxflow(int s, int t) {
        this -> s = s;
        this -> t = t;

        int flow = 0;

        while(BFS()) { // 计算层次图 如果s-t不连通那么退出
            memset(cur, 0, sizeof cur); // 初始化当前弧
            flow += DFS(s, INF); // 计算最大流
        }

        return flow;
    }
} dinic;

当然，这里的DFS用的是递归实现的，但是如果Dinic依然会超时，那么可以尝试将DFS写成迭代的过程，会提高一些速度，但是也会相应地提高代码量，不如直接使用ISAP，不仅更快，而且代码稍微少一些。