华为OD机试 2025B卷题库疯狂收录中，刷题点这里
专栏导读
本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。
一、题目描述
- 房间由XY的方格组成，例如下图为24的大小。每一个方格以坐标(x，y)描述；
- 机器人固定从方格(0，0)出发，只能向东或者向北前进。出口固定为房间的最东北角，如下图的方格(5，3)。用例保证机器人可以从入口走到出口；
- 房间有些方格是墙壁，如(4，1)，机器人不能经过那儿；
- 有些地方是一旦到达就无法走到出口的，如标记为B的方格，称之为陷阱方格；
- 有些地方是机器人无法到达的的，如标记为A的方格，称之为不可达方格，不可达方格不包括墙壁所在的位置；
- 如下示例图中，陷阱方格有2个，不可达方格有3个；
- 请为该机器人实现路径规划功能: 给定房间大小、墙壁位置，请计算出陷阱方格与不可达方格分别有多少个。
二、输入描述
- 第一行为房间的X和Y (0 < X，Y = 1000)
- 第二行为房间中墙壁的个数N (0 = N< X*Y)
同一行中如果有多个数据以一个空格隔开，用例保证所有的输入数据均合法。 (结尾不带回车换行)
三、输出描述
陷阱方格与不可达方格数量，两个信息在一行中输出，以一个空格隔开。(结尾不带回车换行)
四、测试用例
测试用例1：
1、输入
3 3
1
1 1
2、输出
0 0
3、说明
无陷阱，无不可达方格。
测试用例2：
1、输入
5 5
4
1 0
2 2
3 4
4 1
2、输出
3 3
五、解题思路
- 第一行输入行数m、列数n；
- 第二行输入墙数wallNum；
- 下面的wallNum行，输入墙的坐标；
- 定义二维矩阵matrix，并进行初始化，默认0，墙为-1；
- 0：不可达，因为默认是0，向x和y正方向一步一步走的话，如果未涉及，就是不可达，所以是0；
- -1：墙；
- 1：可达；
- -2：陷阱；
- 通过深度优先搜索dfs，遍历matrix；
- 如果x或y正向都可达，则将其设为可达1；
- 如果x或y正向都不可达，则将其设为陷阱-2；
- 遍历matrix；
- 如果此时为0，表示不可达；
- 如果此时为-2，表示陷阱；
- 按照指定格式输出陷阱和不可达的数量。
六、深度优先搜索dfs
在我们遇到的一些问题当中，有些问题我们不能够确切的找出数学模型，即找不出一种直接求解的方法，解决这一类问题，我们一般采用搜索的方法解决。搜索就是用问题的所有可能去试探，按照一定的顺序、规则，不断去试探，直到找到问题的解，试完了也没有找到解，那就是无解，试探时一定要试探完所有的情况（实际上就是穷举）；
对于问题的第一个状态，叫初始状态，要求的状态叫目标状态。
搜索就是把规则应用于实始状态，在其产生的状态中，直到得到一个目标状态为止。
产生新的状态的过程叫扩展（由一个状态，应用规则，产生新状态的过程）。
搜索的要点：
- 初始状态；
- 重复产生新状态；
- 检查新状态是否为目标，是结束，否转（2）；
如果搜索是以接近起始状态的程序依次扩展状态的，叫宽度优先搜索。
如果扩展是首先扩展新产生的状态，则叫深度优先搜索。
深度优先搜索用一个数组存放产生的所有状态。
- 把初始状态放入数组中，设为当前状态；
- 扩展当前的状态，产生一个新的状态放入数组中，同时把新产生的状态设为当前状态；
- 判断当前状态是否和前面的重复，如果重复则回到上一个状态，产生它的另一状态；
- 判断当前状态是否为目标状态，如果是目标，则找到一个解答，结束算法；
- 如果数组为空，说明无解。
六、Python算法源码
import sys
from collections import deque
def main():
input = sys.stdin.read().split()
idx = 0
m = int(input[idx]); idx += 1
n = int(input[idx]); idx += 1
wallNum = int(input[idx]); idx += 1
matrix = [[0 for _ in range(n)] for _ in range(m)]
for _ in range(wallNum):
x = int(input[idx]); idx +=1
y = int(input[idx]); idx +=1
if 0 <= x < m and 0 <= y < n:
matrix[x][y] = -1 # 墙壁
# BFS函数
def bfs(start_x, start_y):
visited = [[False for _ in range(n)] for _ in range(m)]
queue = deque()
if 0 <= start_x < m and 0 <= start_y < n and matrix[start_x][start_y] != -1:
queue.append((start_x, start_y))
visited[start_x][start_y] = True
directions = [ (1,0), (-1,0), (0,1), (0,-1) ]
while queue:
x, y = queue.popleft()
for dx, dy in directions:
new_x = x + dx
new_y = y + dy
if 0 <= new_x < m and 0 <= new_y < n and not visited[new_x][new_y] and matrix[new_x][new_y] != -1:
visited[new_x][new_y] = True
queue.append((new_x, new_y))
return visited
reachableFromStart = bfs(0, 0)
canReachExit = bfs(m-1, n-1)
trapNum = 0
inaccessibleNum = 0
for i in range(m):
for j in range(n):
if matrix[i][j] == -1:
continue # 墙壁不计
if reachableFromStart[i][j]:
if not canReachExit[i][j]:
trapNum +=1
else:
inaccessibleNum +=1
print(f"{trapNum} {inaccessibleNum}")
if __name__ == "__main__":
main()
七、JavaScript算法源码
const readline = require('readline');
function main() {
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
let input = [];
rl.on('line', (line) => {
input = input.concat(line.trim().split(' '));
});
rl.on('close', () => {
let idx = 0;
const m = parseInt(input[idx++]);
const n = parseInt(input[idx++]);
const wallNum = parseInt(input[idx++]);
let matrix = Array.from({length: m}, () => Array(n).fill(0));
for (let i = 0; i < wallNum; i++) {
const x = parseInt(input[idx++]);
const y = parseInt(input[idx++]);
if (x >=0 && x < m && y >=0 && y < n) {
matrix[x][y] = -1; // 墙壁
}
}
// BFS函数
function bfs(startX, startY) {
let visited = Array.from({length: m}, () => Array(n).fill(false));
let queue = [];
if (startX >=0 && startX < m && startY >=0 && startY < n && matrix[startX][startY] !== -1) {
queue.push([startX, startY]);
visited[startX][startY] = true;
}
const directions = [[1,0], [-1,0], [0,1], [0,-1]];
while (queue.length >0) {
const [x, y] = queue.shift();
for (let [dx, dy] of directions) {
const newX = x + dx;
const newY = y + dy;
if (newX >=0 && newX < m && newY >=0 && newY < n && !visited[newX][newY] && matrix[newX][newY] !== -1) {
visited[newX][newY] = true;
queue.push([newX, newY]);
}
}
}
return visited;
}
const reachableFromStart = bfs(0, 0);
const canReachExit = bfs(m-1, n-1);
let trapNum =0;
let inaccessibleNum =0;
for (let i =0; i <m; i++) {
for (let j=0; j <n; j++) {
if (matrix[i][j] === -1) continue;
if (reachableFromStart[i][j]) {
if (!canReachExit[i][j]) trapNum++;
} else {
inaccessibleNum++;
}
}
}
console.log(`${trapNum} ${inaccessibleNum}`);
});
}
main();
八、C算法源码
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
// 定义队列结构
typedef struct {
int x;
int y;
} Point;
typedef struct {
Point* data;
int front;
int rear;
int size;
} Queue;
// 初始化队列
Queue* initQueue(int maxSize) {
Queue* q = (Queue*)malloc(sizeof(Queue));
q->data = (Point*)malloc(sizeof(Point) * maxSize);
q->front = 0;
q->rear = 0;
q->size = maxSize;
return q;
}
// 入队
bool enqueue(Queue* q, int x, int y) {
if (q->rear >= q->size) return false;
q->data[q->rear].x = x;
q->data[q->rear].y = y;
q->rear++;
return true;
}
// 出队
bool dequeue(Queue* q, int* x, int* y) {
if (q->front >= q->rear) return false;
*x = q->data[q->front].x;
*y = q->data[q->front].y;
q->front++;
return true;
}
// BFS函数
bool** bfs(int m, int n, int matrix[][n], int startX, int startY) {
bool** visited = (bool**)malloc(sizeof(bool*) * m);
for(int i=0;i<m;i++) {
visited[i] = (bool*)calloc(n, sizeof(bool));
}
Queue* q = initQueue(m*n);
if(startX >=0 && startX < m && startY >=0 && startY < n && matrix[startX][startY] != -1){
enqueue(q, startX, startY);
visited[startX][startY] = true;
}
int directions[4][2] = { {1,0}, {-1,0}, {0,1}, {0,-1} };
while(q->front < q->rear){
int x, y;
dequeue(q, &x, &y);
for(int d=0; d<4; d++){
int newX = x + directions[d][0];
int newY = y + directions[d][1];
if(newX >=0 && newX < m && newY >=0 && newY < n && !visited[newX][newY] && matrix[newX][newY] != -1){
enqueue(q, newX, newY);
visited[newX][newY] = true;
}
}
}
// 释放队列内存
free(q->data);
free(q);
return visited;
}
int main(){
int m, n, wallNum;
scanf("%d %d", &m, &n);
scanf("%d", &wallNum);
// 动态分配矩阵
int matrix[m][n];
for(int i=0;i<m;i++) {
for(int j=0;j<n;j++) {
matrix[i][j] = 0;
}
}
// 标记墙壁
for(int i=0;i<wallNum;i++){
int x, y;
scanf("%d %d", &x, &y);
if(x >=0 && x < m && y >=0 && y < n){
matrix[x][y] = -1;
}
}
// BFS从起点
bool** reachableFromStart = bfs(m, n, matrix, 0, 0);
// BFS从出口
bool** canReachExit = bfs(m, n, matrix, m-1, n-1);
int trapNum =0, inaccessibleNum =0;
for(int i=0;i<m;i++){
for(int j=0;j<n;j++){
if(matrix[i][j] == -1) continue;
if(reachableFromStart[i][j]){
if(!canReachExit[i][j]){
trapNum++;
}
}
else{
inaccessibleNum++;
}
}
}
printf("%d %d", trapNum, inaccessibleNum);
// 释放内存
for(int i=0;i<m;i++) {
free(reachableFromStart[i]);
free(canReachExit[i]);
}
free(reachableFromStart);
free(canReachExit);
return 0;
}
九、C++算法源码
#include <bits/stdc++.h>
using namespace std;
// BFS函数
vector<vector<bool>> bfs(int m, int n, vector<vector<int>> &matrix, int startX, int startY){
vector<vector<bool>> visited(m, vector<bool>(n, false));
queue<pair<int, int>> q;
if(startX >=0 && startX < m && startY >=0 && startY < n && matrix[startX][startY] != -1){
q.push({startX, startY});
visited[startX][startY] = true;
}
// 四个方向：东、西、南、北
int directions[4][2] = { {1,0}, {-1,0}, {0,1}, {0,-1} };
while(!q.empty()){
pair<int, int> current = q.front(); q.pop();
int x = current.first;
int y = current.second;
for(auto &dir : directions){
int newX = x + dir[0];
int newY = y + dir[1];
if(newX >=0 && newX < m && newY >=0 && newY < n && !visited[newX][newY] && matrix[newX][newY] != -1){
visited[newX][newY] = true;
q.push({newX, newY});
}
}
}
return visited;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int m, n, wallNum;
cin >> m >> n;
cin >> wallNum;
vector<vector<int>> matrix(m, vector<int>(n, 0));
for(int i=0;i<wallNum;i++){
int x, y;
cin >> x >> y;
if(x >=0 && x < m && y >=0 && y < n){
matrix[x][y] = -1;
}
}
// BFS从起点
vector<vector<bool>> reachableFromStart = bfs(m, n, matrix, 0, 0);
// BFS从出口
vector<vector<bool>> canReachExit = bfs(m, n, matrix, m-1, n-1);
int trapNum =0, inaccessibleNum =0;
for(int i=0;i<m;i++){
for(int j=0;j<n;j++){
if(matrix[i][j] == -1) continue;
if(reachableFromStart[i][j]){
if(!canReachExit[i][j]){
trapNum++;
}
}
else{
inaccessibleNum++;
}
}
}
cout << trapNum << " " << inaccessibleNum;
return 0;
}
🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2025 B卷 200分）
🏆本文收录于，华为OD机试真题（Python/JS/C/C++）
刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新。
扫一扫
3504
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
