网络流之最大流-Ford-Fullkerson算法 DFS && BFS

1、最大流的个人理解

举例来说就是一个河流网，从a城市到b城市的河道中有的宽有的窄，问最大水流量能是多少，这个主要取决于这条路上的最窄的河道。

2、Ford-Fullkerson算法 （挑战程序设计竞赛 P210)

由于有很多条河道可选，例如 路径一：a—c—d—b 或者 路径二：a—c—f—b，按上面的想法，可能出现先走路径1和先走路径2产生的结果不一样，这时候可能是因为a-c这条河进的水多了或者少了，导致另一个可能的路上少了或者多了。

这个算法利用了反向边，感觉就是先分配给他这么多水，然后还可以要回来之类的

具体看代码

代码（DFS）

#include <iostream>
#include <stdio.h>
#include <vector>
#include <algorithm>
#include <cstring>

using namespace std;
const int max_v = 1000;
const int INF = 0x3f3f3f3f;

struct edge
{
    int to,cap,rev;   //rev是反向边的编号，即这条反向边是以to为起点的第几条边
};

vector<edge> G[max_v];
bool used[max_v];

int dfs(int v,int t,int f)
{
    if(v==t) return f;
    used[v]=1;
    for(int i =0;i<G[v].size();++i)
    {
        edge &e = G[v][i];
        if(!used[e.to] && e.cap > 0)
        {
            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;//给上一层的d，让上一层也能更新；
            }
        }
    }
    return 0;
}

int  main()
{
    int m,s,t;
    scanf("%d%d%d",&s,&t,&m);

    int from,to,cap;
    for(int i=0;i<m;++i)
    {
        //点从1号开始。
        scanf("%d%d%d",&from,&to,&cap);

        G[from].push_back((edge){to,cap,G[to].size()});//因为下一步要加一条反向边，所以不需要－1
        G[to].push_back((edge){from,0,G[from].size()-1});
    }

    int flow=0;
    while(1)
    {
        memset(used,0,sizeof(used));
        int f=dfs(s,t,INF);
        if(f==0) break;
        flow+=f;
    }
    printf("%d",flow);


    return 0;
}

/*
1 4 7
1 2 10
1 5 2
2 5 6
2 3 6
3 4 8
3 5 3
5 4 5
结果：11
*/

代码（BFS）

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>

using namespace std;

const int maxv = 1000;
const int INF = 0x3f3f3f;

struct edge
{
    int to,cap,rev;
};
vector <edge> G[maxv];
int step[maxv];//从源点到点x的距离
int iter[maxv];//定点x的第几条边开始有用

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)
{
    memset(step,-1,sizeof(step));
    step[s]=0;
    queue <int> q;
    q.push(s);
    while(!q.empty())
    {
        int v=q.front();
        q.pop();
        for(int i=0;i<G[v].size();++i)
        {
            edge &e = G[v][i];
            if(e.cap>0 && step[e.to]<0)
            {
                step[e.to]=step[v]+1;
                q.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)//这里是引用，i++的同时iter也++，其实相当于上个的used，不过不用判断了
    {
        edge &e = G[v][i];
        if(e.cap>0 && step[e.to]>step[v])
        {
            int d=dfs(e.to,t,min(e.cap,f));
            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(step[t]<0) return flow;

        memset(iter,0,sizeof(iter));
        int f;
        while((f = dfs(s,t,INF))>0)
            flow += f;
    }
}

int main()
{
    int s,t,m;
    scanf("%d%d%d",&s,&t,&m);

    int u,v,cap;
    for(int i=0;i<m;++i)
    {
        scanf("%d%d%d",&u,&v,&cap);
        add_edge(u,v,cap);
    }

    printf("%d",max_flow(s,t));
    return 0;
}