J - 数塔 HDU - 2084（深搜，记忆化搜索+）

在讲述DP算法的时候，一个经典的例子就是数塔问题，它是这样描述的：

有如下所示的数塔，要求从顶层走到底层，若每一步只能走到相邻的结点，则经过的结点的数字之和最大是多少？

已经告诉你了，这是个DP的题目，你能AC吗?
Input
输入数据首先包括一个整数C,表示测试实例的个数，每个测试实例的第一行是一个整数N(1 <= N <= 100)，表示数塔的高度，接下来用N行数字表示数塔，其中第i行有个i个整数，且所有的整数均在区间[0,99]内。
Output
对于每个测试实例，输出可能得到的最大和，每个实例的输出占一行。
Sample Input
1
5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
Sample Output
30
一开始学长讲这个题的时候就听懵逼的，回来自己研究了一下，发现还可以。主要是要有从下往上的意识，可以用两种方法，记忆化搜索和dp，先说记忆话搜索
代码如下：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int mp[101][101];
int mk[101][101];
int dp[101][101];
int d[][2]={{1,0},{1,1}};//根据题意写方向。
int n;
int dfs(int x,int y)
{
	if(dp[x][y]!=-1) return dp[x][y];
	if(x==n) dp[x][y]=mp[x][y];//当到达最底层的时候，就要将dp[x][y]更新为mp[x][y].
	int max_=0;
	for(int i=0;i<2;i++)
	{
		int tx=x+d[i][0];
		int ty=y+d[i][1];
		//if(tx>n||ty>tx) continue;
		if(mk[tx][ty]) continue;
		mk[tx][ty]=1;
		max_=max(max_,dfs(tx,ty)+mp[x][y]);
		mk[tx][ty]=0;
	}
	return dp[x][y]=max_;
	/*else
	{
		int tx=dfs(x+1,y);
		int ty=dfs(x+1,y+1);
		dp[x][y]=max(tx,ty)+mp[x][y];
	}
	return dp[x][y];*/
}
int main()
{
	int m;
	cin>>m;
	while(m--)
	{
		cin>>n;
		for(int i=1;i<=n;i++)
		for(int j=1;j<=i;j++)
		cin>>mp[i][j];
		memset(dp,-1,sizeof(dp));//因为有可能是0，所以一开始全为-1。
		cout<<dfs(1,1)<<endl;
	}
	return 0;
}

接下来就是dp思想了。。其实比记忆化搜索简单，就是个动态规划。
代码如下：

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

思路跟记忆化搜索大同小异。个人推荐第二种，比记忆化搜索简单且好想。嘿嘿
努力加油a啊，(^o)/~