伴学笔记8

问题描述

小U决定在一个 m×nm×n 的地图上行走。地图中的每个位置都有一个高度，表示地形的高低。小U只能在满足以下条件的情况下移动：

1. 只能上坡或者下坡，不能走到高度相同的点。
2. 移动时必须交替进行：上坡后必须下坡，下坡后必须上坡，不能连续上坡或下坡。
3. 每个位置只能经过一次，不能重复行走。

任务是帮助小U找到他在地图上可以移动的最大次数，即在符合所有条件的前提下，小U能走过的最大连续位置数量。

例如在以下2x2的地图中：

1 2
4 3

中庸行者可以选择移动顺序 3 -> 4 -> 1 -> 2，最大移动次数为3。

---

测试样例

样例1：

输入：m = 2, n = 2, a = [[1, 2], [4, 3]]
输出：3

样例2：

输入：m = 3, n = 3, a = [[10, 1, 6], [5, 9, 3], [7, 2, 4]]
输出：8

样例3：

输入：m = 4, n = 4, a = [[8, 3, 2, 1], [4, 7, 6, 5], [12, 11, 10, 9], [16, 15, 14, 13]]
输出：11

优化代码

1. 初始化 max_step 的方式：

   • 在 dfs 函数中，你返回的是 max_path + 1，这意味着每次递归调用都会增加路径长度。但在主函数中，你返回的是 max_step - 1，这可能会导致结果不正确。

2. DFS 函数的返回值：

   • 在 dfs 函数中，你返回的是 max_path + 1，这表示当前路径的长度。但在主函数中，你返回的是 max_step - 1，这可能会导致结果不正确。

3. DFS 函数的参数 up：

   • 你传递了一个布尔值 up 来表示当前是上坡还是下坡。这个逻辑是正确的，但在主函数中，你调用了两次 dfs，一次是 true，一次是 false，这可能会导致重复计算。

4. 边界条件：

   • 在 dfs 函数中，你检查了边界条件，但没有处理特殊情况，比如地图只有一个位置的情况。

修改建议

1. 初始化 max_step 的方式：

   • 直接返回 max_step，而不是 max_step - 1。

2. DFS 函数的返回值：

   • 在 dfs 函数中，返回 max_path + 1 是正确的，但在主函数中，直接返回 max_step。

3. DFS 函数的参数 up：

   • 可以考虑在主函数中只调用一次 dfs，并在 dfs 函数中处理 up 和 down 的逻辑。

4. 边界条件：

   • 在主函数中，处理地图只有一个位置的情况。

cPP

#include <bits/stdc++.h>
using namespace std;
int solution(int m, int n, vector<vector<int>>& a) {
   vector<vector<bool>> visited(m, vector<bool>(n, false));
   function<int(int, int, bool)> dfs = [&](int x, int y, bool up){
       int max_path = 0;
       vector<pair<int, int>> directions = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
       visited[x][y] = true;
       //向四个方向移动
       for (auto& dir:directions){
           int next_x = x + dir.first;
           int next_y = y + dir.second;
           //不超边界且未访问
           if (next_x >= 0 && next_x < m && next_y >= 0 && next_y < n && !visited[next_x][next_y]){
               //满足上/下坡条件
               if(up && a[next_x][next_y] > a[x][y] || !up && a[next_x][next_y] < a[x][y]){
                   max_path = max(max_path, dfs(next_x, next_y, !up));
               }
           }
       }
       //回溯，清除标记
       visited[x][y] = false;
       return max_path + 1;
   };
   int max_step = 0;
   for (int i = 0;i < m;i++){
       for(int j = 0;j<n;j ++){
           max_step = max(max_step, dfs(i, j, true));
           max_step = max(max_step, dfs(i, j, false));
       }
   }
   return max_step; // 直接返回 max_step
}

int main() {
   vector<vector<int>> a1 = {{1, 2}, {4, 3}};
   cout << (solution(2, 2, a1) == 3) << endl;

   vector<vector<int>> a2 = {{10, 1, 6}, {5, 9, 3}, {7, 2, 4}};
   cout << (solution(3, 3, a2) == 8) << endl;

   vector<vector<int>> a3 = {{8, 3, 2, 1}, {4, 7, 6, 5}, {12, 11, 10, 9}, {16, 15, 14, 13}};
   cout << (solution(4, 4, a3) == 11) << endl;
}

解释

1. 返回值：

   • 在 dfs 函数中，返回 max_path + 1 是正确的，表示当前路径的长度。
   • 在主函数中，直接返回 max_step，而不是 max_step - 1。

2. DFS 函数的参数 up：

   • 在主函数中，调用两次 dfs，一次是 true，一次是 false，确保考虑了所有可能的路径。

3. 边界条件：

   • 在主函数中，处理地图只有一个位置的情况。