简单数塔问题

数塔问题是入门动态规划的一个经典问题，简单，但是体现了动态规划的思想。

这里我们就以洛谷P1216为例，来粗略讲解一下

求的是最大的和

首先，有人第一眼看，可能会想到dfs，但是，我们发现这种“从顶往下”的朴素暴力算法的时间复杂度非常大，能够达到2的n次方级别，但是小规模数塔仍然可以使用，这里我就先放出来。

int dp[20][20];//dp[i][j]记录从第i层第j个数开始往下走的数字和
int a[20][20];//a[i][j]是数塔第i层的第j个数
int dfs(int i,int j)
{
	if(i==n)
		return a[i][j];//递归边界：到达最后一行，返回
	return dp[i][j] = max(dfs(dp[i+1][j],dp[i+1][j+1])) + a[i][j];
	//从左边走上来，或者从右边走上来，去其中较大的
}

从代码可以很明显看出dfs的弊端

下面我们先来看一下递归+记忆化搜索

int dp[1011][1011];
int a[1011][1011];
void init()
{
	for(int i=1;i<=1010;i++)
		for(int j=1;j<=1010;j++)
			dp[i][j] = -1;
	//这里我们先将dp数组初始化为-1
}

int dfs(int i,int j)
{
	if(i==n)return a[i][j];
	if(dp[i][j]>=0)return dp[i][j];//这里就用到了记忆化搜索的思想
	return dp[i][j] = max(dfs(i+1,j),dfs(i+1,j+1)) + a[i][j];
}

当我们理解了记忆化搜索时，我们会惊奇地发现这种算法的复杂度只有O(n2)。
可见记忆化搜索的优化能力是惊人的。

下面我再加上一段比较好理解的递推代码

int dp[1011][1011];
int a[1011][1011];
//最好将数组放到main函数外
for(int i=1;i<=r;i++)dp[n][i] = a[n][i];//先计算最后一层
for(int i=n-1;i>=1;i--)//从倒数第2层往上走到第1层
	for(int j=1;j<=i;j++)//从左边走上来，或者从右边走上来，取其中较大的
		dp[i][j] = a[i][j] + max(dp[i+1][j],dp[i+1][j+1]) + a[i][j];

最后，我再把ac代码给大家，供大家参考

#include<bits/stdc++.h>
using namespace std;
//数塔问题

int a[1011][1011];
int dp[1011][1011];
int r;

int main()
{
	cin >> r;
	init();
	for (int i = 1; i <= r; i++) 
		for (int j = 1; j <= i; j++)cin >> a[i][j];
	for (int i = 1; i <= r; i++)dp[r][i] = a[r][i];
	for(int i=r-1;i>=1;i--)
		for (int j = 1; j <= i; j++) {
			dp[i][j] = a[i][j] + max(dp[i + 1][j], dp[i + 1][j + 1]);
		}
	cout << dp[1][1] << endl;
	return 0;
}