数字三角形（动态规划经典例题）

资源限制
时间限制：1.0s 内存限制：256.0MB
问题描述
　　（图３.１－１）示出了一个数字三角形。 请编一个程序计算从顶至底的某处的一条路
　　径，使该路径所经过的数字的总和最大。
　　●每一步可沿左斜线向下或右斜线向下走；
　　●1＜三角形行数≤100；
　　●三角形中的数字为整数0，1，…99；

　　 （图３.１－１）
输入格式
5 //三角形行数。下面是三角形
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5

//要求输出最大和

样例输出
30

解题思路：
用二维数组D[r][j]存放数字三角形。
D(r,j)代表第r行第j列个数字
MaxSum(r,j)代表第r行第j列到底边的各条路径中，最佳路径的最大和。
问题就相当于求MaxSum（1,1）

典型的递归问题
D[r][j]出发，只能往下D[r+1][j]走或者往右下D[r+1][j+1]走

下面展示代码。

#include <iostream>
#include <algorithm>
#define MAX 101
using namespace std;
int D[MAX][MAX];
int n;
int MaxSum(int i,int j)
{
    if(i==n)
    {
        return D[i][j];
    }
    else
    {
        int x=MaxSum(i+1,j);
        int y=MaxSum(i+1,j+1);
        return max(x,y)+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;
}

注：这样在输入较多行的时候我们会发现超时。

原因：存在大量重复计算。在调用MaxSum【1】【1】的时候，会调用MaxSum[2][1]和MaxSum[2][2]各一次，调用MaxSum[2][1]和MaxSum[2][2]时，会分别调用MaxSum[3][1]，MaxSum[3][2]，MaxSum[3][3] 1，2,1次呈杨辉三角形，时间复杂度为指数级，对于n=100，肯定超时。

解决方案：如果每算出一个MaxSum(r,j)就保存起来，下次用到其值的时候直接取用，则可以免去重复计算，那可以用O（N^2）时间完成计算，因为三角形的数字总数是n(n+1)/2

数字三角形的记忆递归性动归程序：

#include <iostream>
#include <algorithm>
#define MAX 101
using namespace std;
int D[MAX][MAX];
int n;
int maxSum[MAX][MAX];//存放每一个数字到底边的最大和
int MaxSum(int i,int j)
{
    if(maxSum[i][j]!=-1)
        return maxSum[i][j];
    if(i==n)
    {
       maxSum[i][j]=D[i][j];
    }
    else
    {
        int x=MaxSum(i+1,j);
        int y=MaxSum(i+1,j+1);
        maxSum[i][j]=max(x,y)+D[i][j];
    }
    return maxSum[i][j];
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        for(int j=1;j<=i;j++)
        {
            cin>>D[i][j];
            maxSum[i][j]=-1;
        }
    }
    cout<<MaxSum(1,1)<<endl;
    return 0;
}

递归转成递推：

#include <iostream>
#include <algorithm>
#define MAX 101
using namespace std;
int D[MAX][MAX];
int n;
int maxSum[MAX][MAX];
int main()
{
    int i,j;
    cin>>n;
    for(i=1;i<=n;i++)
    {
        for(j=1;j<=i;j++)
        {
            cin>>D[i][j];
        }
    }
    for(i=1;i<=n;i++)
        maxSum[n][i]=D[n][i];//第n行本身就是到底边的最大和
    for(i=n-1;i>=1;--i)
        for(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];
    return 0;
}

空间优化：
没必要用二维数组maxSum数组存储每一个MaxSum(r,j)，只要从底层一行向上递推，那么只要一维数组maxSum[100]就行，即只要存储一行的MaxSum值就可以。

进一步考虑，连maxSum数组都可以不要，直接用D的第N行替代maxSum即可
节省空间，时间复杂度不变。

#include <iostream>
#include <algorithm>
#define MAX 101
using namespace std;
int D[MAX][MAX];
int n;
int *maxSum;
int main()
{
    int i,j;
    cin>>n;
    for(i=1;i<=n;i++)
    {
        for(j=1;j<=i;j++)
        {
            cin>>D[i][j];
        }
    }
    maxSum=D[n];
    for(i=n-1;i>=1;--i)
        for(j=1;j<=i;j++)
            maxSum[j]=max(maxSum[j],maxSum[j+1])+D[i][j];
    cout<<maxSum[1]<<endl;
    return 0;
}