网络流算法模板

　　1、基于Ford-Fulkerson方法的Edmonds-Karp算法

　　用广度有限搜索来实现对增广路径p 的计算。即，如果增广路径是残留网络种从s 到t 的最短路径，则能够改进Ford-Fulkerson的界。

//做一次增广路径的流量统计

int augment() {
    int v, i, ans;
    bool flag = false;
    deque<int> q;

    memset(vis, 0, sizeof(vis));
    memset(pre, -1, sizeof(pre));

    q.push_back(0);
    vis[0] = true;
    pre[0] = -1;

    while(!q.empty()) {
        v = q.front();
        q.pop_front();

        for(i = 0; i <= n; i++) {
            if(g[v][i] > 0 && !vis[i]) {
                vis[i] = true;
                pre[i] = v;
                if(i == n) {
                    flag = true;
                    q.clear();
                    break;
                } else {
                    q.push_back(i);
                }
            }
        }
    }
    if(!flag)    return 0;
    v = n; ans = inf;
    while(pre[v] != -1) {
        ans = min(ans, g[pre[v]][v]);
        v = pre[v];
    }
    v = n;
    while(pre[v] != -1) {
        g[pre[v]][v] -= ans;
        g[v][pre[v]] += ans;
        v = pre[v];
    }
    return ans;
}

　　2、Dinic算法

　　　详细讲解：http://en.wikipedia.org/wiki/Dinic's_algorithm

　　其实就是对原来的流网络用bfs进行分层，找到一条增广路径后退到节点pos，节点pos满足 f(pos, pos->next) = c(pos, pos->next)；然后再进行bfs找经过pos的其他增广路径。

int g[N][N];
int layer[N];
bool vis[N];

int S, T;

bool Layer() {    //分层次
    deque<int> q;
    memset(layer, -1, sizeof(layer));
    q.push_back(0);
    layer[0] = 1;
    int i, v;
    while(!q.empty()) {
        v = q.front();
        q.pop_front();
        for(i = 0; i <= T; i++) {
            if(g[v][i] > 0 && layer[i] == -1) {
                //printf("%d %d\n", v, i);
                layer[i] = layer[v] + 1;
                if(i == T)    {q.clear(); return true;}
                else    q.push_back(i);
            }
        }
    }
    return false;
}

int Dinic() {
    deque<int> q;
    int i, v, vs, vt, MIN, pos, sum = 0;

    while(Layer()) {
        memset(vis, 0, sizeof(vis));
        q.push_back(0);
        vis[0] = true;

        while(!q.empty()) {
            v = q.back();
            if(v == T) {
                MIN = inf;
                for(i = 1; i < q.size(); i++) {
                    vs = q[i-1]; vt = q[i];
                    if(g[vs][vt] > 0 && g[vs][vt] < MIN) {
                        MIN = g[vs][vt];
                        pos = vs;
                    }
                }
                sum += MIN;
                for(i = 1; i < q.size(); i++) {
                    vs = q[i-1]; vt = q[i];
                    if(g[vs][vt] > 0) {
                        g[vs][vt] -= MIN;
                        g[vt][vs] += MIN;
                    }
                }
                while(!q.empty() && q.back() != pos) {    //退回到pos再找其他增广路径
                    vis[q.back()] = false;
                    q.pop_back();
                }
            } else {
                for(i = 0; i <= T; i++) {
                    if(g[v][i] > 0 && !vis[i] && layer[i] == layer[v] + 1) {
                        vis[i] = true;
                        q.push_back(i);
                        break;
                    }
                }
                if(i > T) q.pop_back();
            }
        }
    }
    return sum;
}

　　Dinic算法邻接表实现，很强大的模板。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>

#define REP(i, n)   for(i = 0; i < n; ++i)
#define FOR(i, l, h)    for(i = l; i <= h; ++i)
#define FORD(i, h, l)   for(i = h; i >= l; --i)
#define CL(arr, val)    memset(arr, val, sizeof(arr))

using namespace std;

const int N = 3000;
const double inf = ~0u;

struct node {
    int to;
    double val;
    int next;
} g[N*N];

int head[N], t;
int layer[N];
int q[N*1000];

int S, T;

void init() {
    CL(head, -1); t = 0;
}

void add(int u, int v, double c) {
    g[t].to = v; g[t].val = c; g[t].next = head[u]; head[u] = t++;
    g[t].to = u; g[t].val = 0; g[t].next = head[v]; head[v] = t++;
}

bool Layer() {    //分层
    CL(layer, -1);
    int f = 0, r = 0, i, u, v;
    q[r++] = S; layer[S] = 1;

    while(f < r) {
        u = q[f++];
        for(i = head[u]; i != -1; i = g[i].next) {
            v = g[i].to;
            if(g[i].val > 0 && layer[v] == -1) {
                layer[v] = layer[u] + 1;
                if(v == T)  return true;
                q[r++] = v;
            }
        }
    }
    return false;
}

double find() {   //找一次增广路
    int u, i, e, pos, top;
    double sum = 0, flow;
    top = 1;

    while(top) {
        u = (top == 1 ? S : g[q[top-1]].to);
        if(u == T) {
            flow = inf;
            FOR(i, 1, top - 1) {
                e = q[i];
                if(g[e].val < flow) {
                    flow = g[e].val; pos = i;
                }
            }
            FOR(i, 1, top - 1) {
                e = q[i];
                g[e].val -= flow;
                g[e^1].val += flow;
            }
            sum += flow;
            top = pos;
        } else {
            for(i = head[u]; i != -1; i = g[i].next) {
                if(g[i].val > 0 && layer[g[i].to] == layer[u] + 1)  break;
            }
            if(i != -1) q[top++] = i;
            else {
                --top;
                layer[u] = -1;
            }
        }
    }
    return sum;
}

double Dinic() {
    double res = 0;
    while(Layer())    res += find();
    return res;
}

int main() {
    //freopen("data.in", "r", stdin);

    int t, n, m, l;
    int i, u, v;
    double val;
    scanf("%d", &t);
    while(t--) {
        init();
        scanf("%d%d%d", &n, &m, &l);
        S = 0; T = n + m + 1;
        FOR(i, 1, n) {
            scanf("%lf", &val);
            add(S, i, log(val));
        }
        FOR(i, 1, m) {
            scanf("%lf", &val);
            add(i + n, T, log(val));
        }
        while(l--) {
            scanf("%d%d", &u, &v);
            add(u, v + n, inf);
        }
        printf("%.4lf\n", exp(Dinic()));
    }
    return 0;
}