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