有LeetCode算法/华为OD考试扣扣交流群可加 948025485
可上全网独家的 欧弟OJ系统 练习华子OD、大厂真题
绿色聊天软件戳od1441
了解算法冲刺训练(备注【CSDN】否则不通过)
文章目录
从2024年4月15号开始,OD机考全部配置为2024D卷。
注意两个关键点:
- 会遇到C卷复用题。虽然可能存在幸存者偏差,但肯定还会有一大部分的旧题。
- 现在又支持做完题目之后倒回去改了。就是可以先做200的再做100的,然后可以反复提交。
题目描述与示例
题目描述
寿司店周年庆,正在举办优惠活动回馈新老客户寿司转盘上总共有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[] input = scanner.nextLine().split(" ");
int n = input.length;
int[] nums = new int[n];
for (int i = 0; i < n; i++) {
nums[i] = Integer.parseInt(input[i]);
}
Stack<Integer> stack = new Stack<>();
int[] ans = Arrays.copyOf(nums, n);
for (int i = 0; i < 2 * n; i++) {
int idx = i % n;
int num = nums[idx];
while (!stack.isEmpty() && nums[stack.peek()] > num) {
int topIdx = stack.pop();
ans[topIdx] = num + nums[topIdx];
}
stack.push(idx);
}
for (int i = 0; i < n; i++) {
System.out.print(ans[i] + " ");
}
}
}
cpp
#include <iostream>
#include <sstream>
#include <vector>
#include <stack>
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> st;
vector<int> ans(nums.begin(), nums.end());
for (int i = 0; i < 2 * n; i++) {
int idx = i % n;
int num = nums[idx];
while (!st.empty() && nums[st.top()] > num) {
int topIdx = st.top();
st.pop();
ans[topIdx] = num + nums[topIdx];
}
st.push(idx);
}
for (int i = 0; i < n; i++) {
cout << ans[i] << " ";
}
cout << endl;
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 <iostream>
#include <sstream>
#include <vector>
#include <stack>
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算法/大厂面试高频题算法冲刺训练目前开始常态化报名!目前已服务300+同学成功上岸!
-
课程讲师为全网50w+粉丝编程博主@吴师兄学算法 以及小红书头部编程博主@闭着眼睛学数理化
-
每期人数维持在20人内,保证能够最大限度地满足到每一个同学的需求,达到和1v1同样的学习效果!
-
60+天陪伴式学习,40+直播课时,300+动画图解视频,300+LeetCode经典题,200+华为OD真题/大厂真题,还有简历修改、模拟面试、专属HR对接将为你解锁
-
可上全网独家的欧弟OJ系统练习华子OD、大厂真题
-
可查看链接 大厂真题汇总 & OD真题汇总(持续更新)
-
绿色聊天软件戳
od1336
了解更多