算法学习之动态规划--数字三角形最大路径和

题目：

7

3  8

8  1  0

2  7  4  4

4  5  2  6  5

在上面的数字三角形中寻找一条从顶部到底边的路径，使得路径上所经过的数字之和最大。路径上的每一步都只能往左下或右下走。只需要求出这个最大和即可，不必给出具体路径。三角形的行数大于1小于等于100，数字为 0 - 99。

输入格式：
5//三角形行数。下面是三角形
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
要求输出最大和

解题思路：
用二维数组存放数字三角形。
D( r, j) : 第r行第 j 个数字(r,j从1开始算)
MaxSum(r, j) : 从D(r,j)到底边的各条路径中，最佳路径的数字之和。
问题转化为求 MaxSum(1,1)，这是典型的递归问题。D(r, j)出发，下一步只能走D(r+1,j)或者D(r+1, j+1)。所以有了下面的第一种方法

方法一：递归求解

#include<iostream>
using namespace std;

const int maxn = 101;
int D[maxn][maxn];                  //存储三角形中第i行第j列的数值，i、j均从1开始
int n;                              //三角形行数

int maxSum(int i, int j){           //从D(i,j)到底边的各条路径中，最佳路径的数字之和。
    if(i == n)                      //D(i,j)就在三角形底边上
        return D[i][j];
    int x = maxSum(i+1,j);
    int y = maxSum(i+1,j+1);
    return max(x,y)+D[i][j];        //D(i,j)到底边最优解
}

int main(){
    cin >> n;
    for(int i=1; i<=n; i++)
        for(int j=1; j<=i; j++)
            cin>>D[i][j];
    cout<<maxSum(1,1)<<endl;        //从三角形顶点到底边最优解
    return 0;
}

这样做会超时，因为有太多的重复计算。当时间复杂度为 2^n,对于 n = 100 行，肯定超时。

对第一种方法的改进：如果每算出一个MaxSum(r,j)就保存起来，下次用到其值的时候直接取用，则可免去重复计算。那么可以用O(n2)时间完成计算。因为三角形的数字总数是 n(n+1)/2。

方法二：记忆递归型动归程序（对方法一的改进）

#include<iostream>
using namespace std;

const int maxn = 101;
int sum[maxn][maxn];                //存储已经算出的maxSum值
int D[maxn][maxn];
int n;

int maxSum(int i, int j){           //从D(i,j)到底边的各条路径中，最佳路径的数字之和。
    if(sum[i][j] != -1)             //此maxSum已算出过
        return sum[i][j];
    if(i == n)
        sum[i][j] = D[i][j];
    else{
        int x = maxSum(i+1,j);
        int y = maxSum(i+1,j+1);
        sum[i][j] = max(x,y)+D[i][j];
    }
    return sum[i][j];
}

int main(){
    cin >> n;
    for(int i=1; i<=n; i++)
        for(int j=1; j<=i; j++){
            cin>>D[i][j];
            sum[i][j] = -1;         //均初始化为-1
        }
    cout<<maxSum(1,1)<<endl;
    return 0;
}

方法二就有点啰嗦，我们现在不用递归，直接用递推，也即动态规划。在此方法中，从最底层往上层一层一层递推求出当前最优解。代码如下。

方法三：动态规划

#include<iostream>
using namespace std;
const int maxn = 101;
int n;
int D[maxn][maxn];
int maxSum[maxn][maxn];         //从D(i,j)到底边的各条路径中，最佳路径的数字之和。
int main(){
    cin >> n;
    for(int i=1; i<=n; i++)
        for(int j=1; j<=i; j++)
            cin >> D[i][j];
    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];
    cout << maxSum[1][1] <<endl;
    return 0;
}

在方法三种，我们用了二维数组存储当前最优解，但实际上往上层递推求解的过程中，我们只会用到下一层的数据，之前的结果都没有用处了。所以只要一维数组maxSum[100]即可。进一步考虑，连maxSum数组都可以不要，直接用D的第n行替代maxSum即可。得到如下方法。

方法四：动态规划(二)   ( 推荐！)

#include<iostream>
using namespace std;
const int maxn = 101;
int n;
int D[maxn][maxn];
int main(){
    cin >> n;
    for(int i=1; i<=n; i++)
        for(int j=1; j<=i; j++)
            cin >> D[i][j];
    int *maxSum = D[n];             //maxSum指向第n行，利用第n行的空间存储结果
    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];
    cout << maxSum[1] <<endl;
    return 0;
}