Dinic算法的原理与构造

出处：http://blog.csdn.net/wall_f/article/details/8207595

为了更好的介绍Dinic算法，我们先来介绍最短增广路算法。

最短增广路算法

1、顶点的层次和层次网络

顶点的层次：在残留网络中，把从源点到顶点u的最短路径长度（该长度仅仅是值路径上边的数目，与容量无关），称为顶点u的层次，记为level(u)。源点Vs的层次为0。

将残留网络中所有的顶点的层次标注出来的过程称为分层。

注意：

（1）对残留网路进行分层后，弧可能有3种可能的情况。

1、从第i层顶点指向第i+1层顶点。

2、从第i层顶点指向第i层顶点。

3、从第i层顶点指向第j层顶点（j < i）。

（2）不存在从第i层顶点指向第i+k层顶点的弧(k>=2)。

（3）并非所有的网络都能分层。

层次网络：对残留网络进行分层后，删去比汇点Vt层次更高的顶点和与汇点Vt同层的顶点(保留Vt)，并删去这些顶点相关联的弧，再删去从某层顶点指向同层顶点和低层顶点的弧，所剩余的各条弧的容量与残留网络中的容量相同，这样得到的网络就是残留网络的子网络，称为层次网络，记为G''(V'',E'')。

根据层次网络定义，层次网络中任意的一条弧<u,v>，有满足level(u)+1 == level(v)，这条弧也叫允许弧。直观的说，层次网络是建立在残留网络基础之上的一张“最短路径图”。从源点开始，在层次网络中沿着边不管怎么走，到达一个终点之后，经过的路径一定是终点在残留网络中的最短路径。

阻塞流：设容量网络的一个可行流为f，当该网络的层次G''中不存在增广路(即从源点Vs到汇点Vt的路径时)，称该可行流f为层次网络G''的阻塞流。

2、最短路增广路径的算法思想

最短增广路的算法思想是：每次在层次网络中找一条含弧数最少的增广路进行增广。最短增广路算法的具体步骤如下：

（1）初始化容量网络和网络流。

（2）构造残留网络和层次网络，若汇点不在层次网络中，则算法结束。

（3）在层次网络中不断用BFS增广，直到层次网络中没有增广路为止；每次增广完毕，在层次网络中要去掉因改进流量而导致饱和的弧。

（4）转步骤（2）。

在最短增广路算法中，第（2）、（3）步被循环执行，将执行（2）、（3）步的一次循环称为一个阶段。在每个阶段中，首先根据残留网络建立层次网络，然后不断用BFS在层次网络中增广，直到出现阻塞流。注意每次增广后，在层次网络中要去掉因改进流量而饱和的弧。该阶段的增广完毕后，进入下一阶段。这样的不断重复，直到汇点不在层次网络中为止。汇点不在层次网络中意味着在残留网络中不存在一条从源点到汇点的路径，即没有增广路。

在程序实现的时候，并不需要真正“构造”层次网络，只需要对每个顶点标记层次，增广的时候，判断边是否满足level(v) = level(u)+1这一约束条件即可。

3、最短增广路算法复杂度分析

最短增广路的复杂度包括建立层次网络和寻找增广路两部分。

在最短增广路中，最多建立n个层次网络，每个层次网络用BFS一次遍历即可得到。一次BFS的复杂度为O（m），所以建层次图的总复杂度为O（n*m）。

每增广一次，层次网络中必定有一条边会被删除。层次网络中最多有m条边，所以认为最多可以增广m次。在最短增广路算法中，用BFS来增广，一次增广的复杂度为O（n+m），其中O（m）为BFS的花费，O（n）为修改流量的花费。所以在每一阶段寻找增广路的复杂度为O（m*(m+n)） = O(m*m)。因此n个阶段寻找增广路的算法总复杂度为O(n*m*m)。

两者之和为O（n*m*m）。

以上介绍最短增广路算法只是为下面介绍Dinic算法而提供给大家一个铺垫，有了以上的基础，接下来我们来介绍Dinic算法，Dinic其实是最短增广路算法的优化版。

 

连续最短增广路算法----Dinic算法

1、Dinic算法思路

Dinic算法的思想也是分阶段地在层次网络中增广。它与最短增广路算法不同之处是：最短增广路每个阶段执行完一次BFS增广后，要重新启动BFS从源点Vs开始寻找另一条增广路;而在Dinic算法中，只需一次DFS过程就可以实现多次增广，这是Dinic算法的巧妙之处。Dinic算法具体步骤如下:

（1）初始化容量网络和网络流。

（2）构造残留网络和层次网络，若汇点不再层次网络中，则算法结束。

（3）在层次网络中用一次DFS过程进行增广，DFS执行完毕，该阶段的增广也执行完毕。

（4）转步骤（2）。

在Dinic的算法步骤中，只有第（3）步与最短增广路相同。在下面实例中，将会发现DFS过程将会使算法的效率有非常大的提高。

Dinic算法复杂度分析

与最短增广路算法一样，Dinic算法最多被分为n个阶段，每个阶段包括建层次网络和寻找增广路两部分，其中建立层次网络的复杂度仍是O（n*m)。

现在来分析DFS过程的总复杂度。在每一阶段，将DFS分成两部分分析。

（1）修改增广路的流量并后退的花费。在每一阶段，最多增广m次，每次修改流量的费用为O（n）。而一次增广后在增广路中后退的费用也为O(n)。所以在每一阶段中，修改增广路以及后退的复杂度为O(m*n)。

（2）DFS遍历时的前进与后退。在DFS遍历时，如果当前路径的最后一个顶点能够继续扩展，则一定是沿着第i层的顶点指向第i+1层顶点的边向汇点前进了一步。因为增广路经长度最长为n，所以最坏的情况下前进n步就会遇到汇点。在前进的过程中，可能会遇到没有边能够沿着继续前进的情况，这时将路径中的最后一个点在层次图中删除。

注意到每后退一次必定会删除一个顶点，所以后退的次数最多为n次。在每一阶段中，后退的复杂度为O（n）。

假设在最坏的情况下，所有的点最后均被退了回来，一共共后退了n次，这也就意味着，有n次的前进被“无情”地退了回来，这n次前进操作都没有起到“寻找增广路”的作用。除去这n次前进和n次后退，其余的前进都对最后找到增广路做了贡献。增广路最多找到m次。每次最多前进n个点。所以所有前进操作最多为n+m*n次，复杂度为O（n*m）。

于是得到，在每一阶段中，DFS遍历时前进与后退的花费为O（m*n）。

综合以上两点，一次DFS的复杂度为O（n*m）。因此，Dinic算法的总复杂度即O（m*n*n）。

下面给出 Dinic具体实现的代码。

预处理：

[cpp]  view plain  copy

1. #include <iostream>  
2. #include <cstdlib>  
3. #include <cstdio>  
4. #include <cstring>  
5. #include <string>  
6. #include <algorithm>  
7. #include <queue>  
8. using namespace std;  
9.   
10. const int MAXN = 210;  
11. const int MAXM = 210*210;  
12. const int INF = 0x3f3f3f3f;  
13.   
14. struct Edge  
15. {  
16.     int v, f;  
17.     int next;  
18. }edge[MAXM];  
19.   
20. int n, m;  
21. int cnt;  
22.   
23. int first[MAXN], level[MAXN];  
24. int q[MAXN];  
25.   
26. void init()  
27. {  
28.     cnt = 0;  
29.     memset(first, -1, sizeof(first));  
30. }  
31.   
32. void read_graph(int u, int v, int f)  
33. {  
34.     edge[cnt].v = v, edge[cnt].f = f;  
35.     edge[cnt].next = first[u], first[u] = cnt++;  
36.     edge[cnt].v = u, edge[cnt].f = 0;  //增加一条反向弧，容量为0   
37.     edge[cnt].next = first[v], first[v] = cnt++;  
38. }  

BFS构建层次网络：

[cpp]  view plain  copy

1. int bfs(int s, int t) //构建层次网络   
2. {  
3.     memset(level, 0, sizeof(level));  
4.     level[s] = 1;  
5.     int front = 0, rear = 1;  
6.     q[front] = s;  
7.     while(front < rear)  
8.     {  
9.         int x = q[front++];  
10.         if(x == t) return 1;  
11.         for(int e = first[x]; e != -1; e = edge[e].next)  
12.         {  
13.             int v = edge[e].v, f = edge[e].f;  
14.             if(!level[v] && f)  
15.             {  
16.                 level[v] = level[x] + 1;  
17.                 q[rear++] = v;  
18.             }  
19.         }  
20.     }  
21.     return 0;  
22. }  

DFS找寻增广路：

[cpp]  view plain  copy

1. int dfs(int u, int maxf, int t)  
2. {  
3.     if(u == t) return maxf;  
4.     int ret = 0;  
5.     for(int e = first[u]; e != -1; e = edge[e].next)  
6.     {  
7.         int v = edge[e].v, f = edge[e].f;  
8.         if(level[u] + 1 == level[v] && f)  
9.         {  
10.             int Min = min(maxf-ret, f);  
11.             f = dfs(v, Min, t);  
12.             edge[e].f -= f;  
13.             edge[e^1].f += f;  
14.             ret += f;  
15.             if(ret == maxf) return ret;  
16.         }  
17.     }  
18.     return ret;  
19. }  

Dinic：

[cpp]  view plain  copy

1. int Dinic(int s, int t) //Dinic  
2. {  
3.     int ans = 0;  
4.     while(bfs(s, t)) ans += dfs(s, INF, t);  
5.     return ans;  
6. }