HDU-2084 数塔

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

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

分析：

        这是一道经典的递推题（动态规划），即把当前位置（i，j）看成一个状态，从（i，j）可以从左下（i+1，j）或右上（i+1,j+1）两个方向出发得到最大和。

        我们有两种方种方法，一种是从数塔最上部开始，分别尝试左下和右上两条路径找最大值进行递归，最后递归到数塔最下部后输出最大和，但这种重复计算方法时间复杂度为2^(n-1),数塔层数太大的话效率太低容易超时挂掉。因为相同的子问题被多次重复。

        另一种方法是递推，即从数塔最下部开始，先用dp数组记录最下部的每个值进行预处理，因为最下层没有再下一层了。所以递推只能从最下行层的上一层开始，然后在往上一层正式开始递推。从下到上递推的优点是在计算d（i，j）前，d（i+1，j+1）和d（i+1，j）一定已经计算出来了。

                             d（i，j）=a（i，j）+max{d（i+1，j），d（i+1，j+1）}

               计算位于（i，j）的最大值      位于（i，j）的值                  取下一层左下或右上的最大值

最终递推到（1,1）后求得的最大值，就是整个数塔能组合出的最大值。时间复杂度为O（n^2）

#include<iostream>
using namespace std;
typedef long long ll;
const int M=1010;
ll map[M][M],dp[M][M],x,n,i,j,k;//map用于记录每个位置的值，dp用于记录每个位置的最优解
int main()
{
	cin>>x;
	while(x--)
        {
		cin>>n;
	    for(i=1;i<=n;i++)
            {
		for(j=1;j<=i;j++)
                {
		    cin>>map[i][j];
		}
	    }
            for(i=1;i<=n;i++)
            {
		dp[n][i]=map[n][i];//先对最下层的dp值进行预处理
            }
	    for(i=n-1;i>=1;i--)
            {
		for(j=1;j<=i;j++)
		dp[i][j]=map[i][j]+max(dp[i+1][j],dp[i+1][j+1]);//从最下层的上一层递推至最上层
	    }
	    cout<<dp[1][1]<<endl;//输出最上层对应的最优解
	}
}