数字金字塔（dfs||dp)

题目描述

假设有如下所示的一个数字金字塔，现在，要求写一个程序来查找从顶点到底部任意处结束的路径，使路径经过的数字的和最大，并输出该路径的最大和。

样例输入

5

7

3 2

8 1 0

2 7 4 4

4 5 2 6 5

样例输出

30

提示：该金字塔的和最大路径的和为7+3+8+7+5=30。

 方法一：记忆化搜索+DFS

记忆化搜索本质上就是dp，只不过他是用递归去实现的；

我们首先要确定他的设计状态，dfs(x,y)表示从该点出发到达终点最大路径和，那么dfs(1,1)就是我们想要的答案；

然后要求他的状态转移方程：

dfs(x,y)=a[x][y]+max(dfs(x+1,y),dfs(x+1,y+1));

最后再通过一个新的数组对答案进行记忆化

#include<iostream>
#include<cstring>
using namespace std;
int a[1010][1010];//记录数字金字塔 
int f[1010][1010]; //记录已经求出来的答案 
int n;
int dfs(int x,int y)
{
	if(f[x][y]!=-1) return f[x][y];
	
	if(x==n) f[x][y]=a[x][y];
	else f[x][y]=a[x][y]+max(dfs(x+1,y),dfs(x+1,y+1));
	
	return f[x][y]; 
}

int main()
{
	
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=i;j++)
		{
			cin>>a[i][j];
		}
	}
	memset(f,-1,sizeof(f));
	dfs(1,1);
	cout<<f[1][1];
	return 0;
}

 方法二：dp顺推

1.设计状态：定义f[x][y]为从（1，1）出发到（x,y)的路径的最大路径和，最后答案就是最后一行所有元素的最大值

2.状态转移方程

    f[i][j]=a[i][j]+max(f[i-1][j],f[i-1][j-1]);

 

#include<iostream>
#include<cstring>
using namespace std;
int a[1010][1010];//记录数字金字塔 
int f[1010][1010]; //记录已经求出来的答案 
int n;


int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=i;j++)
		{
			cin>>a[i][j];
		}
	}
	
	f[1][1]=a[1][1];
	for(int i=2;i<=n;i++)
	{
		for(int j=1;j<=i;j++)
		{
			f[i][j]=a[i][j]+max(f[i-1][j],f[i-1][j-1]);
		}
	} 
	
	int ans=0;
	for(int i=1;i<=n;i++)
	{
		ans=max(ans,f[n][i]);
	}
	cout<<ans;
	
	
	return 0;
}

方法三：dp逆推

1.设计状态：f[x][y]表示从最后一行到这个点的最大路径和，最终答案就是f[1][1];

2.转移状态方程：

f[i][j]=a[i][j]+max(f[i+1][j],f[i+1][j+1]);

#include<iostream>
#include<cstring>
using namespace std;
int a[1010][1010];//记录数字金字塔 
int f[1010][1010]; //记录已经求出来的答案 
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=1;i<=n;i++)
	{
		f[n][i]=a[n][i];
	}
	
	for(int i=n-1;i>=1;i--)
	{
		for(int j=1;j<=i;j++)
		{
			f[i][j]=a[i][j]+max(f[i+1][j],f[i+1][j+1]);
		}
	}
	cout<<f[1][1];
	
	return 0;
}