【记忆化】滑雪

七七是冰属性的角色，因此她很喜欢雪，也喜欢滑雪，这并不奇怪，因为滑雪的确很刺激（虽然她是个萌萌的小僵尸）。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。七七想知道在一个区域中最长的滑坡。滑雪区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子：

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（从 24 开始，在 1 结束）。当然 25－24－23－...－3－2－1更长。事实上，这是最长的一条。

输入

输入的第一行为表示区域的二维数组的行数 R 和列数 C。下面是 R 行，每行有 C 个数，代表高度(两个数字之间用 1 个空格间隔)。

输出

输出区域中最长滑坡的长度。

输入样例 1 

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

输出样例 1

25

分析：

题目需要找从高到低的路线，首先想到的就是贪心（先找最高的高度，然后依次往下找比它小的），这样是不可以的，反例如下：

45	43	42	41	40
47	46	1	1	1
48	49	1	50	1
5	4	1	1	1
3	8	4	6	7

分析：

从最高的50出发，只能到1，接下来就滑不动了。但实际是有比这个路线更长的。所以这样贪心方法行不通。

现在想知道最长的滑雪路线，那么如果能得到到达每个点的最长的滑雪路线后，取最大值就行。

按照上图中49这个位置为例，它可以朝着上下左右四个方向都能滑。如果是朝着上滑，那么它这个位置的滑雪长度就要用上一个位置的滑雪长度+1得到，同理如果往右滑，它这个位置的滑雪长度就要用右边位置的滑雪长度+1得到。所以可以看出是个递推模式。

递推是通过已知推未知，那么对于滑雪长度，只有最低高度的滑雪长度一定是已知的，肯定只能是1。那我们就从最低的开始，找每个位置与它的上下左右四个位置比较，如果有比周围高，那么自身的滑雪长度+1，最后取最大值，作为这个位置的最长滑雪长度。

在二维数组中没有好的办法将数字排序，但是如果放在一维数组中就可以用排序方法排序了。所以还要将二维数组一维化。（当前行数-1）*总列数 + 当前列数

方法：先将二维数组的高度整合成一维的结构体数组，每个结构体数组元素存储x,y和高度。同时记录每个高度的初始滑雪长度，都为1。接着按照高度从小到大排序结构体数组。然后从小到大遍历每一个结构体数组元素，查看每个元素与上下左右四个位置的高度比较，如果当前位置的高度大于上下左右的某个位置高度，就用某个高度上的滑雪长度+1，得到当前位置的最长距离。四个位置都是取最大值存放。结束后，遍历存放结果的二维数组，寻找最大值，最大值就是最长距离。

代码：

#include<iostream>
#include<algorithm>
using namespace std;
int a[200][200];
int f[200][200];
struct point{
    int x,y;
    int h;
}b[100010];

bool cmp(point a,point b){
    return a.h<b.h;
}
int main(){
    int r,c;
    cin>>r>>c;
    for(int i=1;i<=r;i++){
        for(int j=1;j<=c;j++){
            cin>>a[i][j];
            b[c*(i-1)+j].x=i;
            b[c*(i-1)+j].y=j;
            b[c*(i-1)+j].h=a[i][j];
            f[i][j]=1;
        }
    }
    sort(b+1,b+1+r*c,cmp);
    for(int i=1;i<=r*c;i++){
        int _x=b[i].x;
        int _y=b[i].y;
        if(_x>1 && a[_x][_y]>a[_x-1][_y]){//上 
            f[_x][_y]=max(f[_x][_y],f[_x-1][_y]+1);
        }
        if(_x<r && a[_x][_y]>a[_x+1][_y]){//下 
            f[_x][_y]=max(f[_x][_y],f[_x+1][_y]+1);
        }
        if(_y>1 && a[_x][_y]>a[_x][_y-1]){//左 
            f[_x][_y]=max(f[_x][_y],f[_x][_y-1]+1);
        }
        if(_y<c && a[_x][_y]>a[_x][_y+1]){//右 
            f[_x][_y]=max(f[_x][_y],f[_x][_y+1]+1);
        }
    }
    int max=0;
    for(int i=1;i<=r;i++){
        for(int j=1;j<=c;j++){
            if(f[i][j]>max){
                max=f[i][j];
            }
        }
    }
    cout<<max;
    return 0;
}
 

法② 

dfs

如果想要找当前的最长路径，那么直接从第一个点开始往下深搜。

深搜中因为不同位置的点搜索的过程会用到已经搜索过的点，那么就用记忆化方法，存储当前点的值。

所以在深搜中返回的条件其一就是当前位置的值不等于0（提前设置数组f[]表示每次位置的长度都是0），说明之前搜过，直接返回当前位置f[]的值。如果没搜过，那先设置当前位置的滑雪长度为1（任何位置滑雪初始长度都为1），接下来分别朝上下左右四个方向遍历，如果存在上下左右四个位置的点（坐标合乎范围），并且四个位置中存在一个或者多个位置的高度低于当前位置，那么当前位置的滑雪长度=max(当前位置，方向上的位置的长度数+1)。

#include<iostream>
using namespace std;
int a[200][200];
int f[200][200];
int dx[4]={-1,1,0,0};
int dy[4]={0,0,-1,1};
int r,c;
int dfs(int x,int y){
    if(f[x][y]!=0){
        return f[x][y];
    }
    f[x][y]=1;
    for(int i=0;i<4;i++){
        int _x=x+dx[i];
        int _y=y+dy[i];
        if(_x>=1 && _x<=r && _y>=1 &&_y<=c && a[x][y]>a[_x][_y]){
            f[x][y]=max(f[x][y],dfs(_x,_y)+1);
        }
    }
    return f[x][y];
}
int main(){
    
    cin>>r>>c;
    for(int i=1;i<=r;i++){
        for(int j=1;j<=c;j++){
            cin>>a[i][j];
        }
    }
    int ans=0;
    for(int i=1;i<=r;i++){
        for(int j=1;j<=c;j++){
            ans=max(ans,dfs(i,j));
        }
    }
    cout<<ans;
    return 0;
}