关于无向图网络流的建模

我们学习网络流的时候，一般用的都是以有向图为基础的板子，题目很多也是以有向图为基础。在这种时候，一旦碰上了以无向图为基础的网络流模型，容易抓瞎。这里就简单探讨下无向图的网络流建模。

边的建模

对于有向图，我们一般这样对边建模：

void addEdge (int from, int to, int flow){
    edges.push_back((Edge){from, to, flow});
    edges.push_back((Edge){to, from,  0  });
    G[from].push_back(edges.size() - 2);
    G[ to ].push_back(edges.size() - 1);
}

对无向图的话，我们可以两次 addEdge，但是没必要，我们可以写成这样：

void addEdge (int from, int to, int flow){
    edges.push_back((Edge){from, to, flow});
    edges.push_back((Edge){to, from, flow});
    G[from].push_back(edges.size() - 2);
    G[ to ].push_back(edges.size() - 1);
}

也就是正反边容量相同。

拆点的建模

网络流题目的一大精髓在于各种花里胡哨的拆点，例如点化边等等。这时候我们点的内部也需要维持无向图的性质，我们以一个题目为例：

P1345 [USACO5.4]奶牛的电信Telecowmunication

题意：给定一个无向图和起点终点 s，t，试问最多在去掉多少点的情况下可以让 s 和 t 不连通。

分析：根据最大流最小割定理，我们可以转化为最大流来做。只有边能限制流量，所以我们可以点化边，把点内部的边的流量设为 1，点和点之间的流量设置为 INF。

如果这是个有向图，那么题目就结束了。可惜这是个无向图，我们还需要做一些处理。

我们把一个点拆成出点和入点，入点向出点连一条容量为 1 的有向边。

在原图中两个点有双向边，我们记作这两个点分别为 \(A\) 和 \(B\)。

我们将他们拆成\(A_{in}\)，\(A_{out}\)，\(B_{in}\)，\(B_{out}\)，然后内部建边，也就是\(A_{in}\)向\(A_{out}\)，\(B_{in}\)向\(B_{out}\)各连一条容量为 1 的有向边。这时候在外界看的话，in 和 out 是一体的，那么我们应该从\(B_{out}\)向\(A_{in}\)，\(A_{out}\)向\(B_{in}\)各连一条容量为 INF 的边，这样就完成了建模。

贴一下代码：

#include<bits/stdc++.h>
using namespace std;
const int N = 210, INF = 1<<30;
struct Edge {
    int from, to, flow;
    Edge(int u, int v, int f):from(u), to(v), flow(f) {}
};
int n, m, s, t;
vector<Edge> edges;
vector<int> G[N];
void addEdge(int from, int to, int flow) {
    edges.push_back((Edge){from, to, flow});
    G[from].push_back(edges.size() - 1);
}
int d[N];
queue<int>q;
bool bfs() {
    memset(d, 0, sizeof(d));
    while (!q.empty()) q.pop();
    q.push(s), d[s] = 1;
    while (!q.empty()) {
        int x = q.front(); q.pop();
        if (x == t) return true;
        for (int i = 0; i < G[x].size(); ++i) {
            Edge &e = edges[G[x][i]];
            int to = e.to;
            if (!d[to] && e.flow)
                q.push(to), d[to] = d[x] + 1;
        }
    }
    return false;
}
int Dinic (int x, int flow) {
    if (x == t) return flow;
    int rest = flow;
    for (int i = 0; i < G[x].size(); ++i) {
        Edge &e = edges[G[x][i]], &fe = edges[G[x][i]^1];
        int to = e.to;
        if (e.flow && d[to] == d[x] + 1) {
            int k = Dinic(to, min(rest, e.flow));
            if (!k) d[to] = 0;
            e.flow -= k, fe.flow += k;
            rest -= k;
            if (rest == 0) break;
        }
    }
    if (flow == rest) d[x] = 0;
    return flow - rest;
}
int main()
{
    scanf("%d%d%d%d", &n, &m, &s, &t);
    for (int i = 1; i <= n; ++i) {
        int flow = (i==s || i==t) ? INF : 1;
        addEdge(i, i + n, flow);
        addEdge(n + i, i, 0);
    }
    t += n;
    for (int i = 0; i < m; ++i) {
        int u, v;
        scanf("%d%d", &u, &v);
        addEdge(u + n, v, INF);
        addEdge(v + n, u, INF);
    }
    int maxflow = 0, flow;
    while (bfs())
        while (flow = Dinic(s, INF)) maxflow += flow;
    printf("%d", maxflow);
    return 0;
}