【Py/Java/C++三种语言OD独家2024E卷真题】20天拿下华为OD笔试之【BFS】2024E-周末爬山【欧弟算法】全网注释最详细分类最全的华为OD真题题解

于 2024-09-03 14:24:59 发布
阅读量353 收藏 5
点赞数 9
分类专栏： # BFS 文章标签： 算法 java c++ 华为od leetcode 宽度优先 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48157259/article/details/141860755
版权

可上 欧弟OJ系统 练习华子OD、大厂真题
绿色聊天软件戳 od1441了解算法冲刺训练（备注【CSDN】否则不通过）

文章目录

相关推荐阅读

从2024年8月14号开始，OD机考全部配置为2024E卷。
注意几个关键点：

  1. 大部分的题目仍为往期2023A+B+C以及2024D的旧题。注意万变不离其宗，把方法掌握，无论遇到什么题目都可以轻松应对。
  2. 支持多次提交题目，以最后一次提交为准。可以先做200的再做100的，然后可以反复提交。
  3. E卷仍然为单机位+屏幕监控的形式进行监考。
  4. 进入考试界面新加入了这样一段话并且用红字标出，可以看出华子对作弊代考等行为是0容忍的，请各位同学认真学习，不要妄图通过其他违规途径通过考试。
    在这里插入图片描述

题目描述与示例

题目描述：

周末小明准备去爬山锻炼，0代表平地，山的高度使用1到9来表示，小明每次爬山或下山高度只能相差k及k以内，每次只能上下左右一个方向上移动一格，小明从左上角(0,0)位置出发

输入描述

第一行输入m n k(空格分隔)

代表 m*n 的二维山地图，k为小明每次爬山或下山高度差的最大值，然后接下来输入山地图，一共 m行n列，均以空格分隔。

取值范围： 0 < m ≤ 500

0 < n ≤ 500
0 < k < 5

输出描述

请问小明能爬到的最高峰多高，到该最高峰的最短步数，输出以空格分隔。

同高度的山峰输出较短步数。

如果没有可以爬的山峰，则高度和步数都返回0。

备注：所有用例输入均为正确格式，且在取值范围内，考生不需要考虑不合法的输入格式。

示例1

输入

5 4 1
0 1 2 0
1 0 0 0
1 0 1 2
1 3 1 0
0 0 0 9

输入

2 2

说明

根据山地图可知，能爬到的最高峰在(0,2)位置，高度为2，最短路径为(0,0)->(0,1)->(0,2)，最短步数为2。

示例2

输入

5 4 3
0 0 0 0
0 0 0 0
0 9 0 0
0 0 0 0
0 0 0 9

输入

0 0

说明

根据山地图可知，每次爬山距离3，无法爬到山峰上，步数为0。

解题思路

又是二维网格状无向图的搜索问题。

题目包含两个设问：找到最高峰和到达最高峰的最短路径。

找到最高峰的问题可以用DFS也可以用BFS解决，但是最短路径问题只能用BFS解决（回溯可以解决但是会超时）。

综上，可以用一次BFS就同时完成最高峰和最短路径的搜索。

代码

python

# 题目：【BFS】2023C-周末爬山
# 分值：200
# 作者：许老师-闭着眼睛学数理化
# 算法：BFS
# 代码看不懂的地方，请直接在群上提问


from collections import deque
from math import inf


# 四个方向数组
DIERECTIONS = [(0,1), (1,0), (-1,0), (0,-1)]

# 输入长、宽、最大高度差
m, n, k = map(int, input().split())
# 初始化地图
grid = list()
for _ in range(m):
    grid.append(list(map(int, input().split())))

# 初始化BFS搜索层数，表示最短路径大小
level = 0
# 初始化全局的最高山峰高度，为起点的高度
highest_hill = grid[0][0]
# 初始化全局的到达最高山峰的最短路径
shortest_route = 0

# 初始化检查数组
check_list = [[0] * n for _ in range(m)]
# 起点设置为已检查过
check_list[0][0] = 1
# 初始化维护BFS的队列
q = deque()
# 起始位置只包含左上角的(0, 0)
q.append((0, 0))

# 进行BFS
while q:
    # 搜索层数+1
    level += 1
    qSize = len(q)
    for _ in range(qSize):
        x, y = q.popleft()
        # 四个近邻点
        for dx, dy in DIERECTIONS:
            nx, ny = x+dx, y+dy
            # 三个条件：
            # 1.未越界；2.未检查；3.当前点和近邻点之间高度差小于k
            if 0 <= nx < m and 0 <= ny < n and check_list[nx][ny] == 0 and abs(grid[nx][ny]-grid[x][y]) <= k:
                q.append((nx, ny))
                check_list[nx][ny] = 1
                # 如果该近邻点的高度大于全局最高山峰的高度
                # 则更新highest_hill和shortest_route
                if grid[nx][ny] > highest_hill:
                    highest_hill = grid[nx][ny]
                    shortest_route = level

print(highest_hill, shortest_route) if highest_hill > grid[0][0] else print(0, 0)

java

import java.util.*;

public class Main {
    static int[][] DIRECTIONS = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}};

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int m = scanner.nextInt();
        int n = scanner.nextInt();
        int k = scanner.nextInt();

        int[][] grid = new int[m][n];
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                grid[i][j] = scanner.nextInt();
            }
        }

        int level = 0;
        int highestHill = grid[0][0];
        int shortestRoute = 0;

        int[][] checkList = new int[m][n];
        checkList[0][0] = 1;
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{0, 0});

        while (!queue.isEmpty()) {
            level++;
            int qSize = queue.size();
            for (int i = 0; i < qSize; ++i) {
                int[] point = queue.poll();
                int x = point[0];
                int y = point[1];
                for (int[] dir : DIRECTIONS) {
                    int nx = x + dir[0];
                    int ny = y + dir[1];
                    if (0 <= nx && nx < m && 0 <= ny && ny < n && checkList[nx][ny] == 0 && Math.abs(grid[nx][ny] - grid[x][y]) <= k) {
                        queue.add(new int[]{nx, ny});
                        checkList[nx][ny] = 1;
                        if (grid[nx][ny] > highestHill) {
                            highestHill = grid[nx][ny];
                            shortestRoute = level;
                        }
                    }
                }
            }
        }
        if (highestHill > grid[0][0]){
            System.out.println(highestHill + " " + shortestRoute);
        }
        else{
            System.out.println("0 0");
        }
    }
}

cpp

#include <iostream>
#include <vector>
#include <queue>
#include <cmath>

using namespace std;

vector<pair<int, int>> DIRECTIONS = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}};

int main() {
    int m, n, k;
    cin >> m >> n >> k;

    vector<vector<int>> grid(m, vector<int>(n));
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j) {
            cin >> grid[i][j];
        }
    }

    int level = 0;
    int highestHill = grid[0][0];
    int shortestRoute = 0;

    vector<vector<int>> checkList(m, vector<int>(n));
    checkList[0][0] = 1;
    queue<pair<int, int>> q;
    q.push({0, 0});

    while (!q.empty()) {
        level++;
        int qSize = q.size();
        for (int i = 0; i < qSize; ++i) {
            int x = q.front().first;
            int y = q.front().second;
            q.pop();
            for (auto& dir : DIRECTIONS) {
                int nx = x + dir.first;
                int ny = y + dir.second;
                if (0 <= nx && nx < m && 0 <= ny && ny < n && checkList[nx][ny] == 0 && abs(grid[nx][ny] - grid[x][y]) <= k) {
                    q.push({nx, ny});
                    checkList[nx][ny] = 1;
                    if (grid[nx][ny] > highestHill) {
                        highestHill = grid[nx][ny];
                        shortestRoute = level;
                    }
                }
            }
        }
    }
    if (highestHill > grid[0][0]){
            cout << highestHill << " " << shortestRoute << endl;
        }
    else{
        cout << "0 0" << endl;
    }    
    return 0;
}

时空复杂度

时间复杂度：O(NM)。

空间复杂度：O(NM)。

华为OD算法/大厂面试高频题算法练习冲刺训练

  • 华为OD算法/大厂面试高频题算法冲刺训练目前开始常态化报名！目前已服务300+同学成功上岸！

  • 课程讲师为全网50w+粉丝编程博主@吴师兄学算法 以及小红书头部编程博主@闭着眼睛学数理化

  • 每期人数维持在20人内，保证能够最大限度地满足到每一个同学的需求，达到和1v1同样的学习效果！

  • 60+天陪伴式学习，40+直播课时，300+动画图解视频，300+LeetCode经典题，200+华为OD真题/大厂真题，还有简历修改、模拟面试、专属HR对接将为你解锁

  • 可上全网独家的欧弟OJ系统练习华子OD、大厂真题

  • 可查看链接 大厂真题汇总 & OD真题汇总(持续更新)

  • 绿色聊天软件戳 od1336了解更多

闭着眼睛学算法
关注
  • 9
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【Py/Java/C++三种语言OD独家2024E卷真题】20天拿下华为OD笔试之【DFS/BFS】2024E-机器人活动区域【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
08-24 1151
可上练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
【Py/Java/C++三种语言OD独家2024E卷真题】20天拿下华为OD笔试之【DFS/BFS】2024E-BOSS的收入【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
08-29 398
可上练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
【Py/Java/C++三种语言OD独家2024D卷真题】20天拿下华为OD笔试之【BFS】2024D-跳马问题【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
04-22 1595
有LeetCode算法/华为OD考试扣扣交流群可加可上全网独家的练习华子OD、大厂真题绿色聊天软件戳od1336了解算法冲刺训练。
【Py/Java/C++三种语言OD独家2024D卷真题】20天拿下华为OD笔试之【DFS/BFS】2024D-地图寻宝【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
06-03 1413
有LeetCode算法/华为OD考试扣扣交流群可加可上全网独家的练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
【Py/Java/C++三种语言OD独家2024D卷真题】20天拿下华为OD笔试之【BFS/拓扑排序】2024D-启动多任务排序【欧弟算法】全网注释最详细分类最全的华为OD真题题解
weixin_48157259的博客
04-23 1531
有LeetCode算法/华为OD考试扣扣交流群可加可上全网独家的练习华子OD、大厂真题绿色聊天软件戳od1441了解算法冲刺训练（备注【CSDN】否则不通过）
Leetcode42接雨水（单调栈）
AGNING的博客
08-28 438
维护一个栈，满足从栈底到栈顶元素大小递减。如果当前元素高于栈顶，且栈内有至少2个元素，则形成了一个凹槽，及一个图中横着的红色矩形，将它的面积累加即可，第一次写难在维护单调栈中计算面积和。求出前缀最大和后缀最大，用两者较小值减去当前高度，累加即可，这个思路容易想到，这里不赘述。
算法的学习笔记—连续子数组的最大和
业精于勤，荒于嬉
08-29 3476
通过上述的动态规划方法，我们能够有效地解决连续子数组的最大和问题。该方法简单易懂，并且具有较高的效率，适合在大多数情况下使用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论😁如果帮助到您不妨3连支持一下，创造不易您们的支持是我的动力🤞。
递归、搜索与回溯算法
无聊_人的博客
08-29 6535
所谓的递归其实就是函数自己调用自己的情况。
代码随想录算法训练营第62天|Floyd 算法精讲、A * 算法精讲 （A star算法）
Yinems的博客
08-28 1309
分两种情况，一种是节点 i 到节点 j 的最短路径经过节点 k，grid[i][j][k] = grid[i][k][k-1] + grid[k][j][k-1]；另一种情况，节点 i 到节点 j 的最短路径不经过节点 k，grid[i][j][k] = grip[i][j][k-1]；刚开始初始化 k 是不确定的，如果赋值为1，那么不能知道节点 i 到节点 j 经过1个节点的最短距离，所以只能把 k 赋值为0，本题中节点0是无意义的，节点是从1到n。本题求的是最小值，所以其余值初始化为最大值。
57. 插入区间【 力扣(LeetCode) 】
yyh520025的博客
08-29 4551
给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。同样给定一个区间 newInterval = [start, end] 表示另一个区间的开始和结束。在 intervals 中插入区间 newInterval，使得 intervals 依然按照 starti 升序排列，且区间之间不重叠（如果有必要的话，可以合并区间）。
算法训练营|图论第8天 拓扑排序 dijkstra
qq_53125539的博客
09-02 144
拓扑排序。
精选算法编程题
A18937260063的博客
08-30 2660
数组编程
冒泡排序算法
m0_74051652的博客
08-28 1398
冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复进行的，直到没有再需要交换的元素为止，这意味着数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（或说是排序的开头位置），就如同水中的气泡一样上升到水面。冒泡排序的写法可以简单分为两种方式，分别是：前同后异、前异后同。
字节跳动（社招）三面算法原题
宫水三叶的刷题日记
08-29 1769
但当招聘市场"供过于求"的时候，为了不让招聘过程显得突兀（距离招聘截止日期还有很久，但人已招满），这时候通常会卡住一些流程，尽量拖时间，此时越到后面要求越高，希望越少。当我们有了所有排好序的候选边集合之后，我们可以对边进行从前往后处理，每次加入一条边之后，使用并查集来查询「起点」和「终点」是否连通（并查集部分）。所以，虽然目前某些字节跳动的 BU 已经开始拖流程，但在下半年，必然会有新业务大量招兵买马，抓紧准备吧各位。你每次可以往「上，下，左，右」四个方向之一移动，你想要找到耗费体力最小的一条路径。
977.有序数组的平方
argcargv的博客
08-31 196
将双指针l、r分别从头和尾向中间移动（简化了很多，不用再处理边界条件）：基本相同写法（将双指针从中将最小值的下表，向两边移动）组成的新数组，要求也按。
【CSP】坐标变换2(问题拆解,快速输入,知识补充)
weixin_72391681的博客
08-30 3014
总结在这道题目中，我们通过旋转矩阵公式解决了二维平面上的坐标旋转问题，并且通过对浮点数的精度控制，满足了输出精度要求。我们还讨论了如何通过设定缓冲区和自定义输入函数优化大规模数据的输入输出效率。启发几何问题的推广：旋转矩阵的思路不仅适用于二维旋转，还可以推广到三维或更高维度的旋转问题，甚至可以应用于计算机图形学中的各种变换操作。精度控制的重要性：在涉及到浮点数运算的题目中，精度控制是至关重要的。了解并合理使用C++中的格式化输出可以有效避免因为精度丢失导致的错误。高效输入输出的技巧。
强化学习-优化策略算法（DPO和PPO）
weixin_42035282的博客
09-02 277
• 基于强化学习中的策略梯度方法，PPO 改进了 Trust Region Policy Optimization (TRPO)，通过引入剪切损失函数，限制策略更新的幅度，确保优化过程中的稳定性。• DPO 基于用户偏好或人类反馈的直接优化，这种方法的核心是对比学习或通过偏好数据进行的策略调整，理论上更接近人类反馈优化的范畴，且不需要明确的奖励函数。• DPO 更加侧重于直接优化用户偏好，适用于那些传统奖励难以定义的任务，通过直接利用反馈数据进行策略调整，提供了一种新的优化途径。
力扣（距离相等的条形码）
最新发布
yyssas的博客
09-02 246
重点是必须先存放出现次数最多的元素，极端情况下出现次数最多的元素可能是（n+1）/2个，此时相当于最后求出的数组，每间隔两个位置都有一个该元素，如果不先排该元素，则必定会在前面几个两两为一组的小组中没有一个该元素，则后面必定会出现该元素重复存放。对于出现的最大次数是（n+1）/2,是假设每两个相邻元素为一个小组，若没有重复，极端情况下是每个小组的第一个元素都是该元素，而最后一个小组可能只有一个元素，也可能有两个元素，因此是（n+1）/2.首先利用一个数组保存每个元素出现次数，即dp[i]表示i出现的次数。
华为od机试-新学校选址java
10-25
在华为od机试中，新学校选址问题是一个关于使用Java语言解决的问题。在解决这个问题时，我们可以通过以下步骤来完成。 首先，我们需要理解问题的要求和限制条件。新学校选址的目标是在一个给定的地图上找到一个合适的位置来建设新学校。这个位置应满足一定的条件，比如与周围的住宅区距离不宜过远，应尽可能靠近居民区。限制条件可能还包括学校面积和周边环境等。 接下来，我们需要获取地图的数据。可以通过读取一个地图文件或者从数据库中查询地图数据来获得地图的信息。地图数据的存储方式可以灵活选择，比如使用二维数组或者邻接矩阵。 然后，我们需要编写一个Java程序来实现新学校选址算法。可以使用图的遍历算法，比如深度优先搜索（DFS）或广度优先搜索（BFS）来实现。算法的核心是通过递归或循环遍历地图上的每一个位置，并根据选址条件进行判断和筛选。 最后，我们需要输出选址结果。可以将选定的位置以某种方式标记在地图上，比如输出一个新的地图文件或者在图形界面中显示。同时，还可以输出选址的具体坐标和其他相关信息，以便后续的学校建设工作。 总之，通过使用Java语言，我们可以通过一个新学校选址问题来展示我们在算法设计和编程方面的能力。相信在华为od机试中，通过合理的数据处理和算法实现，我们可以解决这个问题并得出满意的选址结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

闭着眼睛学算法

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值