HDOJ 2084 数塔

题目叙述：

 

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

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

 

解题思路：

动态规划，记录从起点到每一个点的数字之和的最大值。

dp[i][j]=max(dp[i-1][j-1],dp[i-1][j])+num[i][j]dp[i][j]

代表从起点到（i，j）的数字之和的最大值，它是由上一个状态确定（即dp[i-1][j-1],dp[i-1][j])中的最大值，加上num[i][j]）

 

 

我的代码：（开辟两个二维数组）

#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
int main()
{
    int num[120][120]={0};
    int dp[120][120]={0};
    int count;
    int n;
    int _max=0;
    cin>>count;
    while(count--)
    {
        cin>>n;
        for(int i=1;i<=n;i++)       //num[0][0]等等不用赋值，避免数组越界
        {
            for(int j=1;j<=i;j++)
            {
                cin>>num[i][j];
            }
        }
        dp[1][1]=num[1][1];
        for(int i=2;i<=n;i++)
        {
            for(int j=1;j<=i;j++)
            {
                dp[i][j]=max(dp[i-1][j-1],dp[i-1][j])+num[i][j];
            }
        }
        for(int i=1;i<=n;i++)
        {
            if(_max<dp[n][i])
                _max=dp[n][i];
        }
        cout<<_max<<endl;              //Presentation Error 错误往往是输出上的空格回车
        _max=0;
        memset(num,0,sizeof(num));     //memset函数为数组赋初值，头文件string.h
        memset(dp,0,sizeof(dp));
    }
    return 0;
}

 

我的代码（改进版，仅用一个二维数组）

#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
int main()
{
    int num[120][120]={0};
    int count;
    int n;
    int _max=0;
    cin>>count;
    while(count--)
    {
        cin>>n;
        for(int i=1;i<=n;i++)       //num[0][0]等等不用赋值，避免数组越界
        {
            for(int j=1;j<=i;j++)
            {
                cin>>num[i][j];
            }
        }
        for(int i=2;i<=n;i++)
        {
            for(int j=1;j<=i;j++)
            {
                num[i][j]=max(num[i-1][j-1],num[i-1][j])+num[i][j];
            }
        }
        for(int i=1;i<=n;i++)
        {
            if(_max<num[n][i])
                _max=num[n][i];
        }
        cout<<_max<<endl;              //Presentation Error 错误往往是输出上的空格回车
        _max=0;
        memset(num,0,sizeof(num));     //memset函数为数组赋初值，头文件string.h
    }
    return 0;
}

 

我的代码（再次改进，不用动态规划）

#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
int main()
{
    int count;
    int n;
    int num[120][120]={0};
    cin>>count;
    while(count--)
    {
        cin>>n;
        for(int i=1;i<=n;i++)       //num[0][0]等等不用赋值，避免数组越界
        {
            for(int j=1;j<=i;j++)
            {
                cin>>num[i][j];
            }
        }
        for(int i=n;i>=1;i--)
        {
            for(int j=1;j<=i-1;j++)
            {
                num[i-1][j]=max(num[i][j],num[i][j+1])+num[i-1][j];
            }
        }
        cout<<num[1][1]<<endl;              //Presentation Error 错误往往是输出上的空格回车
        memset(num,0,sizeof(num));
    }
    return 0;
}

//据说比动态规划会快，但是呵呵~~