AcWing 901. 滑雪

地址 https://www.acwing.com/problem/content/description/903/

题目描述
给定一个R行C列的矩阵，表示一个矩形网格滑雪场。

矩阵中第 i 行第 j 列的点表示滑雪场的第 i 行第 j 列区域的高度。

一我的从滑雪场中的某个区域内出发，每次能够向上下左右任意一个方向滑动一个单位距离。

固然，一我的可以滑动到某相邻区域的前提是该区域的高度低于本身目前所在区域的高度。

下面给出一个矩阵做为例子：

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-2-1。

在给定矩阵中，最长的滑行轨迹为25-24-23-…-3-2-1，沿途共通过25个区域。

如今给定你一个二维矩阵表示滑雪场各区域的高度，请你找出在该滑雪场中可以完成的最长滑雪轨迹，并输出其长度(可通过最大区域数)。

输入格式
第一行包含两个整数R和C。

接下来R行，每行包含C个整数，表示完整的二维矩阵。

输出格式
输出一个整数，表示可完成的最长滑雪长度。

数据范围
1≤R,C≤300,
0≤矩阵中整数≤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

算法1
一开始 写的常规DFS
可是在某些数据 超时。果真没那么简单

代码

 1 #include <iostream>
 2 #include <vector>
 3 
 4 using namespace std;
 5 
 6 const int N = 310;
 7 int n,m;
 8 int maxlen = -1;
 9 vector<vector<int>>  vv;
10 
11 int addx[] = {1,-1,0,0};
12 int addy[] = {0,0,1,-1};
13 
14 void dfs(int x,int y,int len)
15 {
16     if(len > maxlen) maxlen = len;
17 
18     for(int i = 0;i < 4;i++){
19         int newx = x + addx[i];
20         int newy = y + addy[i];
21 
22         if(newx >=0 && newx < n && newy >=0 && newy < m &&
23             vv[newx][newy] < vv[x][y])
24         {
25             dfs(newx,newy,len+1);        
26         }
27     }
28 }
29 
30 
31 int main()
32 {
33     cin >> n >> m;
34 
35     for(int i = 0; i < n;i++){
36         vector<int> v;
37         vv.push_back(v);
38         for(int j = 0;j< m;j++){
39             int t =0;
40             cin >> t;
41             vv[i].push_back(t);    
42         }
43     }
44 
45 
46     for(int i = 0; i < n;i++){
47         for(int j = 0;j < m;j++){
48             int len =0;
49             dfs(i,j,len);
50         }
51     }
52 
53     cout << maxlen+1  << endl;
54 
55     return 0;
56 }

View Code

算法2
使用记忆化数组 记录每一个点的最大滑动长度
遍历每一个点做为起点
而后检测该点四周的点 若是能够滑动到其余的点
那么该点的最大滑动长度 就是其余能够滑到的点的滑动长度+1
dp[i][j] = max(dp[i][j-1], dp[i][j+1],dp[i-1][j],dp[i+1][j])

因为滑雪是必须滑到比当前低的点  在任意一个起点的dfs中，不会存在一个点屡次进入的问题
若是该点的dp[][] 不为初始化值 那么就说明计算过 没必要再次计算。

按照上述公式 代码以下 AC

#include <iostream>

using namespace std;

const int N = 310;
int R,C;

int arr[N][N];
int dp[N][N];

int maxlen = -1;

int addx[] = {1,-1,0,0};
int addy[] = {0,0,1,-1};

int  Dfs(int x,int y)
{
    if(dp[x][y] != 0) return dp[x][y];


     for(int i = 0;i < 4;i++){
        int newx = x + addx[i];
        int newy = y + addy[i];

        if(newx >=0 && newx < C && newy >=0 && newy < R &&
            arr[newx][newy] < arr[x][y])
        {
            dp[x][y] = max(dp[x][y], Dfs(newx,newy) +1);
        }
    }
    return dp[x][y];
}

int main()
{
    ios::sync_with_stdio(false);

  cin >> R >>C;

  for(int i = 0; i < R;i++){
      for(int j=0;j<C;j++){
        cin >> arr[i][j];    
      }
  }

  for(int i = 0; i < R;i++){
      for(int j = 0;j< C;j++){
        int len = Dfs(i,j);   
        maxlen = max(maxlen,len);
      }
  }  

  cout << maxlen +1  << endl;

    return 0;
}