网络流之Dinic算法

Dinic 算法的基本步骤为:

1) 计算残余网络的层次图。我们定义 h[i] 为顶点 i 距离源 S 所经过到最小边数，求出所有顶点的 h 值，h[] 值相同的顶点属于同一层，这就是网络的层次图。

2) 在层次图上进行 BFS 增广，直到不存在增广路径。这时求得的增广路径上顶点是分层的，路径上不可能存在两个顶点属于同一层，即 h[i]== h[j] (i!= j )。同时，求得层次图后，我们可以在层次图上进行多次增广。

3) 重复 1 和 2。直到不存在增广路径。

最小割：对于图中的两个点(一般为源点和汇点)来说，如果把图中的一些边去掉，如果它们之间无法连通的话，则这些边组成的集合就叫为割了。如果这些边有权值，最小割就是指权值之和最小的一个割。

最大流最小割：应用于网络中，指总流量不超过链路可承载的最大值，且在每条子路径上取尽可能少的流量。对任意一个只有一个源点一个汇点的图来说，从源点到汇点的最大流等于最小割。

struct{

    int u, v, next;

    double c;

}bf[2*eMax];//边信息

int ne, head[nMax];//head[i]记录最后一条以i为起点的边的id,即以i为起点的最后一条边为bf[head[i]],而bf[head[i]].next则为以i为起点的倒数第二条边，以此类推  

int cur[nMax], ps[nMax], dep[nMax];//dep[i]记录i点的层次 。

 

void addEdge(int u, int v, double c){    // dinic的加边，还是有点不同的。

    bf[ne].u = u;

    bf[ne].v = v;

    bf[ne].c = c;

    bf[ne].next = head[u];

    head[u] = ne ++;

    bf[ne].u = v;

    bf[ne].v = u;

    bf[ne].c = 0;

    bf[ne].next = head[v];

    head[v] = ne ++;

}

double dinic(int s, int t)    //dinic模板：源点为s，汇点为t

{

    double tr, res = 0;

    int i, j, k, f, r, top;

    while(1){

        memset(dep, -1, sizeof(dep));

        for(f = dep[ps[0]=s] = 0, r = 1; f != r;)

            for(i = ps[f ++], j = head[i]; j; j = bf[j].next)

                if(bf[j].c && dep[k=bf[j].v] == -1){

                    dep[k] = dep[i] + 1;

                    ps[r ++] = k;

                    if(k == t){

                        f = r; break;

                    }

                }

        if(dep[t] == -1) break;

        memcpy(cur, head, sizeof(cur));

        i = s, top = 0;

        while(1){

            if(i == t){

                for(tr = inf, k = 0; k < top; k ++)

                    if(bf[ps[k]].c < tr)

                        tr = bf[ps[f=k]].c;

                for(k = 0; k < top; k ++){

                    bf[ps[k]].c -= tr;

                    bf[ps[k]^1].c += tr;

                }

                i = bf[ps[top=f]].u;

                res += tr;          // 当前的最大流，每次累积上去。    

            }

            for(j = cur[i]; cur[i]; j = cur[i] = bf[cur[i]].next)

                if(bf[j].c && dep[i]+1 == dep[bf[j].v]) break;

            if(cur[i]){

                ps[top ++] = cur[i];

                i = bf[cur[i]].v;   // i=bf[cur[i]].v 绝不能写为 bf[cur[i]].v=i，脑残了一次。

            }else{

                if(top == 0) break;

                dep[i] = -1;

                i = bf[ps[-- top]].u;

            }

        }

    }

    return res;

}