POJ 1088滑雪的一种非记忆搜索的解法

Description

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更长。事实上，这是最长的一条。

Input

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

Output

输出最长区域的长度。

这个题是在看DP跟DFS的时候接触到的，当时受惯性思维的影响，就采用了DFS加记忆化搜索的方法。

某天偶然又看到了这个题，细想一下这个问题完全有更简便的解法

其实可以先将地图上的点按照高度由低到高排序，然后从最低的开始每次寻找上下左右比他低的且步数最大的点加一就是此点的步数。

这样一直找到最高点后，存在的最大步数即为答案。

然后贴一下自己的代码，由于这个是好久没敲代码之后写的所以逻辑啥的难看的要死，后面会有一个整理后的代码

原始代码：

#include<cstdio>
#include<queue>
#include<string.h>
using namespace std;

int dr[4] = {-1,+1,0,0};
int dc[4] = {0,0,-1,+1};

struct m{
    int high;
    int num;
}imap[110][110];


typedef struct spoint{ //每一个路径点
    int high;//高度
    //int num;//该路径点最长步数，初始化为1
    int thisr;//坐标
    int thisc;
}point;


struct cmp{
    bool operator()(point p1, point p2){
        return p1.high > p2.high;
    }
};

//priority_queue <int> step;//储存最长的步数
priority_queue <spoint, vector<spoint>, cmp> path;//用来读取当前最低点

int main()
{
    //freopen("ans.txt","w",stdout);
    point p;
    point temp;

    int ans;
    int r, c;
    //int imap[110][110];
    int stop = 0; //一个小小小小小的优化，确立一下最高点，这样最后遍历的时候省点事
    memset(imap,0,sizeof(imap));

    scanf("%d%d", &r, &c);
        ans = 0;
        for(int i = 0; i<r; ++i){
            for(int j = 0; j<c; ++j){
                scanf("%d", &p.high);
                imap[i][j].high = p.high;
                p.thisr = i;
                p.thisc = j;
                path.push(p);//将每一个点放入堆中
                stop = stop > p.high ? stop : p.high;
            }
        }

        while(!path.empty()){

            int imax = 0; //储存当前最值
            int tr, tc; //临时的坐标
            int tstep; //坐标下的步数
            temp = path.top(); //获得最低点
            bool f = true; //判断有没有能走的点

            for(int i = 0; i<4; ++i){ //循环四个方向
                tr = temp.thisr+dr[i];
                tc = temp.thisc+dc[i];
                if(tr>=0 && tr<r && tc>=0 && tc<c){//合法判断
                    if(temp.high>imap[tr][tc].high){
                        tstep = imap[tr][tc].num;
                        imax = imax > tstep ? imax : tstep;//获得当前最值
                        f = false;
                    }

                }
            }

            imap[temp.thisr][temp.thisc].num = imax+1; //更新该点的步数
            if(f) imap[temp.thisr][temp.thisc].num--; //如果没有能走的点就不能加一
            ans = ans > imap[temp.thisr][temp.thisc].num ? ans : imap[temp.thisr][temp.thisc].num;
            //printf("--%d-%d--%d\n", imap[temp.thisr][temp.thisc].high, imap[temp.thisr][temp.thisc].num,ans);
            path.pop();
        }

        printf("%d\n", ans+1);


    return 0;
}

其实当时我对根堆什么的也有点忘，所以做了个小笔记用用来回忆

后来的代码

#include <cstdio>
#include <queue>
#include <algorithm>

using namespace std;

const int MAXN = 100 + 2;
int dx[4] = {0, -1, 0, 1};
int dy[4] = {-1, 0, 1, 0};

struct Elem
{
    int num;
    int x, y;
    
    Elem(int n, int xx, int yy) : num(n), x(xx), y(yy) {}
    
    bool operator > (const Elem& a) const {
        return num > a.num;
    }
};

int map[MAXN][MAXN];
int d[MAXN][MAXN];

priority_queue <Elem, vector<Elem>, greater<Elem> > que1;
priority_queue <int> que2;

int main()
{
    int r, c;
    scanf("%d%d", &r, &c);
    for (int i = 0; i < r; i++) {
        for (int j = 0; j < c; j++) {
            scanf("%d", &map[i][j]);
            que1.push(Elem(map[i][j], i, j));
        }
    }
    
    while (!que1.empty()) {
        Elem e = que1.top();
        que1.pop();
        for (int i = 0; i < 4; i++) {
            int nx = e.x + dx[i];
            int ny = e.y + dy[i];
            if (nx >= 0 && nx < r && ny >= 0 && ny < c && map[nx][ny] < map[e.x][e.y]) {
                d[e.x][e.y] = max(d[e.x][e.y], d[nx][ny]);
            }
        }
        que2.push(d[e.x][e.y]++);
    }
    
    printf("%d\n", que2.top() + 1);
    
    return 0;
}