动态规划快速入门 之 经典的数塔问题

数塔问题练习网址 戳这<<<

题目要求

题意

给定一个具有 N 层的数字三角形，从顶至底有多条路径，每一步可沿左斜线向下或沿右斜线向下，路径所经过的数字之和为路径得分，请求出最大路径得分。

输入

1
5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5

输出

30

状态设计

• 显然满足重叠子问题和最优子结构性质。
• 递推公式：DP(X,Y) ＝ max(DP(X+1,Y)，DP(X+1,Y+1))+DP(X,Y)。

递推型动态规划

对于递推型分析，我们从倒数第二行开始
现分析数字2，2可以和最后一行4相加，也可以和最后一行的5相加，但是很显然和5相加要更大一点，结果为7，我们此时就可以将7覆盖掉倒数二行原来数字2的位置，因为从2往下，这个点值最大，然后分析数字7，7可以和最后一行的5相加，也可以和最后一行的2相加，很显然和5相加更大，结果为12，因此我们将12保存起来。以此类推。。我们可以得到下面这张图：

最后只要输出最顶端的30即为答案。

#include <cstdio>
#include <iostream>
using namespace std;

typedef long long LL;

int dp[105][105];
int main()
{
    int T;
    scanf("%d",&T);
    for(int cas=1;cas<=T;++cas){
        int n;
        scanf("%d",&n);
        for(int i=1;i<=n;i++){
            for(int j=1;j<=i;j++){
                scanf("%d",&dp[i][j]);
            }
        }
        for(int i=n-1;i>=1;i--){
            for(int j=1;j<=i;j++){
                dp[i][j]+=max(dp[i+1][j],dp[i+1][j+1]);
            }
        }
        printf("%d\n",dp[1][1]);
    }
    return 0;
}

递归型动态规划

对于递归的深度遍历，我们会经历很多重复的步骤，这时候我们要剪枝，也就是定义一个数组dp[][]，如果dp[x][y]不等于-1，我们就认为此时的dp[x][y]是这个位置及其以下最大点值。

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

typedef long long LL;

int dp[105][105],a[105][105];
int n;
int cal(int x,int y)
{
    if(dp[x][y]!=-1) return dp[x][y];
    if(x==n) dp[x][y]=a[x][y];
    else dp[x][y]=a[x][y]+max(cal(x+1,y),cal(x+1,y+1));
    return dp[x][y];

}
int main()
{
    int T;
    scanf("%d",&T);
    for(int cas=1;cas<=T;++cas){
        scanf("%d",&n);
        memset(dp,0xff,sizeof(dp));
        for(int i=1;i<=n;i++){
            for(int j=1;j<=i;j++){
                scanf("%d",&a[i][j]);
            }
        }
        printf("%d\n",cal(1,1));
    }
    return 0;
}

问题拓展 - 最优路径的输出

递推型动态输出 - 计算时存储路径

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

typedef long long LL;

int dp[105][105],path[105][105];
int main()
{
    int T;
    scanf("%d",&T);
    for(int cas=1;cas<=T;++cas){
        int n;
        scanf("%d",&n);
        for(int i=1;i<=n;i++){
            for(int j=1;j<=i;j++){
                scanf("%d",&dp[i][j]);
            }
        }
        for(int i=n-1;i>=1;i--){
            for(int j=1;j<=i;j++){
                if(dp[i+1][j]>dp[i+1][j+1]){
                    dp[i][j]+=dp[i+1][j];
                    path[i][j]=j;
                }else{
                    dp[i][j]+=dp[i+1][j+1];
                    path[i][j]=j+1;
                }
            }
        }
        printf("%d\n",dp[1][1]);
        int cur=1;
        for(int i=1;i<=n;i++){
            printf("(%d %d) ",i,cur);
            cur=path[i][cur];
        }
        printf("\n");
    }
    return 0;
}

递归型输出 - 计算后回溯

#include <cstdio>
#include <iostream>
using namespace std;

typedef long long LL;

int dp[105][105],path[105];
int n;
void print_path(int i)
{
    if(i>n){
        for(i=1;i<=n;i++)
            printf("(%d %d) ",i,path[i]);
        printf("\n");
        return;
    }
    int ind=path[i-1];
    if(dp[i][ind]>dp[i][ind+1]){
        path[i]=ind;
        print_path(i+1);
    }else if(dp[i][ind]<dp[i][ind+1]){
        path[i]=ind+1;
        print_path(i+1);
    }else{
        path[i]=ind;
        print_path(i+1);
        path[i]=ind+1;
        print_path(i+1);
    }
}
int main()
{
    int T;
    scanf("%d",&T);
    for(int cas=1;cas<=T;++cas){
        scanf("%d",&n);
        for(int i=1;i<=n;i++){
            for(int j=1;j<=i;j++){
                scanf("%d",&dp[i][j]);
            }
        }
        for(int i=n-1;i>=1;i--){
            for(int j=1;j<=i;j++){
                dp[i][j]+=max(dp[i+1][j],dp[i+1][j+1]);
            }
        }
        printf("%d\n",dp[1][1]);
        path[1]=1;
        print_path(2);
    }
    return 0;
}