wiki 1913 数字梯形问题

这是一道很经典的费用流题目，可以通过最大费用最大流实现
通过分析题目，我们很容易想到建模方法：

1、对于规则一，题目规定每一个节点只能访问一次，也就是说，实际上这个时候每一个点都有容量限制，所以我们必须把点i拆分成两个点Xi,Yi。此时每一条边的容量都是1，费用为改点的权值，此时只允许使用该节点一次，并且代价为权值。数字梯形是逐层向下的，并且每一个点可以向下面两个方向进行扩展，于是我们在这些点之间建立容量为1，费用为0的边。对于最顶层与最底层，我们分让两层分别与源点和汇点相连，容量同样是1，费用为0。（注意所有的边都是有向边，并且结点i与j相连是指Yi与Xj相连）

2、对于规则二，由于可以共点，所以就不用拆点了，源点与上层继续保持容量为1，其他的关联除了不用拆点外，其他都差不多，注意一下底层与汇点的容量限制改为无穷大即可。

3、对于规则三，由于边和节点都可以共用，此时没有必要把原网络销毁，直接在上一个规则的前提下修改每一条边的容量即可（注意源点与顶层节点之间的容量是不能变的，否则就无法满足是m条路径取得的最大值，其他边的容量改成无穷大即可）

上面是我摘录的别人的题解，我的代码跟这个题解思路完全一致，我的AC代码

#include<cstdio>
#include<cstring>
#include<iostream>
#include<iomanip>
#include<queue>
#include<cmath>
#include<stack>
#include<map>
#include<vector>
#include<set>
#include<algorithm>

using namespace std;
const int INF = 1<<30;
const int maxN = 2000;
int m,n,s,t,result;
int mymap[50][50];
struct Edge{
    int from, to, cap, flow, cost;
};
vector<Edge> es;
vector<int> g[maxN];
int pos[50][50][2];
int dir[2][2] = {1,0,1,1};
void addedge (int from, int to, int cap, int cost){
    es.push_back(Edge{from, to, cap, 0, cost});
    es.push_back(Edge{to, from, 0, 0, -cost});
    int u = es.size();
    g[from].push_back(u-2);
    g[to].push_back(u-1);
}
void init(){
    cin >> m >> n;
    memset(mymap, -1, sizeof(mymap));
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m+i; j++){
            cin >> mymap[i][j];
        }
    }
}
void make1(){
    memset(pos, -1, sizeof(pos));
    int sz = 0;
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m+i; j++){
            pos[i][j][0] = sz++;
            pos[i][j][1] = sz++;
        }
    }
    s = sz++;
    t = sz++;
    for(int i = 0; i < m; i++) addedge(s, pos[0][i][0], 1, 0);
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m+i; j++){
            addedge(pos[i][j][0], pos[i][j][1], 1, -mymap[i][j]);
            for(int u = 0; u < 2; u++){
                int x = i + dir[u][0];
                int y = j + dir[u][1];
                if(x < n){
                    addedge(pos[i][j][1], pos[x][y][0], 1, 0);
                }
            }
        }
    }
    for(int i = 0; i < m+n-1; i++){
        addedge(pos[n-1][i][1], t, 1, 0);
    }
}
void solve (){
    int a[maxN],d[maxN],p[maxN],inq[maxN];
    memset(a, 0, sizeof(a));
    a[s] = INF;
    while(true){
        for(int i = 0; i < maxN; i++) d[i] = INF;
        d[s] = 0;
        memset(inq, 0, sizeof(inq));
        queue<int> q;
        q.push(s);
        inq[s] = 1;
        while(!q.empty()){
            int u = q.front();
            q.pop();
            inq[u] = 0;
            for(int i = 0; i < g[u].size(); i++){
                Edge& e = es[g[u][i]];
                if(e.cap>e.flow && d[e.to] > d[e.from]+e.cost){
                    a[e.to] = (a[e.from] > e.cap-e.flow ? e.cap-e.flow : a[e.from]);
                    d[e.to] = d[e.from] + e.cost;
                    p[e.to] = g[u][i];
                    if(!inq[e.to]) {q.push(e.to); inq[e.to] = 1;}
                }
            }
        }
        if(d[t]==INF) break;
        result += -(d[t]*a[t]);
        int u = t;
        while(u!=s){
            es[p[u]].flow += a[t];
            es[p[u]^1].flow -= a[t];
            u = es[p[u]].from;
        }
    }
}
void make2(){
    memset(pos, -1, sizeof(pos));
    int sz = 0;
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m+i; j++){
            pos[i][j][0] = sz++;
        }
    }
    s = sz++;
    t = sz++;
    for(int i = 0; i < m; i++) addedge(s, pos[0][i][0], 1, -mymap[0][i]);
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m+i; j++){
            for(int u = 0; u < 2; u++){
                int x = i + dir[u][0];
                int y = j + dir[u][1];
                if(x < n){
                    addedge(pos[i][j][0], pos[x][y][0], 1, -mymap[x][y]);
                }
            }
        }
    }
    for(int i = 0; i < m+n-1; i++){
        addedge(pos[n-1][i][0], t, INF, 0);
    }
}
void make3 (){
    memset(pos, -1, sizeof(pos));
    int sz = 0;
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m+i; j++){
            pos[i][j][0] = sz++;
        }
    }
    s = sz++;
    t = sz++;
    for(int i = 0; i < m; i++) addedge(s, pos[0][i][0], 1, -mymap[0][i]);
    for(int i = 0; i < n; i++){
        for(int j = 0; j < m+i; j++){
            for(int u = 0; u < 2; u++){
                int x = i + dir[u][0];
                int y = j + dir[u][1];
                if(x < n){
                    addedge(pos[i][j][0], pos[x][y][0], INF, -mymap[x][y]);
                }
            }
        }
    }
    for(int i = 0; i < m+n-1; i++){
        addedge(pos[n-1][i][0], t, INF, 0);
    }
}
int main(int argc, const char * argv[])
{
    init();
    es.clear();
    for(int i = 0; i < maxN; i++) g[i].clear();
    make1();
    solve();
    cout << result << endl;
    
    es.clear();
    for(int i = 0; i < maxN; i++) g[i].clear();
    result = 0;
    make2();
    solve();
    cout << result << endl;
    
    es.clear();
    for(int i = 0; i < maxN; i++) g[i].clear();
    result = 0;
    make3();
    solve();
    cout << result << endl;
}