[题解]洛谷P1434滑雪

目录

• #0.0 方法
• #1.0 动态规划
  • #1.1 思路
  • #1.2 代码
  • #1.3 时间复杂度
• #2.0 搜索
• 更新&说明

洛谷 P1434 滑雪

---

#0.0 方法

我觉得这道题主要方法应该有两种：

• 动态规划

• 搜索

下面会分别对这两种方法进行简述

---

#1.0 动态规划

#1.1 思路

首先的想法是用 $L(i,j)$表示从点 $(i,j)$ 出发能到达的最长距离

• 因为从 $(i,j)$ 出发最少能滑行自己 $1$ 格，所以每个点 $L$ 值都先初始化为 $1$

• 我们可以从 $(i,j)$ 出发，向四周寻找，如果四周没有比他低的点，那么 $L(i,j)$ 即为 $1$，否则 $L(i,j)$ 就为从 $(i,j)$ 出发四周高度比 $L$ 低且 $L$ 值最大的那个点 $P$ 的 $L$ 值加 $1$

递推时的顺序为点的高度由低到高，那么在递推过程中，计算 $L(i,j)$时，他四周比他低的点P的L值一定已经被计算出来了

接下来需要解决的问题便是如何按点的高度由小到大递推

关于这个问题，我们难道要每次递推时用两遍循环找出当前未递推的最低点？

显然不可取，时间复杂度会爆炸的。那么就考虑能否一个sort()解决问题（懒得自己写排序）。sort()能给一个二维数组排序？不知大佬们怎么想，反正本蒟蒻不会。。。那为了sort()更香可以方便的使用，我用一个一维数组进行存储每个点的数据。

那么，**结构体 **成为我们的第一选择

struct Point{
    int r; //行号
    int c; //列号
    int h; //高度
    bool operator < (const Point & p) const {
        return h < p.h;
    }//构造函数，不懂的同学可以写一个cmp代替,下面代码会有特别说明
};
Point point[10101];

为了方便储存以及不造成浪费（个人习惯）这里 $i$ 和 $j$ 都从 $0$ 开始取，那么点 $(i,j)$ 用point数组存的下标为 $c \times i + j$ 由于 $i,j$ 从 $0$ 开始存，$c \times i + j$ 这个式子表示的是第 $i+1$ 行第 $j+1$ 个数，那么，$i$ 最大为 $R-1$，$j$ 最大为 $C-1$，整个数组最大下标为$C\times (R-1)+C-1$，即 $C\times R-1$，若 $i,j$ 从 $1$开始取，为保证运算方便及善待空间，下标应为 $C\times(i-1)+j-1$。

该算法的分析已给出，大家可以结合代码自行理解

#1.2 代码

#include <iostream>//头文件，不多解释
#include <cstdio>
#include <algorithm>
using namespace std;
struct Point{
    int r;//行号
    int c;//列号
    int h;//高度
    bool operator < (const Point & p) const {
        return h < p.h;//构造函数，不会的可删掉看下面cmp
    }
};Point point[10101];
int cmp(Point a,Point b){
    if (a.h < b.h)   //如果a的高度小于b的高度
      return 1;//返回真
    else
      return 0;//否则返回假
}
int R,C,ans = -0x3ffff;//需初始化ans为较小值（害怕玄学出错）
int a[101][101],d[102][102];//a为每点的高度，d为该点可滑行的最大值
int main(){
    cin >> R >> C;
    for (int i = 0;i < R;i ++)
      for (int j = 0;j < C;j ++){
        cin >> a[i][j];//输入点的高度
        point[i * C + j].h = a[i][j];//根据上面所说的下标，
        point[i * C + j].r = i;      //对点的数据进行存储
        point[i * C + j].c = j;
        d[i][j] = 1;            //初始可滑行长度为1
      }
    sort(point,point + R * C);//如果用了cmp可换为sort(point,point + R * C，cmp);
    for (int i = 0;i < R * C;i ++){
        int r = point[i].r;//找一个替身,怕玄学或运算时出错
        int c = point[i].c;//同理
        if (r > 0 && a[r - 1][c] < a[r][c])//找上面的
          d[r][c] = max(d[r][c],d[r - 1][c] + 1);//进行更新
        if (c > 0 && a[r][c - 1] < a[r][c])//找左面的
          d[r][c] = max(d[r][c],d[r][c - 1] + 1);//进行更新
        if (r < R - 1 && a[r + 1][c] < a[r][c])//找下面的
          d[r][c] = max(d[r][c],d[r + 1][c] + 1);//进行更新
        if (c < C - 1 && a[r][c + 1] < a[r][c])//找右面的
          d[r][c] = max(d[r][c],d[r][c + 1] + 1); //进行更新
    }
    for (int i = 0;i < R;i ++)
      for (int j = 0;j < C;j ++)
        ans = max(ans,d[i][j]); //找出最大值
    cout << ans;
    return 0;//完美撒花
}

#1.3 时间复杂度

由于点 $(i,j)$ 的 $L$ 值的计算为极小的常数值，所以这个算法的复杂度为 $O(R \times C)$

#2.0 搜索

相信大家都会想到DFS，但若是单纯的DFS，会TLE一个点，所以，我们就要考虑到记忆化搜索。那么也很好实现，具体请见下方代码：

#include <iostream>
#include <cstdio>
using namespace std;
int R,C;
int g1[4] = {0,1,0,-1};//定义寻找的4个方向
int g2[4] = {-1,0,1,0};
int m[101][101];//储存每个点的高度
int lj[101][101];//储存每个点可滑行的最大长度
int maxn,lr;
int dfs(int i,int j){
    if (lj[i][j] - 1)//判断是否搜过，因为下面将每一个点的最初滑行长度为1
                 //如果该点最长长度-1为0，说明该点未被搜过
      return lj[i][j];
    for (int o = 0;o < 4;o ++)//向4个方向搜
      if (i + g1[o] >= 0 && i + g1[o] < R && j + g2[o] >= 0 && j + g2[o] < C && m[i + g1[o]][j + g2[o]] < m[i][j]){//保证不越界
        lj[i][j] = max(lj[i][j],dfs(i + g1[o],j + g2[o]) + 1);//进行搜索及更新
      }
    return lj[i][j];
}
int main(){
    cin >> R >> C;
    for (int i = 0;i < R;i ++)//初始化
      for (int j = 0;j < C;j ++)
        lj[i][j] = 1;
    for (int i = 0;i < R;i ++)
      for (int j = 0;j < C;j ++)
        cin >> m[i][j];
    for (int i = 0;i < R;i ++)
      for (int j = 0;j < C;j ++){
        if (lj[i][j] - 1 != 0){//如果该点被搜过
            maxn = max(maxn,lj[i][j]);//直接更新
            continue;
          }
        lj[i][j] = dfs(i,j);
        maxn = max(maxn,lj[i][j]);
      }
    cout << maxn;
    return 0;//撒花
}

这就是该题本人的思路，希望能给你带来帮助

更新&说明

• 初次发布 - $\mathfrak{2019.11.25}$

• 更换 markdown 编辑器 - 2021.2.19

  持续修改完善