Dinic算法----最大流常用算法之一

——没有什么是一个BFS或一个DFS解决不了的；如果有，那就两个一起。

最大流的$EK$算法虽然简单，但时间复杂度是$O(nm^2)$，在竞赛中不太常用。

竞赛中常用的$Dinic$算法和$SAP$，其实也不太难。

那么，$Dinic$算法到底是什么呢？

---

多路增广

$Dinic$算法最核心的内容就是多路增广。

沿着$EK$算法的过程：

我们有一个图，如图一。

按照套路，我们先$BFS$，找$S-T$最短路。所有的距离标号都画在了图二上（$EK$算法可能用不到，但$Dinic$用得到）。

假设我们选的是$S-3-T$这条路，增广。。。（如图三，绿色）

然后我们再来一遍$BFS$。。。 等等！

细心的你可能也发现了，$S-1-T$也是一条$S-T$最短路。

那就增广吧！（如图四）

您可以检查一下，这时候没有长度为$2$的最短路了。

但EK算法不会这样。它会再笨拙地$BFS$一遍，这就浪费了不少时间。

所以说，多路增广是很重要的。

我们换一种思路，如果网络流在一个$DAG$上，还不用考虑回退边，你会怎么做？

这很简单，$dfs$就能解决。

至于回退边。。。再来一次$BFS-DFS$就好了啊。

还有一个优化：当前弧优化：

对于每个点，我可能在一次$BFS$之后$DFS$多次。那么它出发的边所到的点里， 有些点出发已经满流。

这样， 我就可以每个点记录一个当前弧， 表示这次$DFS$它最后$DFS$到哪条弧，下次$DFS$它的时候就从这条弧开始。

这样，我就可以保证每条边在一次$DFS$中满流后不会再遍历。

这样的复杂度。。。理论上最坏是$O(n^2m)$，但这上界很松。

附代码！

 int n;

 struct Dinic{
     struct Edge{
         int from, to;
         LL cap, flow;
         Edge(int f = -, int t = -, LL c = )
         :from(f), to(t), cap(c), flow()
         {}
     }edges[MAXM];
     int next[MAXM], cnt;
     int pre[MAXN], dis[MAXN];
     int cur[MAXN];                                    //当前弧
     Dinic()
     {
         memset(pre, -, sizeof(pre));
         cnt = ;
     }
     void addedge(int f, int t, LL c)
     {
         edges[cnt] = Edge(f, t, c);
         next[cnt] = pre[f];
         pre[f] = cnt++;
         edges[cnt] = Edge(t, f, );
         next[cnt] = pre[t];
         pre[t] = cnt++;
     }
     queue<int> Q;
     bool BFS(int s, int t)
     {
         while(!Q.empty()) Q.pop();
         memset(dis, -, sizeof(dis));
         dis[s] = ;
         Q.push(s);
         while(!Q.empty())
         {
             int u = Q.front(); Q.pop();
             for(int i = pre[u]; i >= ; i = next[i]) if(edges[i].cap > edges[i].flow)
             {
                 int v = edges[i].to;
                 if(dis[v] >= ) continue;
                 dis[v] = dis[u] + ;
                 if(v == t) return true;
                 Q.push(v);
             }
         }
         return false;
     }
     LL DFS(int now, int t, LL maxflow)            //当前在now，汇点t
     {                                             //最大可以提供maxflow的流量
         if(now == t) return maxflow;
         int ret = ;
         for(int i = cur[now] != - ? cur[now] : pre[now]; i >= ; i = next[i]) if(edges[i].cap > edges[i].flow)
         {
             int v = edges[i].to;
             if(dis[v] != dis[now] + ) continue;
             int l = DFS(v, t, min(edges[i].cap - edges[i].flow, maxflow - ret));
             ret += l;
             edges[i].flow += l;
             edges[i^].flow -= l;
             cur[now] = i;
             if(ret == maxflow) return ret;
         }
         cur[now] = -;
         return ret;
     }
     LL solve(int s, int t)
     {
         int res = ;
         while(BFS(s,t))
         {
             memset(cur, -, n * sizeof(int));
             res += DFS(s, t, inf);
         }
         return res;
     }
 };

Dinic

代码可能有错，烦请指出。谢谢。

另外，如果有人知道些好用的画图软件麻烦推荐一下。用windows自带画图太累了。