poj 1163 The Triangle （dp入门）

题目链接 The Triangle
图片引用自，传送门
1、自上向下的递归方法：
首先，我们需要用二维数组去存三角形，这里先定义 MaxSum[MAXN][MAXN]（每个点的最大值）,d[MAXN][MAXN] （存三角形）。
我们自上向下看，可以得到一个dp的递推公式:
MaxSum[i][j] = max(MaxSum[i + 1] [j],MaxSum[i + 1] [j + 1]) + d[i][j];
从(i,j)点出发，无非就是走到（i + 1，j）(i + 1, j + 1)。那么对于n行的三角形，根据递推公式，可以得到如下代码

if(i == n){
        MaxSum[i][j] = d[i][j];
    }
    else{
        int x = dpMaxSum(i + 1, j,n);
        int y = dpMaxSum(i + 1, j + 1,n);
        MaxSum[i][j] = max(x,y) + d[i][j];
    }

根据这个简单递推式，我们可以得到完整的递归代码
但是我们要防止重复计算，所以需要对递归式进行优化，使其成为带有记忆的递归式的dp代码。

#include <iostream>
#include <string.h>
#define MAXN 105

using namespace std;

int MaxSum[MAXN][MAXN],d[MAXN][MAXN];

int dpMaxSum(int i, int j, int n){
    if(MaxSum[i][j] != -1){//为了防止重复计算带来的时间超限，对于已经求得最大和的该点，直接使用结果，不再进行重复计算。
        return MaxSum[i][j];
    }
    if(i == n){
        MaxSum[i][j] = d[i][j];
    }
    else{
        int x = dpMaxSum(i + 1, j,n);
        int y = dpMaxSum(i + 1, j + 1,n);
        MaxSum[i][j] = max(x,y) + d[i][j];
    }
    return MaxSum[i][j];
}

int main(){
    int n;
    cin>>n;
    memset(MaxSum,-1,sizeof(MaxSum));
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= i; j++){
            cin>>d[i][j];
        }
    }
    int ans = dpMaxSum(1,1,n);
    cout<<ans<<endl;
    return 0;
}

但是对于上面的代码，还是会造成堆栈的溢出，所以可以将递归式优化成递推式
也就是下面的思路。
2、自底向上的dp
我们自底向上可以发现，还是上面的那个递推式，我们可以从底层开始向上存储最大和，再以最大的和为底继续向上递推，这里引用的图来进行更具体的说明

那么我们就可以得到如下代码

#include <iostream>
#include <string.h>
#define MAXN 105

using namespace std;

int MaxSum[MAXN][MAXN],d[MAXN][MAXN];

int dpMaxSum(int i, int j, int n){
    for(int i = 1; i <= n; i++){
        MaxSum[n][i] = d[n][i];
    }
    for(int i = n - 1; i>=1; i--){
        for(int j = 1; j <= i; j++){
            MaxSum[i][j] = max(MaxSum[i + 1][j],MaxSum[i + 1][j + 1]) + d[i][j];
        }
    }
    return MaxSum[1][1];
}

int main(){
    int n;
    cin>>n;
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= i; j++){
            cin>>d[i][j];
        }
    }
    int ans = dpMaxSum(1,1,n);
    cout<<ans<<endl;
    return 0;
}

那么我们可以继续思考，是不是不需要二维数组存储最大和了呢？
显然是可以的，这里还是要引用一下的图，来更直观的进行解释



由此我们可以得到进一步的优化代码

#include <iostream>
#include <string.h>
#define MAXN 105

using namespace std;

int MaxSum[MAXN],d[MAXN][MAXN];

int dpMaxSum(int i, int j, int n){
    for(int i = 1; i <= n; i++){
        MaxSum[i] = d[n][i];
    }
    for(int i = n - 1; i>=1; i--){
        for(int j = 1; j <= i; j++){
            MaxSum[j] = max(MaxSum[j],MaxSum[j + 1]) + d[i][j];
        }
    }
    return MaxSum[1];
}

int main(){
    int n;
    cin>>n;
    for(int i = 1; i <= n; i++){
        for(int j = 1; j <= i; j++){
            cin>>d[i][j];
        }
    }
    int ans = dpMaxSum(1,1,n);
    cout<<ans<<endl;
    return 0;
}