数字金字塔（动态规划）

问题描述：

观察下面的数字金字塔，查找从最高点到底部任意结束的路径，使路径经过的数字之和最大。每一步可以从当前点走到左下方的点或者右下方的点。

                         13

                   11         8

             12          7          26

       6          14          15          8

12          7          13         24         11

（每个点与左下方和右下方有连接线，请自己想象喔！！）

最优路线：13-8-26-15-24=86.

本题介绍四种方法给大家，有助于大家对动态规划有更深入的了解。

方法一：搜索

路径起点终点明确，走法固定，可以考虑搜索解决。

定义递归函数void  dfs(int x,int y,int curr),表示从（1，1）走到点（x，y）的权值和curr。

当x=n时，到达边界。用所得的curr和ans比较，如果curr比较大，更新ans的值。

如果x<n,继续递归，dfs(x+1,y,curr+a[x+1][y])和dfs(x+1,y+1,a[x+1][y+1])。

参考程序：

#include<iostream>
using namespace std;
int a[1010][1010],ans=0;
int n;//输入数塔层数n
void dfs(int x,int y,int curr)
{
	if(x==n)
	{
		if(curr>ans) ans=curr;
		return ;
	}
	dfs(x+1,y,curr+a[x+1][y]);
	dfs(x+1,y+1,curr+a[x+1][y+1]); 
}
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=i;j++)
			cin>>a[i][j];
	dfs(1,1,a[1][1]); 
	cout<<ans<<endl; 
	return 0;
}

此方法实际把所有的路径都走了一遍，由于每条路径有n-1步组成，每一步有左下，右下两种选择，路径总数为2^n-1   时间复杂度为O(2^n-1),

方法二：记忆化搜索

方法一有严重的问题，当n比较大时会花费太多时间，因为它进行了重复的搜索。如一条路径为13-11-12-6-12，另一条为13-11-12-6-7，对于11，12，6这些点进行了重复的搜索。我们完全可以在第一次搜索这些点时，就将这些点到终点的最大权值和记录下来，当我们再次到达这个点，就可以直接调用，不用重复搜索，这种方法就叫记忆化搜索。

因此，我们需要重新定义递归函数dfs。定义dfs（int x，int y）表示（x，y）到终点的最大权值和，最后的答案就是dfs（1，1）.

为了避免重复搜索，我们开设一个数组dg[x][y]表示（x，y）点到终点的最大权值。

参考程序：

#include<iostream>
using namespace std;
int a[550][550],dg[550][550];
int n;
int dfs(int x,int y)
{
	if(dg[x][y]==-1)//判断是否已经计算过 
	{
		if(x==n)  dg[x][y]=a[x][y];
		else dg[x][y]=max(dfs(x+1,y),dfs(x+1,y+1))+a[x][y];
	}
	return dg[x][y];//计算过直接返回 
}
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=i;j++)
		{
			cin>>a[i][j];
			dg[i][j]=-1;
		}	
	dfs(1,1);
	cout<<dg[1][1]<<endl;
	return 0;
}

由于每一个点都只计算过一次，且是O（1）的时间，所以这种方法的时间复杂度为O（N*N）(n的平方）

方法三：动态规划（顺推法）

方法二的记忆化搜索，从本质来讲已经算是动态规划了。下面从动态规划的角度分析解题过程。

1.确定状态：

题目求解（1，1）到最底层路径的最大权值，路径起点固定，终点和中间点不确定，因此定义dg[x][y]表示从（1，1）出发到（x，y）路径的最大权值和。最终答案就是寻找最底层的最大值，ans=max{dg[n][1],dg[n][2],dg[n][3]...dg[n][n]}.

2.确定状态转移方程和边界条件

不去考虑（1，1）到（x，y）中间是怎么走的，只需要考虑（x，y）上一步是怎么来的，上一步可能是（x-1，y），也可能是（x-1，y-1），因此dg[x][y]的最大值就是上一步的最大权值和：max{dg[x-1][y],dg[x-1][y-1])，再加上自己的权值a[x][y]。

所以状态转移方程就是：dg[x][y]=max{dg[x-1][y],dg[x-1][y-1]}+a[i][j]。

与递归一样，我们也需要终止条件，防止无限递归下去。我们发现dg[x][y]的值取决于dh[x-1][y],dg[x-1][y-1]，随着递归的深入，最后一定会递归到dg[1][1]，dg[1][1]不能再使用状态转移方程了，所以给dg[1][1]附一个初值，即a[1][1]。

参考程序

#include<iostream>
using namespace std;
int a[550][550],dg[550][550];
int n;
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=i;j++)
			cin>>a[i][j];
	dg[1][1]=a[1][1];	
	for(int i=2;i<=n;i++)
	{
		for(int j=1;j<=i;j++)
		{
			dg[i][j]=max(dg[i-1][j-1],dg[i-1][j])+a[i][j];
		}
	 } 
	 int ans=0;
	 for(int i=1;i<=n;i++)
	 	ans=max(ans,dg[n][i]);
	cout<<ans<<endl;
	return 0;
}

这种方法的时间复杂度一样是O（n*n）（n的平方）

方法四：动态规划（逆推）

从根节点，最底层的点出发，向上走，选择它上一层两个方向的最大值为最大的路径，然后从n-1层继续向上，找自己两个方向的最大值，一直到（1，1）。

动态规划求解过程就可以归纳为：自顶向下分析，自底向上计算。

下面具体分析整个过程，大家就明白了。

以问题描述中的样例为例。

第4层  6  14  15  8

6这个点要找最大路径，就要选择和它连接12和7中的最大值，同理14选择7和13中最大值，15选择13和24中最大值，8选择24和11中最大值，他们分别选择两个方向的最大值，然后第4层就更新为了

18  27  39  32

同理第三层12  7  26

寻找两个方向的最大值，不过两个方向的值已经更新，选择新的值中的最大值，12选择18和27，7选择27和39，26选择39和32

得到第三层为39  46  65

第二层 11  8

更新为57  73

最后第一层选择57和73，a[1][1]就为73+13=86，即最后的答案。

参考程序：

#include<iostream>
using namespace std;
int a[550][550];
int n;
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=i;j++)
			cin>>a[i][j];	
	for(int i=n-1;i>=1;i--)
	{
		for(int j=1;j<=i;j++)
			a[i][j]+=max(a[i+1][j],a[i+1][j+1]);//寻找最大的路径 
	 } 
	cout<<a[1][1]<<endl;
	return 0;
}