如下图是一个数塔，从顶部出发在每一个节点可以选择向左或者向右走，一直走到底层，要求找出一条路径，使得路径上的数字之和最大。

思路分析：

• 这道题目如果使用贪婪算法不能保证找到真正的最大和。在用动态规划考虑数塔问题时可以自顶向下的分析，自底向上的计算。
• 从顶点出发时到底向左走还是向右走应取决于是从左走能取到最大值还是从右走能取到最大值，只要左右两道路径上的最大值求出来了才能作出决策。同样的道理下一层的走向又要取决于再下一层上的最大值是否已经求出才能决策。这样一层一层推下去，直到倒数第二层时就非常明了。

所以第一步对第五层的8个数据，做如下四次决策：
如果经过第四层2，则在第五层的19和7中肯定是19；
如果经过第四层18，则在第五层的7和10中肯定是10；
如果经过第四层9，则在第五层的10和4中肯定是10；
如果经过第四层5，则在第五层的4和16中肯定是16；

• 经过一次决策，问题降了一阶。5层数塔问题转换成4层数塔问题，如此循环决策…… 最后得到1阶的数塔问题。

• 算法实现：首先利用一个二维数组data存储数塔的原始数据（其实我们只使用数组data一半的空间，一个下三角矩阵），然后利用一个中间数组dp存储每一次决策过程中的结果（也是一个下三角矩阵）。

• 初始化dp，将data的最后一层拷贝到dp中。dp[n][j] = data[n][j] (j = 1, 2, …, n) 其中，n为数塔的层数。

• 在动态规划过程汇总，我们有dp[i][j] = max(dp[i+1][j], dp[i+1][j+1]) + data[i][j]，最后的结果保存在dp[0][0]中。

实验原理：

• 从顶点出发时到底向左走还是向右走应取决于是从左走能取到最大值还是从右走能取到最大值，只要左右两道路径上的最大值求出来了才能作出决策。同样的道理下一层的走向又要取决于再下一层上的最大值是否已经求出才能决策。这样一层一层推下去，直到倒数第二层时就非常明了。
• 首先利用一个二维数组data存储数塔的原始数据（其实我们只使用数组data一半的空间，一个下三角矩阵），然后利用一个中间数组dp存储每一次决策过程中的结果（也是一个下三角矩阵）。
• 初始化dp，将data的最后一层拷贝到dp中。dp[n][j] = data[n][j] (j = 1, 2, …, n) 其中，n为数塔的层数。
  在动态规划过程汇总，我们有dp[i][j] = max(dp[i+1][j], dp[i+1][j+1]) + data[i][j]，最后的结果保存在dp[0][0]中。

实验代码：

#include <stdio.h>
#include <stdlib.h>
int maxdata(int data1,int data2)   //比较data1和data2的大小
{
    
    if(data1>data2)
        return data1;
    else
        return data2;

}

int main()
{
    
    int  node;
    int op[5][5]={
    };//将其初始化为0
    int data[5][5]={
    
        {
    9, 0, 0, 0, 0},
        {
    12,15, 0, 0, 0},
        {
    10, 6, 8, 0, 0},
        {
    2,18, 9, 5, 0},
        {
    19, 7,10, 4,16}};    //定义原始数据二维数组
    int n=5,i,j,temp=0;//n为第几层
    for(j=0;j<n;j++)
    {
    
        op[n-1][j]=data[n-1][j];
    }//初始化op数据，data最底层赋值给op最底层；其余还是为0

    for(i=3;i>=0;i--)//从data[3][0]开始，也就是2;比较19和7
    {
    
        for(j=0;j<=i;j++)  //内层同一行数据的比较
        {
    
            temp=maxdata(op[i+1][j],op[i+1][j+1]);   //比较同行的较大值
            op[i][j]=temp+data[i][j];    //较大值累加到op[i][j]
        }
    }
    for(i=0;i<=4;i++)   //输出所有的二维数组数据，也就输出存储的路径
    {
    
        for(j=0;j<=4;j++)
        {
    
            printf("%d ",op[i][j]);
        }
        printf("\n");
    }

    printf("路径之和最大为:%d\n",op[0][0]);
    printf("最大路径:%d",data[0][0]);   //输出路径之和以及最大路径
    for(i=1,j=0;i<n;i++)
    {
    
        node=op[i-1][j]-data[i-1][j];
        if(node==op[i][j+1])
            ++j;
            printf("——>%d",data[i][j]);
    }
    return 0;
}

实验测试：

以data[5][5]={ {9, 0, 0, 0, 0},{12,15, 0, 0, 0},{10, 6, 8, 0, 0},{2,18, 9, 5, 0},{19, 7,10, 4,16}};做测试寻找路径之和和最大路径

以data[5][5]={ {14, 0, 0, 0, 0},{20,13, 0, 0, 0},{11, 7, 3, 0, 0},{14,16, 2, 4, 0},{21, 12,6, 17,11}};做测试寻找路径之和和最大路径

复杂度分析：
将每一层的值和其子树塔和的最大值存于二维数组op[][]中；将op最底层的所有数据初始化为数塔最底层的数据；从倒数第二层开始，逐层往上选择最大的子树塔与父节点相加，直到第一层；循环结束得到的op [1][1]即为和需要求的最大值。
时间复杂度：O(n^2)
空间复杂度：O(n^2)