7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
在上面的数字三角形中寻找一条从顶部到底边的路径,使得路径上所经过的数字之和最大。路径上的每一步都只能往左下或右下走。只需要求出这个最大和即可,不必给出具体路径。
三角形的行数大于1小于等于100,数字为 0 - 99
输入格式:
5//三角形行数。下面是三角形
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
要求输出最大和
思路:这是一道很典型的动态规划的问题,什么时候用动态规划一般具有两个特点:
1.问题具有最优子结构性质。如果问题的最优解所包含的子问题的解也是最优的,我们就称该问题具有最优子结构性质。
2.无后效性。当前的若干个状态值一旦确定,则此后过程的演变就只和这若干个状态的值有关,和之前是采取哪种手段或经过哪条路径演变到当前的这若干个状态,没有关系。
第一个代码是递归的函数实现,很简单一看就会(但是用很多重复的运算,所以非常非常非常的耗时间)O(2^n)
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int n;
int a[101][101];
int MaxSum(int i,int j){
if(i==n){
return a[i][j];
}
int x=MaxSum(i+1,j);
int y=MaxSum(i+1,j+1);
return max(x,y)+a[i][j];
}
int main(){
cin>>n;
for(int i=1;i<=1;i++){
for(inr j=1;j<=i;j++){
cin>>a[i][j];
}
}
cout<<MaxSum(1,1)<<endl;
}
改进之后就是第二种,引入一个二维数组p,把算的的值都放在对应的数组里,需要用的时候就直接调用
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int n;
int a[101][101];
int p[101][101];
int MaxSum(int i,int j){
if(p[i][j]!=-1){
return p[i][j];
}
if(i==n){//递归出口
return p[i][j]=a[i][j];
}
else{
int x=MaxSum(i+1,j);
int y=MaxSum(i+1,j+1);
return p[i][j]=max(x,y)+a[i][j];
}
}
int main(){
cin>>n;
for(int i=1;i<=n;i++){
for(int j=1;j<=i;j++){
cin>>a[i][j];
p[i][j]=-1;
}
}
cout<<MaxSum(1,1)<<endl;
}
因为递归相对于递推来说,运行效率不是很高,所以一般把递归转换成递推;
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int n;
int a[101][101];
int x[101][101];
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=1;i<n;i++){//最后一行
x[n][i]=a[n][i];
}
for(int i=n-1;i>=1;i--){//递归转变成递推
for(int j=1;j<=i;j++){//递归转变成递推
x[i][j]=max(x[i+1][j],x[i+1][j+1])+a[i][j];
}
}
cout<<x[1][1]<<endl;
}
最后,要节省空间,可以用数组的最后一行代替,因为在执行完一遍之后,最后一行就没有作用了。
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int n;
int a[101][101];
int *t;
int main(){
cin>>n;
for(int i=1;i<=n;i++){//行数
for(int j=1;j<=i;j++){//列数
cin>>a[i][j];
}
}
t=a[n];
for(int i=n-1;i>=1;i--){//递归转变成递推
for(int j=1;j<=i;j++){//递归转变成递推
t[j]=max(t[j],t[j+1])+a[i][j];
}
}
cout<<t[1]<<endl;
}