POJ 1088滑雪（3种解法）

描述

Michael喜欢滑雪百这并不奇怪， 因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael想知道载一个区域中最长的滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子

 1 2 3 4 5 
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度减小。在上面的例子中，一条可滑行的滑坡为24-17-16-1。当然25-24-23-...-3-2-1更长。事实上，这是最长的一条。

输入

输入的第一行表示区域的行数R和列数C(1 <= R,C <= 100)。下面是R行，每行有C个整数，代表高度h，0<=h<=10000。

输出

输出最长区域的长度。

样例输入

5 5 
1 2 3 4 5
16 17 18 19 6 
15 24 25 20 7
14 23 22 21 8 
13 12 11 10 9

样例输出

25

这道题有三种解法

第一种记忆化搜索.

引用  https://blog.csdn.net/hjf1201/article/details/78680814

什么是记忆化搜索呢？搜索的低效在于没有能够很好地处理重叠子问题；动态规划虽然比较好地处理了重叠子问题，但是在有些拓扑关系比较复杂的题目面前，又显得无奈。记忆化搜索正是在这样的情况下产生的，它采用搜索的形式和动态规划中递推的思想将这两种方法有机地综合在一起，扬长避短，简单实用，在信息学中有着重要的作用。
用一个公式简单地说：记忆化搜索=搜索的形式+动态规划的思想。
动态规划：就是一个最优化问题，先将问题分解为子问题，并且对于这些分解的子问题自身就是最优的才能在这个基础上得出我们要解决的问题的最优方案，要不然的话就能找到一个更优的解来替代这个解，得出新的最优自问题，这当然是和前提是矛盾的。动态规划不同于 贪心算法，因为贪心算法是从局部最优来解决问题，而动态规划是全局最优的。用动态规划的时候不可能在子问题还没有得到最优解的情况下就做出决策，而是必须等待子问题得到了最优解之后才对当下的情况做出决策，所以往往动态规划都可以用 一个或多个递归式来描述。而贪心算法却是先做出一个决策，然后在去解决子问题。这就是贪心和动态规划的不同。
一般遇到一个动态规划类型的问题，都先要确定最优子结构，还有重叠子问题，这两个是动态规划最大的特征，然后就是要写 动态规划的状态方程，这个步骤十分十分的重要的，写动归方程是需要一定的经验的，这可以通过训练来达到目的。接着就是要自底向上的求解问题的，先将最小规模的子问题的最优解求出，一般都用一张表来记录下求得的解，到后来遇到同样的子问题的时候就可以直接查表得到答案，最后就是通过一步一步的迭代得出最后问题的答案了。
我的理解最重要的东西就是一定会要一个数组或者其他的存储结构存储得到的子问题的解。这样就可以省很多时间，也就是典型的空间换时间
动态规划的一种变形就是记忆化搜索，就是根据动归方程写出递归式，然后在函数的开头直接返回以前计算过的结果，当然这样做也需要一个存储结构记下前面计算过的结果，所以又称为记忆化搜索。
记忆化搜索递归式动态规划
1.记忆化搜索的思想
记忆化搜索的思想是,在搜索过程中，会有很多重复计算,如果我们能记录一些状态的答案，就可以减少重复搜索量
2、记忆化搜索的适用范围
根据记忆化搜索的思想，它是解决重复计算，而不是重复生成，也就是说，这些搜索必须是在搜索扩展路径的过程中分步计算的题目，也就是“搜索答案与路径相关”的题目，而不能是搜索一个路径之后才能进行计算的题目，必须要分步计算，并且搜索过程中，一个搜索结果必须可以建立在同类型问题的结果上，也就是类似于动态规划解决的那种。
也就是说，他的问题表达，不是单纯生成一个走步方案，而是生成一个走步方案的代价等，而且每走一步，在搜索树/图中生成一个新状态，都可以精确计算出到此为止的费用，也就是，可以分步计算，这样才可以套用已经得到的答案
3、记忆化搜索的核心实现
    a. 首先，要通过一个表记录已经存储下的搜索结果，一般用哈希表实现
    b.状态表示，由于是要用哈希表实现，所以状态最好可以用数字表示，常用的方法是把一个状态连写成一个p进制数字，然后把这个数字对应的十进制数字作为状态
    c.在每一状态搜索的开始，高效的使用哈希表搜索这个状态是否出现过，如果已经做过，直接调用答案，回溯  
    d.如果没有，则按正常方法搜索
4、记忆化搜索是类似于动态规划的，不同的是，它是倒做的“递归式动态规划”。

这道题我要写的第一种写法就是记忆化搜索

应为你要求最长的滑雪坡的长度   求一个最长的下降序列，并且 你只能向 上下左右走，只能走更低的位置，这样的话，我们搜索每一个点能够下降的最长的长度，我们就可以用递归DFS去搜索，直到搜到边界返回（边界就是上下左右都不能走，然后自己的值是 1 ），但是这样搜索一定会超时，因为我们进行了太多的重复搜索。因为，当这个位置已经被搜过后，那这个点就是此时能够到最低点的最长的坡，当我们下次搜索时，还会进去继续搜索，所以记忆化搜索就出现了，我们用一个数组来保存当我们搜索过的值，就可以避免重复搜索，每当我们再搜索到这里时，我们直接用它已经搜索过的值即可。

//什么是记忆化搜索？
//简单的说就是深搜或者广搜有时会对一个数据多次没必要的访问，我们用一个数组把这个数据的值保存下来，比这个数值小或者大的时间我们就没有必要再继续访问。
 
#include<iostream>
using namespace std;
int to[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
int n, m;
int high[105][105];
int maxLen[105][105];
bool check(int x, int y){
	if(x >= 1 && y >= 1 && x <= n && y <= m)
		return 1;
	else
		return 0;
}

int dfs(int x, int y){
	if (maxLen[x][y] != 0)	//退出边界 ，这个点已经搜索过，或者这个点是边界
		return maxLen[x][y];
	
	maxLen[x][y] = 1;        //最低的点就是1;
	for(int i = 0; i <= 4; i++){    //搜索上下左右
		int x1 = x + to[i][0];
		int y1 = y + to[i][1];
		if( check(x1, y1) && high[x1][y1] < high[x][y]){    //判断能否向下滑
			maxLen[x][y] = max(dfs(x1, y1) + 1, maxLen[x][y]);
		}
	}
	return maxLen[x][y];    //返回搜索过的点，并保存在数组中
}
int main(){

	cin >> n >> m;

	int ans = 1;
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= m; j++){
			cin >> high[i][j];
			maxLen[i][j] = 0;      
		}
	}
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= m; j++){
			ans = max(ans, dfs(i, j));	//搜索每一个点，并且找出最大值
		}
	}
	cout << ans << endl;
	return 0;
} 

第二种写法（我为人人形式的动态规划）

这题的本质：我们需要找到一个最长的上升子序列，那我们就可以想，这道题的动态规划的状态方程，我们稍加思考，我们如果从下往上推，找到最小的点，然后可以用这个点更新上下左右的点，如果从这个点到上下左右4个点的上升序列比 这4个点本身的上升序列 变长了就更新并记录。直到找到最大值。

第一步，我们需要将所有的点按 递增序列排序。

第二步，我们从最低点更新上下左右的4个点，直到每给个点都用了。

第三步，输出我们找的过程中的最大值。

为什么是我为人人型 动态规划呢？因为每用一个点，这个点的作用是更新其他4个点的最大上升序列值，所以是我为人人。

#include<iostream>
#include<algorithm>
using namespace std;
int n ,m;
int high[105][105];

int maxLen[105][105];
int to[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
int max1 = 1;
struct node{
	int x;
	int y;
	int data;
};

bool cmp(node a, node b){
	return a.data < b.data;
}

bool check(int x, int y){
	if( x >= 1 && y >= 1 && x <= n && y <= m)
		return 1;
	else
		return 0;
}
void maxL(node s[], int index){
	int x, y;
	x = s[index].x;
	y = s[index].y;
	for(int i = 0; i < 4; i++){
		int x1 = x + to[i][0];
		int y1 = y + to[i][1];
		if( check(x1, y1 )){
			if(maxLen[x1][y1] < maxLen[x][y] + 1 && high[x1][y1] > high[x][y]){
				maxLen[x1][y1] = maxLen[x][y] + 1;
				if( max1 < maxLen[x1][y1] ){
					max1 = maxLen[x1][y1];
				}
			}
		}
	}
}

int main (){

	cin >> n >> m;
	int k = 0;
	node s[10005];
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= m; j++){
			cin >> high[i][j];
			s[++k].data = high[i][j];
			s[k].x = i;
			s[k].y = j;
			maxLen[i][j] = 1;    //为什么初始化为1 想一想
		}
	}
	sort(s + 1, s + k + 1, cmp);
	for(int i = 1; i <= k; i++){
		maxL(s, i);
	}	
	cout << max1 <<  endl;

	return 0;
}

第三种 人人为我型 动态规划

这种给记忆化搜索差不多，你的目的是求每一个结点的最长升子序列，那你这个点的值取决什么呢？  是不是取决与他上下左右4个点的最长上升子序列，那用递归就好写了，但是把他转化成动态规划，这个思路就是找到状态方程，那我们把这个问题分解，就是求每个点的上升子序列，那我们找到边界，就是最低的那个点。这个人人为我型和我为人人型的唯一不一样就是这里，我为人人型 是用这个点更新其他4个点，而人人为我型就是用周围4个点更新这个一个点。找到一个周围4个点没法更新他的，不就是最低的那个点么？我们就想出了这个状态方程，从边界往上推，直到推到最后一个点（最高的点）

第一步，先进行点排序递增排序。

第二步，找到最小的点，用上下左右的点更新他，然后次小，一直到最大，（排完序后一个循环就OK）

第三步，找的过程中记录每个点的状态，并找到最大值，

#include<iostream>
#include<stdio.h>
#include<algorithm>
using namespace std;
	int n ,m;
struct node{
	int x;
	int y;
	int data;
};

bool cmp(node a, node b){
	return a.data < b.data;
}

bool check(int x, int y){
	if( x >= 1 && y >= 1 && x <= n && y <= m)
		return 1;
	else
		return 0;
}

int main (){

	int high[105][105];
	int maxLen[105][105];
	int to[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
	int ans = 1;
	cin >> n >> m;
	int k = 0;
	node s[10006];
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= m; j++){
			scanf("%d", &high[i][j]);
			s[++k].data = high[i][j];
			s[k].x = i;
			s[k].y = j;
			maxLen[i][j] = 1;
		}
	}
	sort(s + 1, s + k + 1, cmp);
	for(int i = 1 ; i <= k; i++){
		int x1, y1;
		
		for(int j = 0; j < 4; j++){
			int x = s[i].x;
			int y = s[i].y;
			x1 = x + to[j][0];
			y1 = y + to[j][1];
			if(check(x1, y1)){
				if(high[x][y] > high[x1][y1]){
					maxLen[x][y] = max(maxLen[x1][y1] + 1, maxLen[x][y]);
					ans = max(ans, maxLen[x][y]);
				}
			}
		} 
	}
	cout << ans <<  endl;
	return 0;
}