观察下面的数字金字塔,查找从最高点到底部任意结束的路径,使路径经过的数字之和最大。每一步可以从当前点走到左下方的点或者右下方的点。
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步组成,每一步有左下,右下两种选择,路径总数为2n-1 时间复杂度为O(2n-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;
}