网络流~最大流算法模板题

Ford-Fulkerson算法
记F为最大流的流量。
通过深度优先搜索寻找增广路，并沿着它增广。
时间复杂度 O(FE) E为边的条数

模板题：【hdu 1532】 （Ford-Fulkerson算法和Dinic算法）

Ford-Fulkerson算法 模板代码：

#include <cstdio>
#include <iostream>
#include <cstring>
#include <map>
#include <set>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <queue>
#include <cmath>
#include <stack>
#include <ctime>
#include <string>
#include <vector>
#include <sstream>
#include <functional>
#include <algorithm>
using namespace std;

#define mem(a,n) memset(a,n,sizeof(a))
#define memc(a,b) memcpy(a,b,sizeof(b))
#define rep(i,a,n) for(int i=a;i<n;i++)
#define pb push_back
#define IO ios::sync_with_stdio(false)
#define fre freopen("in.txt","r",stdin)
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
typedef long long ll;
const double PI=acos(-1.0);
const double eps=1e-8;
const int INF=0x3f3f3f3f;
const int MOD=1e8;
const int N=2e2+5;
const ll maxn=1LL<<60;
const int dir[4][2]= {-1,0,1,0,0,-1,0,1};
struct Edge
{
    int to,cap,rev;///边的终点，容量，反向边
    Edge(int to,int cap,int rev):to(to),cap(cap),rev(rev){}
};
vector<Edge>g[N<<1];///图的邻接表  最多有2*n条边
bool vis[N];///dfs用到的访问标记
/// 向图中增加一条从s到t容量为cap的边
void addedge(int from,int to,int cap)
{
    g[from].pb(Edge(to,cap,g[to].size()));
    g[to].pb(Edge(from,0,g[from].size()-1));
}
///通过dfs寻找增广路
int dfs(int v,int t,int f)
{
    if(v==t) return f;
    vis[v]=true;
    rep(i,0,g[v].size())
    {
        Edge& e=g[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;
                g[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}
///求解从s到t的最大流
int max_flow(int s,int t)
{
    int flow=0;
    while(1)
    {
        mem(vis,0);
        int f=dfs(s,t,INF);
        if(f==0) return flow;
        flow+=f;
    }
}
int main()
{
    //fre;
    IO;
    int n,m;
    while(cin>>n>>m)
    {
        rep(i,0,m+1) g[i].clear();
        int a,b,c;
        rep(i,0,n)
        {
            cin>>a>>b>>c;
            addedge(a,b,c);
        }
        cout<<max_flow(1,m)<<endl;
    }
    return 0;
}

Dinic 算法
复杂度：O(E*V^2）
Dinic算法总是寻找最短的增广路，并沿着它增广。 因为最短增广路的长度在增广的过程中始终不会变短，所以考虑由近距离顶点指向远距离顶点的边所组成的分层图，在上面进行深度优先搜索寻找最短增广路。
增广路的长度不会超过V-1，所以最多重复O(V)步就可以了。

#include <cstdio>
#include <iostream>
#include <cstring>
#include <map>
#include <set>
#include <bitset>
#include <cctype>
#include <cstdlib>
#include <queue>
#include <cmath>
#include <stack>
#include <ctime>
#include <string>
#include <vector>
#include <sstream>
#include <functional>
#include <algorithm>
using namespace std;

#define mem(a,n) memset(a,n,sizeof(a))
#define memc(a,b) memcpy(a,b,sizeof(b))
#define rep(i,a,n) for(int i=a;i<n;i++)
#define pb push_back
#define IO ios::sync_with_stdio(false)
#define fre freopen("in.txt","r",stdin)
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
typedef long long ll;
typedef unsigned long long ull;
const double PI=acos(-1.0);
const double eps=1e-8;
const int INF=0x3f3f3f3f;
const int MOD=1e8;
const int N=2e2+5;
const ll maxn=5e4;
const int dir[4][2]= {-1,0,1,0,0,-1,0,1};
struct Edge
{
    int to,cap,rev;
    Edge(int to,int cap,int rev):to(to),cap(cap),rev(rev) {}
};
vector<Edge>g[N];///图的邻接表
int level[N];///顶点到源点的距离标号
int iter[N];///当前弧，在其之前的边已经没用了
///向图中增加一条从from到to的容量为cap的边
void addedge(int from,int to,int cap)
{
    g[from].pb(Edge(to,cap,g[to].size()));
    g[to].pb(Edge(from,0,g[from].size()-1));
}
///通过bfs计算从源点出发的距离标号
void bfs(int s)
{
    mem(level,-1);
    queue<int>que;
    level[s]=0;
    que.push(s);
    while(!que.empty())
    {
        int v=que.front();
        que.pop();
        rep(i,0,g[v].size())
        {
            Edge &e=g[v][i];
            if(e.cap>0&&level[e.to]<0)
            {
                level[e.to]=level[v]+1;
                que.push(e.to);
            }
        }
    }
}
///通过dfs寻找增广路
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;
}
///求解从s到t的最大流
int max_flow(int s,int t)
{
    int flow=0;
    while(1)
    {
        bfs(s);
        if(level[t]<0) return flow;
        mem(iter,0);
        int f;
        while((f=dfs(s,t,INF))>0) flow+=f;
    }
}

int main()
{
    //fre;
    IO;
    int n,m;
    while(cin>>n>>m)
    {
        rep(i,0,m+1) g[i].clear();
        int a,b,c;
        rep(i,0,n)
        {
            cin>>a>>b>>c;
            addedge(a,b,c);
        }
        cout<<max_flow(1,m)<<endl;
    }
    return 0;
}