数字梯形问题

本题就是从上到下按三种规则取数，使取出的那些数的和最大。

其实就可以看成是一个图，选择一些路径，使选择的路径的权值之和最大，即使图的最大权不相交路径，另外两种规则就是它的变种。

这种题可以用费用流处理，就是建图之后跑最大费用最大流（最大费用最大流就是在最小费用最小流算法加边时，给负权值，最后求出的就是最大费用最大流）。

三种规则就分三种方法建图：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <vector>
#include <queue>

#define M 1010011
#define INF 0x7fffffff/3
#define ST 2001
#define ED 2002

using namespace std;

int n,m;
int num=0;
int ans=0;

int p[M];
struct node
{
    int a;
    int b;
    int w;
    int f;
    int next;
}str1[M];

int cost[M],flag[M],pre[M];
int q[4*M];
int fmap[101][101];

void add(int x,int y,int z,int fl)
{
    str1[num].a=x;
    str1[num].b=y;
    str1[num].w=z;
    str1[num].f=fl;
    str1[num].next=p[x];
    p[x]=num++;

    swap(x,y);

    str1[num].a=x;
    str1[num].b=y;
    str1[num].w=-z;
    str1[num].f=0;
    str1[num].next=p[x];
    p[x]=num++;
}

bool spfa(int src)
{
    memset(flag,0,sizeof(flag));
    for(int i=0;i<=ED;i++)
        cost[i]=INF;
    int l=0,r=0;
    cost[src]=0;
    pre[src]=-1;
    flag[src]=1;
    q[r++]=src;
    while(l<r)
    {
        int k=q[l++];
        flag[k]=0;
        for(int i=p[k];i!=-1;i=str1[i].next)
        {
            int v=str1[i].b;
            if(cost[v]>cost[k]+str1[i].w&&str1[i].f>0)
            {
                cost[v]=cost[k]+str1[i].w;
                pre[v]=i;
                if(!flag[v])
                {
                    flag[v]=1;
                    q[r++]=v;
                }
            }
        }
    }
    if(cost[ED]==INF)
        return false;
    return true;
}

void start()
{
    int minx=INF;
    for(int i=pre[ED];i!=-1;i=pre[str1[i^1].b])
        minx=min(minx,str1[i].f);
    for(int i=pre[ED];i!=-1;i=pre[str1[i^1].b])
    {
        str1[i].f-=minx;
        str1[i^1].f+=minx;
    }
    ans+=cost[ED]*minx;
}

int spfaflow()
{
    ans=0;
    while(spfa(ST))
        start();
    return ans;
}

void init()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        for(int j=1;j<=n+i-1;j++)
        {
            int x;
            scanf("%d",&x);
            fmap[i][j]=x;
        }
    }
}

int change(int x,int y)
{
    return (x-1)*(n+n+x-2)/2+y;
}

int change1(int x,int y)
{
    return 2*change(x,y)-1;
}

void start1()
{
    num=0;
    memset(p,-1,sizeof(p));
    for(int i=1;i<=n;i++)
        add(ST,change1(1,i),0,1);
    for(int i=1;i<=n+m-1;i++)
        add(change1(m,i)+1,ED,0,1);
    for(int i=1;i<=m;i++)
    for(int j=1;j<=n+i-1;j++)
        add(change1(i,j),change1(i,j)+1,-fmap[i][j],1);
    for(int i=1;i<=m-1;i++)
    {
        for(int j=1;j<=n+i-1;j++)
        {
            add(change1(i,j)+1,change1(i+1,j),0,1);
            add(change1(i,j)+1,change1(i+1,j+1),0,1);
        }
    }
    spfaflow();
    printf("%d\n",-ans);
}

void start2()
{
    num=0;
    memset(p,-1,sizeof(p));
    for(int i=1;i<=n;i++)
        add(ST,change(1,i),-fmap[1][i],1);
    for(int i=1;i<=n+m-1;i++)
        add(change(m,i),ED,0,INF);
    for(int i=1;i<=m-1;i++)
    {
        for(int j=1;j<=n+i-1;j++)
        {
            add(change(i,j),change(i+1,j),-fmap[i+1][j],1);
            add(change(i,j),change(i+1,j+1),-fmap[i+1][j+1],1);
        }
    }
    spfaflow();
    printf("%d\n",-ans);
}

void start3()
{
    num=0;
    memset(p,-1,sizeof(p));
    for(int i=1;i<=n;i++)
        add(ST,change(1,i),-fmap[1][i],1);
    for(int i=1;i<=n+m-1;i++)
        add(change(m,i),ED,0,INF);
    for(int i=1;i<=m-1;i++)
    {
        for(int j=1;j<=n+i-1;j++)
        {
            add(change(i,j),change(i+1,j),-fmap[i+1][j],INF);
            add(change(i,j),change(i+1,j+1),-fmap[i+1][j+1],INF);
        }
    }
    spfaflow();
    printf("%d\n",-ans);
}

int main()
{
    freopen("t16.in","r",stdin);
    freopen("t16.out","w",stdout);
    init();
    start1();
    start2();
    start3();

    return 0;
}

规则一因为每个只能被选一次，所以就把没个点分成x，y两个点，之间连权值为0，流量为1的边，再由ST向顶排的x点连边，末排的y向ED连边，再把每个点向下的两个点连边，最后跑最大费用最大流就行啦。

剩下两种情况简单些。

规则二不用拆点，点点之间流量为一。

规则三不用拆点，点点之间流量为无穷大。

代码如下：