让我先讲一个故事吧。

一些小精灵要准备从银月城(S)迁徙到Nibel山(T)。

这两个地方之间的道路构成了一个网络。

每个道路都有它自己的容量，这决定了每天有多少小精灵可以同时从这儿通过。

现在它们想知道，它们迁徙的速度最大是多少只每天。

这就是一道红果果的最大流问题。

在建图时，我们把每条边拆成2条，

它们方向相反，和原来那条边方向相同的边的容量还是原来的容量，

而另一条边的容量就设成0。

当我们要修改剩余容量的时候，

把正方向的边的容量减少，把反方向的边的容量增加，

就可以很方便的修改它了。

一种最朴实的算法是，

每次寻找一条可以从S到T的有可用容量剩余的路径(我们把它叫增广路，虽然我也不知道为什么是这个名字)，

不断寻找到没有这种路径为止。

这种算法叫EK，复杂度是\(O(fm)\)，f是得到的最大流，m是道路数量。

可见这个算法运行速度很垃圾，特别时遇到这种情况

              /> 次元壁1(999/999) __/     |     \__ (999/999)/        |        \>银月城        (1/1)         Nibel山\__      |      __/>(999/999)   \     v     /   (999/999)\> 次元壁2

寻找的增广路会一直穿过次元壁1和次元壁2来回走动

每次都只找到一条可以通过1只精灵的路

卡成gou bi

因此，我们提出了一个改进的算法：

把每一个点到起点S的距离用BFS求出来，得到一个分层图，

然后在寻找增广路的时候，限制当前点只能往比它距离刚刚好大1的点前进，

在找到一条增广路后，再用BFS更新分层图，继续寻找增广路，肛到你听到为止直到找不到为止。

我们把这个算法叫做Dinic，复杂度是\(O(min(Xuanxue,n^2 \times m))\)，n是点数。不要问我Xuanxue是什么鬼

这个算法有一个优化，叫GAP优化，
主要就是把离起点S等于某个距离的点的数量记下来，
如果离起点S的距离等于某值的点全都不见了，
那么这个图就发生了断层，
再也找不到一条增广路出来。
这个时候就阔以提前结束程序哒。
有时候可以为程序提速100倍以上

有些人啊，发现这个狄尼克dinic算法有个大问题，

就是它每一次BFS的意义好像并不大，

毕竟出现改动的道路就那么点。

于是这些人就搞出了一个更快的算法：

isap

复杂度也许是\(O(0.8*(n^2 \times m))\)

和dinic最大的不同就是，它可以在寻找增广路的同时，自己更新分层图。

主要就是在找不到合法的增广路的时候（比如没有满足距离刚刚好大1的点），

就把现在这个点的距离设为离自己最近的出边的点的距离+1。

这里还有个优化叫当前弧优化，不过意义不大。

这是网上某个isap代码

int source;         // 源点
int sink;           // 汇点
int p[max_nodes];   // 可增广路上的上一条弧的编号
int num[max_nodes]; // 和 t 的最短距离等于 i 的节点数量
int cur[max_nodes]; // 当前弧下标
int d[max_nodes];   // 残量网络中节点 i 到汇点 t 的最短距离
bool visited[max_nodes];// 预处理, 反向 BFS 构造 d 数组
bool bfs()
{memset(visited, 0, sizeof(visited));queue<int> Q;Q.push(sink);visited[sink] = 1;d[sink] = 0;while (!Q.empty()){int u = Q.front();Q.pop();for (iterator_t ix = G[u].begin(); ix != G[u].end(); ++ix){Edge &e = edges[(*ix)^1];if (!visited[e.from] && e.capacity > e.flow){visited[e.from] = true;d[e.from] = d[u] + 1;Q.push(e.from);}}}return visited[source];
}// 增广
int augment()
{int u = sink, df = __inf;// 从汇点到源点通过 p 追踪增广路径, df 为一路上最小的残量while (u != source){Edge &e = edges[p[u]];df = min(df, e.capacity - e.flow);u = edges[p[u]].from;}u = sink;// 从汇点到源点更新流量while (u != source){edges[p[u]].flow += df;edges[p[u]^1].flow -= df;u = edges[p[u]].from;}return df;
}int max_flow()
{int flow = 0;bfs();memset(num, 0, sizeof(num));for (int i = 0; i < num_nodes; i++) num[d[i]]++;int u = source;memset(cur, 0, sizeof(cur));while (d[source] < num_nodes){if (u == sink) {flow += augment();u = source;}bool advanced = false;for (int i = cur[u]; i < G[u].size(); i++){ Edge& e = edges[G[u][i]];if (e.capacity > e.flow && d[u] == d[e.to] + 1){advanced = true;p[e.to] = G[u][i];cur[u] = i;u = e.to;break;}}if (!advanced){ // retreatint m = num_nodes - 1;for (iterator_t ix = G[u].begin(); ix != G[u].end(); ++ix)if (edges[*ix].capacity > edges[*ix].flow)m = min(m, d[edges[*ix].to]);if (--num[d[u]] == 0) break; // gap 优化num[d[u] = m+1]++;cur[u] = 0;if (u != source)u = edges[p[u]].from;}}return flow;
}

看起来isap代码量很大。

其实不然，isap可以写的很简单。

这是我的这一题的全部代码

#include<bits/stdc++.h>
using namespace std;
inline int gotcha()
{register int a=0,b=1,c=getchar();while(!isdigit(c))b^=c=='-',c=getchar();while(isdigit(c))a=a*10+c-48,c=getchar();return b?a:-a;
}
const int _ = 10002 , __ = 200002;
int to[__],ne[__],v[__],he[_]={0},ecnt=1;
void adde(int a,int b,int c){to[++ecnt]=b,v[ecnt]=c,ne[ecnt]=he[a],he[a]=ecnt;}
int n,m,S,T,dis[_],gap[_];
int dfs(int d,int flw)
{if(d==T || flw==0)return flw;int i,g,mid=n-1,los=flw;for(i=he[d];i;i=ne[i])if(v[i]>0){if(dis[d]==dis[to[i]]+1){g=dfs(to[i],min(los,v[i])),v[i]-=g,v[i^1]+=g,los-=g;if(dis[S]>=n)return flw-los;if(!los)break;}mid=min(mid,dis[to[i]]);}if(flw==los){if(--gap[dis[d]]==0)dis[S]=n;dis[d]=mid+1,gap[dis[d]]++;}return flw-los;
}
int isap(){int ans=0;gap[S]=n;while(dis[S]<n)ans+=dfs(S,1e9);return ans;}
int main()
{register int i,j,k,a;n=gotcha(),m=gotcha(),S=gotcha(),T=gotcha();for(i=1;i<=m;i++)j=gotcha(),k=gotcha(),a=gotcha(),adde(j,k,a),adde(k,j,0);printf("%d",isap());return 0;
}

我在这儿省去了累赘的BFS和retreat操作，

把它们简化到dfs中。

实测运行速度依然很快

且程序关键部分（链式前向星，dfs()，isap()）只有约0.6KB

性价比极高啊

以下是博主抽风内容

我突然有个写伪代码的冲动

要不我就写在这儿吧，还可以增强记忆

大法师的工作
信息：现在在哪儿现在带领了多少精灵如果我现在已经到了Nibel山，或者我这里已经没有更多的精灵了，那么我就把现在我这儿的精灵数量汇报回去。现在我要记录这儿离银月城的可能的最短距离，以及我还有多少精灵还滞留在这儿。我要寻找可以走的道路。如果这条路还有精灵的容身之地，并且这条路的终点离我们这儿的距离差是1的话，我将派出一个大法师信使，让她去这条路的终点，而她带领精灵的数量是，这条路的剩余容量与我这儿还滞留的精灵数量的最小值，毕竟带多了没有用。等她把成功到达终点的精灵数量带回来，我就把仍滞留在这儿的精灵的数量记录一下，也把这条道路的容量修改一下。当我收到了紧急的停止通知(GAP优化)，我将立刻把成功前往目的地的精灵的数量汇报回去。如果我这儿已经没有滞留的精灵了，那我就不用寻找道路了。除此之外，我还要更新这儿离银月城的可能的最短距离。当我没有把任何精灵送到Nibel山，我会考虑这儿的距离是不是有点问题。我会将这里从距离统计的计数君中抹除，如果已经没有和这儿距离一样的点，那么就散布紧急通知(GAP优化)。之后把这里的距离改成可能的最短距离，并且让计数君把这里加入距离统计中。最后，我将汇报从我这里成功到达Nibel山的精灵的数量。领主伊萨普的工作
没有信息我将不断地派遣大法师，让她带上许多的精灵，从银月城出发，统计成功到达Nibel山的精灵的数量，
直到收到紧急的停止通知(GAP优化)为止。

upd:做了狼抓兔子之后还是决定把bfs代码放上来

queue<int> q;
void bfs()
{memset(dis,-64,sizeof(dis)),memset(gap,0,sizeof(gap));while(!q.empty())q.pop();dis[T]=1,gap[1]=1,q.push(T);int i,a,b;while(!q.empty()){a=q.front(),q.pop();for(i=he[a];i;i=ne[i])if(dis[to[i]]<0)b=to[i],dis[b]=dis[a]+1,gap[dis[b]]++,q.push(b);}
}