#6010. 「网络流 24 题」数字梯形 最大费用最大流 建图

题目链接
题意

分别求三个规则满足条件的所有路径最大和。
思路
网络流问题最重要的是建图问题。
1.路径互不相交，也就是一个数字只能用一次，那就是拆点了，每个点拆分为入点和出点，入点和出点之间连一条容量为1费用为权值的边；建立一个源点和一个汇点，源点与第一行的入点相连，容量为1费用为0，最后一行的出点与汇点相连，容量为1费用为0，除最后一行外，每个点的出点向它的正下方和右下方的入点连一条容量为1费用为0的边。然后跑最大费用最大流。
2.数字节点可以相交，那就把每个节点的入点连出点的边容量改为INF，费用不变，就可以取消点只能取一次的限制了，还有最后一行的出点与汇点连容量为INF费用为0的边，然后也是直接跑最大费用最大流。
3.边和点都可以相交，那就是取消点与点之间的限制，在第二问的建边的基础上把第一问中的每个点的出点与它正下方和右下方的入点的容量改为INF，费用还是为0。

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;
const int N = 5e3 + 7;
const int M = 1e4 + 7;
typedef long long ll;
int maxflow, maxcost;
struct Edge {
    int from, to, cap, flow, cost;
    Edge(int u, int v, int ca, int f, int co):from(u), to(v), cap(ca), flow(f), cost(co){};
};
struct MCMF
{
    int n, m, s, t;
    vector<Edge> edges;
    vector<int> G[N];
    int inq[N], d[N], p[N], a[N];//是否在队列 距离 上一条弧 可改进量
    void init(int n) {
        this->n = n;
        for (int i = 0; i < n; i++) G[i].clear();
        edges.clear();
    }
    void add(int from, int to, int cap, int cost) {
        edges.push_back(Edge(from, to, cap, 0, cost));
        edges.push_back(Edge(to, from, 0, 0, -cost));
        int m = edges.size();
        G[from].push_back(m - 2);
        G[to].push_back(m - 1);
    }
    bool SPFA(int s, int t, int &flow, int &cost) {
        for (int i = 0; i < N; i++) d[i] = -INF;
        memset(inq, 0, sizeof(inq));
        d[s] = 0; inq[s] = 1; p[s] = 0; a[s] = INF;
        queue<int> que;
        que.push(s);
        while (!que.empty()) {
            int u = que.front();
            que.pop();
            inq[u]--;
            for (int i = 0; i < G[u].size(); i++) {
                Edge& e = edges[G[u][i]];
                if(e.cap > e.flow && d[e.to] < d[u] + e.cost) {
                    d[e.to] = d[u] + e.cost;
                    p[e.to] = G[u][i];
                    a[e.to] = min(a[u], e.cap - e.flow);
                    if(!inq[e.to]) {
                        inq[e.to]++;
                        que.push(e.to);
                    }
                }
            }
        }
        if(d[t] == -INF) return false;
        flow += a[t];
        cost += d[t] * a[t];
        int u = t;
        while (u != s) {
            edges[p[u]].flow += a[t];
            edges[p[u]^1].flow -= a[t];
            u = edges[p[u]].from;
        }
        return true;
    }
    int MaxMaxflow(int s, int t) {
        int flow = 0, cost = 0;
        while (SPFA(s, t, flow, cost));
        maxflow = flow; maxcost = cost;
        return cost;
    }
};
int id[50][50], val[50][50];
int main()
{
    int m, n, s, t, tmp;
    MCMF solve;
    scanf("%d%d", &m, &n);
    s = 0; tmp = n * (2 * m + n - 1) / 2; t = tmp * 2 + 1;
    int tot = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m + i - 1; j++) {
            id[i][j] = ++tot;
            scanf("%d", &val[i][j]);
        }
    }
    //1
    for (int i = 1; i <= m; i++) solve.add(s, i, 1, 0);
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m + i - 1; j++) {
            solve.add(id[i][j], id[i][j] + tmp, 1, val[i][j]);
            if(i != n) {
                solve.add(id[i][j] + tmp, id[i + 1][j], 1, 0);
                solve.add(id[i][j] + tmp, id[i + 1][j + 1], 1, 0);
            }
            if(i == n) {
                solve.add(id[i][j] + tmp, t, 1, 0);
            }
        }
    }
    solve.MaxMaxflow(s, t);
    printf("%d\n", maxcost);
    //2
    solve.init(N);
    for (int i = 1; i <= m; i++) solve.add(s, i, 1, 0);
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m + i - 1; j++) {
            solve.add(id[i][j], id[i][j] + tmp, INF, val[i][j]);
            if(i != n) {
                solve.add(id[i][j] + tmp, id[i + 1][j], 1, 0);
                solve.add(id[i][j] + tmp, id[i + 1][j + 1], 1, 0);
            }
            if(i == n) {
                solve.add(id[i][j] + tmp, t, INF, 0);
            }
        }
    }
    solve.MaxMaxflow(s, t);
    printf("%d\n", maxcost);
    //3
    solve.init(N);
    for (int i = 1; i <= m; i++) solve.add(s, i, 1, 0);
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m + i - 1; j++) {
            solve.add(id[i][j], id[i][j] + tmp, INF, val[i][j]);
            if(i != n) {
                solve.add(id[i][j] + tmp, id[i + 1][j], INF, 0);
                solve.add(id[i][j] + tmp, id[i + 1][j + 1], INF, 0);
            }
            if(i == n) {
                solve.add(id[i][j] + tmp, t, INF, 0);
            }
        }
    }
    solve.MaxMaxflow(s, t);
    printf("%d\n", maxcost);
}