网络流学习笔记（含破烂板子）

Σ_aphasia

已于 2022-10-17 09:44:43 修改

阅读量590

点赞数 1

分类专栏：网络流图论文章标签：图论

于 2022-10-14 19:44:23 首次发布

本文链接：https://blog.csdn.net/laysan/article/details/127326435

版权

图论同时被 2 个专栏收录

31 篇文章 0 订阅

订阅专栏

网络流

14 篇文章 0 订阅

订阅专栏

非常神仙的博客，基本是参考里面的

目前缺少：存在上下界限制的费用流

可能存在诸多 bug，~~如果有人看的话~~ 还请指出

自用Dinic模板

struct Edge {
    int from, to, cap, flow;
    Edge(int f, int t, int c, int fl) {
        from = f;
        to = t;
        cap = c;
        flow = fl;
    }
};

struct Dinic {
    int n, m, s, t;  //结点数，边数（包括反向弧），源点编号和汇点编号
    vector<Edge> edges;  //边表。edge[e]和edge[e^1]互为反向弧
    vector<int> G[N];  //邻接表，G[i][j]表示节点i和第j条边在e数组中的序号
    bool vis[N];  // BFS使用
    int d[N];     //从起点到i的距离
    int cur[N];   //当前弧下标

    void clear_all(int n) {
        for (int i = 0; i < n; i++)
            G[i].clear();
        edges.clear();
    }
    void clear_flow() {
        int len = edges.size();
        for (int i = 0; i < len; i++)
            edges[i].flow = 0;
    }
    void add_edge(int from, int to, int cap) {
        edges.push_back(Edge(from, to, cap, 0));
        edges.push_back(Edge(to, from, 0, 0));
        m = edges.size();
        G[from].push_back(m - 2);
        G[to].push_back(m - 1);
    }
    bool BFS() {
        memset(vis, 0, sizeof(vis));
        queue<int> q;
        q.push(s);
        d[s] = 0;
        vis[s] = 1;
        while (!q.empty()) {
            int x = q.front();
            q.pop();
            int len = G[x].size();
            for (int i = 0; i < len; i++) {
                Edge& e = edges[G[x][i]];
                if (!vis[e.to] && e.cap > e.flow) {
                    vis[e.to] = 1;
                    d[e.to] = d[x] + 1;
                    q.push(e.to);
                }
            }
        }
        return vis[t];
    }
    int DFS(int x, int a) {
        if (x == t || a == 0)
            return a;
        int flow = 0, f, len = G[x].size();
        for (int& i = cur[x]; i < len; i++) {
            Edge& e = edges[G[x][i]];
            if (d[x] + 1 == d[e.to] &&
                (f = DFS(e.to, min(a, e.cap - e.flow))) > 0) {
                e.flow += f;
                edges[G[x][i] ^ 1].flow -= f;
                flow += f;
                a -= f;
                if (a == 0)
                    break;
            }
        }
        return flow;
    }
    int maxflow(int s, int t) {
        this->s = s;
        this->t = t;
        int flow = 0;
        while (BFS()) {
            memset(cur, 0, sizeof(cur));
            flow += DFS(s, inf);
        }
        return flow;
    }
    
    int mincut() {  // call this after maxflow
        int ans = 0;
        int len = edges.size();
        for (int i = 0; i < len; i++) {
            Edge& e = edges[i];
            if (vis[e.from] && !vis[e.to] && e.cap > 0)
                ans++;
        }
        return ans;
    }
    void reduce() {
        int len = edges.size();
        for (int i = 0; i < len; i++)
            edges[i].cap -= edges[i].flow;
    }
} dinic;

关于该板子的某些使用事项

因为喜欢用 vector 搬来的这份板子，但原作者已经不得而知（sad），由于和普遍流通板子的某些差异性，导致很多时候因为无法掌握强大功能引发了很多 bug。

每条边存在四个属性： $f ro m, t o, c a p, f l o w$ ，调用建边函数时将自动建出反向边，初始时 $f l o w = 0$ 。在边表 $e d g es$ 中， $e d g es [e]$ 与 $e d g es [e$ ^ $1]$ 互为反向边。

跑完最大流后，在不做其他任何操作的情况下， $f l o w$ 将改变为满足该最大流情况下该条边经过的流量，但 $c a p$ 并没有发生改变，即此时获得的并不是残余网络。但好处是可以在该情况下直接访问某条边经过的流量，而不需要查找其对应反边。

如果需要获得残余网络，调用以下：

dinic.reduce();
dinic.clear_flow();

其中 $re d u ce$ 使所有边的容量减去流量， $clear\_flow$ 将所有边的流量清空。

无源汇上下界可行流

设某边的限制为下界为 $d o w n$ ，上界为 $u p$ ，可以默认所有边都已流过下界的流量，那么该边上还能流过的流量为 $u p - d o w n$

通过 $in$ 数组记录该点的流量平衡问题，如果 $in < 0$ ，说明流入太多，多余部分需要给平衡汇点 $t$ 。如果 $in > 0$ ，说明流入太少，缺少的部分需要由平衡源点 $s$ 补充。

可行流即为平衡源点 $s$ 到平衡汇点 $t$ 的最大流。

最后实际流量=该边流量+下界

参考用

for (int i = 1; i <= m; i++) {
    int u, v;
    cin >> u >> v >> down[i] >> up[i];  //下界 上界
    dinic.add_edge(u, v, up[i] - down[i]);
    in[u] -= down[i], in[v] += down[i];
    //该边有down[i]的流量 所以前面u需要down[i]流入 v需要流出down[i]
}
s = 0, t = n + 1;
int ans = 0, sumn = 0;
for (int i = 1; i <= n; i++) {
    if (in[i] < 0)
        dinic.add_edge(i, t, -in[i]);  //流入太多 给汇点
    else
        dinic.add_edge(s, i, in[i]), sumn += in[i];  //流出太多 源点补充
}
ans = dinic.maxflow(s, t);
if (ans != sumn) {
    cout << "NO" << endl;
    return;
}
cout << "YES" << endl;
for (int i = 0; i < m * 2; i += 2) {
    cout << dinic.edges[i].flow + down[i / 2 + 1] << endl;
    //下界+该边流量=实际流量
}

智慧建边工具

void ins(int u, int v, int l, int r) {
    dinic.add_edge(u, v, r - l);
    in[u] -= l;
    in[v] += l;
}

有源汇上下界可行流

有源汇与无源汇的区别是，在后者的基础上增加了流量不平衡的两个点 $s$ ， $t$

因此只要使这两个点也满足流量平衡，就能套用上面的无源汇上下界可行流

方法：在原图中让 $t$ 连向 $s$ 一条流量上下界为 $[0, in f]$ 的边

注意平衡源汇点和原图源汇点的区别

有源汇上下界最大流

步骤：

1、在原图中让 $t$ 连向 $s$ 一条流量上下界为 $[0, in f]$ 的边

2、增加虚拟源点 $ss$ 和虚拟汇点 $tt$ ，跑 $ss$ 到 $tt$ 的可行流 $f l o w 1$ 。

（以上为有源汇上下界可行流）

3、去除原图中 $t$ 连向 $s$ 一条流量上下界为 $[0, in f]$ 的边

4、跑原图中 $s$ 到 $t$ 的最大流 $f l o w 2$ 。

最终= $f l o w 1 + f l o w 2$

删边

dinic.reduce();
dinic.clear_flow();
//以上为转化成残留网络
dinic.edges[len - 2].cap = dinic.edges[len - 1].cap = 0;

有源汇上下界最小流步骤：

1、在原图中让 $t$ 连向 $s$ 一条流量上下界为 $[0, in f]$ 的边

2、增加虚拟源点 $ss$ 和虚拟汇点 $tt$ ，跑 $ss$ 到 $tt$ 的可行流 $f l o w 1$ 。

（以上为有源汇上下界可行流）

3、去除原图中 $t$ 连向 $s$ 一条流量上下界为 $[0, in f]$ 的边

4、跑原图中 $t$ 到 $s$ 的最大流 $f l o w 2$ 。（在不改变流量平衡的情况下能够退回的最大流量）

最终= $f l o w 1 - f l o w 2$

自用费用流（dij实现）板子

template <int N>
struct MCMF {
    struct E {
        int to, cap, val, inv;
    };
    vector<E> g[N];
    int dis[N], now[N], h[N], pre[N], preu[N];
    void add(int u, int v, int f, int w) {
        g[u].push_back({v, f, w, (int)g[v].size()});
        g[v].push_back({u, 0, -w, (int)g[u].size() - 1});
    }
    void dijkstra(int st) {
        priority_queue<pair<int, int>, vector<pair<int, int>>,
                       greater<pair<int, int>>>
            q;
        memset(dis, 0x3f, sizeof dis);
        memset(pre, -1, sizeof pre);
        memset(preu, -1, sizeof preu);
        dis[st] = 0;
        q.push({0, st});
        while (q.size()) {
            // auto [d, u] = q.top();
            auto qnow = q.top();
            int d = qnow.first, u = qnow.second;
            q.pop();
            if (dis[u] < d)
                continue;
            int x = 0;
            for (auto gnow : g[u]) {
                int v = gnow.to, f = gnow.cap, w = gnow.val, inv = gnow.inv;
                if (f && dis[v] > dis[u] + w + h[u] - h[v]) {
                    dis[v] = dis[u] + h[u] - h[v] + w;
                    pre[v] = x;
                    preu[v] = u;
                    q.push({dis[v], v});
                }
                x++;
            }
        }
    }
    pair<int, int> min_cost_max_flow(int st, int ed) {
        memset(h, 0, sizeof h);
        for (int flow = 0, cost = 0, res = inf;; res = inf) {
            dijkstra(st);
            if (dis[ed] > inf)
                return {flow, cost};
            for (int i = 0; i < N; i++) {
                h[i] += dis[i];
            }
            for (int i = ed; i != st; i = preu[i]) {
                res = min(res, g[preu[i]][pre[i]].cap);
            }
            flow += res;
            cost += res * h[ed];
            for (int i = ed; i != st; i = preu[i]) {
                g[i][g[preu[i]][pre[i]].inv].cap += res;
                g[preu[i]][pre[i]].cap -= res;
            }
        }
    }
};
MCMF<505> mcmf;
int n, m, s, t;
void solve() {
    cin >> n >> m >> s >> t;
    for (int i = 1; i <= m; i++) {
        int u, v, w, c;
        cin >> u >> v >> w >> c;
        mcmf.add(u, v, w, c);//最大费用最大流：建-c边 最后输出-ans.second.
    }
    auto ans = mcmf.min_cost_max_flow(s, t);
    cout << ans.first << " " << ans.second << endl;
}