一道题弄懂递归、深度优先搜索、记忆化搜索、DP动态规划

参考博客https://blog.csdn.net/weixin_38391092/article/details/79590710

有一个层数为n(n<=1000)的数字三角形。现有一只蚂蚁从顶层开始向下走,每走下一级,可向左下方向或右下方向走。求走到底层后它所经过数字的总和的最大值。
【输入格式】
第一个整数为n,一下n行为各层的数字。
【输出格式】
一个整数,即最大值。
【输入样例 】
5
1
6 3
8 2 6
2 1 6 5
3 2 4 7 6
【输出样例】
23
【样例说明】
最大值=1+3+6+6+7=23

最近有点搞不懂DP、递归和DFS的有什么区别,看了这个博客,让我领悟了不少东西。这是很经典的一个题,学DP的时候知道这是DP经典的简单题,不知道还能用递归和DFS做。后来发现那样做也挺简单的,但是复杂度要高不少。好了,开始研究一下这三种方法吧。

递归算法

思路:如果用递归的方法,我们可以这样认为,要知道某一点所能达到的最大值,必须知道其左下或右下所能达到的最大值。依次推至最底层,获得最底层的值,再依次会算至顶点(1,1)

#include
using namespace std;
const int maxn = 1005;
int a[maxn][maxn];
int n;
int f(int x,int y)
{
	if(x==n)	return a[x][y];
	return a[x][y]+max(f(x+1,y),f(x+1,y+1));
}

int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		for(int j=1;j<=i;j++)
			scanf("%d",&a[i][j]);
	printf("%d\n",f(1,1));
	return 0;
}

记忆化搜索优化算法

运行上面的程序,可以发现运行速度是很慢的,会超时。这是因为在运行过程中,很多值被反复地计算。其实如果把已经计算出来的值保存起来,下次 用的时候直接那来算,速度会快上很多(其实就是用一个二维数组dp【】【】存储每个位置的最优解)。这就是所谓的记忆化搜索。

#include
using namespace std;
const int maxn = 1005;
int a[maxn][maxn];
int dp[maxn][maxn];
int n;
int f(int x,int y)
{
	if(x==n)	return a[x][y];
	if(dp[x][y])	return dp[x][y];
	dp[x][y]=a[x][y]+max(f(x+1,y),f(x+1,y+1));
	return dp[x][y];
}

int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		for(int j=1;j<=i;j++)
			scanf("%d",&a[i][j]);
	printf("%d\n",f(1,1));
	return 0;
}

深度优先搜索

前面的递归算法,实际上是将整个数字三角形搜索了一遍,所以,完全可以用深度优先搜索算法。就是一条路走到黑,前面没有路就返回上一个路口,另选一条路走到黑…..如此反复,知道所有路全部走遍。

#include
using namespace std;
const int maxn = 1005;
int a[maxn][maxn];
int dp[maxn][maxn];
int n;
int sum=0;
int MAX=0;
void dfs(int i,int j)
{
	sum+=a[i][j];
	if(i==n)
	{
		MAX=max(MAX,sum);
		return ;
	}
	for(int x=0;x<2;x++)
	{
		dfs(i+1,j+x);
		sum-=a[i+1][j+x];
	}
}

int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		for(int j=1;j<=i;j++)
			scanf("%d",&a[i][j]);
	dfs(1,1);
	printf("%d\n",MAX);
	return 0;
}

不过这个时间也很长,可能也会超时。原因一样,他没有记录每个位置的最优解,导致你计算其他位置的时候要重新计算这个位置的值。

动态规划

分析出状态转移方程:dp[i][j]=max(dp[i+1][j],dp[i+1][j+1])+a[i][j];

#include
using namespace std;
const int maxn = 1005;
int a[maxn][maxn];
int dp[maxn][maxn];
int n;

int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		for(int j=1;j<=i;j++)
			scanf("%d",&a[i][j]);
	for(int i=n;i>=1;i--)
	{
		for(int j=1;j<=i;j++)
		{
			dp[i][j]=max(dp[i+1][j],dp[i+1][j+1])+a[i][j];
		}
	}
	printf("%d\n",dp[1][1]);
	return 0;
}

至此,四种方法全部讲完,相信你们对递归、深度优先搜索、DP动态规划和记忆化搜索的理解又加深了不少吧。

你可能感兴趣的:(dp动态规划,dfs,递归,记忆化搜索)