网络流模板

推荐篇网络流入门：网络流入门即模板    EK

在这贴下模板先：

EK（Edmond—Karp）算法:

#include <iostream>
#include <queue>
#include<string.h>
using namespace std;

#define INF 0x3f3f3f3f
const int maxn=205;
int capacity[maxn][maxn]; ///记录残留网络的容量
int flow[maxn];                ///标记从源点到当前节点实际还剩多少流量可用
int pre[maxn];                 ///标记在这条路径上当前节点的前驱,同时标记该节点是否在队列中
int n,m;
queue<int> myqueue;
int BFS(int src,int des)
{
    int i,j;
    while(!myqueue.empty())       ///队列清空
        myqueue.pop();
    for(i=1;i<m+1;++i)
    {
        pre[i]=-1;
    }
    pre[src]=0;
    flow[src]= INF;
    myqueue.push(src);
    while(!myqueue.empty())
    {
        int index = myqueue.front();
        myqueue.pop();
        if(index == des)            ///找到了增广路径
            break;
        for(i=src;i<=des;++i)  ///从源点开始枚举到目标点 ，注意下这个地方
        {
            if(i!=src && capacity[index][i]>0 && pre[i]==-1)
            {
                 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)
         {
              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;
}

 

Ford-Fulkerson算法:

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;

#define INF 0x3f3f3f3f
int capacity[300][300];
int used[300];
int n,m;

int dfs(int s,int t,int f)
{
    if(s == t) return f;
    for(int i = 1 ; i <= n ; i ++) {
        if(capacity[s][i] > 0 && !used[i]) {
            used[i] = true;
            int d = dfs(i,t,min(f,capacity[s][i]));
            if(d > 0) {
                capacity[s][i] -= d;
                capacity[i][s] += d;
                return d;
            }
        }
    }
}
int maxflow(int s,int t)
{
    int flow = 0;
    while(true) {
        memset(used,0,sizeof(used));
        int f = dfs(s,t,INF);///不断找从s到t的增广路
        if(f == 0) return flow;///找不到了就回去
        flow += f;///找到一个流量f的路
    }
}
int main()
{
    while(scanf("%d%d",&m,&n) != EOF) {
        memset(capacity,0,sizeof(capacity));
        for(int i = 0 ; i < m ; i ++) {
            int from,to,cap;
            scanf("%d%d%d",&from,&to,&cap);
            capacity[from][to] += cap;
        }
        cout << maxflow(1,n) << endl;
    }
    return 0;
}

 

用vector写的Ford-Fulkerson算法:

#include <cstdio>
#include <string.h>
#include <vector>
#include <algorithm>
using namespace std;
#define INF 0x3f3f3f3f
int const MAX = 300;
struct Node
{
    int to;  ///与这个点相连的点
    int cap; ///以这个射出的边的容量
    int rev; ///这个点的反向边
};
vector<Node> v[MAX];
bool used[MAX];

void add_node(int from, int to, int cap)///重边情况不影响
{
    v[from].push_back((Node){to, cap, v[to].size()});
    v[to].push_back((Node){from, 0, v[from].size() - 1});
}
int dfs(int s, int t, int f)
{
    if(s == t)
        return f;
    used[s] = true;
    for(int i = 0; i < v[s].size(); i++){
        Node &tmp = v[s][i];
        if(used[tmp.to] == false && tmp.cap > 0){
            int d = dfs(tmp.to, t, min(f, tmp.cap));
            if(d > 0){
                tmp.cap -= d;
                v[tmp.to][tmp.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}
int max_flow(int s, int t)
{
    int flow = 0;
    while(1){
        memset(used, false, sizeof(used));
        int f = dfs(s, t, INF);
        if(f == 0)
            return flow;
        flow += f;
    }
    return flow;
}
int main()
{
    int n, m;
    while(scanf("%d %d", &n, &m) != EOF){
        for(int i = 0; i <= m; i++)
            v[i].clear();
        int u1, v1, w;
        for(int i = 1; i <= n; i++){
            scanf("%d %d %d", &u1, &v1, &w);
            add_node(u1, v1, w);
        }
        printf("%d\n", max_flow(1, m));
    }
    return 0;
}

 

Dinic算法:

#include <cstdio>
#include <string.h>
#include <queue>
using namespace std;
int const INF = 0x3f3f3f3f;
int const MAX = 205;
int n, m;
int capacity[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(capacity[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(capacity[u][v] > 0 && dep[v] == dep[u] + 1  && (tmp = dfs(v, min(mi, capacity[u][v]), t))){
            capacity[u][v] -= tmp;
            capacity[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(capacity, 0, sizeof(capacity));
        int u, v, w;
        while(n--){
            scanf("%d %d %d", &u, &v, &w);
            capacity[u][v] += w;
        }
        printf("%d\n", dinic());
    }
    return 0;
}