网络流与线性规划24题（写了一半，先鸽下了……）

最新推荐文章于 2024-01-21 19:41:11 发布
最新推荐文章于 2024-01-21 19:41:11 发布
阅读量347 收藏 1
点赞数 2
分类专栏： 网络流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45483201/article/details/110823578
版权
本文详细介绍了网络流算法在解决实际问题中的应用，包括最大流、最小割、最大匹配等经典问题，并给出了多个实例，如飞行员配对、试题库分配、运输问题和分配问题等，通过具体代码实现展示了网络流算法的灵活性和实用性。
摘要由CSDN通过智能技术生成

Network-flows

Ford-Fulkerson算法

typedef long long ll;

const int N = 1e5 + 10;

int head[N], to[N], nex[N], flow[N], cnt;

int vis[N], n, m, s, t;

void add(int x, int y, int w) {
    to[cnt] = y;
    nex[cnt] = head[x];
    flow[cnt] = w;
    head[x] = cnt++;
}

ll dfs(int rt, ll now) {
    if(rt == t) return now;
    vis[rt] = 1;
    for(int i = head[rt]; ~i; i = nex[i]) {
        if(!vis[to[i]] && flow[i] > 0) {
            ll cur = dfs(to[i], min(now, 1ll * flow[i]));
            if(cur != -1) {
                flow[i] -= cur;
                flow[i ^ 1] += cur;
                return cur;
            }
        }
    }
    return -1;
}

ll solve() {
    ll ans = 0, cur;
    while(true) {
        cur = dfs(s, 0x3f3f3f3f3f3f3f3f);
        if(cur == -1) return ans;
        ans += cur;
        memset(vis, 0, sizeof vis);
    }
}

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    memset(head, -1, sizeof head);
    n = read(), m = read(), s = read(), t = read();
    for(int i = 1; i <= m; i++) {
        int x = read(), y = read(), w = read();
        add(x, y, w);
        add(y, x, 0);
    }
    printf("%lld\n", solve());
    return 0;
}

Edmond-Karp

typedef long long ll;

const int N = 1e5 + 10;

ll head[N], to[N], nex[N], flow[N], cnt;

ll last[N], n, m, s, t;

ll flo[N];

void add(int x, int y, int w) {
    to[cnt] = y;
    nex[cnt] = head[x];
    flow[cnt] = w;
    head[x] = cnt++;
}

bool bfs() {
    queue<int> q;
    q.push(s);
    flo[s] = 0x3f3f3f3f3f3f3f3f;
    memset(last, -1, sizeof last);
    while(q.size()) {
        int temp = q.front();
        q.pop();
        if(temp == t) {
            break;
        }
        for(int i = head[temp]; ~i; i = nex[i]) {
            if(last[to[i]] == -1 && flow[i]) {
                last[to[i]] = i;
                flo[to[i]] = min(flo[temp], 1ll * flow[i]);
                q.push(to[i]);
            }
        }
    }
    return last[t] != -1;
}

ll solve() {
    ll ans = 0;
    while(bfs()) {
        ans += flo[t];
        for(int i = t; i != s; i = to[last[i] ^ 1]) {
            flow[last[i]] -= flo[t];
            flow[last[i] ^ 1] += flo[t];
        }
    }
    return ans;
}

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    memset(head, -1, sizeof head);
    n = read(), m = read(), s = read(), t = read();
    for(int i = 1; i <= m; i++) {
        int x = read(), y = read(), w = read();
        add(x, y, w);
        add(y, x, 0);
    }
    printf("%lld\n", solve());
    return 0;
}

Dinic

/*
  Author : lifehappy
*/
#include <bits/stdc++.h>

using namespace std;

const int N = 5e5 + 10, inf = 0x3f3f3f3f;

struct max_flow {

    int head[N], to[N], nex[N], cap[N], cnt;

    int s, t, dep[N], x[N], y[N], f[N];

    void init() {
        memset(head, -1, sizeof head), cnt = 0;
    }

    void Add(int x, int y, int c) {
        to[cnt] = y;
        nex[cnt] = head[x];
        cap[cnt] = c;
        head[x] = cnt++;
    }

    void add(int x, int y, int c) {
        Add(x, y, c);
        Add(y, x, 0);
    }

    bool bfs() {
        queue<int> q;
        memset(dep, -1, sizeof dep);
        dep[s] = 0;
        q.push(s);
        while(q.size()) {
            int u = q.front();
            q.pop();
            for(int i = head[u]; ~i; i = nex[i]) {
                if(dep[to[i]] == -1 && cap[i]) {
                    q.push(to[i]);
                    dep[to[i]] = dep[u] + 1;
                }
            }
        }
        return dep[t] != -1;
    }

    int dfs(int rt, int flow) {
        if(rt == t) return flow;
        int res = flow;
        for(int i = head[rt]; ~i; i = nex[i]) {
            if(dep[to[i]] == dep[rt] + 1 && cap[i]) {
                int temp = dfs(to[i], min(res, cap[i]));
                if(temp == 0) dep[to[i]] = -1;
                res -= temp;
                cap[i] -= temp;
                cap[i ^ 1] += temp;
            }
            if(res == 0) break;
        }
        return flow - res;
    }

    int Dinic() {
        int ans = 0;
        while(bfs()) {
            ans += dfs(s, inf);
        }
        return ans;
    }

    // void print(int rt) {
    //     for(int i = head[rt]; ~i; i = nex[i]) {
    //         if(cap[i] || to[i] == s || to[i] == rt + m) continue;
    //         printf(" %d", to[i] - m);
    //         print(to[i] - m);
    //         return ;
    //     }
    // }
}dinic;

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    return 0;
}

Mcmf

Spfa

/*
  Author : lifehappy
*/
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef pair<int, int> pii;

const int N = 5e5 + 10, inf = 0x3f3f3f3f;

struct min_cost_max_flow {
    int head[N], cap[N], to[N], nex[N], value[N], cnt;

    int s, t, dis[N], vis[N], flow[N], pre[N];

    void init() {
        memset(head, -1, sizeof head), cnt = 0;
    }

    void Add(int x, int y, int w, int c) {
        to[cnt] = y;
        nex[cnt] = head[x];
        value[cnt] = w;
        cap[cnt] = c;
        head[x] = cnt++;
    }

    void add(int x, int y, int w, int c) {
        Add(x, y, w, c);
        Add(y, x, -w, 0);
    }

    bool spfa() {
        queue<int> q;
        memset(dis, 0x3f, sizeof dis);
        memset(vis, 0, sizeof vis);
        q.push(s), dis[s] = 0, vis[s] = 1;
        flow[s] = 1 << 30;
        while(q.size()) {
            int rt = q.front();
            q.pop(), vis[rt] = 0;
            for(int i = head[rt]; ~i; i = nex[i]) {
                if(cap[i] && dis[to[i]] > dis[rt] + value[i]) {
                    dis[to[i]] = dis[rt] + value[i];
                    flow[to[i]] = min(flow[rt], cap[i]);
                    pre[to[i]] = i;
                    if(!vis[to[i]]) {
                        vis[to[i]] = 1;
                        q.push(to[i]);
                    }
                }
            }
        }
        return dis[t] != 0x3f3f3f3f;
    }

    pii Mcmf() {
        int res = 0, ans = 0;
        while(spfa()) {
            int cur = flow[t];
            res += cur, ans += dis[t] * cur;
            int now = t;
            while(now != s) {
                cap[pre[now]] -= cur;
                cap[pre[now] ^ 1] += cur;
                now = to[pre[now] ^ 1];
            }
        }
        return make_pair(res, ans);
    }
}mcmf;

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    return 0;
}

Dijkstra

/*
  Author : lifehappy
*/
#include <bits/stdc++.h>

using namespace std;

typedef pair<int, int> pii;

const int N = 5e3 + 10, inf = 0x3f3f3f3f;

struct edge {
    int to, capacity, cost, rev;
    edge() {}
    edge(int to = 0, int _capacity = 0, int _cost = 0, int _rev = 0) :to(to), capacity(_capacity), cost(_cost), rev(_rev) {}
};
struct Min_Cost_Max_Flow {
    
    int V, s, t, H[N + 5], dis[N + 5], PreV[N + 5], PreE[N + 5];
    
    vector<edge> G[N + 5];
    
    void init(int n) {
        V = n;
        for (int i = 0; i <= V; ++i)G[i].clear();
    }

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

    pii mcmf() {
        int res = 0, f = inf, flow = 0; fill(H, H + 1 + V, 0);
        while (f) {
            priority_queue <pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>> > q;
            fill(dis, dis + 1 + V, inf);
            dis[s] = 0; q.push(pair<int, int>(0, s));
            while (!q.empty()) {
                pair<int, int> now = q.top(); q.pop();
                int v = now.second;
                if (dis[v] < now.first)continue;
                for (int i = 0; i < G[v].size(); ++i) {
                    edge& e = G[v][i];
                    if (e.capacity > 0 && dis[e.to] > dis[v] + e.cost + H[v] - H[e.to]) {
                        dis[e.to] = dis[v] + e.cost + H[v] - H[e.to];
                        PreV[e.to] = v;
                        PreE[e.to] = i;
                        q.push(pair<int, int>(dis[e.to], e.to));
                    }
                }
            }
            if (dis[t] == inf)break;
            for (int i = 0; i <= V; ++i)H[i] += dis[i];
            int d = f;
            for (int v = t; v != s; v = PreV[v])d = min(d, G[PreV[v]][PreE[v]].capacity);
            f -= d; flow += d; res += d*H[t];
            for (int v = t; v != s; v = PreV[v]) {
                edge& e = G[PreV[v]][PreE[v]];
                e.capacity -= d;
                G[v][e.rev].capacity += d;
            }
        }
        return make_pair(flow, res);
    }
}mcmf;

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    return 0;
}

P2756 飞行员配对方案问题（二分图匹配）

二分图匹配问题然后输出匹配方案。

/*
  Author : lifehappy
*/
#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10, inf = 0x3f3f3f3f;

int head[N], to[N], nex[N], cap[N], cnt;

int s, t, n, m, dep[N];

void Add(int x, int y, int c) {
    to[cnt] = y;
    nex[cnt] = head[x];
    cap[cnt] = c;
    head[x] = cnt++;
}

void add(int x, int y, int c) {
    Add(x, y, c);
    Add(y, x, 0);
}

bool bfs() {
    queue<int> q;
    memset(dep, -1, sizeof dep);
    dep[s] = 0;
    q.push(s);
    while(q.size()) {
        int u = q.front();
        q.pop();
        for(int i = head[u]; ~i; i = nex[i]) {
            if(dep[to[i]] == -1 && cap[i]) {
                q.push(to[i]);
                dep[to[i]] = dep[u] + 1;
            }
        }
    }
    return dep[t] != -1;
}

int dfs(int rt, int flow) {
    if(rt == t) return flow;
    int res = flow;
    for(int i = head[rt]; ~i; i = nex[i]) {
        if(dep[to[i]] == dep[rt] + 1 && cap[i]) {
            int temp = dfs(to[i], min(res, cap[i]));
            if(temp == 0) dep[to[i]] = 0;
            res -= temp;
            cap[i] -= temp;
            cap[i ^ 1] += temp;
        }
        if(res == 0) break;
    }
    return flow - res;
}

int Dinic() {
    int ans = 0;
    while(bfs()) {
        ans += dfs(s, inf);
    }
    return ans;
}

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    memset(head, -1, sizeof head);
    scanf("%d %d", &m, &n);
    cnt = 0, s = 0, t = n + 1;
    for(int i = 1; i <= m; i++) {
        add(s, i, 1);
    }
    for(int i = m + 1; i <= n; i++) {
        add(i, t, 1);
    }
    int tot = cnt;
    int x, y;
    while(scanf("%d %d", &x, &y) && x != -1) {
        add(x, y, 1); 	
    }
    int ans = Dinic();
    printf("%d\n", ans);
    for(int i = tot; i < cnt; i += 2) {
        if(cap[i] == 0 && cap[i ^ 1] == 1) {
            printf("%d %d\n", to[i ^ 1], to[i]);
        }
    }
    return 0;
}

P5039 [SHOI2010]最小生成树

我们要使 a − b a-b a−b出现在最小生成树集合中那么，必然有 a − > b a -> b a−>b的所有路径中，每个路径中一定有一条边是大于 a − b a-b a−b边的权值的，

对于每种操作，我们可以看作对选定的边进行 + 1操作，所以我们考虑如何将这个问题转化为网络流模型，

首先对于边权大于w[lab]的边是一定没有影响的，我们考虑边权小于w[a, b]的情况，

我们可以考虑用 w [ l a b ] − w [ n o w ] + 1 w[lab] - w[now] + 1 w[lab]−w[now]+1为 n o w a , n o w b now_a, now_b nowa​,nowb​两点间的流量的，然后跑一遍 l a − > l b l_a -> l_b la​−>lb​的最小割就行了，

/*
  Author : lifehappy
*/
#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10, inf = 0x3f3f3f3f;

int head[N], to[N], nex[N], cap[N], cnt;

int s, t, n, m, l, dep[N], x[N], y[N], f[N];

void Add(int x, int y, int c) {
    to[cnt] = y;
    nex[cnt] = head[x];
    cap[cnt] = c;
    head[x] = cnt++;
}

void add(int x, int y, int c) {
    Add(x, y, c);
    Add(y, x, 0);
}

bool bfs() {
    queue<int> q;
    memset(dep, -1, sizeof dep);
    dep[s] = 0;
    q.push(s);
    while(q.size()) {
        int u = q.front();
        q.pop();
        for(int i = head[u]; ~i; i = nex[i]) {
            if(dep[to[i]] == -1 && cap[i]) {
                q.push(to[i]);
                dep[to[i]] = dep[u] + 1;
            }
        }
    }
    return dep[t] != -1;
}

int dfs(int rt, int flow) {
    if(rt == t) return flow;
    int res = flow;
    for(int i = head[rt]; ~i; i = nex[i]) {
        if(dep[to[i]] == dep[rt] + 1 && cap[i]) {
            int temp = dfs(to[i], min(res, cap[i]));
            if(temp == 0) dep[to[i]] = 0;
            res -= temp;
            cap[i] -= temp;
            cap[i ^ 1] += temp;
        }
        if(res == 0) break;
    }
    return flow - res;
}

int Dinic() {
    int ans = 0;
    while(bfs()) {
        ans += dfs(s, inf);
    }
    return ans;
}

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    memset(head, -1, sizeof head);
    scanf("%d %d %d", &n, &m, &l);
    for(int i = 1; i <= m; i++) {
        scanf("%d %d %d", &x[i], &y[i], &f[i]);
    }
    s = x[l], t = y[l];
    for(int i = 1; i <= m; i++) {
        if(i != l && f[i] <= f[l]) {
            Add(x[i], y[i], f[l] - f[i] + 1);
            Add(y[i], x[i], f[l] - f[i] + 1);
        }
    }
    printf("%d\n", Dinic());
    return 0;
}

P5934 [清华集训2012]最小生成树

这道题目与上一道不同的有两点，

  • 可能出现，可选这条边，可不选这条边，那就要使能到这两个点的所有路径中都有一条的权值 ≥ l \geq l ≥l了。
  • 直接删边，代价改成 1 1 1就好了。
/*
  Author : lifehappy
*/
#include <bits/stdc++.h>

using namespace std;

const int N = 4e5 + 10, inf = 0x3f3f3f3f;

int head[N], to[N], nex[N], cap[N], cnt;

int s, t, n, m, l, dep[N], x[N], y[N], f[N];

void Add(int x, int y, int c) {
    to[cnt] = y;
    nex[cnt] = head[x];
    cap[cnt] = c;
    head[x] = cnt++;
}

void add(int x, int y, int c) {
    Add(x, y, c);
    Add(y, x, 0);
}

bool bfs() {
    queue<int> q;
    memset(dep, -1, sizeof dep);
    dep[s] = 0;
    q.push(s);
    while(q.size()) {
        int u = q.front();
        q.pop();
        for(int i = head[u]; ~i; i = nex[i]) {
            if(dep[to[i]] == -1 && cap[i]) {
                q.push(to[i]);
                dep[to[i]] = dep[u] + 1;
            }
        }
    }
    return dep[t] != -1;
}

int dfs(int rt, int flow) {
    if(rt == t) return flow;
    int res = flow;
    for(int i = head[rt]; ~i; i = nex[i]) {
        if(dep[to[i]] == dep[rt] + 1 && cap[i]) {
            int temp = dfs(to[i], min(res, cap[i]));
            if(temp == 0) dep[to[i]] = 0;
            res -= temp;
            cap[i] -= temp;
            cap[i ^ 1] += temp;
        }
        if(res == 0) break;
    }
    return flow - res;
}

int Dinic() {
    int ans = 0;
    while(bfs()) {
        ans += dfs(s, inf);
    }
    return ans;
}

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    memset(head, -1, sizeof head);
    scanf("%d %d", &n, &m);
    for(int i = 1; i <= m; i++) {
        scanf("%d %d %d", &x[i], &y[i], &f[i]);
    }
    scanf("%d %d %d", &s, &t, &l);
    for(int i = 1; i <= m; i++) {
        if(f[i] < l) {
            Add(x[i], y[i], 1);
            Add(y[i], x[i], 1);
        }
    }
    int ans = Dinic();
    memset(head, -1, sizeof head), cnt = 0;
    for(int i = 1; i <= m; i++) {
        if(f[i] > l) {
            Add(x[i], y[i], 1);
            Add(y[i], x[i], 1);
        }
    }
    ans += Dinic();
    printf("%d\n", ans);
    return 0;
}

#6001. 「网络流 24 题」太空飞行计划

最大权闭合子图模板

S S S点连向正权值的点（权值累加），负权值的点连向 T T T，然后在每个关系中建立流量为无穷的有向边。

跑一遍最大流，最大权值为（累加的权值 - 最小割（最大流））， d e p dep dep数组标记为不为 − 1 -1 −1的点，即被选中的点。

/*
  Author : lifehappy
*/
#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 10, inf = 0x3f3f3f3f;

int head[N], to[N], nex[N], cap[N], cnt;

int s, t, n, m, l, ans, dep[N], x[N], y[N], f[N];

void Add(int x, int y, int c) {
    to[cnt] = y;
    nex[cnt] = head[x];
    cap[cnt] = c;
    head[x] = cnt++;
}

void add(int x, int y, int c) {
    Add(x, y, c);
    Add(y, x, 0);
}

bool bfs() {
    queue<int> q;
    memset(dep, -1, sizeof dep);
    dep[s] = 0;
    q.push(s);
    while(q.size()) {
        int u = q.front();
        q.pop();
        for(int i = head[u]; ~i; i = nex[i]) {
            if(dep[to[i]] == -1 && cap[i]) {
                q.push(to[i]);
                dep[to[i]] = dep[u] + 1;
            }
        }
    }
    return dep[t] != -1;
}

int dfs(int rt, int flow) {
    if(rt == t) return flow;
    int res = flow;
    for(int i = head[rt]; ~i; i = nex[i]) {
        if(dep[to[i]] == dep[rt] + 1 && cap[i]) {
            int temp = dfs(to[i], min(res, cap[i]));
            if(temp == 0) dep[to[i]] = -1;
            res -= temp;
            cap[i] -= temp;
            cap[i ^ 1] += temp;
        }
        if(res == 0) break;
    }
    return flow - res;
}

int Dinic() {
    int ans = 0;
    while(bfs()) {
        ans += dfs(s, inf);
    }
    return ans;
}

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    memset(head, -1, sizeof head);
    scanf("%d %d", &n, &m);
    s = 0, t = n + m + 1;
    for(int i = 1, x; i <= n; i++) {
        scanf("%d", &x);
        add(s, i, x);
        ans += x;
        while(getchar() == ' ') {
            scanf("%d", &x);
            add(i, n + x, inf);
        }
    }
    for(int i = 1, x; i <= m; i++) {
        scanf("%d", &x);
        add(n + i, t, x);
    }
    ans -= Dinic();
    for(int i = 1, flag = 0; i <= n; i++) {
        if(dep[i] != -1) {
            if(!flag) {
                flag = 1;
            }
            else {
                printf(" ");
            }
            printf("%d", i);
        }
    }
    puts("");
    for(int i = n + 1, flag = 0; i <= n + m; i++) {
        if(dep[i] != -1) {
            if(!flag) {
                flag = 1;
            }
            else {
                printf(" ");
            }
            printf("%d", i - n);
        }
    }
    printf("\n%d\n", ans);
    return 0;
}

Firing

/*
  Author : lifehappy
*/
// #include <bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>

using namespace std;

#define int long long

const int N = 1e6 + 10, inf = 0x3f3f3f3f;

int head[N], to[N], nex[N], cap[N], cnt;

int s, t, n, m, dep[N], value[N];

void Add(int x, int y, int c) {
    to[cnt] = y;
    nex[cnt] = head[x];
    cap[cnt] = c;
    head[x] = cnt++;
}

void add(int x, int y, int c) {
    Add(x, y, c);
    Add(y, x, 0);
}

bool bfs() {
    queue<int> q;
    memset(dep, -1, sizeof dep);
    dep[s] = 0;
    q.push(s);
    while(q.size()) {
        int u = q.front();
        q.pop();
        for(int i = head[u]; ~i; i = nex[i]) {
            if(dep[to[i]] == -1 && cap[i]) {
                q.push(to[i]);
                dep[to[i]] = dep[u] + 1;
            }
        }
    }
    return dep[t] != -1;
}

int dfs(int rt, int flow) {
    if(rt == t) return flow;
    int res = flow;
    for(int i = head[rt]; ~i; i = nex[i]) {
        if(dep[to[i]] == dep[rt] + 1 && cap[i]) {
            int temp = dfs(to[i], min(res, cap[i]));
            if(temp == 0) dep[to[i]] = -1;
            res -= temp;
            cap[i] -= temp;
            cap[i ^ 1] += temp;
        }
        if(res == 0) break;
    }
    return flow - res;
}

int Dinic() {
    int ans = 0;
    while(bfs()) {
        ans += dfs(s, inf);
    }
    return ans;
}

signed main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    while(scanf("%lld %lld", &n, &m) != EOF) {
        memset(head, -1, sizeof head), cnt = 0;
        s = 0, t = n + 1;
        int ans = 0;
        for(int i = 1; i <= n; i++) {
            int value;
            scanf("%lld", &value);
            if(value > 0) {
                ans += value;
                add(s, i, value);
            }
            else {
                add(i, t, -value);
            }
        }
        for(int i = 1; i <= m; i++) {
            int x, y;
            scanf("%lld %lld", &x, &y);
            add(x, y, inf * inf);
        }
        ans -= Dinic();
        int res = 0;
        for(int i = 1; i <= n; i++) {
            if(dep[i] != -1) {
                res++;
            }
        }
        printf("%lld %lld\n", res, ans);
    }
    return 0;
}

[网络流 24 题]最小路径覆盖

最小路径数为 顶 点 个 数 − 最 大 匹 配 数 顶点个数- 最大匹配数 顶点个数−最大匹配数

/*
  Author : lifehappy
*/
#include <bits/stdc++.h>

using namespace std;

const int N = 1e6 + 10, inf = 0x3f3f3f3f;

int head[N], to[N], nex[N], cap[N], cnt;

int s, t, n, m, dep[N], x[N], y[N], f[N];

void Add(int x, int y, int c) {
    to[cnt] = y;
    nex[cnt] = head[x];
    cap[cnt] = c;
    head[x] = cnt++;
}

void add(int x, int y, int c) {
    Add(x, y, c);
    Add(y, x, 0);
}

bool bfs() {
    queue<int> q;
    memset(dep, -1, sizeof dep);
    dep[s] = 0;
    q.push(s);
    while(q.size()) {
        int u = q.front();
        q.pop();
        for(int i = head[u]; ~i; i = nex[i]) {
            if(dep[to[i]] == -1 && cap[i]) {
                q.push(to[i]);
                dep[to[i]] = dep[u] + 1;
            }
        }
    }
    return dep[t] != -1;
}

int dfs(int rt, int flow) {
    if(rt == t) return flow;
    int res = flow;
    for(int i = head[rt]; ~i; i = nex[i]) {
        if(dep[to[i]] == dep[rt] + 1 && cap[i]) {
            int temp = dfs(to[i], min(res, cap[i]));
            if(temp == 0) dep[to[i]] = -1;
            res -= temp;
            cap[i] -= temp;
            cap[i ^ 1] += temp;
        }
        if(res == 0) break;
    }
    return flow - res;
}

int Dinic() {
    int ans = 0;
    while(bfs()) {
        ans += dfs(s, inf);
    }
    return ans;
}

void print(int rt) {
    printf("%d ", rt);
    for(int i = head[rt]; ~i; i = nex[i]) {
        if(cap[i] || to[i] == s || to[i] == rt + n) continue;
        print(to[i] - n);
        return ;
    }
}

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    memset(head, -1, sizeof head), cnt = 0;
    scanf("%d %d", &n, &m);
    s = 0, t = 2 * n + 1;
    for(int i = 1; i <= n; i++) {
        add(s, i, 1);
        add(i + n, t, 1);
    }
    for(int i = 1; i <= m; i++) {
        int x, y;
        scanf("%d %d", &x, &y);
        add(x, y + n, 1);
    }
    int ans = Dinic();
    for(int i = 1; i <= n; i++) {
        int flag = 1;
        for(int j = head[i + n]; ~j; j = nex[j]) {
            if(cap[j] && to[j] != i && to[j] != t) {
                flag = 0;
                break;
            }
        }
        if(flag) {
            print(i);
            puts("");
        }
    }
    printf("%d\n", n - ans);
    return 0;
}

[网络流 24 题 魔术球]

最小路径覆盖的变形题。

/*
  Author : lifehappy
*/
#include <bits/stdc++.h>

using namespace std;

const int N = 1e6 + 10, inf = 0x3f3f3f3f;

int head[N], to[N], nex[N], cap[N], cnt;

int s, t, n, m, tot, ans, dep[N], x[N], y[N], f[N];

void Add(int x, int y, int c) {
    to[cnt] = y;
    nex[cnt] = head[x];
    cap[cnt] = c;
    head[x] = cnt++;
}

void add(int x, int y, int c) {
    Add(x, y, c);
    Add(y, x, 0);
}

bool bfs() {
    queue<int> q;
    memset(dep, -1, sizeof dep);
    dep[s] = 0;
    q.push(s);

    while (q.size()) {
        int u = q.front();
        q.pop();

        for (int i = head[u]; ~i; i = nex[i]) {
            if (dep[to[i]] == -1 && cap[i]) {
                q.push(to[i]);
                dep[to[i]] = dep[u] + 1;
            }
        }
    }

    return dep[t] != -1;
}

int dfs(int rt, int flow) {
    if (rt == t)
        return flow;

    int res = flow;

    for (int i = head[rt]; ~i; i = nex[i]) {
        if (dep[to[i]] == dep[rt] + 1 && cap[i]) {
            int temp = dfs(to[i], min(res, cap[i]));

            if (temp == 0)
                dep[to[i]] = -1;

            res -= temp;
            cap[i] -= temp;
            cap[i ^ 1] += temp;
        }

        if (res == 0)
            break;
    }

    return flow - res;
}

int Dinic() {
    int ans = 0;

    while (bfs()) {
        ans += dfs(s, inf);
    }

    return ans;
}

void print(int rt) {
    for (int i = head[rt]; ~i; i = nex[i]) {
        if (cap[i] || to[i] == s || to[i] == rt + m)
            continue;

        printf(" %d", to[i] - m);
        print(to[i] - m);
        return ;
    }
}

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    memset(head, -1, sizeof head), cnt = 0;
    scanf("%d", &n);
    tot = 0, m = 5000, s = 0, t = 10001;

    while (++tot) {
        add(s, tot, 1), add(tot + m, t, 1);

        for (int i = 1; i < tot; i++) {
            if (sqrt(i + tot) == int(sqrt(i + tot))) {
                add(i, tot + m, 1);
            }
        }

        ans += Dinic();

        if (tot - ans > n)
            break;
    }

    printf("%d\n", tot - 1);

    for (int i = 1; i < tot; i++) {
        int flag = 1;

        for (int j = head[i + m]; ~j; j = nex[j]) {
            if (cap[j] && to[j] != i && to[j] != t) {
                flag = 0;
                break;
            }
        }

        if (flag) {
            printf("%d", i);
            print(i);
            puts("");
        }
    }

    return 0;
}

[网络流 24 题]圆桌聚餐

挺好想的这题，直接二分图匹配，然后输出方案数就行了。

/*
  Author : lifehappy
*/
#include <bits/stdc++.h>

using namespace std;

const int N = 1e6 + 10, inf = 0x3f3f3f3f;

int head[N], to[N], nex[N], cap[N], cnt;

int s, t, n, m, dep[N], x[N], y[N], f[N];

void Add(int x, int y, int c) {
    to[cnt] = y;
    nex[cnt] = head[x];
    cap[cnt] = c;
    head[x] = cnt++;
}

void add(int x, int y, int c) {
    Add(x, y, c);
    Add(y, x, 0);
}

bool bfs() {
    queue<int> q;
    memset(dep, -1, sizeof dep);
    dep[s] = 0;
    q.push(s);
    while(q.size()) {
        int u = q.front();
        q.pop();
        for(int i = head[u]; ~i; i = nex[i]) {
            if(dep[to[i]] == -1 && cap[i]) {
                q.push(to[i]);
                dep[to[i]] = dep[u] + 1;
            }
        }
    }
    return dep[t] != -1;
}

int dfs(int rt, int flow) {
    if(rt == t) return flow;
    int res = flow;
    for(int i = head[rt]; ~i; i = nex[i]) {
        if(dep[to[i]] == dep[rt] + 1 && cap[i]) {
            int temp = dfs(to[i], min(res, cap[i]));
            if(temp == 0) dep[to[i]] = -1;
            res -= temp;
            cap[i] -= temp;
            cap[i ^ 1] += temp;
        }
        if(res == 0) break;
    }
    return flow - res;
}

int Dinic() {
    int ans = 0;
    while(bfs()) {
        ans += dfs(s, inf);
    }
    return ans;
}

void print(int rt) {
    for(int i = head[rt]; ~i; i = nex[i]) {
        if(cap[i] || to[i] == s || to[i] == rt + m) continue;
        printf(" %d", to[i] - m);
        print(to[i] - m);
        return ;
    }
}

vector<int> res[300];

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    memset(head, -1, sizeof head), cnt = 0;
    scanf("%d %d", &m, &n);
    s = 0, t = n + m + 1;
    int sum1 = 0;
    for(int i = 1; i <= m; i++) {
        int x;
        scanf("%d", &x);
        add(i + n, t, x);
        sum1 += x;
    }
    int sum2 = 0;
    for(int i = 1; i <= n; i++) {
        int x;
        scanf("%d", &x);
        add(s, i, x);
        sum2 += x;
    }
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            add(i, j + n, 1);
        }
    }
    int ans = Dinic();
    if(ans != min(sum1, sum2)) {
        puts("0");
        return 0;
    }
    printf("%d\n", 1);
    for(int i = 1; i <= n; i++) {
        for(int j = head[i]; ~j; j = nex[j]) {
            if(cap[j] == 0 && to[j] != s) {
                res[to[j] - n].push_back(i);
            }
        }
    }
    for(int i = 1; i <= m; i++) {
        for(auto it : res[i]) {
            printf("%d ", it);
        }
        puts("");
    }
    return 0;
}

[网络流 24 题]试题库

有点像二分图最大匹配，其实好像就是吧。

/*
  Author : lifehappy
*/
#include <bits/stdc++.h>

using namespace std;

const int N = 1e6 + 10, inf = 0x3f3f3f3f;

int head[N], to[N], nex[N], cap[N], cnt;

int s, t, n, m, dep[N], x[N], y[N], f[N];

void Add(int x, int y, int c) {
    to[cnt] = y;
    nex[cnt] = head[x];
    cap[cnt] = c;
    head[x] = cnt++;
}

void add(int x, int y, int c) {
    Add(x, y, c);
    Add(y, x, 0);
}

bool bfs() {
    queue<int> q;
    memset(dep, -1, sizeof dep);
    dep[s] = 0;
    q.push(s);
    while(q.size()) {
        int u = q.front();
        q.pop();
        for(int i = head[u]; ~i; i = nex[i]) {
            if(dep[to[i]] == -1 && cap[i]) {
                q.push(to[i]);
                dep[to[i]] = dep[u] + 1;
            }
        }
    }
    return dep[t] != -1;
}

int dfs(int rt, int flow) {
    if(rt == t) return flow;
    int res = flow;
    for(int i = head[rt]; ~i; i = nex[i]) {
        if(dep[to[i]] == dep[rt] + 1 && cap[i]) {
            int temp = dfs(to[i], min(res, cap[i]));
            if(temp == 0) dep[to[i]] = -1;
            res -= temp;
            cap[i] -= temp;
            cap[i ^ 1] += temp;
        }
        if(res == 0) break;
    }
    return flow - res;
}

int Dinic() {
    int ans = 0;
    while(bfs()) {
        ans += dfs(s, inf);
    }
    return ans;
}

void print(int rt) {
    for(int i = head[rt]; ~i; i = nex[i]) {
        if(cap[i] || to[i] == s || to[i] == rt + m) continue;
        printf(" %d", to[i] - m);
        print(to[i] - m);
        return ;
    }
}

vector<int> res[50];

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    memset(head, -1, sizeof head), cnt = 0;
    scanf("%d %d", &m, &n);
    s = 0, t = n + m + 1;
    int sum = 0;
    for(int i = 1; i <= m; i++) {
        int x;
        scanf("%d", &x);
        add(n + i, t, x);
        sum += x;
    }
    for(int i = 1; i <= n; i++) {
        int tot, x;
        scanf("%d", &tot);
        add(s, i, 1);
        for(int j = 1; j <= tot; j++) {
            scanf("%d", &x);
            add(i, x + n, 1);
        }
    }
    int ans = Dinic();
    if(ans != sum) {
        puts("No Solution!");
        return 0;
    }
    for(int i = 1; i <= n; i++) {
        for(int j = head[i]; ~j; j = nex[j]) {
            if(!cap[j] && to[j] != s) {
                res[to[j] - n].push_back(i);
            }
        }
    }
    for(int i = 1; i <= m; i++) {
        printf("%d: ", i);
        for(auto it : res[i]) {
            printf("%d ", it);
        }
        puts("");
    }
    return 0;
}

[网络流 24 题]最长递增子序列

先跑一次 d p dp dp求得 s s s，

对于问题二，先拆点然后对所有 d p [ i ] = 1 dp[i] = 1 dp[i]=1的连一条 a d d ( s , i , 1 ) add(s, i, 1) add(s,i,1)的边，对所有 d p [ i ] = s dp[i] = s dp[i]=s的点连一条 a d d ( i + n , t , 1 ) add(i + n, t, 1) add(i+n,t,1)的边

然后对 i < j , a [ i ] ≤ a [ j ] , d p [ i ] + 1 = d p [ j ] i < j, a[i] \leq a[j],dp[i] + 1 = dp[j] i<j,a[i]≤a[j],dp[i]+1=dp[j]，连一条 a d d ( i + n , j , 1 ) add(i + n, j, 1) add(i+n,j,1)的边，然后跑一遍最大流即可了。

对于问题二， a d d ( s , 1 , i n f ) , a d d ( 1 , n + 1 , i n f ) add(s, 1, inf), add(1, n + 1, inf) add(s,1,inf),add(1,n+1,inf)，如果 d p [ n ] = s dp[n] = s dp[n]=s， a d d ( n , n + n , i n f ) , a d d ( n + n , T , i n f ) add(n, n + n, inf), add(n + n, T, inf) add(n,n+n,inf),add(n+n,T,inf)然后跑一遍最大流即可。

/*
  Author : lifehappy
*/
#include <bits/stdc++.h>

using namespace std;

const int N = 1e6 + 10, inf = 0x3f3f3f3f;

int head[N], to[N], nex[N], cap[N], cnt;

int s, t, n, m, res, dep[N], x[N], y[N], f[N];

void Add(int x, int y, int c) {
    to[cnt] = y;
    nex[cnt] = head[x];
    cap[cnt] = c;
    head[x] = cnt++;
}

void add(int x, int y, int c) {
    Add(x, y, c);
    Add(y, x, 0);
}

bool bfs() {
    queue<int> q;
    memset(dep, -1, sizeof dep);
    dep[s] = 0;
    q.push(s);
    while(q.size()) {
        int u = q.front();
        q.pop();
        for(int i = head[u]; ~i; i = nex[i]) {
            if(dep[to[i]] == -1 && cap[i]) {
                q.push(to[i]);
                dep[to[i]] = dep[u] + 1;
            }
        }
    }
    return dep[t] != -1;
}

int dfs(int rt, int flow) {
    if(rt == t) return flow;
    int res = flow;
    for(int i = head[rt]; ~i; i = nex[i]) {
        if(dep[to[i]] == dep[rt] + 1 && cap[i]) {
            int temp = dfs(to[i], min(res, cap[i]));
            if(temp == 0) dep[to[i]] = -1;
            res -= temp;
            cap[i] -= temp;
            cap[i ^ 1] += temp;
        }
        if(res == 0) break;
    }
    return flow - res;
}

int Dinic() {
    int ans = 0;
    while(bfs()) {
        ans += dfs(s, inf);
    }
    return ans;
}

void print(int rt) {
    for(int i = head[rt]; ~i; i = nex[i]) {
        if(cap[i] || to[i] == s || to[i] == rt + m) continue;
        printf(" %d", to[i] - m);
        print(to[i] - m);
        return ;
    }
}

const int N1 = 510;

int a[N], dp[N];

void solve1() {
    for(int i = 1; i <= n; i++) {
        dp[i] = 1;
        for(int j = 1; j < i; j++) {
            if(a[i] >= a[j]) {
                dp[i] = max(dp[i], dp[j] + 1);
            }
        }
        res = max(res, dp[i]);
    }
    printf("%d\n", res);
}

int solve2() {
    memset(head, -1, sizeof head), cnt = 0, s = 0, t = 2 * n + 1;
    for(int i = 1; i <= n; i++) {
        if(dp[i] == 1) {
            add(s, i, 1);
        }
        if(dp[i] == res) {
            add(i + n, t, 1);
        }
        add(i, i + n, 1);
        for(int j = i + 1; j <= n; j++) {
            if(a[j] >= a[i] && dp[i] + 1 == dp[j]) {
                add(i + n, j, 1);
            }
        }
    }
    int ans = Dinic();
    printf("%d\n", ans);
    return ans;
}

void solve3() {
    int ans = solve2();
    add(s, 1, inf), add(1, 1 + n, inf);
    if(dp[n] == res) {
        add(n, n + n, inf);
        add(n + n, t, inf);
    }
    printf("%d\n", Dinic() + ans);
}

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
    }
    if(n == 1) {
        puts("1\n1\n1");
        return 0;
    }
    solve1();
    solve3();
    return 0;
}

[网络流 24 题]方格取数

/*
  Author : lifehappy
*/
#include <bits/stdc++.h>

using namespace std;

const int N = 5e5 + 10, inf = 0x3f3f3f3f;

int head[N], to[N], nex[N], cap[N], cnt;

int s, t, n, m, dep[N], x[N], y[N], f[N];

void Add(int x, int y, int c) {
    to[cnt] = y;
    nex[cnt] = head[x];
    cap[cnt] = c;
    head[x] = cnt++;
}

void add(int x, int y, int c) {
    Add(x, y, c);
    Add(y, x, 0);
}

bool bfs() {
    queue<int> q;
    memset(dep, -1, sizeof dep);
    dep[s] = 0;
    q.push(s);
    while(q.size()) {
        int u = q.front();
        q.pop();
        for(int i = head[u]; ~i; i = nex[i]) {
            if(dep[to[i]] == -1 && cap[i]) {
                q.push(to[i]);
                dep[to[i]] = dep[u] + 1;
            }
        }
    }
    return dep[t] != -1;
}

int dfs(int rt, int flow) {
    if(rt == t) return flow;
    int res = flow;
    for(int i = head[rt]; ~i; i = nex[i]) {
        if(dep[to[i]] == dep[rt] + 1 && cap[i]) {
            int temp = dfs(to[i], min(res, cap[i]));
            if(temp == 0) dep[to[i]] = -1;
            res -= temp;
            cap[i] -= temp;
            cap[i ^ 1] += temp;
        }
        if(res == 0) break;
    }
    return flow - res;
}

int Dinic() {
    int ans = 0;
    while(bfs()) {
        ans += dfs(s, inf);
    }
    return ans;
}

void print(int rt) {
    for(int i = head[rt]; ~i; i = nex[i]) {
        if(cap[i] || to[i] == s || to[i] == rt + m) continue;
        printf(" %d", to[i] - m);
        print(to[i] - m);
        return ;
    }
}

const int ax[4] = {1, -1, 0, 0}, ay[4] = {0, 0, 1, -1};

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    memset(head, -1, sizeof head), cnt = 0;
    scanf("%d %d", &n, &m);
    s = 0, t = n * m + 1;
    int sum = 0;
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            int x;
            scanf("%d", &x);
            sum += x;
            if((i + j) & 1) {
                add(s, (i - 1) * m + j, x);
                for(int k = 0; k < 4; k++) {
                    int x = i + ax[k], y = j + ay[k];
                    if(x < 1 || x > n || y < 1 || y > m) continue;
                    add((i - 1) * m + j, (x - 1) * m + y, inf);
                }
            }
            else {
                add((i - 1) * m + j, t, x);
            }
        }
    }
    printf("%d\n", sum - Dinic());
    return 0;
}

[网络流 24 题]餐巾计划

/*
  Author : lifehappy
*/
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef pair<ll, ll> pii;

const int N = 5e5 + 10;
ll inf = 0x3f3f3f3f3f3f3f3f;

ll head[N], cap[N], to[N], nex[N], value[N], cnt;

ll n, m, s, t, dis[N], vis[N], flow[N], pre[N];

void Add(int x, int y, int w, int c) {
    to[cnt] = y;
    nex[cnt] = head[x];
    value[cnt] = w;
    cap[cnt] = c;
    head[x] = cnt++;
}

void add(int x, int y, int w, int c) {
    Add(x, y, w, c);
    Add(y, x, -w, 0);
}

bool spfa() {
    queue<int> q;
    memset(dis, 0x3f, sizeof dis);
    memset(vis, 0, sizeof vis);
    q.push(s), dis[s] = 0, vis[s] = 1;
    flow[s] = 1 << 30;
    while(q.size()) {
        int rt = q.front();
        q.pop(), vis[rt] = 0;
        for(int i = head[rt]; ~i; i = nex[i]) {
            if(cap[i] && dis[to[i]] > dis[rt] + value[i]) {
                dis[to[i]] = dis[rt] + value[i];
                flow[to[i]] = min(flow[rt], cap[i]);
                pre[to[i]] = i;
                if(!vis[to[i]]) {
                    vis[to[i]] = 1;
                    q.push(to[i]);
                }
            }
        }
    }
    return dis[t] != 0x3f3f3f3f3f3f3f3f;
}

pii Mcmf() {
    ll res = 0, ans = 0;
    while(spfa()) {
        int cur = flow[t];
        res += cur, ans += dis[t] * cur;
        int now = t;
        while(now != s) {
            cap[pre[now]] -= cur;
            cap[pre[now] ^ 1] += cur;
            now = to[pre[now] ^ 1];
        }
    }
    return make_pair(res, ans);
}

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    memset(head, -1, sizeof head), cnt = 0;
    int P, M, F, N, S;
    scanf("%d", &n);
    s = 0, t = 2 * n + 1;
    for(int i = 1; i <= n; i++) {
        int x;
        scanf("%d", &x);
        add(s, i, 0, x);
        add(i + n, t, 0, x);
    }
    scanf("%d %d %d %d %d", &P, &M, &F, &N, &S);
    for(int i = 1; i <= n; i++) {
        add(s, i + n, P, inf);
        if(i + 1 <= n) add(i, i + 1, 0, inf);
        if(i + M <= n) add(i, i + M + n, F, inf);
        if(i + N <= n) add(i, i + N + n, S, inf);
    }
    pii ans = Mcmf();
    // printf("%d\n", ans.second);
    cout << ans.second << "\n";
    return 0;
}

[网络流 24 题]数字梯形

/*
  Author : lifehappy
*/
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef pair<int, int> pii;

const int N = 5e5 + 10, inf = 0x3f3f3f3f;

int head[N], cap[N], to[N], nex[N], value[N], cnt;

int n, m, s, t, dis[N], vis[N], flow[N], pre[N];

void Add(int x, int y, int w, int c) {
    to[cnt] = y;
    nex[cnt] = head[x];
    value[cnt] = w;
    cap[cnt] = c;
    head[x] = cnt++;
}

void add(int x, int y, int w, int c) {
    Add(x, y, w, c);
    Add(y, x, -w, 0);
}

bool spfa() {
    queue<int> q;
    memset(dis, 0x3f, sizeof dis);
    memset(vis, 0, sizeof vis);
    q.push(s), dis[s] = 0, vis[s] = 1;
    flow[s] = 1 << 30;
    while(q.size()) {
        int rt = q.front();
        q.pop(), vis[rt] = 0;
        for(int i = head[rt]; ~i; i = nex[i]) {
            if(cap[i] && dis[to[i]] > dis[rt] + value[i]) {
                dis[to[i]] = dis[rt] + value[i];
                flow[to[i]] = min(flow[rt], cap[i]);
                pre[to[i]] = i;
                if(!vis[to[i]]) {
                    vis[to[i]] = 1;
                    q.push(to[i]);
                }
            }
        }
    }
    return dis[t] != 0x3f3f3f3f;
}

pii Mcmf() {
    int res = 0, ans = 0;
    while(spfa()) {
        int cur = flow[t];
        res += cur, ans += dis[t] * cur;
        int now = t;
        while(now != s) {
            cap[pre[now]] -= cur;
            cap[pre[now] ^ 1] += cur;
            now = to[pre[now] ^ 1];
        }
    }
    return make_pair(res, ans);
}

int a[50][50], id[50][50], tot;

void solve1() {
    memset(head, -1, sizeof head), cnt = 0;
    s = 0, t = 2 * tot + 1;
    for(int i = 1; i <= n; i++) {
        add(s, id[1][i], 0, 1);
    }
    for(int i = 1; i < m; i++) {
        for(int j = 1; j <= n + i - 1; j++) {
            add(id[i][j], id[i][j] + tot, -a[i][j], 1);
            add(id[i][j] + tot, id[i + 1][j], 0, 1);
            add(id[i][j] + tot, id[i + 1][j + 1], 0, 1);
        }
    }
    for(int i = 1; i <= n + m - 1; i++) {
        add(id[m][i], id[m][i] + tot, -a[m][i], 1);
        add(id[m][i] + tot, t, 0, 1);
    }
    printf("%d\n", -Mcmf().second);
}

void solve2() {
    memset(head, -1, sizeof head), cnt = 0;
    s = 0, t = 2 * tot + 1;
    for(int i = 1; i <= n; i++) {
        add(s, id[1][i], 0, 1);
    }
    for(int i = 1; i < m; i++) {
        for(int j = 1; j <= n + i - 1; j++) {
            add(id[i][j], id[i][j] + tot, -a[i][j], inf);
            add(id[i][j] + tot, id[i + 1][j], 0, 1);
            add(id[i][j] + tot, id[i + 1][j + 1], 0, 1);
        }
    }
    for(int i = 1; i <= n + m - 1; i++) {
        add(id[m][i], id[m][i] + tot, -a[m][i], inf);
        add(id[m][i] + tot, t, 0, inf);
    }
    printf("%d\n", -Mcmf().second);
}

void solve3() {
    memset(head, -1, sizeof head), cnt = 0;
    s = 0, t = 2 * tot + 1;
    for(int i = 1; i <= n; i++) {
        add(s, id[1][i], 0, 1);
    }
    for(int i = 1; i < m; i++) {
        for(int j = 1; j <= n + i - 1; j++) {
            add(id[i][j], id[i][j] + tot, -a[i][j], inf);
            add(id[i][j] + tot, id[i + 1][j], 0, inf);
            add(id[i][j] + tot, id[i + 1][j + 1], 0, inf);
        }
    }
    for(int i = 1; i <= n + m - 1; i++) {
        add(id[m][i], id[m][i] + tot, -a[m][i], inf);
        add(id[m][i] + tot, t, 0, inf);
    }
    printf("%d\n", -Mcmf().second);
}

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    scanf("%d %d", &n, &m);
    for(int i = 1; i <= m; i++) {
        for(int j = 1; j <= n + i - 1; j++) {
            scanf("%d", &a[i][j]);
            id[i][j] = ++tot;
        }
    }
    solve1();
    solve2();
    solve3();
    return 0;
}

[网络流 24 题]运输问题

/*
  Author : lifehappy
*/
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef pair<int, int> pii;

const int N = 5e5 + 10, inf = 0x3f3f3f3f;

int head[N], cap[N], to[N], nex[N], value[N], cnt;

int n, m, s, t, dis[N], vis[N], flow[N], pre[N];

void Add(int x, int y, int w, int c) {
    to[cnt] = y;
    nex[cnt] = head[x];
    value[cnt] = w;
    cap[cnt] = c;
    head[x] = cnt++;
}

void add(int x, int y, int w, int c) {
    Add(x, y, w, c);
    Add(y, x, -w, 0);
}

bool spfa() {
    queue<int> q;
    memset(dis, 0x3f, sizeof dis);
    memset(vis, 0, sizeof vis);
    q.push(s), dis[s] = 0, vis[s] = 1;
    flow[s] = 1 << 30;
    while(q.size()) {
        int rt = q.front();
        q.pop(), vis[rt] = 0;
        for(int i = head[rt]; ~i; i = nex[i]) {
            if(cap[i] && dis[to[i]] > dis[rt] + value[i]) {
                dis[to[i]] = dis[rt] + value[i];
                flow[to[i]] = min(flow[rt], cap[i]);
                pre[to[i]] = i;
                if(!vis[to[i]]) {
                    vis[to[i]] = 1;
                    q.push(to[i]);
                }
            }
        }
    }
    return dis[t] != 0x3f3f3f3f;
}

pii Mcmf() {
    int res = 0, ans = 0;
    while(spfa()) {
        int cur = flow[t];
        res += cur, ans += dis[t] * cur;
        int now = t;
        while(now != s) {
            cap[pre[now]] -= cur;
            cap[pre[now] ^ 1] += cur;
            now = to[pre[now] ^ 1];
        }
    }
    return make_pair(res, ans);
}

const int N1 = 110;

int a[N1], b[N1], x[N1][N1];

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    memset(head, -1, sizeof head), cnt = 0;
    scanf("%d %d", &n, &m);
    s = 0, t = n + m + 1;
    for(int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
        add(s, i, 0, a[i]);
    }
    for(int i = 1; i <= m; i++) {
        scanf("%d", &b[i]);
        add(i + n, t, 0, b[i]);
    }
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            scanf("%d", &x[i][j]);
            add(i, j + n, x[i][j], inf);
        }
    }
    printf("%d\n", Mcmf().second);
    memset(head, -1, sizeof head), cnt = 0;
    for(int i = 1; i <= n; i++) {
        add(s, i, 0, a[i]);
    }
    for(int i = 1; i <= m; i++) {
        add(i + n, t, 0, b[i]);
    }
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            add(i, j + n, -x[i][j], inf);
        }
    }
    printf("%d\n", -Mcmf().second);
    return 0;
}

[网络流 24 题]分配问题

/*
  Author : lifehappy
*/
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef pair<int, int> pii;

const int N = 5e5 + 10, inf = 0x3f3f3f3f;

int head[N], cap[N], to[N], nex[N], value[N], cnt;

int n, m, s, t, dis[N], vis[N], flow[N], pre[N];

void Add(int x, int y, int w, int c) {
    to[cnt] = y;
    nex[cnt] = head[x];
    value[cnt] = w;
    cap[cnt] = c;
    head[x] = cnt++;
}

void add(int x, int y, int w, int c) {
    Add(x, y, w, c);
    Add(y, x, -w, 0);
}

bool spfa() {
    queue<int> q;
    memset(dis, 0x3f, sizeof dis);
    memset(vis, 0, sizeof vis);
    q.push(s), dis[s] = 0, vis[s] = 1;
    flow[s] = 1 << 30;
    while(q.size()) {
        int rt = q.front();
        q.pop(), vis[rt] = 0;
        for(int i = head[rt]; ~i; i = nex[i]) {
            if(cap[i] && dis[to[i]] > dis[rt] + value[i]) {
                dis[to[i]] = dis[rt] + value[i];
                flow[to[i]] = min(flow[rt], cap[i]);
                pre[to[i]] = i;
                if(!vis[to[i]]) {
                    vis[to[i]] = 1;
                    q.push(to[i]);
                }
            }
        }
    }
    return dis[t] != 0x3f3f3f3f;
}

pii Mcmf() {
    int res = 0, ans = 0;
    while(spfa()) {
        int cur = flow[t];
        res += cur, ans += dis[t] * cur;
        int now = t;
        while(now != s) {
            cap[pre[now]] -= cur;
            cap[pre[now] ^ 1] += cur;
            now = to[pre[now] ^ 1];
        }
    }
    return make_pair(res, ans);
}

const int N1 = 110;

int x[N1][N1];

int main() {
    // freopen("in.txt", "r", stdin);
    // freopen("out.txt", "w", stdout);
    // ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= n; j++) {
            scanf("%d", &x[i][j]);       
        }
    }
    s = 0, t = n + n + 1;
    memset(head, -1, sizeof head), cnt = 0;
    for(int i = 1; i <= n; i++) {
        add(s, i, 0, 1);
    }
    for(int i = 1; i <= n; i++) {
        add(i + n, t, 0, 1);
    }
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= n; j++) {
            add(i, j + n, x[i][j], 1);
        }
    }
    printf("%d\n", Mcmf().second);
    memset(head, -1, sizeof head), cnt = 0;
    for(int i = 1; i <= n; i++) {
        add(s, i, 0, 1);
    }
    for(int i = 1; i <= n; i++) {
        add(i + n, t, 0, 1);
    }
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= n; j++) {
            add(i, j + n, -x[i][j], 1);
        }
    }
    printf("%d\n", -Mcmf().second);
    return 0;
}
脑科学磁共振成像（MRI)初学者必看——功能脑网络、小世界网络、FDR校正、脑电信号频率变换、模板、假设检验、广义线性模型、独立成分分析、影像组学、任务态和静息态方法汇总
从事脑科学核磁共振方法学研究，在Nature communications等权威期刊发表研究论文，熟练掌握磁共振处理方法和统计学方法，欢迎大家和我交流。
04-17 2万+
磁共振成像初学者必看一、浅谈功能脑网络二、不同模态脑网络的构建功能脑网络结构脑网络白质纤维束脑网络加权网络二值网络三、趣谈散点图与相关系数四、脑电信号频域变换五、fMRI中的FDR校正六、模板（mask）1、模板(mask )往往是与ROI联系在一起的2、mask作用的原理3、常见的mask七、假设检验和效果量八、组水平标准化九、由 ALFF 说开去十、计算机存取MRI影像的那些事十二、Linux基础命令十三、浅谈标准空间模板和空间变换一：标准空间模板二：空间变换十四 、 功能连接十五、大脑激活与功能连接的
深入浅出区块链
GitChat
04-12 3919
内容简介 2017年，是区块链爆发又冷静的一年。 如果你持续关注过区块链技术，这一年可能已经对没完没了的概念介绍、前景描绘、行业探讨和链圈新闻产生了审美疲劳。没错，区块链必须与行业紧密结合，它也有颠覆人类协作方式之洪荒巨力，但是说到底它还是一个技术活，是要写代码的，在咖啡厅里整天坐而论道是造不出金链子来的。 本期我们梳理了2017年区块链发展现状，从关键技术原理与实际应用出发，带你深入浅出探索区块...
线性规划与网络流24题
08-07
线性规划与网络流24题，含题解以及数据..及C源码，要PASCAL源码另外来找我。
【线性规划和网络流24题】
weixin_30578677的博客
05-08 116
（1）飞行员配对方案问题：二分图最大匹配。 思路：略。 View Code 1 #include<cstdio> 2 #include<cstring> 3 #define MAXN 1010 4 int cx[MAXN], cy[MAXN]; 5 int first[MAXN], next[MAXN], v[MAXN], e; 6 boo...
[网络流24题 #5]圆桌问题
doveccl
01-23 678
又是一道多解的题 【问题分析】 二分图多重匹配问题，可以用最大流解决。 【建模方法】 建立二分图，每个单位为X集合中的顶点，每个餐桌为Y集合中的顶点，增设附加源S和汇T。 1、从S向每个Xi顶点连接一条容量为该单位人数的有向边。 2、从每个Yi顶点向T连接一条容量为该餐桌容量的有向边。 3、X集合中每个顶点向Y集合中每个顶点连接一条容量为1的有向边。 求网络最大
汤姆·齐格弗里德《纳什均衡与博弈论》笔记（3）博弈论与生物学
最新发布
feiyu66666的博客
01-21 1465
作为概率论的拓展材料来阅读吧~
《TensorFlow2.0》一、机器学习和深度学习简介及基础编程 part 1
Tian121381的博客
03-24 436
Python版本： Python3.x 运行平台： Windows 参考资料：吴恩达 IDE： jupyter 转载请标明出处：https://blog.csdn.net/tian121381/category_9748511.html 目录一、前言二、相当于Hello World的神经网络编辑定义神经网络优化器和代价函数定义提供数据训练神经网络课后小练习三、 较复杂的神经网络数据处理模型构建预...
记2018年北航夏令营+机试面试心得体会
热门推荐
记录每一次小小的进步
07-18 2万+
个人情况见上一篇博客 去火车站路上才看北京的天气预报，这就导致我又特么得买一把伞，这次回去我的伞足够整个宿舍用了…… 北航这次夏令营总共申请了1355人，初审不需要网上报名，只能邮寄材料，每两天公布一次收到资料名单。截止后官网公告说7.6日公布初审通过名单，也就是入营名单。 当时因为我已经有了上交软件的夏令营入营资格，也不算特别慌，所以说一定得多做准备，觉得自己弱就不敢报真的是会错失很多...
线性规划与网络流24题 题解及部分代码以及小结
Bfk的博客
02-11 711
1.飞行员配对方案问题 最大匹配 2 太空飞行计划问题 之前写的详细题解 最大权闭合子图-&gt;最小割 #include&lt;cstdio&gt; #include&lt;iostream&gt; #include&lt;cstring&gt; #include&lt;algorithm&gt; #include&lt;queue&gt; using namespac...
解题报告：线性规划与网络流24题
繁凡さん的博客
07-31 2243
目录A.luogu P2756 飞行员配对方案问题 【提高+/省选- 】B.luoguP2762 太空飞行计划问题【省选/NOI- 】 *【题解】网络流24题 24/24 线性规划与网络流24题 解题报告 [线性规划与网络流24题] 网络流常见模型 问题编号 问题名称 问题模型 转化模型 1 飞行员配对方案问题 二分图最大匹配 网络最大流 2 太空飞行计划问题 最大权闭合图 网络最小割 3 最小路径覆盖问题 有向无环图最小路径覆盖 网络最大流 4 魔术球问题 有向无环图最小路径
旅游路线问题 线性规划网络流
高万禄的博客
05-05 516
旅游路线问题 #include <iostream>在这里插入图片描述 #include <cstring> #include <map> #include <queue> using namespace std; using std::cout; const int INF = 1000000; //正无穷 const int NODESIZE = 100; //结点最大个数 const int EDGESIZE = 10000; //最大边数
【线性规划与网络流24题 20】深海机器人问题
ACdream
09-20 867
机器人问题 这个题很明显跟费用有关，每个机器人可以看作是最大的通过的流量 源点S，汇点T，图中的任何一个点都是中间点，这些都好理解 那么，费用怎么理解？ 求最大费用最大流啊！ 不仅仅有拆点，还会有拆边！ 每两个点的路径分成两条边啊：有一种边是容量为1，费用为边上的价值：（u，v，1，value）；有一种边是容量是无限的，费用为0，（u，v，INF，0） 然后跑模板就好了啊
最大收益问题 线性规划网络流
高万禄的博客
05-05 428
最大收益问题 一批实验 E={E1,E2…} 需要仪器集合 I={I1,I2,I3…} 进行Ei可盈利 pi 购入仪器Ii要花费ci 进行实验可盈利一定金额 没买一种仪器也要花费一定金额 怎样选实验 使得盈利最大? 实验净收益=选中实验项目收益 - 选中的仪器费用 选中实验项目收益=全部项目收益 - 未选中的项目收益 实验净收益= 全部项目收益 - (未选中的项目收益+选中的仪器费用) 切割线将图分为两部分 S T, S :选中的实验项目与仪器 T:未选中的实验项目与仪器 未选中的项目收益+选中的仪器费用
线性规划与网络流
ZCC的专栏
01-02 3940
一.线性规划问题及其表示 例如: 二.最大网络流问题    （1） 网络   G是一个简单有向图，G=(V,E)，V={1，2，…，n}。   在V中指定一个顶点s，称为源和另一个顶点t，称为汇。   有向图G的每一条边(v,w)∈E，对应有一个值cap(v,w)≥0，称为边的容量。   这样的有向图G称作一个网络。 （2） 网络流
【线性规划与网络流24题 19】负载平衡问题
ACdream
09-20 987
Description G公司有n个沿铁路运输线环形排列的仓库，每个仓库存储的货物数量不等。如何用最少搬运量可以使n个仓库的库存数量相同。 搬运货物时，只能在相邻的仓库之间搬运。 对于给定的n个环形排列的仓库的库存量，编程计算使n个仓库的库存数量相同的最少搬运量。 Input 第1行中有1个正整数n（n Output 一个整数，表示最少搬运量 Sample Input 5 17
【算法概论】线性规划与规约：网络流
t11383的博客
05-23 1275
最大流和最小割 问题描述： 网络流：一个连通的赋权有向图 G = (V、E、C)，其中 V 是该图的顶点集，E 是有向边(即弧)集，C 是弧上的容量。此外顶点集中包括一个起点和一个终点。网络上的流就是由起点流向终点的可行流，它有两个性质：① 每条边的流量不超过它的容量；② 除 s 和 t 的任意结点，流入 u 的流量等于流出 u 的流量。 最大流问题：找到从 s...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值