华为OD机试 - 中庸行者 - 深度优先搜索DFS（Python/JS/C/C++ 2025 A卷 100分）

2025A卷华为OD机试统一考试题库清单（持续收录中）以及考点说明（Python/JS/C/C++）。

专栏导读

本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。

一、题目描述

给定一个m*n的整数矩阵作为地图，矩阵数值为地形高度中庸行者选择地图中的任意一点作为起点，尝试往上、下、左、右四个相邻格子移动;移动时有如下约束：

1. 中庸行者只能上坡或者下坡，不能走到高度相同的点
2. 不允许连续上坡或者连续下坡，需要交替进行
3. 每个位置只能经过一次，不能重复行走

请给出中庸行者在本地图内，能连续移动的最大次数

二、输入描述

第一行两个数字，分别为行数和每行的列数；

后续数据为矩阵地图内容

矩阵边长范围1-8，地形高度范围0-100000

三、输出描述

一个整数，代表中庸行者在本地图内，能连续移动的最大次数

四、测试用例

测试用例1：

1、输入

2 2
1 2
4 3

2、输出

3

3、说明

测试用例2：

1、输入

3 3
1 2 4
3 5 7
6 8 9

2、输出

4

3、说明

五、解题思路

本题采用深度优先搜索（DFS）来遍历地图中所有可能的路径。对于每个起点，通过DFS递归探索每个相邻格子，判断移动是否符合以下条件：

1. 移动目标点未被访问；
2. 高度不相同；
3. 移动方向（上坡或下坡）与前一步相交替。
4. 每条路径结束时更新全局最大移动次数。由于地图尺寸较小（最多8×8），采用递归DFS遍历所有路径的时间开销可以接受。

六、Python算法源码

# 导入sys模块用于读取控制台输入
import sys

sys.setrecursionlimit(10000)  # 增大递归深度，防止递归深度不足

# 读取输入数据
data = sys.stdin.read().split()
# data中的第一个两个数字为行数和列数
m = int(data[0])  # 行数
n = int(data[1])  # 列数
# 初始化地图矩阵
grid = []
index = 2  # 数据索引从2开始
for i in range(m):
    # 每行读取n个整数
    row = []
    for j in range(n):
        row.append(int(data[index]))
        index += 1
    grid.append(row)

# 初始化全局最大移动次数
maxMoves = 0

# 定义四个方向的偏移量：上、下、左、右
dx = [-1, 1, 0, 0]
dy = [0, 0, -1, 1]

# 定义DFS函数
def dfs(x, y, lastType, count, visited):
    global maxMoves
    # 更新全局最大移动次数
    maxMoves = max(maxMoves, count)
    # 遍历四个方向
    for i in range(4):
        nx = x + dx[i]
        ny = y + dy[i]
        # 判断是否超出边界
        if nx < 0 or nx >= m or ny < 0 or ny >= n:
            continue
        # 判断该位置是否已经访问过
        if visited[nx][ny]:
            continue
        # 如果高度相同，则不能移动
        if grid[nx][ny] == grid[x][y]:
            continue
        # 判断当前移动类型：1表示上坡，-1表示下坡
        currType = 1 if grid[nx][ny] > grid[x][y] else -1
        # 如果上一次移动存在，则要求本次必须交替
        if lastType != 0 and currType == lastType:
            continue
        # 标记该位置已访问
        visited[nx][ny] = True
        # 递归调用DFS，步数加1
        dfs(nx, ny, currType, count + 1, visited)
        # 回溯时取消标记
        visited[nx][ny] = False

# 从每个点作为起点尝试DFS搜索最长路径
for i in range(m):
    for j in range(n):
        # 初始化访问矩阵
        visited = [[False for _ in range(n)] for _ in range(m)]
        visited[i][j] = True
        dfs(i, j, 0, 0, visited)

# 输出最大移动次数
print(maxMoves)

七、JavaScript算法源码

// 引入readline模块用于读取控制台输入
const readline = require('readline');

// 创建接口读取输入数据
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    terminal: false
});

let inputData = [];

// 读取输入的每一行数据
rl.on('line', function(line){
    inputData.push(line.trim());
});

// 输入结束后进行处理
rl.on('close', function(){
    // 第一行数据为行数和列数
    let firstLine = inputData[0].split(' ').map(Number);
    let m = firstLine[0], n = firstLine[1];
    // 构造地图矩阵
    let grid = [];
    for (let i = 0; i < m; i++) {
        // 每行数据可能以空格分隔
        let row = inputData[i+1].split(' ').map(Number);
        grid.push(row);
    }
    
    let maxMoves = 0;
    // 四个方向：上、下、左、右
    const dx = [-1, 1, 0, 0];
    const dy = [0, 0, -1, 1];
    
    // 定义DFS函数，参数：x,y当前位置，lastType上一步移动类型（1上坡，-1下坡，0无），count当前步数，visited访问标记矩阵
    function dfs(x, y, lastType, count, visited) {
        maxMoves = Math.max(maxMoves, count);
        for (let i = 0; i < 4; i++) {
            let nx = x + dx[i];
            let ny = y + dy[i];
            // 检查是否越界
            if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue;
            // 判断是否已访问
            if (visited[nx][ny]) continue;
            // 高度相同，不允许移动
            if (grid[nx][ny] === grid[x][y]) continue;
            // 判断当前移动类型
            let currType = grid[nx][ny] > grid[x][y] ? 1 : -1;
            // 如果已有上一步，则必须交替移动
            if (lastType !== 0 && currType === lastType) continue;
            visited[nx][ny] = true;
            dfs(nx, ny, currType, count + 1, visited);
            visited[nx][ny] = false;
        }
    }
    
    // 从每个点作为起点进行DFS
    for (let i = 0; i < m; i++) {
        for (let j = 0; j < n; j++) {
            let visited = Array.from({length: m}, () => Array(n).fill(false));
            visited[i][j] = true;
            dfs(i, j, 0, 0, visited);
        }
    }
    // 输出最大移动次数，要求输出时仅有结果，不附带其他描述
    console.log(maxMoves);
});

八、C算法源码

#include <stdio.h>
#include <stdbool.h>

// 定义全局变量
int m, n;                    // 矩阵的行数和列数
int grid[10][10];            // 存储地图高度（题目范围最大8x8，留有余量）
bool visited[10][10];        // 记录是否访问过该位置
int maxMoves = 0;            // 最大移动次数

// 定义四个方向的偏移量：上、下、左、右
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};

// 深度优先搜索函数声明
void dfs(int x, int y, int lastType, int count);

// 主函数，从控制台读取输入
int main() {
    // 读取行数和列数
    scanf("%d %d", &m, &n);
    // 读取矩阵数据
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &grid[i][j]);
        }
    }
    // 从每个点作为起点尝试DFS
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            // 初始化访问标记数组
            for (int p = 0; p < m; p++)
                for (int q = 0; q < n; q++)
                    visited[p][q] = false;
            visited[i][j] = true;
            dfs(i, j, 0, 0);
        }
    }
    // 输出最大移动次数
    printf("%d", maxMoves);
    return 0;
}

/**
 * DFS递归函数
 * @param x 当前行
 * @param y 当前列
 * @param lastType 上一步移动类型，1代表上坡，-1代表下坡，0代表无
 * @param count 当前已移动的步数
 */
void dfs(int x, int y, int lastType, int count) {
    // 更新全局最大移动次数
    if (count > maxMoves)
        maxMoves = count;
    // 遍历四个方向
    for (int i = 0; i < 4; i++) {
        int nx = x + dx[i];
        int ny = y + dy[i];
        // 检查是否越界
        if (nx < 0 || nx >= m || ny < 0 || ny >= n)
            continue;
        // 如果已访问过，则跳过
        if (visited[nx][ny])
            continue;
        // 如果高度相同，则不允许移动
        if (grid[nx][ny] == grid[x][y])
            continue;
        // 判断当前移动类型：1表示上坡，-1表示下坡
        int currType = (grid[nx][ny] > grid[x][y]) ? 1 : -1;
        // 如果上一步存在，则要求移动方向必须交替
        if (lastType != 0 && currType == lastType)
            continue;
        // 标记该位置已访问
        visited[nx][ny] = true;
        dfs(nx, ny, currType, count + 1);
        // 回溯时取消访问标记
        visited[nx][ny] = false;
    }
}

九、C++算法源码

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

// 定义全局变量
int m, n;  // 矩阵行数和列数
vector<vector<int>> grid;    // 存储地图高度的二维数组
vector<vector<bool>> visited; // 标记是否访问过
int maxMoves = 0;            // 最大移动次数

// 定义四个方向的偏移量：上、下、左、右
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};

/**
 * DFS递归函数
 * @param x 当前所在行
 * @param y 当前所在列
 * @param lastType 上一步移动类型，1代表上坡，-1代表下坡，0代表无
 * @param count 当前已移动步数
 */
void dfs(int x, int y, int lastType, int count) {
    maxMoves = max(maxMoves, count);
    // 遍历四个方向
    for (int i = 0; i < 4; i++) {
        int nx = x + dx[i];
        int ny = y + dy[i];
        // 检查是否超出边界
        if (nx < 0 || nx >= m || ny < 0 || ny >= n)
            continue;
        // 如果已访问则跳过
        if (visited[nx][ny])
            continue;
        // 如果高度相同，不允许移动
        if (grid[nx][ny] == grid[x][y])
            continue;
        // 判断当前移动类型
        int currType = (grid[nx][ny] > grid[x][y]) ? 1 : -1;
        // 如果上一步存在，则要求必须交替
        if (lastType != 0 && currType == lastType)
            continue;
        // 标记该位置为已访问
        visited[nx][ny] = true;
        dfs(nx, ny, currType, count + 1);
        // 回溯时取消标记
        visited[nx][ny] = false;
    }
}

int main() {
    // 读取行数和列数
    cin >> m >> n;
    grid.resize(m, vector<int>(n));
    visited.resize(m, vector<bool>(n, false));
    // 读取地图数据
    for (int i = 0; i < m; i++)
        for (int j = 0; j < n; j++)
            cin >> grid[i][j];
    
    // 从每个点作为起点进行DFS搜索
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            // 重置访问数组
            for (int p = 0; p < m; p++)
                fill(visited[p].begin(), visited[p].end(), false);
            visited[i][j] = true;
            dfs(i, j, 0, 0);
        }
    }
    // 输出结果，仅输出答案
    cout << maxMoves;
    return 0;
}

🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2025 A卷 200分）

🏆本文收录于，华为OD机试真题（Python/JS/C/C++）

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。