杭电oj HDOJ 2084 数塔（动态规划 DP）

杭电oj HDOJ 2084 数塔

题目来源：http://acm.hdu.edu.cn/showproblem.php?pid=2084

Problem Descripition

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

有如下所示的数塔，要求从顶层走到底层，若每一步只能走到相邻的结点，则经过的结点的数字之和最大是多少？
已经告诉你了，这是个DP的题目，你能AC吗?

Input

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

Output

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

解题思路

非常典型的DP问题，先用一个二位数组来存储整个数塔。
$$num=\left[\begin{array}{ccccc}9& & & & \\ 12& 15& & & \\ 10& 6& 8& & \\ 2& 18& 9& 5& \\ 19& 7& 10& 4& 16\end{array}\right]$$
由于“左对齐”的原因，数塔的形状有些“变形”，但是对照原图可以知道，（我们约定把数组的第5行第3列表示成“5，3”）如果一个“求和”的路线走到了数组的“5，3”，那么一定是从“4，2”到“5，3”或从“4，3”到“5，3”，换句话说如果“回溯”的话，“5，3”只能回溯到“4，2”或“4，3”。进而假设dp(5，3)为以“5，3”为最后结点的最大数字之和，那么dp(5，3)就等于dp(4，2)与dp(4，3）二者之间的最大值加上“5，3”表示的值，同理dp(“4，2”)等于dp(“3，1”)与dp(“3，2”)二者之间的最大值加上“4，2”表示的值，继续如此操作就可以把问题不断地向上“回溯”。经过推广的“公式”可以表示为：
$$dp(i,j)=max\left\{\begin{array}{c}左上回溯：dp(i-1,j-1)\\ 正上回溯：dp(i-1,j)\end{array}\right\}+num[i][j]$$
接下来寻找回溯的终点，当以最上方的“1，1”为最后节点时，不能再向上回溯，最大值就是其本身，即dp(1，1) = 9。

是否存在特殊的“回溯”情况：

1. 当目前点处于第一列时，只能向正上“回溯”
   $$dp(i,j)=dp(i-1,j)+num[i][j]$$
2. 当目前点的“行数”和列数相等时，只能向左上“回溯”
   $$dp(i,j)=dp(i-1,j-1)+num[i][j]$$

根据以上分析则可以写出本题DP的“递归函数”：

int dp(int i, int j)
{
	int temp1, temp2;
	// 数塔的高度只有1，最大和就是其本身
	if (i == 1 && j == 1) {
		return num[1][1];
	}
	// 当位置坐标在最左侧时，只能回溯到正上方的坐标
	else if (j == 1){
		return dp(i - 1, j) + num[i][j];
	}
	// 当位置坐标在数塔正方形的对角线上时，只能回溯到左上角的坐标
	else if (i == j) {
		return dp(i - 1, j - 1) + num[i][j];
	}
	else {
		// 回溯到左上角的坐标
		temp1 = dp(i - 1, j - 1);
		// 回溯到正上方的坐标
		temp2 = dp(i - 1, j);
		return max(temp1, temp2) + num[i][j];
	}
}

求出最后一行每个点的dp(i,j)，他们其中的最大值就是这个数塔所要求的最大值。

结果不出所料，超时！！！所以考虑使用“动态规划表”求解！

用一个二维数组dp[][]来记录动态规划的计算过程，dp[i][j]就对应dp(i,j)的含义，所以$dp[1][1]=9$，接着利用上面总结出的公式可以不断地向下递推填写，直到写出一个与原数塔相同规格的矩阵
$$dp=\left[\begin{array}{ccccc}9& & & & \\ 21& 24& & & \\ 31& 30& 32& & \\ 33& 49& 41& 37& \\ 52& 56& 59& 45& 53\end{array}\right]$$
最后一行元素中的最大值就是这个数塔所要求的最大值，即59！“动态规划表”的好处就是时间复杂度小于递归函数的方法，不会造成“超时”的结果！

C++代码

#include <iostream>
using namespace std;

int main()
{
	int C, N, i, j, k, num[101][101], dp[101][101], temp1, temp2, max;
	cin >> C;
	for (i = 0; i < C; i++) {
		cin >> N;
		for (j = 1; j <= N; j++) {
			for (k = 1; k <= j; k++) {
				cin >> num[j][k];
			}
		}
		// 数塔的高度只有1，最大和就是其本身
		dp[1][1] = num[1][1];
		for (j = 2; j <= N; j++) {
			for (k = 1; k <= j; k++) {
				// 当位置坐标在最左侧时，只能上溯到正上方的坐标
				if (k == 1) {
					dp[j][k] = dp[j - 1][k] + num[j][k];
				}
				// 当位置坐标在数塔正方形的对角线上时，只能上溯到左上角的坐标
				else if (k == j) {
					dp[j][k] = dp[j - 1][k - 1] + num[j][k];
				}
				else {
					// 上溯到正上方的坐标
					temp1 = dp[j - 1][k];
					// 上溯到左上角的坐标
					temp2 = dp[j - 1][k - 1];
					if (temp1 > temp2) {
						dp[j][k] = temp1 + num[j][k];
					}
					else {
						dp[j][k] = temp2 + num[j][k];
					}
				}
			}
		}
		max = dp[N][1];
		for (j = 2; j <= N; j++) {
			if (dp[N][j] > max) {
				max = dp[N][j];
			}
		}
		cout << max << endl;
	}
	return 0;
}

代码通过HDOJ平台运行检查，如发现错误，欢迎指出和纠正，谢谢！