Libre 6010「网络流 24 题」数字梯形 （网络流，最大费用最大流）

Libre 6010「网络流 24 题」数字梯形 （网络流，最大费用最大流）

Description

给定一个由n 行数字组成的数字梯形如下图所示。梯形的第一行有m 个数字。从梯形的顶部的m 个数字开始，在每个数字处可以沿左下或右下方向移动，形成一条从梯形的顶至底的路径。

规则1：从梯形的顶至底的m条路径互不相交。

规则2：从梯形的顶至底的m条路径仅在数字结点处相交。

规则3：从梯形的顶至底的m条路径允许在数字结点相交或边相交。

对于给定的数字梯形，分别按照规则1，规则2，和规则3 计算出从梯形的顶至底的m条路径，使这m条路径经过的数字总和最大。

Input

第1 行中有2个正整数m和n（m,n<=20），分别表示数字梯形的第一行有m个数字，共有n 行。

接下来的n 行是数字梯形中各行的数字。第1 行有m个数字，第2 行有m+1 个数字

Output

将按照规则1，规则2，和规则3 计算出的最大数字总和输出，每行一个最大总和。

Sample Input

2 5

2 3

3 4 5

9 10 9 1

1 1 10 1 1

1 1 10 12 1 1

Sample Output

66

75

77

Http

Libre:https://loj.ac/problem/6010

Source

网络流，最大费用最大流

解决思路

三种规则大体上是差不多的，我们分开来看。

对于规则一，因为要求不能有点走两次，所以我们把点拆成两个，两个之间连容量为1，花费为该点权值的边，而因为一个点可以走到下面的点和右下的点，所以也分别连容量为1但花费为0的边。同时，建立一个汇点一个源点，源点连到第一行的m个数，容量为1花费为0的边，汇点连到最后一行的n+m-1个点，同样也是容量为1花费为0的边。

然后跑一遍最大费用最大流即可。

对于规则二，由于可以允许点走多次，所以我们有两种处理方法，一是把上面规则一中的图里连接两个拆开的点的边的容量改为无穷大，另一种方法是直接不拆点。

对于规则三，由于边和点都可以走多次，所以可以把所有边（除从源点出发连向第一行的边）的容量均改为无穷大。

需要注意的是，不管怎么改，从源点出发的边容量一定为1，因为要保证只能走m次。

代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
using namespace std;

const int maxN=800;
const int maxM=maxN*maxN*2;
const int inf=2147483647;

class Edge
{
public:
    int u,v,cost,flow;
};

int n,m;
int nodesum=0;
int cnt=-1;
int Arr[maxN][maxN];
int Map[maxN][maxN];
int Head[maxN];
int Next[maxM];
Edge E[maxM];
int Dist[maxN];
bool inqueue[maxN];
int Path[maxN];
int Flow[maxN];
int Queue[maxM];

void Add_Edge(int u,int v,int cost,int flow);
bool spfa();

int main()
{
    scanf("%d%d",&m,&n);
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m+i-1;j++)
        {
            scanf("%d",&Arr[i][j]);
            nodesum++;//nodesum用来统计总的数的数量
            Map[i][j]=nodesum;//Map用来标记第i行j个数对应的编号是多少，方便后面拆点，对于编号为i的点，我们将其拆成i和i+nodesum两个点。另建立源点0和汇点nodesum*2+1
        }
    //Q1第一问
    cnt=-1;
    memset(Head,-1,sizeof(Head));
    for (int i=1;i<=m;i++)
        Add_Edge(0,i,0,1);//连接源点与第一行
    for (int i=1;i<=n;i++)
        for (int j=1;j<=i+m-1;j++)
        {
            Add_Edge(Map[i][j],Map[i][j]+nodesum,Arr[i][j],1);//连接拆开的两点
            if (i!=n)//连接下面和右下，注意要判断不在最后一行才行
            {
                Add_Edge(Map[i][j]+nodesum,Map[i+1][j],0,1);
                Add_Edge(Map[i][j]+nodesum,Map[i+1][j+1],0,1);
            }
        }
    for (int i=1;i<=m+n-1;i++)//连接最后一行与汇点
        Add_Edge(Map[n][i]+nodesum,nodesum*2+1,0,1);
    int Ans=0;
    while (spfa())//spfa求最大费用最大流
    {
        int now=nodesum*2+1;
        int last=Path[now];
        int nowflow=Flow[nodesum*2+1];
        while(now!=0)
        {
            E[last].flow-=nowflow;
            E[last^1].flow+=nowflow;
            now=E[last].u;
            last=Path[now];
        }
        Ans+=Flow[nodesum*2+1]*Dist[nodesum*2+1];
    }
    cout<<Ans<<endl;
    //Q2第二问
    cnt=-1;
    memset(Head,-1,sizeof(Head));
    for (int i=1;i<=m;i++)//连接源点与第一行
        Add_Edge(0,i,0,1);
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m+i-1;j++)
        {
            Add_Edge(Map[i][j],Map[i][j]+nodesum,Arr[i][j],inf);//连接拆点后的两点，注意此时流量为无穷大
            if (i!=n)
            {
                Add_Edge(Map[i][j]+nodesum,Map[i+1][j],0,1);//连接下面和右下
                Add_Edge(Map[i][j]+nodesum,Map[i+1][j+1],0,1);
            }
        }
    for (int i=1;i<=n+m-1;i++)//连接最后一行与汇点，注意这里也是容量无穷大，因为有的路径可以在同一点结束
        Add_Edge(Map[n][i]+nodesum,nodesum*2+1,0,inf);
    Ans=0;
    while (spfa())//求解最大费用最大流
    {
        int now=nodesum*2+1;
        int last=Path[now];
        int nowflow=Flow[nodesum*2+1];
        while (now!=0)
        {
            E[last].flow-=nowflow;
            E[last^1].flow+=nowflow;
            now=E[last].u;
            last=Path[now];
        }
        Ans+=nowflow*Dist[nodesum*2+1];
    }
    cout<<Ans<<endl;
    //Q3第三问
    memset(Head,-1,sizeof(Head));
    cnt=-1;
    for (int i=1;i<=m;i++)
        Add_Edge(0,i,0,1);//连接源点与第一行，注意这里的容量还是为1
    for (int i=1;i<=n;i++)
        for (int j=1;j<=m+i-1;j++)
        {
            Add_Edge(Map[i][j],Map[i][j]+nodesum,Arr[i][j],inf);//同上面的连边，但容量均为无穷大
            if (i!=n)
            {
                Add_Edge(Map[i][j]+nodesum,Map[i+1][j],0,inf);
                Add_Edge(Map[i][j]+nodesum,Map[i+1][j+1],0,inf);
            }
        }
    for (int i=1;i<=n+m-1;i++)
        Add_Edge(Map[n][i]+nodesum,nodesum*2+1,0,inf);
    Ans=0;//求解最大费用最大流
    while (spfa())
    {
        int now=nodesum*2+1;
        int last=Path[now];
        int nowflow=Flow[nodesum*2+1];
        while (now!=0)
        {
            E[last].flow-=nowflow;
            E[last^1].flow+=nowflow;
            now=E[last].u;
            last=Path[now];
        }
        Ans+=nowflow*Dist[nodesum*2+1];
    }
    cout<<Ans<<endl;
    return 0;
}

void Add_Edge(int u,int v,int cost,int flow)
{
    cnt++;
    Next[cnt]=Head[u];
    Head[u]=cnt;
    E[cnt].u=u;
    E[cnt].v=v;
    E[cnt].cost=cost;
    E[cnt].flow=flow;

    cnt++;//加反边
    Next[cnt]=Head[v];
    Head[v]=cnt;
    E[cnt].u=v;
    E[cnt].v=u;
    E[cnt].cost=-cost;
    E[cnt].flow=0;
}

bool spfa()
{
    for (int i=0;i<=2*nodesum+1;i++)
        Dist[i]=-inf;
    memset(inqueue,0,sizeof(inqueue));
    int h=1,t=0;
    Queue[1]=0;
    inqueue[0]=1;
    Dist[0]=0;
    Flow[0]=inf;
    do
    {
        t++;
        int u=Queue[t];
        //cout<<Dist[u]<<endl;
        for (int i=Head[u];i!=-1;i=Next[i])
        {
            int v=E[i].v;
            //cout<<u<<"->"<<v<<endl;
            //cout<<Dist[u]+E[i].cost<<" "<<Dist[v]<<endl;
            //system("pause");
            if ((E[i].flow>0)&&(Dist[u]+E[i].cost>Dist[v]))
            {
                //cout<<"Modefy!"<<endl;
                Dist[v]=E[i].cost+Dist[u];
                Path[v]=i;
                Flow[v]=min(Flow[u],E[i].flow);
                if (inqueue[v]==0)
                {
                    h++;
                    Queue[h]=v;
                    inqueue[v]=1;
                }
            }
        }
        inqueue[u]=0;
    }
    while(t<h);
    if (Dist[nodesum*2+1]==-inf)
        return 0;
    return 1;
}