代码随想录刷题Day59 | 503. 下一个更大元素 II | 42. 接雨水_go实现给定一个循环数组 nums ( nums[nums.length - 1] 的下一个元素是

代码随想录刷题Day59 | 503. 下一个更大元素 II | 42. 接雨水

503. 下一个更大元素 II

题目：

给定一个循环数组 nums （ nums[nums.length - 1] 的下一个元素是 nums[0] ），返回 nums 中每个元素的 下一个更大元素 。

数字 x 的 下一个更大的元素 是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1 。

示例 1:

输入: nums = [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2；
数字 2 找不到下一个更大的数； 
第二个 1 的下一个最大的数需要循环搜索，结果也是 2。
1
2
3
4
5

思路：

看到这道题，就想那我直接把两个数组拼接在一起，然后使用单调栈求下一个最大值不就行了！

确实可以！

讲两个nums数组拼接在一起，使用单调栈计算出每一个元素的下一个最大值，最后再把结果集即result数组resize到原数组大小就可以了。

这种写法确实比较直观，但做了很多无用操作，例如修改了nums数组，而且最后还要把result数组resize回去。

resize倒是不费时间，是O(1)的操作，但扩充nums数组相当于多了一个O(n)的操作。

其实也可以不扩充nums，而是在遍历的过程中模拟走了两边nums。

代码：

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        int[] ans = new int[nums.length];
        for(int i = 0; i < ans.length; i++){
            ans[i] = -1;
        }
        Stack<Integer> s = new Stack<>();
        for(int i = 0; i < nums.length * 2; i++){
            if(s.empty() || nums[i % nums.length] <= nums[s.peek() % nums.length]){
                s.push(i);
            }else{
                while(!s.empty() && nums[i % nums.length] > nums[s.peek() % nums.length]){
                    int index = s.pop();
                    ans[index % nums.length] = nums[i % nums.length];
                }
                s.push(i);
            }
        }
        return ans;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

42. 接雨水

题目：

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例 1：

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。

思路：

动态规划解法

在上一节的双指针解法中，我们可以看到只要记录左边柱子的最高高度 和 右边柱子的最高高度，就可以计算当前位置的雨水面积，这就是通过列来计算。

当前列雨水面积：min(左边柱子的最高高度，记录右边柱子的最高高度) - 当前柱子高度。

为了得到两边的最高高度，使用了双指针来遍历，每到一个柱子都向两边遍历一遍，这其实是有重复计算的。我们把每一个位置的左边最高高度记录在一个数组上（maxLeft），右边最高高度记录在一个数组上（maxRight）。这样就避免了重复计算，这就用到了动态规划。

当前位置，左边的最高高度是前一个位置的左边最高高度和本高度的最大值。

即从左向右遍历：maxLeft[i] = max(height[i], maxLeft[i - 1]);

从右向左遍历：maxRight[i] = max(height[i], maxRight[i + 1]);

这样就找到递推公式。

代码：

class Solution {
    public int trap(int[] h) {
        int[] maxLeft = new int[h.length];
        int[] maxRight = new int[h.length];
        maxLeft[0] = h[0];
        for(int i = 1; i < h.length; i++){
            maxLeft[i] = Math.max(maxLeft[i - 1], h[i]);
        }
        maxRight[h.length - 1] = h[h.length - 1];
        for(int i = h.length - 2; i >= 0; i--){
            maxRight[i] = Math.max(maxRight[i + 1], h[i]);
        }
        int res = 0;
        for(int i = 0; i < h.length; i++){
            int cnt = Math.min(maxLeft[i], maxRight[i]) - h[i];
            if(cnt > 0) res += cnt;
        }
        return res;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20