挑战程序设计竞赛 3.5.1 最大流（部分）

《挑战程序设计竞赛》课后练习题解集——3.5 借助水流解决问题的网络流

网络流相关问题有几个模型的定理是必须先掌握的：相关证明参考胡伯涛的《最小割模型在信息学竞赛中的应用》

1. 最大权闭合图

正点权连s，容量为点权；负点权连t，容量为点权的绝对值；原图的边保留，容量为正无穷。网络N取最小割[S, T]时，对应的闭合图V1是最大权闭合图，最大权wi = 所有正点权之和 - 最小割。

未解：V1的点的数量是最少的吗，为什么？

2.1 最大密度子图

法1：类似01分数规划，当取了一条边时，它的端点也一定要取，可以转化为二分图的最大权闭合图。子图的密度差 ≥ 1 / n ^ 2。

法2：增加源点s，汇点t，原图无向边替换成两条容量为1的有向边，s到每个点v连容量为U的边，v向t连容量为U+2g-dv，g为二分答案的猜测值，U为使容量为正数的调整值，可取边数m。N取最小割[S, T]时，s在残余网络能到达的点就是子图V', c[S, T] = U×n - 2 (E' - g×V'), 即h(g) = (U×n - c[S, T]) / 2. 

2.2 带边权图

每条边有权值wi≥0，密度为边权除以点数。度数dv改为与点v相连的点的权值和，原图中的边容量为边权，U为边权和。h(g)不变。

2.3 点边均带权图

点具有点权pv（可正可负），每条边有权值wi≥0，密度为边权+点权除以点数。在2.2基础上，g改为g-pv，U为点权绝对值和的两倍与总边权和的和。

2.4（例题 最大获利） 最大点边均带权子图

（点为负权，边为正权）2.3基础上g-pv改为-pv（原论文为pv，那是pv为正数）

2.5 总结

化归为“最大化 边权和 - 点权×系数”的模型

 

最大流和最小割

POJ 3713  给出一个无向图，N ≤ 500, M ≤ 20000，问是否满足对于图中任意两点ab，都有至少三条路径连接ab，并且这些路径只在ab点重合。

这题可能真的不是用网络流，网上相关做法很少，而且全都认为只要判断从0出发就可以了，这是不对的。这里给出一组数据

6 11
0 1
0 2
0 3
0 4
0 5
1 2
1 3
2 3
3 4
3 5
4 5

回头用tarjan填一下这个坑。

 

POJ 2987  有n个员工，有m个从属关系，n (0 < n ≤ 5000), m (0 ≤ m ≤ 60000)。解雇某一员工会获利或受损bi，并且他的下属也会被解雇。问最大获利及最大获利下解雇员工的最少数量。

  最大权闭合图模板题。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
#define ll long long
#define mem(x, k) memset(x, k, sizeof(x))
const int V = 5e3 + 5, E = 6e4 * 2 + 5;
const ll INF = 0x7f7f7f7f7f7f7f7f;

int n, m, u, v, ans;
struct edge {
    int to, rev;
    ll cap;
};
vector<edge> G[V];
int level[V];
int iter[V];
int vis[V];

ll min(ll x, ll y) { return x < y ? x : y; }

void add_edge(int from, int to, ll cap) {
    G[from].push_back((edge){to, (int)G[to].size(), cap});
    G[to].push_back((edge){from, (int)(G[from].size() - 1), 0});
}

void bfs(int s) {
    memset(level, -1, sizeof(level));
    queue<int> que;
    level[s] = 0;
    que.push(s);
    while (!que.empty()) {
        int v = que.front();
        que.pop();
        for (int i = 0; i < G[v].size(); i++) {
            edge &e = G[v][i];
            if (e.cap > 0 && level[e.to] < 0) {
                level[e.to] = level[v] + 1;
                que.push(e.to);
            }
        }
    }
}

ll dfs(int v, int t, ll 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]) {
            ll 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;
}

ll max_flow(int s, int t) {
    ll flow = 0;
    for (;;) {
        bfs(s);
        if (level[t] < 0) return flow;
        memset(iter, 0, sizeof(iter));
        ll f;
        while ((f = dfs(s, t, INF)) > 0) {
            flow += f;
        }
    }
}

void dfs_(int v) {
    vis[v] = 1;
    ans++;
    for (int i = 0; i < G[v].size(); i++) {
        edge e = G[v][i];
        if (vis[e.to] || e.cap <= 0) continue;
        dfs_(e.to);
    }
}

int main() {
    ll x, sum = 0;
    scanf("%d %d", &n, &m);
    for (int i = 1; i <= n; i++) {
        scanf("%lld", &x);
        if (x > 0) {
            sum += x;
            add_edge(0, i, x);
        }
        if (x < 0) add_edge(i, n + 1, -x);
    }
    for (int i = 0; i < m; i++) {
        scanf("%d%d", &u, &v);
        add_edge(u, v, INF);
    }
    ll res = sum - max_flow(0, n + 1);
    dfs_(0);
    printf("%d %lld\n", ans - 1, res);
}

 

POJ 2914  全局最小割模板题

有关证明找了还久还是没有比较满意的……最后发现洛谷有模板题，以及看起来还不错的题解，但是不想花时间看了，留个坑以后看证明。

这个板子通过洛谷数据，跑得也算比较快的了，应该比较可靠。复杂度O(N^3)

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
#define mem(x, k) memset(x, k, sizeof(x))
const int inf = 0x3f3f3f3f;
const int maxn = 605;

int n, m;
int cap[maxn][maxn], dis[maxn], par[maxn], vis[maxn];

int stoer_wanger(int n) {
    int res = inf;
    for (int i = 0; i < n; i++) par[i] = i;
    while (n > 1) {
        int k, pre = 0;
        mem(vis, 0);
        mem(dis, 0);
        vis[par[0]] = 1;
        for (int i = 1; i < n; i++) {
            k = -1;
            for (int j = 1; j < n; j++) {
                if (!vis[par[j]]) {
                    dis[par[j]] += cap[par[pre]][par[j]];
                    if (k == -1 || dis[par[k]] < dis[par[j]]) k = j;
                }
            }
            vis[par[k]] = 1;
            if (i == n - 1) {
                res = min(res, dis[par[k]]);
                for (int j = 0; j < n; j++) {
                    cap[par[pre]][par[j]] += cap[par[j]][par[k]];
                    cap[par[j]][par[pre]] += cap[par[j]][par[k]];
                }
                par[k] = par[--n];
            }
            pre = k;
        }
    }
    return res;
}

int main() {
    int u, v, c;
    while (scanf("%d %d", &n, &m) != EOF) {
        memset(cap, 0, sizeof(cap));
        for (int i = 0; i < m; i++) {
            scanf("%d %d %d", &u, &v, &c);
            cap[u][v] += c;
            cap[v][u] += c;
        }
        printf("%d\n", stoer_wanger(n));
    }
}