网络流-最大流

网络最大流

有一个网络，其中有源点和汇点两个特殊的点，分别表示水流的源头和水流汇入的大海；两个点之间有很多支流，他们的单位时间运水量也不相同，问单位时间内最大可以运送多少的水流呢？

以下是解决网络最大流的一些算法：

1.EK算法

求解思路：

首先，假如所有边上的流量都没有超过容量(不大于容量)，那么就把这一组流量，或者说，这个流，称为一个可行流。

一个最简单的例子就是，零流，即所有的流量都是0的流。

• (1).我们就从这个零流开始考虑，假如有这么一条路，这条路从源点开始一直一段一段的连到了汇点，并且，这条路上的每一段都满足流量<容量，注意，是严格的<,而不是<=。
• (2).那么，我们一定能找到这条路上的每一段的(容量-流量)的值当中的最小值delta。我们把这条路上每一段的流量都加上这个delta，一定可以保证这个流依然是可行流，这是显然的。
• (3).这样我们就得到了一个更大的流，他的流量是之前的流量+delta，而这条路就叫做增广路。我们不断地从起点开始寻找增广路，每次都对其进行增广，直到源点和汇点不连通，也就是找不到增广路为止。
• (4).当找不到增广路的时候，当前的流量就是最大流，这个结论非常重要。

转载：讲解易懂

2.dinic算法

Dinic算法的基本思路:

  1.根据残量网络计算层次图。
  2.在层次图中使用DFS进行增广直到不存在增广路
  3.重复以上步骤直到无法增广

转载：点击打开链接

3.sap算法

代码见kuangbin模板

代码：

//网络流EK算法 模板 poj1273 63ms

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
#define mem(a,b) memset(a,b,sizeof(a))

const int N=1010;
const int inf=0x3f3f3f3f;

int n,m,sum;
int c[N+10][N+10],f[N+10][N+10]; //容量，流量；
int pre[N+10]; //记录增广路径中的点的父亲；
int p[N+10]; //记录中转站的中转量；

void bfs()
{
    queue<int>que;
    while(1)
    {
        mem(p,0);
        p[1]=inf;
        que.push(1);
        while(!que.empty())
        {
            int u=que.front();
            que.pop();

            for(int i=1;i<=n;i++)
            {
                if(!p[i]&&f[u][i]<c[u][i])
                {
                    p[i]=min(p[u],c[u][i]-f[u][i]);
                    pre[i]=u;
                    que.push(i);
                }
            }
        }

        sum+=p[n];
        if(!p[n]) break;

        int tmp=n;
        while(pre[tmp])
        {
            f[pre[tmp]][tmp]+=p[n];
            f[tmp][pre[tmp]]-=p[n]; //反向边的容量，流量初始化均为0；这里会使得反向边的流量为负，不过没有关系仍可正确计算；
            tmp=pre[tmp];
        }
    }
}

int main()
{
    while(scanf("%d%d",&m,&n)!=EOF)
    {
        sum=0;
        mem(c,0),mem(f,0),mem(pre,0);
        for(int i=1;i<=m;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            c[x][y]+=z;
        }

        bfs();
        printf("%d\n",sum);
    }
    return 0;
}


//网络流dinic算法（邻接矩阵） 模板 poj1273 0ms

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#define min(x,y) ((x<y)?(x):(y))
using namespace std;
const int MAX=0x5fffffff;//
int tab[250][250];//邻接矩阵
int dis[250];//距源点距离,分层图
int q[2000],h,r;//BFS队列 ,首,尾
int N,M,ANS;//N:点数;M,边数
int BFS()
{
    int i,j;
    memset(dis,0xff,sizeof(dis));//以-1填充
    dis[1]=0;
    h=0;
    r=1;
    q[1]=1;
    while (h<r)
    {
        j=q[++h];
        for (i=1; i<=N; i++)
            if (dis[i]<0 && tab[j][i]>0)
            {
                dis[i]=dis[j]+1;
                q[++r]=i;
            }
    }
    if (dis[N]>0)
        return 1;
    else
        return 0;//汇点的DIS小于零,表明BFS不到汇点
}

//Find代表一次增广,函数返回本次增广的流量,返回0表示无法增广
int find(int x,int low)//Low是源点到现在最窄的(剩余流量最小)的边的剩余流量
{
    int i,a=0;
    if (x==N)return low;//是汇点
    for (i=1; i<=N; i++)
        if (tab[x][i] >0 //联通
            && dis[i]==dis[x]+1 //是分层图的下一层
                &&(a=find(i,min(low,tab[x][i]))))//能到汇点(a <> 0)
        {
            tab[x][i]-=a;
            tab[i][x]+=a;
            return a;
        }
    return 0;

}
int main()
{
    //freopen("ditch.in" ,"r",stdin );
    //freopen("ditch.out","w",stdout);
    int f,t,flow,tans;
    while (scanf("%d%d",&M,&N)!=EOF)
    {
        memset(tab,0,sizeof(tab));
        for (int i=1; i<=M; i++)
        {
            scanf("%d%d%d",&f,&t,&flow);
            tab[f][t]+=flow;
        }
        //
        ANS=0;
        while (BFS())//要不停地建立分层图,如果BFS不到汇点才结束
        {
            while(tans=find(1,0x7fffffff))
                ANS+=tans;//一次BFS要不停地找增广路,直到找不到为止
        }
        printf("%d\n",ANS);
    }
    system("pause");
}


//网络流dinic算法（邻接表） 模板 poj1459

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;
int N, NP, NC, M;
struct Edge
{
    int u, v, cap;
    Edge() {}
    Edge(int u, int v, int cap): u(u), v(v), cap(cap) {}
} es[150 * 150];
int R, S, T;
vector<int> tab[109]; // 边集
int dis[109];
int current[109];
void addedge(int u, int v, int cap)
{
    tab[u].push_back(R);
    es[R++] = Edge(u, v, cap); // 正向边
    tab[v].push_back(R);
    es[R++] = Edge(v, u, 0); // 反向边容量为0
    // 正向边下标通过异或就得到反向边下标, 2 ^ 1 == 3 ; 3 ^ 1 == 2
}
int BFS()
{
    queue<int> q;
    q.push(S);
    memset(dis, 0x3f, sizeof(dis));

    dis[S] = 0;
    while (!q.empty())
    {
        int h = q.front();
        q.pop();
        for (int i = 0; i < tab[h].size(); i++)
        {
            Edge &e = es[tab[h][i]];
            if (e.cap > 0 && dis[e.v] == 0x3f3f3f3f)
            {
                dis[e.v] = dis[h] + 1;
                q.push(e.v);
            }
        }
    }
    return dis[T] < 0x3f3f3f3f; // 返回是否能够到达汇点
}
int dinic(int x, int maxflow)
{
    if (x == T)
        return maxflow;
    // i = current[x] 当前弧优化
    for (int i = current[x]; i < tab[x].size(); i++)
    {
        current[x] = i;
        Edge &e = es[tab[x][i]];
        if (dis[e.v] == dis[x] + 1 && e.cap > 0)
        {
            int flow = dinic(e.v, min(maxflow, e.cap));
            if (flow)
            {
                e.cap -= flow; // 正向边流量降低
                es[tab[x][i] ^ 1].cap += flow; // 反向边流量增加
                return flow;
            }
        }
    }
    return 0; // 找不到增广路 退出
}
int DINIC()
{
    int ans = 0;

    while (BFS()) // 建立分层图
    {
        int flow;
        memset(current, 0, sizeof(current)); // BFS后应当清空当前弧数组
        while (flow = dinic(S, 0x3f3f3f3f)) // 一次BFS可以进行多次增广
            ans += flow;
    }
    return ans;
}
int main()
{
    while (scanf("%d%d%d%d", &N, &NP, &NC, &M) != EOF)
    {
        R = 0;
        S = N;
        T = N + 1;
        for (int i = 0; i <= T; i++)
            tab[i].clear();
        for (int i = 0; i < M; i++)
        {
            int u, v, cap;
            scanf(" (%d,%d)%d", &u, &v, &cap);
            addedge(u, v, cap);
        }
        for (int i = 0; i < NP; i++)
        {
            int u, p;
            scanf(" (%d)%d", &u, &p);
            addedge(S, u, p);
        }
        for (int i = 0; i < NC; i++)
        {
            int u, c;
            scanf(" (%d)%d", &u, &c);
            addedge(u, T, c);
        }

        printf("%d\n", DINIC());
    }
    return 0;
}