最大网络流 EK 算法

网络流是什么类型的问题，看一道题目你就知道了点击打开链接。

默认具备图论的基本知识，网络流概念比较多，先看看书熟悉一下那些概念。比较好！一个寄出的网络最大流。EK算法写的。

这是一幅网络，求S ------> T 点的最大网络流。这是初始状态。{a,b} a 代表该边的最大流量，b代表实际的流量。

一开始，实际流量为0；下面是代码。

<pre name="code" class="cpp">#include <cstdio>
#include <cstring>
#include <cctype>
#include <cmath>
#include <set>
#include <map>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <bitset>
#include <vector>
#include <iostream>
#include <algorithm>
#include <stdlib.h>

using namespace std;
typedef long long LL;
const int INF=2e9+1e8;
const int MOD=1e9+7;
const int MM=250;
const double eps=0.0000000001;

struct Node
{
    int c,f;
};
Node edge[MM][MM];
int n,m,pre[MM];

bool bfs(int s,int t)
{
    bool vis[MM];
    memset(vis,0,sizeof(vis));
    memset(pre,-1,sizeof(pre));
    queue<int>q;
    q.push(s);
    vis[s]=true;
    while(!q.empty())
    {
        s=q.front();
        q.pop();
        for(int i=1; i<=m; i++)
        {
            if(!vis[i]&&edge[s][i].c>abs(edge[s][i].f))
            {
                vis[i]=true;
                pre[i]=s;
                if(i==t) return true;
                q.push(i);
            }
        }
    }
    return false;
}
void print(stack<int>& a)//打印路径
{
    cout<<"1";
    while(!a.empty())
    {
        cout<<"->"<<a.top();
        a.pop();
    }
    cout<<endl;
}
int solve()
{
    int maxflow=0;
    while(true)
    {
        if(!bfs(1,m)) return maxflow;
        int flow=INF;
        stack<int>s;
        for(int x=m,y=pre[m]; y!=-1; x=y,y=pre[y])
        {
            flow=min(flow,edge[y][x].c-edge[y][x].f);
            s.push(x);
        }
        //  print(s);
        for(int x=m,y=pre[m]; y!=-1; x=y,y=pre[y])
        {
            edge[y][x].f+=flow;
            edge[x][y].f-=flow;
        }
        maxflow+=flow;
    }
}
int main()
{
    while(cin>>n>>m)
    {
        memset(edge,0,sizeof(edge));
        for(int i=0; i<n; i++)
        {
            int s,t,val;
            cin>>s>>t>>val;
            edge[s][t].c+=val;
        }
        printf("%d\n",solve());
    }
    return 0;
}


/*
                   _ooOoo_
                  o8888888o
                  88" . "88
                  (| -_- |)
                  O\  =  /O
               ____/`---'\____
             .'  \\|     |//  `.
            /  \\|||  :  |||//  \
           /  _||||| -:- |||||-  \
           |   | \\\  -  /// |   |
           | \_|  ''\---/''  |   |
           \  .-\__  `-`  ___/-. /
         ___`. .'  /--.--\  `. . __
      ."" '<  `.___\_<|>_/___.'  >'"".
     | | :  `- \`.;`\ _ /`;.`/ - ` : | |
     \  \ `-.   \_ __\ /__ _/   .-` /  /
======`-.____`-.___\_____/___.-`____.-'======
                   `=---='
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
         The program have no BUG.
*/

该算法的大致思路是：不断的找寻s到t的可行流。直到找不到为止。每次找到都要之后改变该路径上的实际流量。

用广搜来寻找路径。

比如第一次找到的路径是 S → 1 →2 →T；增加流量为4

把实际流量更新后得到