poj1163 The Triangle

The Triangle
Time Limit: 1000MS Memory Limit: 10000K
Total Submissions: 42118 Accepted: 25454
Description


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


(Figure 1)
Figure 1 shows a number triangle. Write a program that calculates the highest sum of numbers passed on a route that starts at the top and ends somewhere on the base. Each step can go either diagonally down to the left or diagonally down to the right. 
Input


Your program is to read from standard input. The first line contains one integer N: the number of rows in the triangle. The following N lines describe the data of the triangle. The number of rows in the triangle is > 1 but <= 100. The numbers in the triangle, all integers, are between 0 and 99.
Output


Your program is to write to standard output. The highest sum is written as an integer.
Sample Input


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

30

dp经典题

类似一个树状结构，dp状态定义为到当前节点（包括当前节点）最大和，子问题是到左右子节点（包括节点本身）最大和，状态转移方程可描述为

取到左右子节点为止（包括节点本身）最大和中的的较大值加上当前节点的值即为到当前节点（包括当前节点）最大和

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

可能最容易想到的方法是直接递归，利用递归本身回溯特性来从低到上计算，但是如果不做什么处理的话可能超时

#include <cstdio>
#include <algorithm>
#include <iostream>

using namespace std;

int a[105][105];
int n;

int solve(int i, int j) {   //容易超时，因为很多子问题被重复计算了多次
	if (i == n) {
		return a[i][j];
	}
	else {
		return a[i][j] + max(solve(i + 1, j), solve(i + 1, j + 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", solve(1, 1));
	return 0;
}

下面采用记忆化搜索，即先用一个特殊值标记dp数组，若检测dp为标记值说明之前没有被更新过，则更新dp数组，否则说明dp在之前计算过，则直接拿来用

#include <cstdio>
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>

using namespace std;

int a[105][105], dp[105][105], n;;
int sized = sizeof(dp);

int solve(int i, int j) {
	if (dp[i][j] >= 0) return dp[i][j]; //说明之前计算过
	//没有计算过
	if (i == n) {  //边界
		dp[i][j] = a[i][j];
	}
	else {
		dp[i][j] = a[i][j] + max(solve(i + 1, j + 1), solve(i + 1, j));
	}
	return dp[i][j];
}

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

最后一种是直接从下往上直接递推计算

#include <cstdio>
#include <algorithm>
#include <iostream>

using namespace std;

int a[105][105];
int dp[105][1005];

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