poj-1163 动态规划

这道题目并不能直接使用递归，因为

                                 7（1）

                       7（1）         7（1）   

                7（1）      7（2）         7（1）

        7（1）       7（3）         7（3）          7（1）

7（1）      7（4）         7（6）        7（4）         7（1）

假设题目中的数据是这样子的，小括号内代表着每个数被递归调用的次数。

这个三角实际上是一个杨辉三角，它的和为  2^n -2  ，题目中的层数大小是100以内，那最大的话就要算到  2^100 ，

这已经不是超时的问题了，汗颜。

那怎么办呢？我们只需要将每次用到的值它的最大值存起来，等着返回的时候，让上层的递归直接使用就可以了。

这样的话复杂度就是等差数列，就是n（n-1）/2，所以这次就不用等到宇宙毁灭了。

#include <iostream>
#include <algorithm>
#define MAX 101
using namespace std;
int n,D[MAX][MAX];
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 (int i=1;i<=n;i++) {
		for (int j=1;j<=i;j++) {
			cin>>D[i][j];
			maxsum[i][j]=-1;
		}
	}
	cout<<MaxSum(1,1)<<endl;
	return 0;
}