算法笔记--最大流和最小割 && 最小费用最大流 && 上下界网络流

最大流：

给定指定的一个有向图，其中有两个特殊的点源S(Sources)和汇T(Sinks)，每条边有指定的容量(Capacity)，求满足条件的从S到T的最大流(MaxFlow)。

最小割：

割是网络中定点的一个划分，它把网络中的所有顶点划分成两个顶点集合S和T，其中源点s∈S,汇点t∈T，从S出发指向T的边的集合，称为割(S,T)，这些边的容量之和称为割的容量。容量最小的割称为最小割。

根据最大流最小割定理，最大流等于最小割。

其他：

求最小割边的个数的方法：

①建边的时候每条边权 w = w * (E + 1) + 1;这样得到最大流 maxflow / (E + 1) ，最少割边数 maxflow % (E + 1)

②建图，得到最大流后，图中边若满流，说明该边是最小割上的边；再建图，原则：满流的边改为容量为 1 的边，未满流的边改为容量 INF 的边，然后最大流即答案

Ford-Fulkerson算法模板：

const int INF = 0x7f7f7f7f;
struct edge {
    int to, w, rev;
};
vector<edge> g[N];
bool vis[];
void add_edge(int from, int to, int w) {
    g[from].pb((edge){to, w, g[to].size()});
    g[to].pb((edge){from, , g[from].size()-});
}
//通过dfs寻找增广路
int dfs(int u, int t,int f) {
    if (u == t) return f;
    vis[u] = true;
    for (int i = ; i < g[u].size(); i++) {
        edge &e = g[u][i];
        if(!vis[e.to] && e.w > ) {
            int d = dfs(e.to, t, min(f, e.w));
            if(d > ) {
                e.w -= d;
                g[e.to][e.rev].w += d;
                return d;
            }
        }
    }
    return ;
}
int max_flow(int s, int t) {
    int flow = ;
    while(true) {
        mem(vis, false);
        int f = dfs(s, t, INF);
        if (f == ) return flow;
        flow += f;
    }
    return flow;
}

Dinic算法+弧优化模板：

const int INF = 0x7f7f7f7f;
int level[N], iter[N];
struct edge {
    int to, w, rev;
};
vector<edge>g[N];
void add_edge(int u, int v, int w) {
    g[u].pb(edge{v, w, g[v].size()});
    g[v].pb(edge{u, , g[u].size()-});
}
void bfs(int s) {
    mem(level, -);
    queue<int>q;
    level[s] = ;
    q.push(s);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int i = ; i < g[u].size(); i++) {
            edge e = g[u][i];
            if(e.w >  && level[e.to] < ) {
                level[e.to] = level[u] + ;
                q.push(e.to);

            }
        }
    }
}
int dfs(int u, int t, int f) {
    if(u == t ) return f;
    for (int &i = iter[u]; i < g[u].size(); i++) {
        edge &e = g[u][i];
        if(e.w >  && level[u] < level[e.to]) {
            int d = dfs(e.to, t, min(f, e.w));
            if(d > ) {
                e.w -= d;
                g[e.to][e.rev].w +=d;
                return d;
            }
        }
    }
    return ;
}
int max_flow(int s, int t) {
    int flow = ;
    while(true) {
        bfs(s);
        if(level[t] < ) return flow;
        int f;
        mem(iter, );
        while ((f = dfs(s, t, INF)) > ) {
            flow += f;
        }
    }
}

POJ 3281

建图：把每头牛拆成两个，然后之间建一条容量为1的边，然后把food和drink分别放在牛的两边，分别和牛建容量为1的边，然后再在food和drink左右两边分别加一个源点s和汇点t。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<vector>
#include<algorithm>
using namespace std;
#define LL long long
#define pb push_back
#define mem(a, b) memset(a, b, sizeof(a))

const int N = ;
const int INF = 0x7f7f7f7f;
struct edge {
    int to, w, rev;
};
vector<edge> g[N];
bool vis[];
void add_edge(int from, int to, int w) {
    g[from].pb((edge){to, w, g[to].size()});
    g[to].pb((edge){from, , g[from].size()-});
}
int dfs(int u, int t,int f) {
    if (u == t) return f;
    vis[u] = true;
    for (int i = ; i < g[u].size(); i++) {
        edge &e = g[u][i];
        if(!vis[e.to] && e.w > ) {
            int d = dfs(e.to, t, min(f, e.w));
            if(d > ) {
                e.w -= d;
                g[e.to][e.rev].w += d;
                return d;
            }
        }
    }
    return ;
}
int max_flow(int s, int t) {
    int flow = ;
    while(true) {
        mem(vis, false);
        int f = dfs(s, t, INF);
        if (f == ) return flow;
        flow += f;
    }
    return flow;
}
int main() {
    int n, f, d, t, _t, u;
    scanf("%d%d%d", &n, &f, &d);
    for (int i = ; i <= n; i++) {
        add_edge(i, i+n, );
    }
    for (int i = ; i <= n; i++) {
        scanf("%d%d", &t, &_t);
        while(t--) {
            scanf("%d", &u);
            add_edge(u+*n, i, );
        }
        while(_t--) {
            scanf("%d", &u);
            add_edge(i+n, u+*n+f, );
        }
    }
    for (int i = ; i <= f; i++) {
        add_edge(, i+*n, );
    }
    for (int i = ; i <= d; i++) {
        add_edge(i+*n+f, , );
    }
    printf("%d\n", max_flow(, ));
    return ;
}

POJ 3436

建图：把每台设备拆成两个，然后之间建一条容量为设备操作台数的边，然后在所有的input里找没有1的设备，与源点s相连，在所有的output里找没有0的设备，与汇点t相连。然后设备之间如果input和output能匹配，就相连。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<vector>
#include<queue>
#include<algorithm>
using namespace std;
#define LL long long
#define pb push_back
#define mem(a, b) memset(a, b, sizeof(a))

const int N = ;
const int INF = 0x7f7f7f7f;
int level[N*], iter[N*], in[N][], out[N][];
bool vis[N][N];
struct edge {
    int to, w, rev;
};
struct node {
    int x, y, z;
}res[N*N];
vector<edge>g[N*];
void add_edge(int u, int v, int w) {
    g[u].pb(edge{v, w, g[v].size()});
    g[v].pb(edge{u, , g[u].size()-});
}
void bfs(int s) {
    mem(level, -);
    queue<int>q;
    level[s] = ;
    q.push(s);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int i = ; i < g[u].size(); i++) {
            edge e = g[u][i];
            if(e.w >  && level[e.to] < ) {
                level[e.to] = level[u] + ;
                q.push(e.to);

            }
        }
    }
}
int dfs(int u, int t, int f) {
    if(u == t ) return f;
    for (int &i = iter[u]; i < g[u].size(); i++) {
        edge &e = g[u][i];
        if(e.w >  && level[u] < level[e.to]) {
            int d = dfs(e.to, t, min(f, e.w));
            if(d > ) {
                e.w -= d;
                g[e.to][e.rev].w +=d;
                return d;
            }
        }
    }
    return ;
}
int max_flow(int s, int t) {
    int flow = ;
    while(true) {
        bfs(s);
        if(level[t] < ) return flow;
        int f;
        mem(iter, );
        while ((f = dfs(s, t, INF)) > ) {
            flow += f;
        }
    }
}
int main() {
    int p, n, w;
    while(~ scanf("%d%d", &p, &n)) {
        for (int i = ; i < N*; i++) g[i].clear();
        mem(vis, false);
        for (int i = ; i <= n; i++) {
            scanf("%d", &w);
            add_edge(i, i+n, w);
            for (int j = ; j <= p; j++) scanf("%d", &in[i][j]);
            for (int j = ; j <= p; j++) scanf("%d", &out[i][j]);
        }
        for (int i = ; i <= n; i++) {
            bool f = true, _f = true;
            for (int j = ; j <= p; j++) if(in[i][j] == ) f = false;
            for (int j = ; j <= p; j++) if(!out[i][j]) _f = false;
            if(f) add_edge(, i, INF);
            if(_f) add_edge(i+n, , INF);
            for (int j = i + ; j <= n; j++) {
                bool f = true, _f = true;
                for (int k = ; k <= p; k++) {
                    if(in[j][k] == );
                    else {
                        if(out[i][k] != in[j][k]) f = false;
                    }
                    if(in[i][k] == );
                    else {
                        if(out[j][k] != in[i][k]) _f = false;
                    }
                }
                if(f) add_edge(i+n, j, INF), vis[i][j] = true;
                if(_f) add_edge(j+n, i, INF), vis[j][i] = true;
            }
        }
        int ans = max_flow(, );
        int cnt = ;
        for (int i = ; i <= n; i++) {
            if(g[i].size() == )continue;
            for (int j = ; j < g[i].size(); j++) {
                if(g[i][j].to ==  || g[i][j].to ==  || g[i][j].to == i+n || g[i][j].to <= n ) continue;
                if( < g[i][j].w && vis[g[i][j].to-n][i]) {
                    res[++cnt].x = g[i][j].to - n;
                    res[cnt].y = i;
                    res[cnt].z = g[i][j].w;
                }
            }
        }
        printf("%d %d\n", ans, cnt);
        for (int i = ; i <= cnt; i++) printf("%d %d %d\n", res[i].x, res[i].y, res[i].z);
    }
    return ;
} 

最小费用最大流：

坑

详见挑战程序设计

上下界网络流：

https://www.cnblogs.com/NineSwords/p/9415962.html