【独家OD2023C卷真题】20天拿下华为OD笔试【单调栈】2023C-回转寿司【欧弟算法】全网注释最详细分类最全的华为OD真题题解

文章目录

  • 题目描述与示例
    • 题目描述
    • 输入描述
    • 输出描述
    • 示例一
        • 输入
        • 输出
    • 示例二
        • 输入
        • 输出
  • 解题思路
  • 代码
    • 解法一:正序遍历写法
      • python
      • java
      • cpp
    • 解法二:逆序遍历写法
      • python
      • java
      • cpp
    • 时空复杂度
  • 华为OD算法/大厂面试高频题算法练习冲刺训练

题目描述与示例

题目描述

寿司店周年庆,正在举办优惠活动回馈新老客户寿司转盘上总共有n盘寿司,prices[i] 是第 i 盘寿司的价格,如果客户选择了第 i盘寿司,寿司店免费赠送客户距离第 i 盘寿司最近的下一盘寿司 j,前提是prices[j] < prices[i],如果没有满足条件的 j,则不赠送寿司。 每个价格的寿司都可无限供应。

输入描述

输入的每一个数字代表每盘寿司的价格,每盘寿司的价格之间使用空格分隔 寿司的盘数 n范围为: 1 <= n <= 500

输出描述

输出享受优惠后的一组数据,每个值表示客户选择第i 盘寿司时实际得到的寿司的总价格。使用空格进行分隔。

示例一

输入
3 15 6 14
输出
3 21 9 17

示例二

输入
5 12 7 13
输出
5 19 12 18

解题思路

本题是在环型数组中计算每一个元素右侧的下一个更小元素,显然应该使用单调栈来完成。本题和LeetCode503. 下一个更大元素II的方法非常类似。

处理环型数组,可以将数组nums进行拼接,然后索引遍历的范围在[0, 2*n-1]进行即可。

PS:由于数据范围最多只有500,所以O(n^2)的暴力解是可以接受的。不熟悉单调栈的同学在考试遇到可以尝试使用暴力解。

代码

解法一:正序遍历写法

python

# 题目:【单调栈】2023C-回转寿司
# 分值:200
# 作者:许老师-闭着眼睛学数理化
# 算法:单调栈/正序遍历写法
# 代码看不懂的地方,请直接在群上提问

# 正序遍历写法
nums = list(map(int, input().split()))
n = len(nums)
stack = list()
# 初始化答案列表为nums的一个拷贝
# 这样对于数组中的最小值就不用额外考虑了
ans = nums.copy()
# 正序遍历下标
# 范围从0开始,到2*n-1结束
for i in range(2*n):
    # i对n求余,得到数字在nums中的真实下标
    idx = i % n
    num = nums[idx]
    while stack and nums[stack[-1]] > num:
        # 如果此时栈不为空,则栈顶元素top_idx索引右侧的下一个更小元素是nums[idx]
        # 因此ans[top_idx]为两者相加;否则只为nums[top_idx]
        top_idx = stack.pop()
        ans[top_idx] = num + nums[top_idx]
    stack.append(idx)

# 用解包的方式输出答案
print(*ans)

java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String[] inputs = scanner.nextLine().split(" ");
        int[] nums = new int[inputs.length];
        for (int i = 0; i < inputs.length; i++) {
            nums[i] = Integer.parseInt(inputs[i]);
        }
        int n = nums.length;
        Deque<Integer> stack = new ArrayDeque<>();
        int[] ans = Arrays.copyOf(nums, n);

        for (int i = 2 * n - 1; i >= 0; i--) {
            int idx = i % n;
            int num = nums[idx];
            while (!stack.isEmpty() && nums[stack.peekLast()] >= num) {
                stack.pollLast();
            }
            if (!stack.isEmpty()) {
                ans[idx] = nums[stack.peekLast()] + nums[idx];
            }
            stack.offerLast(idx);
        }

        for (int num : ans) {
            System.out.print(num + " ");
        }
    }
}

cpp

#include 
#include 
#include 
#include 

using namespace std;

int main() {
    string input;
    getline(cin, input);
    stringstream ss(input);
    vector<int> nums;
    int num;
    while (ss >> num) {
        nums.push_back(num);
    }
    int n = nums.size();
    stack<int> stk;
    vector<int> ans = nums;

    for (int i = 2 * n - 1; i >= 0; --i) {
        int idx = i % n;
        int num = nums[idx];
        while (!stk.empty() && nums[stk.top()] >= num) {
            stk.pop();
        }
        if (!stk.empty()) {
            ans[idx] = nums[stk.top()] + nums[idx];
        }
        stk.push(idx);
    }

    for (int i = 0; i < n; ++i) {
        cout << ans[i] << " ";
    }
    return 0;
}

解法二:逆序遍历写法

python

# 题目:【单调栈】2023C-回转寿司
# 分值:200
# 作者:许老师-闭着眼睛学数理化
# 算法:单调栈/逆序遍历写法
# 代码看不懂的地方,请直接在群上提问


# 逆序遍历写法
nums = list(map(int, input().split()))
n = len(nums)
stack = list()
# 初始化答案列表为nums的一个拷贝
# 这样对于数组中的最小值就不用额外考虑了
ans = nums.copy()
# 逆序遍历下标
# 范围从2*n-1开始,到0结束
for i in range(2*n-1, -1, -1):
    # i对n求余,得到数字在nums中的真实下标
    idx = i % n
    num = nums[idx]
    while stack and nums[stack[-1]] >= num:
        stack.pop()
    # 如果此时栈不为空,则栈顶是idx右侧的下一个更小元素的索引
    # 因此ans[idx]为两者相加;否则只为nums[idx]
    if stack:
        ans[idx] = nums[stack[-1]] + nums[idx]
    stack.append(idx)

# 用解包的方式输出答案
print(*ans)

java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String[] inputs = scanner.nextLine().split(" ");
        int[] nums = new int[inputs.length];
        for (int i = 0; i < inputs.length; i++) {
            nums[i] = Integer.parseInt(inputs[i]);
        }
        int n = nums.length;
        Deque<Integer> stack = new ArrayDeque<>();
        int[] ans = Arrays.copyOf(nums, n);

        for (int i = 2 * n - 1; i >= 0; i--) {
            int idx = i % n;
            int num = nums[idx];
            while (!stack.isEmpty() && nums[stack.peekLast()] >= num) {
                stack.pollLast();
            }
            if (!stack.isEmpty()) {
                ans[idx] = nums[stack.peekLast()] + nums[idx];
            }
            stack.offerLast(idx);
        }

        for (int num : ans) {
            System.out.print(num + " ");
        }
    }
}

cpp

#include 
#include 
#include 
#include 

using namespace std;

int main() {
    string input;
    getline(cin, input);
    stringstream ss(input);
    vector<int> nums;
    int num;
    while (ss >> num) {
        nums.push_back(num);
    }
    int n = nums.size();
    stack<int> stk;
    vector<int> ans = nums;

    for (int i = 2 * n - 1; i >= 0; --i) {
        int idx = i % n;
        int num = nums[idx];
        while (!stk.empty() && nums[stk.top()] >= num) {
            stk.pop();
        }
        if (!stk.empty()) {
            ans[idx] = nums[stk.top()] + nums[idx];
        }
        stk.push(idx);
    }

    for (int i = 0; i < n; ++i) {
        cout << ans[i] << " ";
    }
    return 0;
}

时空复杂度

时间复杂度:O(N)。循环遍历长度为2N的数组,每个元素只会出栈和入栈至多一次。

空间复杂度:O(N)。单调栈所占空间。


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

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

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

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

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

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

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

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

你可能感兴趣的:(最新华为OD真题,#,单调栈,华为od,算法)