数塔问题（经典动态规划）

两种方法，一种从上到下的递归寻找max；另一种为从下到上的迭代max

在讲述DP算法的时候，一个经典的例子就是数塔问题，它是这样描述的：

有如下所示的数塔，要求从顶层走到底层，若每一步只能走到相邻的结点，则经过的结点的数字之和最大是多少？

已经告诉你了，这是个DP的题目，你能AC吗?

Input

输入数据首先包括一个整数C,表示测试实例的个数，每个测试实例的第一行是一个整数N(1 <= N <= 100)，表示数塔的高度，接下来用N行数字表示数塔，其中第i行有个i个整数，且所有的整数均在区间[0,99]内。

Output

对于每个测试实例，输出可能得到的最大和，每个实例的输出占一行。

Sample Input

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

Sample Output

30

一种从上到下的递归寻找max

#include <iostream>
#include <algorithm>
#include<string.h>
using namespace std;


const int N = 1000;//为了算法写起来简单，这里定义一个足够大的数用来存储数据(为了避免运算过程中动态申请空间，这样的话算法看起来比较麻烦，这里只是为了算法看起来简单)
int data[N][N];//存储数塔原始数据
int dp[N][N];//存储动态规划过程中的数据
int n;//塔的层数

/*动态规划实现数塔求解*/
void tower_walk()
{
    // dp初始化
    for (int i = 1; i <=n; ++i)
    {
        dp[ n ][i] = data[ n ][i];
    }
    for (int i = n-1 ; i >= 0; --i)
    {
        for (int j = 1; j <= i; ++j)
        {
            // 使用递推公式计算dp的值
            dp[i][j] =  max(dp[i + 1][j], dp[i + 1][j + 1]) + data[i][j];
        }
    }
}
int main()
{
    int num;
    cin>>num;
    while(num--)
    {
        memset(dp,0,sizeof(dp));
        memset(data,0,sizeof(data));

        cin >> n;
        for (int i = 1; i <= n; ++i)
        {
            for (int j = 1; j <= i; ++j)
            {
                cin >> data[i][j];
            }
        }
        tower_walk();
        cout<<dp[1][1]<<endl;
    }
}

 

另一种为从下到上的迭代max

#include <iostream>
#include <algorithm>
#include<string.h>
using namespace std;


const int N = 1000;//为了算法写起来简单，这里定义一个足够大的数用来存储数据(为了避免运算过程中动态申请空间，这样的话算法看起来比较麻烦，这里只是为了算法看起来简单)
int data[N][N];//存储数塔原始数据
int dp[N][N];//存储动态规划过程中的数据
int n;//塔的层数
int vis[N][N];

/*动态规划实现数塔求解*/
int tower_walk(int x,int y)
{
    if(x==n)
        return data[x][y];
    if(vis[x][y])
        return vis[x][y];

    vis[x+1][y]=tower_walk(x+1,y);
    vis[x+1][y+1]=tower_walk(x+1,y+1);

    if( vis[x+1][y] >= vis[x+1][y+1] )
        return vis[x+1][y] + data[x][y];
    else
        return vis[x+1][y+1] + data[x][y];

    /*
    for (int i = n-1 ; i >= 0; --i)
    {
        for (int j = 1; j <= i; ++j)
        {
            // 使用递推公式计算dp的值
            dp[i][j] =  max(dp[i + 1][j], dp[i + 1][j + 1]) + data[i][j];
        }
    }
    */
}
int main()
{
    int num;
    cin>>num;
    while(num--)
    {
        memset(dp,0,sizeof(dp));
        memset(data,0,sizeof(data));
        memset(vis,0,sizeof(vis));

        cin >> n;
        for (int i = 1; i <= n; ++i)
        {
            for (int j = 1; j <= i; ++j)
            {
                cin >> data[i][j];
            }
        }
        for (int i = 1; i <=n; ++i)// dp初始化
        {
            dp[ n ][i] = data[ n ][i];
        }

        cout<<tower_walk(1,1)<<endl;
    }
}