网络流（最大流模板）Ford_Fulkerson算法

这个博客很全：https://blog.csdn.net/x_y_q_/article/details/51999466  

EK（Edmond—Karp）算法 

Ford-Fulkerson算法

Dinic算法（前两种的优化）

网络中有两台计算机s和t  ，现在想从s传输数据到t   该网络中一共有n太计算机    其中一些计算机之间炼油一条单向的通信线缆都对应的一秒钟内所能传输的最大数据量，当其他计算机之间没有数据传输是，在一秒内s最多可以传输多少数据到t

5 7
0 1 10
0 2 2
1 2 6
1 3 6
3 2 3
2 4 5
3 4 8

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<set>
#include<algorithm>
#include<map>
#define maxn 200005
typedef long long ll;
#define inf 1000000009
int x,y,num;
using namespace std;
struct edge{
   int to,cap,rev;    //边的终点，容量，反向边
};
vector<edge>mp[maxn];  // 邻接图
bool vis[maxn];
void add_edge(int from,int to,int cap)   //建图
{
    mp[from].push_back((edge){to,cap,mp[to].size()});
     mp[to].push_back((edge){from,0,mp[from].size()-1});  //反向弧
}
int dfs(int v,int t,int f)   //找增广路 v，t是最终点  用了f的流量
{
   if(v==t)return f;
   vis[v]=true;
   for(int i=0;i<mp[v].size();i++)
   {
       edge &e=mp[v][i];
       if(!vis[e.to]&&e.cap>0)
       {
           int d=dfs(e.to,t,min(f,e.cap));  //遍历所有的路径
           if(d>0)
           {
               e.cap-=d;                    //求增加的流量
               mp[e.to][e.rev].cap+=d;       
               return d;
           }
       }
   }
   return 0;
}
int max_flow(int s,int t)
{
    int flow=0;
    for(;;)
    {
        memset(vis,0,sizeof(vis));   //初始化
        int f=dfs(s,t,inf);
        if(f==0)return flow;
        flow+=f;
    }
}
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=0;i<m;i++)
    {
        cin>>x>>y>>num;
        add_edge(x,y,num);
    }
    int ans=max_flow(0,4);
    cout<<ans<<endl;
    return 0;
}

dinic模板：

<span style="font-size:12px;"><strong>#include <cstdio>

#include <string.h>

#include <queue>

using namespace std;

int const inf = 0x3f3f3f3f;

int const MAX = 205;

int n, m;

int c[MAX][MAX], dep[MAX];//dep[MAX]代表当前层数

 

int bfs(int s, int t)//重新建图，按层次建图

{

    queue<int> q;

    while(!q.empty())

        q.pop();

    memset(dep, -1, sizeof(dep));

    dep[s] = 0;

    q.push(s);

    while(!q.empty()){

        int u = q.front();

        q.pop();

        for(int v = 1; v <= m; v++){

            if(c[u][v] > 0 && dep[v] == -1){//如果可以到达且还没有访问，可以到达的条件是剩余容量大于0，没有访问的条件是当前层数还未知

                dep[v] = dep[u] + 1;

                q.push(v);

            }

        }

    }

    return dep[t] != -1;

}

 

int dfs(int u, int mi, int t)//查找路径上的最小流量

{

    if(u == t)

        return mi;

    int tmp;

    for(int v = 1; v <= m; v++){

        if(c[u][v] > 0 && dep[v] == dep[u] + 1  && (tmp = dfs(v, min(mi, c[u][v]), t))){

            c[u][v] -= tmp;

            c[v][u] += tmp;

            return tmp;

        }

    }

    return 0;

}

 

int dinic()

{

    int ans = 0, tmp;

    while(bfs(1, m)){

        while(1){

            tmp = dfs(1, inf, m);

            if(tmp == 0)

                break;

            ans += tmp;

        }

    }

    return ans;

}

 

int main()

{

    while(~scanf("%d %d", &n, &m)){

        memset(c, 0, sizeof(c));

        int u, v, w;

        while(n--){

            scanf("%d %d %d", &u, &v, &w);

            c[u][v] += w;

        }

        printf("%d
", dinic());

    }

    return 0;

}

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<queue>
#include<set>
#include<algorithm>
#include<map>
#define maxn 200005
typedef long long ll;
using namespace std;
#define inf 1000000000
struct edge{
int to,cap,rev;
};
vector <edge>G[maxn];
int level[maxn];
int iter[maxn];
void add_edge(int from,int to,int cap)
{
    G[from].push_back((edge){to,cap,G[to].size()});
    G[to].push_back((edge){from,0,G[from].size()-1});
}

void bfs(int s)
{
    queue<int>que;
    memset(level,-1,sizeof(level));
    level[s]=0;
    que.push(s);
    while(!que.empty())
    {
        int v=que.front();
        que.pop();
        for(int i=0;i<G[v].size();i++)
        {
            edge &e=G[v][i];
            if(e.cap>0&&level[e.to]<0){
            level[e.to]=level[v]+1;
            que.push(e.to);
          }
        }
    }
}
int dfs(int v,int t,int f)
{
    if(v==t)return f;
    for(int &i=iter[v];i<G[v].size();i++)
    {
        edge &e=G[v][i];
        if(e.cap>0&&level[v]<level[e.to])
        {
            int d=dfs(e.to,t,min(f,e.cap));
            if(d>0){
                e.cap-=d;
                G[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}
int max_flow(int s,int t)
{
    int flow=0;
    for(;;)
    {
        bfs(s);
        if(level[t]<0)return flow;
        memset(iter,0,sizeof(iter));
        int f;
        while((f=dfs(s,t,inf))>0){
            flow+=f;
        }
    }
}