POJ 1163 The Triangle（经典问题教你彻底理解动归思想）

The Triangle

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 38195		Accepted: 22946

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

题意：

在上面的数字三角形中寻找一条从顶部到底边的路径，使得
路径上所经过的数字之和最大。路径上的每一步都只能往左下或
右下走。只需要求出这个最大和即可，不必给出具体路径。
三角形的行数大于1小于等于100，数字为 0 - 99

超级经典啊有木有，，理解动归必看啊有木有。。。

解题思路：
用二维数组存放数字三角形。
D( r, j) : 第r行第 j 个数字(r,j从1开始算)
MaxSum(r, j) : 从D(r,j)到底边的各条路径中，
最佳路径的数字之和。
问题：求 MaxSum(1,1)
典型的递归问题。
D(r, j)出发，下一步只能走D(r+1,j)或者D(r+1, j+1)。故对于N行的三角形：
if ( r == N)
MaxSum(r,j) = D(r,j)
else
MaxSum( r, j) = Max{ MaxSum(r＋1,j), MaxSum(r+1,j+1) } + D(r,j)

数字三角形的递归程序:

#include <iostream>
#include <algorithm>
#define MAX 101
using namespace std;
int D[MAX][MAX];
int n;
int MaxSum(int i, int j){
if(i==n)
return D[i][j];
int x = MaxSum(i+1,j);
int y = MaxSum(i+1,j+1);
return max(x,y)+D[i][j];
}

int main(){
int i,j;
cin >> n;
for(i=1;i<=n;i++)
for(j=1;j<=i;j++)
cin >> D[i][j];
cout << MaxSum(1,1) << endl;
}

为什么超时？
回答：重复计算
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
如果采用递规的方法，深度遍历每条路径，存在大
量重复计算。则时间复杂度为 2 n ,对于 n = 100
行，肯定超时。

比如：当我们在计算第三行长度时，因为8 1 0的产生都基于第四行的”7“这个位置，即的D[4][2],又在进行路径搜索时前面共有1*2*3条路径，这就会重复计算6*2次==12次。

考虑到如果能去除重复将会使得程序运行效率大大提高。那么具体怎么做呢？？？

如果每算出一个MaxSum(r,j)就保存起来，下次用
到其值的时候直接取用，则可免去重复计算。那么
可以用O(n 2 )时间完成计算。因为三角形的数字总
数是 n(n+1)/2

数字三角形的记忆递归型动归程序：

#include <iostream>
#include <algorithm>
using namespace std;
#define MAX 101
int D[MAX][MAX]; int n;
int maxSum[MAX][MAX];
int MaxSum(int i, int j){
if( maxSum[i][j] != -1 )
return maxSum[i][j];
if(i==n) maxSum[i][j] = D[i][j];
else {
int x = MaxSum(i+1,j);
int y = MaxSum(i+1,j+1);
maxSum[i][j] = max(x,y)+ D[i][j];
}
return maxSum[i][j];
}
int main(){
int i,j;
cin >> n;
for(i=1;i<=n;i++)
for(j=1;j<=i;j++) {
cin >> D[i][j];
maxSum[i][j] = -1;
}
cout << MaxSum(1,1) << endl;
}

若首先对最底层maxsum[n][j]进行赋值，那么就可以不断向上递推出最大值maxsum[1][1]。

递推型动归程序：

#include <iostream>
#include <algorithm>
using namespace std;
#define MAX 101
int D[MAX][MAX]; int n;
int maxSum[MAX][MAX];
int main() {
int i,j;
cin >> n;
for(i=1;i<=n;i++)
for(j=1;j<=i;j++)
cin >> D[i][j];
for( int i = 1;i <= n; ++ i )
maxSum[n][i] = D[n][i];
for( int i = n-1; i>= 1; --i )
for( int j = 1; j <= i; ++j )
maxSum[i][j] = max(maxSum[i+1][j],maxSum[i+1][j+1]) + D[i][j]
cout << maxSum[1][1] << endl;
}

空间优化：

没必要用二维maxSum数组存储每一个MaxSum(r,j),只要从底层一行行向上
递推，那么只要一维数组maxSum[100]即可,即只要存储一行的MaxSum值就
可以。

想一下：具体情形是这样的，依次选取相邻两个中最大的再加上D[i][j],那么新得到的数值将存储到数组中并覆盖这个相邻数的前一个，每经过一次i循环，数组被覆盖的数值逐渐减少，知道第二行相加覆盖第一行也就是第一个数组D[1].你会发现，只有数组中的第n个数是没有改变的，，

看代码：

#include <iostream>
#include <algorithm>
using namespace std;
#define MAX 101
int D[MAX][MAX];
 int n;
int maxSum[MAX];
int max(int a,int b)
{return a>b?a:b;}
int main() {
	int i,j;
	cin >> n;
	for(i=1;i<=n;i++)
		for(j=1;j<=i;j++)
			cin >> D[i][j];
		for(i = 1;i <= n; ++ i )
			maxSum[i] = D[n][i];
		for(i = n-1; i>= 1; --i )
			for(j = 1; j <= i; ++j )
				maxSum[j] = max(maxSum[j],maxSum[j+1]) + D[i][j];
				cout << maxSum[1] << endl;
				return 0;
}

进一步考虑，连maxSum数组都可以不要，直接用D的
第n行替代maxSum即可。
节省空间，时间复杂度不变

看代码：

#include <iostream>
#include <algorithm>
using namespace std;
#define MAX 101
int D[MAX][MAX];
int n; int * maxSum;
int main(){
int i,j;
cin >> n;
for(i=1;i<=n;i++)
for(j=1;j<=i;j++)
cin >> D[i][j];
maxSum = D[n]; //maxSum指向第n行
for( int i = n-1; i>= 1; --i )
for( int j = 1; j <= i; ++j )
maxSum[j] = max(maxSum[j],maxSum[j+1]) + D[i][j];
cout << maxSum[1] << endl;
}

动规解题的一般思路
1. 将原问题分解为子问题
 把原问题分解为若干个子问题，子问题和原问题形式相同
或类似，只不过规模变小了。子问题都解决，原问题即解
决(数字三角形例）。
 子问题的解一旦求出就会被保存，所以每个子问题只需求
解一次。

2. 确定状态
 在用动态规划解题时，我们往往将和子问题相
关的各个变量的一组取值，称之为一个“状
态”。一个“状态”对应于一个或多个子问题，
所谓某个“状态”下的“值”，就是这个“状
态”所对应的子问题的解。

2. 确定状态
所有“状态”的集合，构成问题的“状态空间”。“状态
空间”的大小，与用动态规划解决问题的时间复杂度直接相关。
在数字三角形的例子里，一共有N×(N+1)/2个数字，所以这个
问题的状态空间里一共就有N×(N+1)/2个状态。
整个问题的时间复杂度是状态数目乘以计算每个状态所需
时间。
在数字三角形里每个“状态”只需要经过一次，且在每个
状态上作计算所花的时间都是和N无关的常数。

2. 确定状态
用动态规划解题，经常碰到的情况是，K个整型变量能
构成一个状态（如数字三角形中的行号和列号这两个变量
构成“状态”）。如果这K个整型变量的取值范围分别是
N1, N2, ……Nk，那么，我们就可以用一个K维的数组
array[N1] [N2]……[Nk]来存储各个状态的“值”。这个
“值”未必就是一个整数或浮点数，可能是需要一个结构
才能表示的，那么array就可以是一个结构数组。一个
“状态”下的“值”通常会是一个或多个子问题的解。

3. 确定一些初始状态（边界状态）的值
以“数字三角形”为例，初始状态就是底边数字，值
就是底边数字值。

4. 确定状态转移方程
定义出什么是“状态”，以及在该 “状态”下的“值”后，就要
找出不同的状态之间如何迁移――即如何从一个或多个“值”已知的
“状态”，求出另一个“状态”的“值”(“人人为我”递推型)。状
态的迁移可以用递推公式表示，此递推公式也可被称作“状态转移方
程”。
数字三角形的状态转移方程:

能用动规解决的问题的特点
1) 问题具有最优子结构性质。如果问题的最优解所包含的
子问题的解也是最优的，我们就称该问题具有最优子结
构性质。
2) 无后效性。当前的若干个状态值一旦确定，则此后过程
的演变就只和这若干个状态的值有关，和之前是采取哪
种手段或经过哪条路径演变到当前的这若干个状态，没
有关系。