动态规划——P1216 [USACO1.5][IOI1994]数字三角形 Number Triangles

观察下面的数字金字塔。

写一个程序来查找从最高点到底部任意处结束的路径，使路径经过数字的和最大。每一步可以走到左下方的点也可以到达右下方的点。

    7 
  3   8 
8   1   0 

2 7 4 4
4 5 2 6 5

在上面的样例中,从 7→3→8→7→57 \to 3 \to 8 \to 7 \to 57→3→8→7→5 的路径产生了最大
输入格式

第一个行一个正整数 rrr ,表示行的数目。

后面每行为这个数字金字塔特定行包含的整数。
输出格式

单独的一行,包含那个可能得到的最大的和。
输入输出样例
输入

5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5

输出

30

说明/提示

【数据范围】
对于 100%100%100% 的数据，1≤r≤10001\le r \le 10001≤r≤1000，所有输入在 [0,100][0,100][0,100] 范围内。

#include<iostream>
using namespace std;
int a[1001][1001];
int n;
//返回最大值的函数
int max(int a, int b)
{
	return a > b ? a : b;
}
int f(int i, int j)
{
	int ans = 0;
	if (i == n)return ans;//递归出口，当找到最后面一层就是答案
	ans = a[i][j] + max(f(i + 1, j), f(i + 1, j + 1));//状态转移方程：分为选择a[i+1][j]和a[i+1][j+1]两种情况，返回最优解
}
int main()
{
	//输入格式
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j <= i; j++)
		{
			cin >> a[i][j];
		}
	}
	cout << f(0, 0);//自上而下规划
	return 0;
}

虽然状态转移方程没错，但是这种方法过不了洛谷，出现了超时的现象，因为在状态转移方程中会出现很多重复的数据，进行了重复的运算，我们可以通过记忆性搜索进行优化。

#include<iostream>
using namespace std;
//空间换取时间
int a[1001][1001], record[1001][1001], dp[1001][1001];//数组都为0  a是输入的数组，record是记录数组，dp是返回记录的值的数组
int n;
//返回最大值的函数
int max(int a, int b)
{
	return a > b ? a : b;
}
int f(int i, int j)
{
	int ans = 0;
	if (i == n)return ans;//递归出口，当找到最后面一层就是答案
	if (record[i][j] > 0)return dp[i][j];//如果大于0，则意味着之前运算过，直接返回，减少多余的运算
	ans = a[i][j] + max(f(i + 1, j), f(i + 1, j + 1));//状态转移方程：分为选择a[i+1][j]和a[i+1][j+1]两种情况，返回最优解
	record[i][j] = 1;//进行标记
	dp[i][j] = ans;//进行标记
	return ans;
}
int main()
{
	//输入格式
	cin >> n;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j <= i; j++)
		{
			cin >> a[i][j];
		}
	}
	cout << f(0, 0);//自上而下规划
	return 0;
}

介绍完上面两种方法，还有一个滑窗技巧，因为都是从头到尾，那么我们从后往前看也不会影响动态规划最优子结构性和无后效性,a[i][j]就是a[i-1][j]和a[i-1][j-1]二者最优解所产生。

//滑窗做法
#include<iostream>
using namespace std;
int a[1001][1001], dp[1001];//a是输入的数组，dp是的最后一行数据
int max(int a, int b)
{
	return a > b ? a : b;
}
int f(int n)
{
	//从后往前处理，先将最后一行赋值给dp
	for (int j = 1; j <= n; j++)
	{
		dp[j] = a[n][j];
	}
	for (int i = n - 1; i >= 1; i--)
	{
		for (int j = 1; j <= i; j++)
		{
			//状态转移方程，dp[j]和dp[j+1]里面产生的dp[j]（逆向思维）
			dp[j] = max(dp[j], dp[j + 1]) + a[i][j];
		}
	}
	return dp[1];//从后面找到前面，返回答案
}
int main()
{
	int n;
	cin >> n;
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= i; j++)
		{
			cin >> a[i][j];
		}
	}
	cout << f(n);
	return 0;
}