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++)        {            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;}