HDU_2084 数塔(DP)

数塔

Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 24465    Accepted Submission(s): 14717

Problem Description

在讲述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
  
  

 

题意：有一个数塔，从上往下走，只能走到下一层与当前点相邻的位置，让你找到一条路使你经过的点的和最大。

题解：题目已经告诉我们需要用到动态规划，这是DP的第一题，也是寒假每日一题的第一题。对于DP感觉理解还不是很好，所以先大概讲一下这道题的思路吧。想到的第一种方法就是记忆化搜索，从下往上遍历，将每个点的最优路径(即所能达到最大值)保存下来，每种情况只需要便利一次，时间复杂度可能为O(nW),附上代码：

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <cstring>
#include <algorithm>
#define MAX_N 105

using namespace std;

int N,M;
int m[MAX_N][MAX_N];
int d[MAX_N][MAX_N];
int renew(int i,int j);
int main()
{
    cin>>N;
    while( N-- )
    {
        cin>>M;
        memset(m,0,sizeof(m));
        memset(d,0,sizeof(d));
        int result=0;
        for( int i = 1; i <= M; i++ )
        {
            for( int j = 1; j <= i; j++ )
                scanf("%d",&m[i][j]);
        }
        for( int i = 1; i <= M; i++ )
        {
            result = max( renew( M , i ) , result );
        }
        printf("%d\n",result);
    }
    return 0;
}
int renew(int x,int y)
{
    if( d[x][y] > 0 )
        return d[x][y];
    int result;
    if( x == 1)
        return d[x][y] = m[1][1];
    else
        result = max(renew( x-1 , y-1),renew( x-1 , y)) + m[x][y];
    return d[x][y] = result;
}

掌握了记忆化搜索后进一步，我们可以尝试推导出递推式，时间复杂度相同，但是代码会简洁了很多：

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <cstring>
#include <algorithm>
#define MAX_N 105

using namespace std;

int N,M;
int m[MAX_N][MAX_N];
int main()
{
    cin>>N;
    while( N-- )
    {
        cin>>M;
        memset(m,0,sizeof(m));
        for( int i = 1; i <= M; i++ )
            for( int j = 1; j <= i; j++ )
                scanf("%d",&m[i][j]);
        for( int i = M-1; i > 0; i--)
            for( int j = 1; j <= i; j++)
                m[i][j] += max( m[i+1][j] , m[i+1][j+1] );
        printf("%d\n",m[1][1]);
    }
    return 0;
}

来看一个更加性感的同学的代码，用滚动数组。因为当下一行永远比上一行先得出最大值，所以当计算到上一行时下一行已经没用了，所以可以滚动覆盖。从下往上遍历，思路是一致的，但是更加节省空间与内存，赞一个！！

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <iostream>
using namespace std;
int max(int a ,int b) {return a>b?a:b;}
int main()
{
   int t,n,i,j;
   int a[101][101];
   int dp[101];
   scanf("%d",&t);
   while(t--)
   {
       scanf("%d",&n);
       memset(a,0,sizeof(a));
       memset(dp,0,sizeof(dp));
       for(i=0;i<n;i++)
        for(j=0;j<=i;j++)
            scanf("%d",&a[i][j]);
       for(i=n-2;i>=0;i--)
           for(j=0;j<=i;j++)
                dp[j]=max(dp[j]+a[i+1][j],dp[j+1]+a[i+1][j+1]);
       printf("%d\n",dp[0]+a[0][0]);
   }
    return 0;
}