2016-8-9夏令营总结(网络流—增广路+dinic)

今天我们学习了一个新的一个算法：网络流。

网络流其实就是最大流。在一个有向图中，每条边的边权就是每条边的能通过的最大流量，问从源点到汇点的最大流量是多少？

增广路

我们看看这个图，源点是s，汇点是t。如果我们一开始还不会网络流算法的话，或许我们会想到的是：每次都找一条容量最大的路径。比如我们先把1-3-4的路径搜了，然后把他们的容量全部减去20，然后再搜最大的1-2-4，把容量减去20，然后1-2-3-4，容量减去10，总流量就是50.

但是这个很明显的并不严谨，我们可以找到反例来推翻它。



看这个图：如果我们每次找流量最大的，那会先搜到1-2-3-4，把容量减去3，然后就没有路径可以走了，那么总流量是3。可是实际上我们走1-3-4和1-2-4，那样总流量就是4.所以这个贪心的方法是错的。



我们在上面贪心的过程中，发现一开始走完1-2-3-4，搜1-3的时候，发现2-3传过来了3个流量。那么我们能不能用这1-3的2个流量把2-3传过来3个流量的从3-2反向挤回去呢？我们有2个流量，就把2-3的2个流量挤回去然后用1-3的这2个流量顶替2-3的2个流量继续走，那么也就意味着2-3只流了1个流量，剩下的流量就可以走2-4了。那么就把每一个流量都尽量地利用回来。

其实上面的操作，就类似于讲1-3的两个流量通过3-2反向地流过去，所以我们就可以在3个流量从2-3流过时增加1条反向弧，这条反向弧的容量就是从2-3流过去的流量数。

那么整个流程就是这样的：每次都找一条可以到汇点的路径搜过去（可包含反向弧），当我们流过一条边时，假设流量为从，那么我们把它的容量减去c，它的反向弧的容量增加c（如果这条边是反向弧，那么它原来的边就是这条反向弧的反向弧）。直到找不到一条路径能流流量到汇点的时候，这个方案就是最优方案。

这就是最简单的解决网络流的方法。

最短增广路

最短增广路是增广路的优化，其实它们相差不大。因为我们在搜索一条路径时，为了尽量减少时间，我们要尽量每次都找最短的。我们建立一个层次网络，每一个点的层次就是这个点到源点的最短距离。那么我们每次第i层的点搜索时，就要搜第i+1层的点，这样就能保证每次搜的都是最短的路径，时间会尽量地减少。

所以我们每次先用bfs把每一个点的层次给算出来，同时判断能否到达汇点。如果到不了汇点，就代表已经没有增广路，所以当前总流量就是最后的总流量。如果还有路径到达汇点，那么我们就dfs搜索路径，每一次都只搜当前点的下一层的点，并且注意维护反向弧，搜到汇点之后就退出，继续下一次的bfs。

那么这个时间复杂度是多少呢？我们知道每一次dfs都会至少删掉一条边（就是会把路径中容量最小的边填满），所以bfs的次数最多是m次。根据用最短路径不断搜，最坏情况下是o(n*m)次（可证明，但我不会）。所以最短增广路的时间复杂度o(nm^2)。

dinic算法

dinic算法其实是最短增广路的优化。它们两个的不同之处在于，最短增广路每次bfs建图只可以单次增广，而dinic算法可以一次bfs建图多次增广。最短增广路是搜到一条到汇点的路径就停止，而dinic算法是搜一个点时，会尽量利用传进来的流量把他所连到的边尽量填满。也就是说每次bfs的构造层次网络，基本都可以删掉一个点，所以会bfs大约n次左右，所以总时间复杂度为o(n^2*m).

模版题：POJ1273

题目大意：

现在有m个池塘(从1到m开始编号,1为源点,m为汇点),及n条水渠,给出这n条水渠所连接的池塘和所能流过的水量,求水渠中所能流过的水的最大容量。

n,m<=200，保证所有结果在int范围内，多组数据。

题目分析：

这题很明显是网络流，由于数据较小，我们可以使用增广路，也可以用dinic算法。

参考代码：

增广路：

#include <iostream>
#include <fstream>
#include <algorithm>
#include <cstring>
#include <vector>
using namespace std;

struct Tline
{ int x,y,v; };
Tline l[407];
int n,m;
vector<int> line[207][207];
bool f[207];
int ans,minn,fl=1;

bool dfs(int k)
{
if(k==m)
{
ans+=minn;
return true;
}
f[k]=1;
for(int i=1;i<=m;i++)
{
if(!line[k][i].size()) continue;
for(int j=0;j<line[k][i].size();j++)
{
int y=line[k][i][j];
if(l[y].v==0 || f[i]) continue;
minn=min(minn,l[y].v);
if(dfs(i))
{
int tmp=l[y].v;
l[y].v-=minn;
l[y^1].v+=minn;
return true;
}
}
}
return false;
}

int main()
{
scanf("%d%d",&n,&m);
while(1)
{
fl=0;
memset(l,0,sizeof(l));
for(int i=1;i<=m;i++)
for(int j=1;j<=m;j++)
line[i][j].clear();
int x,y,v;
for(int i=0;i<n;i++)

4000
{
scanf("%d%d%d",&x,&y,&v);
l[fl].x=x;
l[fl].y=y;
l[fl].v=v;
line[x][y].push_back(fl);
fl++;
l[fl].x=y;
l[fl].y=x;
line[y][x].push_back(fl);
fl++;
}
memset(f,0,sizeof(f));
ans=0;
minn=100000000;
for(;dfs(1);)
{
minn=100000000;
memset(f,0,sizeof(f));
}
printf("%d\n",ans);
n=-1;
scanf("%d%d",&n,&m);
if(n==-1) break;
}

return 0;
}

dinic算法：

#include <iostream>
#include <fstream>
#include <algorithm>
#include <cstring>
#include <vector>
using namespace std;

const int maxN=200100;
const int maxM=500100;
const int oo=100000000;
struct Tline
{ int x,y,c; };
Tline line[maxM];
struct Tnode
{ int t,l; };
vector<Tnode> node[maxN];
int n,m;
int que[maxN],level[maxN];
int lnum=0;
long long Max=0;

bool bfs(int s,int t)   //构造新的层次网络 level表示第几层
{
memset(level,0,sizeof(level));
int head=0,tail=1;
level[s]=1;
que[head]=s;
for(;head<tail;head++)
{
int u=que[head];
if(u==t) return true;
for(int i=0;i<node[u].size();i++)
{
int v=node[u][i].t;
int l=node[u][i].l;
if(!level[v] && line[l].c)
{
level[v]=level[u]+1;
que[tail++]=v;
}
}
}
return false;
}

int dfs(int u,int t,int c)
{
if(u==t) return c;
int ret=0;
for(int i=0;i<node[u].size();i++)
{
int v=node[u][i].t,l=node[u][i].l;
if(level[v]==level[u]+1 && line[l].c)
{
int Min=min(c-ret,line[l].c);
int tmp=dfs(v,t,Min);
line[l].c-=tmp;
line[l^1].c+=tmp;
ret+=tmp;
if(ret==c) return ret;  //dinic多次增广
}
}
return ret;
}

int main()
{
scanf("%d%d",&m,&n);
while(1)
{
lnum=0;
int x,y,c;
Tnode tmp;
for(int i=1;i<=n;i++)
node[i].clear();
memset(line,0,sizeof(line));
for(int i=0;i<m;i++)
{
scanf("%d%d%d",&x,&y,&c);
tmp.t=y;tmp.l=lnum;
node[x].push_back(tmp);
line[lnum].x=x;
line[lnum].y=y;
line[lnum].c=c;
lnum++;
tmp.t=x;tmp.l=lnum;
node[y].push_back(tmp);
line[lnum].x=y;
line[lnum].y=x;
line[lnum].c=0;
lnum++;
}
int s=1,t=n;
long long ans=0;
while(bfs(s,t)) ans+=dfs(s,t,oo);
printf("%d\n",ans);
n=-1;
scanf("%d%d",&m,&n);
if(n==-1) break;
}

return 0;
}