最大流 EK算法

最新推荐文章于 2022-08-27 15:06:08 发布

mlm5678

最新推荐文章于 2022-08-27 15:06:08 发布

阅读量266

点赞数

分类专栏： ac

本文链接：https://blog.csdn.net/mlm5678/article/details/82726411

版权

ac 专栏收录该内容

95 篇文章 0 订阅

订阅专栏

首先要先清楚最大流的含义，就是说从源点到经过的所有路径的最终到达汇点的所有流量和

EK算法的核心
反复寻找源点s到汇点t之间的增广路径，若有，找出增广路径上每一段[容量-流量]的最小值delta，若无，则结束。
在寻找增广路径时，可以用BFS来找，并且更新残留网络的值(涉及到反向边)。
而找到delta后，则使最大流值加上delta，更新为当前的最大流值。

这么一个图，求源点1，到汇点4的最大流

通过分析代码，来详细叙述ek算法

#include <iostream>
#include <queue>
#include<string.h>
using namespace std;
#define arraysize 201
int maxData = 0x7fffffff;
int capacity[arraysize][arraysize]; //记录残留网络的容量
int flow[arraysize];                //标记从源点到当前节点实际还剩多少流量可用
int pre[arraysize];                 //标记在这条路径上当前节点的前驱,同时标记该节点是否在队列中
int n,m;
queue<int> myqueue;
int BFS(int src,int des)
{
    int i,j;
    while(!myqueue.empty())       //队列清空  因为maxFlow函数调用的bfs，	                             
        myqueue.pop();            //此次bfs残余网络的队列与此次并无关系 
        
    for(i=1;i<m+1;++i)            //对前驱进行标记，先初始化所有点都没有前驱
        pre[i]=-1;
    
    pre[src]=0;
    flow[src]= maxData;
    myqueue.push(src);
    while(!myqueue.empty())
    {
        int index = myqueue.front();
        myqueue.pop();
        if(index == des)            //找到了增广路径
            break;
        for(i=1;i<m+1;++i)
        {
            if(i!=src && capacity[index][i]>0 && pre[i]==-1)
            {    //i！=src避免了与  源点双向连接的点 流回去又流回来的情况 
                 //pre[i]==-1避免了重复流动的情况，每条路每个点只能有一个前驱！！！ 
                 // capacity[index][i]>0判断能不能流 有没有流量！！！ 
                 pre[i] = index; //记录前驱
                 flow[i] = min(capacity[index][i],flow[index]);   //关键：迭代的找到增量
                 myqueue.push(i);
            }
        }
    }
    if(pre[des]==-1)      //残留图中不再存在增广路径
        return -1;
    else
        return flow[des];
}
int maxFlow(int src,int des)
{
    int increasement= 0;
    int sumflow = 0;
    while((increasement=BFS(src,des))!=-1)
    {
         int k = des;          //利用前驱寻找路径
         while(k!=src)         //利用pre前驱更新残余网络！！！ 
         {
              int last = pre[k];
              capacity[last][k] -= increasement; //改变正向边的容量
              capacity[k][last] += increasement; //改变反向边的容量
              k = last;
         }
         sumflow += increasement;
    }
    return sumflow;
}
int main()
{
    int i,j;
    int start,end,ci;
    while(cin>>n>>m)
    {
        memset(capacity,0,sizeof(capacity));
        memset(flow,0,sizeof(flow));
        for(i=0;i<n;++i)
        {
            cin>>start>>end>>ci;
            if(start == end)               //考虑起点终点相同的情况
               continue;
            capacity[start][end] +=ci;     //此处注意可能出现多条同一起点终点的情况
        }
        cout<<maxFlow(1,m)<<endl;
    }
    return 0;
}

显而易见capacity存变的流量，进行ek求解

对于BFS找增广路：

1. flow[1]=INF，pre[1]=0;

源点1进队列，开始找增广路，capacity[1][2]=40>0，则flow[2]=min(flow[1],40)=40;

capacity[1][4]=20>0,则flow[4]=min(flow[1],20)=20;

capacity[2][3]=30>0,则flow[3]=min(folw[2]=40，30)=30；

capacity[2][4]=30,但是pre[4]=1(已经在capacity[1][4]这遍历过4号点了)

capacity[3][4].....

当index=4（汇点），结束增广路的寻找

传递回increasement（该路径的流），利用前驱pre寻找路径

路径也自然变成了这样：