初涉网络流[EK&dinic]

主要还是板子

Edmonds-Karp

从S开始bfs，直到找到一条到达T的路径后将该路径增广，并重复这一过程。

在处理过程中，为了应对“找到的一条路径把其他路径堵塞”的情况，采用了建反向弧的方式来实现“反悔”过程。

这种“反悔”的想法和技巧值得借鉴。

 int maxFlow()
 {
     int ret = ;
     for (;;)
     {
         memset(f, , sizeof f);
         memset(bck, , sizeof bck);
         std::queue<int> q;
         f[S] = INF, q.push(S);
         for (int tmp; q.size(); )
         {
             tmp = q.front(), q.pop();
             for (int i=head[tmp]; i!=-; i=nxt[i])
             {
                 int v = edges[i].v;
                 if (!f[v]&&edges[i].f < edges[i].c){
                     f[v] = std::min(f[tmp], edges[i].c-edges[i].f);
                     bck[v] = i, q.push(v);
                 }
             }
             if (f[T]) break;
         }
         if (!f[T]) break;
         for (int i=T; i!=S; i=edges[bck[i]].u)
         {
             edges[bck[i]].f += f[T];
             edges[bck[i]^].f -= f[T];
         }
         ret += f[T];
     }
     return ret;
 }

Dinic

EK的效率是$O(nm^2)$的，它把很多时间浪费在了重复的搜索上面。

dinic有如下两个重要的定义：

• 层次$\text{level(x)}$：表示点$x$在层次图中与源点$S$的距离。
• 层次图：在原来的残量网络当中，只保留所有可被增广的边以及与之相连的点。

bfs建出来的层次图对于接下去的dfs增广具有一种“指导”作用。使用了反向弧技巧，意味着不管用什么方法，只需要找到一条增广路就行。在这种情况下，我们来考虑dfs增广的优劣之处：一方面它一旦找到一条增广路就能快速退出，比bfs的逐级外扩更高效；另一方面纯粹的dfs受搜索顺序的影响很大，因为（可以像卡SPFA以及某些图论算法一样）挂一些诱导节点附带数量巨大的边，就能置dfs于死地。但是这里dfs依靠建出来的层次图，每次只向距离+1的点搜索。这意味着我们避免了对同一个节点的重复搜索，或是偏离T方向浪费时间。

 bool buildLevel()
 {
     memset(lv, , sizeof lv);
     std::queue<int> q;
     q.push(S), lv[S] = ;
     for (int i=; i<=T; i++) cur[i] = head[i];　　　//tip1
     for (int tmp; q.size(); )
     {
         tmp = q.front(), q.pop();
         for (int i=head[tmp]; i!=-; i=nxt[i])
         {
             int v = edges[i].v;
             if (!lv[v]&&edges[i].f < edges[i].c){
                 lv[v] = lv[tmp]+, q.push(v);
                 if (v==T) return true;　　　　　　　　//tip2
             }
         }
     }
     return false;
 }
 int fndPath(int x, int lim)　　　　　　　　//此处已更新，详情见下
 {
     if (x==T) return lim;
     for (int &i=cur[x]; i!=-; i=nxt[i])　　　　　　 //tip1
     {
         int v = edges[i].v, val;
         if (lv[x]+==lv[v]&&edges[i].f < edges[i].c){
             if ((val = fndPath(v, std::min(lim, edges[i].c-edges[i].f)))){
                 edges[i].f += val, edges[i^].f -= val;
                 return val;
             }else lv[v] = -;　　　　　　　　　　　　　//tip3　　
         }
     }
     cur[x] = head[x];
     return ;
 }
 int dinic()
 {
     int ret = , val;
     while (buildLevel())
         while ((val = fndPath(S, INF))) ret += val;
     return ret;
 }

dinic有三个常见优化：

tip1当前弧优化：这个优化是针对边的，有些网络流的边数巨大。这个优化是为了确保在同一层次图的多次增广当中，可以实现“从上一次成功增广停下的地方再次开始”这一个功能。

tip2层次图优化：每次建层次图只需要达到T即可。

tip3堵塞点优化：姑且这么叫吧……在同一层次图下，一个点若未被增广则再也不会被增广了。

个人觉得tip3的效果最明显。tip1是为了少遍历一些边，但是节省的只不过是遍历（因为并不执行操作）的代价；tip2是看脸的优化；tip3应该算是强剪枝。

3.5upd：

今天写最大权闭合子图时候，才发现我学了个假的dinic.

当时是照着menci的 Dinic 学习笔记 学的dinic，然而今天才发现，menci的指针小常数真的是非常人可比拟的……

就拿bzoj1497: [NOI2006]最大获利来说吧：同样的流程结构，我结构体写法用时7.5s；menci的指针版本只需要0.75s（本地不开O2），这比我加满优化（包括改成以下这个写法）都要快得多……

dinic需要多路优化，而非以上dfs提到的每次寻找到一条增广路就退出。

正经的板子：

 bool buildLevel()
 {
     std::queue<int> q;
     memset(lv, , sizeof lv);
     lv[S] = , q.push(S);
     for (int i=; i<=T; i++) cur[i] = head[i];
     for (int tmp; q.size(); )
     {
         tmp = q.front(), q.pop();
         for (int i=head[tmp]; i!=-; i=nxt[i])
         {
             int v = edges[i].v;
             if (!lv[v]&&edges[i].f < edges[i].c){
                 lv[v] = lv[tmp]+, q.push(v);
                 if (v==T) return true;
             }
         }
     }
     return false;
 }
 int fndPath(int x, int lim)
 {
     int sum = ;
     if (x==T||!lim) return lim;
     for (int i=cur[x]; i!=-&&sum <= lim; i=nxt[i])
     {
         int v = edges[i].v, val;
         if (lv[x]+==lv[v]&&edges[i].f < edges[i].c){
             if ((val = fndPath(v, std::min(lim-sum, edges[i].c-edges[i].f)))){
                 edges[i].f += val, edges[i^].f -= val;
                 sum += val;
             }else lv[v] = -;
         }
　　　　　 if (lim==sum) break;　　　　　　　　//小trick的效果是玄学致命的
     }
     cur[x] = head[x];
     return sum;
 }
 int dinic()
 {
     int ret = , val;
     while (buildLevel())
         while ((val = fndPath(S, INF))) ret += val;
     return ret;
 }