代码随想录算法训练营第六十二天| 503.下一个更大元素II，42. 接雨水

最新推荐文章于 2024-09-21 14:48:47 发布

WDR8965

最新推荐文章于 2024-09-21 14:48:47 发布

阅读量1.6k

点赞数 32

分类专栏：代码随想录算法训练营33期文章标签：算法数据结构 leetcode java

本文链接：https://blog.csdn.net/qq_42973684/article/details/138575241

版权

代码随想录算法训练营33期专栏收录该内容

53 篇文章 2 订阅

订阅专栏

题目与题解

503.下一个更大元素II

题目链接：503.下一个更大元素II

代码随想录题解：503.下一个更大元素II

视频讲解：单调栈，成环了可怎么办？LeetCode：503.下一个更大元素II_哔哩哔哩_bilibili

解题思路：

这题就是最简单的在一个数组中求当前元素的下一个最大元素的问题，加上数组可循环的条件，实际上意思就是寻找完当前元素后面的所有元素后，还需要按顺序从头遍历当前元素前面的所有元素，那么最简单的方法就是遍历两次数组，即将数组的开头接到数组结尾，保证所有元素的前后都能遍历到。

同样用单调栈解决，当前元素nums[i % nums.length]小于等于nums[s.peek()]时直接压栈，否则不断弹出栈顶元素，更新结果数组res[s.pop()]为nums[i]，直到栈为空或nums[i % nums.length]小于等于nums[s.peek()]。

class Solution {
    public int[] nextGreaterElements(int[] nums) {
		int[] res = new int[nums.length];
		Arrays.fill(res, -1);
		Stack<Integer> s = new Stack<>();
		s.push(0);
		for (int i = 1; i < nums.length * 2; i++) {
			while (!s.isEmpty() && nums[i % nums.length] > nums[s.peek()]) {
				res[s.pop()] = nums[i % nums.length];
			}
			s.push(i % nums.length);
		}
		return res;
    }
}

看完代码随想录之后的想法

一样

遇到的困难

这题要注意一下下标，因为遍历了两次数组，下标需要取余数，否则会超出范围报错。

42. 接雨水

题目链接：42. 接雨水

代码随想录题解：42. 接雨水

视频讲解：单调栈，经典来袭！LeetCode:42.接雨水_哔哩哔哩_bilibili

解题思路：

题目没有翻译好，不会，看答案。

看完代码随想录之后的想法

实际上题目要求的是每个“凹槽”体积有多少，这样就能计算其储水量。

如果出现凹槽，那么其左右必然有比当前元素更大的元素，所以只要求出凹槽左边最高的数值和右边最高的数值即可。此时取两个数值中较小的数值，减去当前凹槽的高度，就是当前列所能储水的最大体积。

双指针法：

先从左到右计算每一个下标对应的其左边最高的数值Math.max(maxLeft[i-1], height[i])，再从右到左计算每一个下标对应的其右边最高的数值Math.max(maxRight[i-1], height[i])，maxLeft[0]和maxRight[size-1]分别初始化为height[0]和height[size-1]。接着遍历height中的每一个元素，计算min(maxLeft[i], maxRight[i]) - height[i]，如果大于0，就加到结果中。遍历完后就会得到最终的储水量。

class Solution {
    public int trap(int[] height) {
		if (height.length <= 2) return 0;
		int size = height.length;
		int[] maxLeft = new int[size];
		maxLeft[0] = height[0];
		for (int i = 1; i < size; i++) {
			maxLeft[i] = Math.max(maxLeft[i-1], height[i]);
		}
		int[] maxRight = new int[size];
		maxRight[size-1] = height[size-1];
		for (int j = size - 2; j >= 0; j--) {
			maxRight[j] = Math.max(maxRight[j+1], height[j]);
		}
		int sum = 0;
		for (int i = 0; i < size; i++) {
			int volume = Math.min(maxRight[i], maxLeft[i]) - height[i];
			if (volume > 0) sum += volume;
		}
		return sum;
    }
}

单调栈法：

很奇妙，这也能一遍遍历来做。

单调栈法的思路是，仍按照栈底到栈顶单调递减的方式入栈，相当于记录元素左边高点的情况，如果遇到新入栈元素高度比栈顶元素高度要大，就形成了一个凹槽，可以计算当前储水量，但是这个凹槽计算得到的并不是当前列的最高储水量，而是仅限于其左右两个高点之间的储水量，即所谓按行计算。

分三种情况讨论当前元素和栈顶元素关系：

1. 当前元素高度小于栈顶元素高度，直接入栈

2. 当前元素高度等于当前元素高度，相当于两堵一样高的墙，直接去掉一个也不影响计算，直接弹出栈顶元素，再入栈

3. 当前元素高度大于栈顶元素高度，此时形成了凹槽，需要计算当前凹槽的高和宽得到体积。其高度为左右高度最小值减去凹槽高度，凹槽高度mid = height[s.peek()]，弹出栈顶元素后，如果栈不为空，则得到左边高度height[s.peek()]，右边高度为height[i]，则储水高度为h = Math.min(height[s.peek()],height[i]) - height[mid]，宽度为w = i - s.peek() - 1，体积为h*w，将其加到储水量中即可。

class Solution {
    public int trap(int[] height) {
		if (height.length <= 2) return 0;
		Stack<Integer> s = new Stack<>();
		int sum = 0;
		s.push(0);
		for (int i = 1; i < height.length; i++) {
			if (!s.isEmpty() && height[s.peek()] == height[i]) {
				s.pop();
				s.push(i);
			} else if (!s.isEmpty() && height[s.peek()] > height[i]) {
				s.push(i);
			} else {
				while (!s.isEmpty() && height[s.peek()] < height[i]) {
					int mid = s.pop();
					if (!s.isEmpty()) {
						int h = Math.min(height[s.peek()], height[i]) - height[mid];
						int w = i - s.peek() - 1;
						sum += h * w;
					}
				}
				s.push(i);
			}
		}
		return sum;
    }
}