【力扣刷题】Day32——单调栈专题

最新推荐文章于 2024-07-12 18:12:33 发布

不会喵喵喵的捣蛋猫

最新推荐文章于 2024-07-12 18:12:33 发布

阅读量557

点赞数 1

分类专栏：代码随想录力扣刷题文章标签： leetcode 算法数据结构

本文链接：https://blog.csdn.net/qq_54773252/article/details/127479821

版权

代码随想录力扣刷题专栏收录该内容

27 篇文章 5 订阅

订阅专栏

文章目录

单调栈

单调栈

单调栈基础知识回顾：单调栈与单调队列_塔塔开!!!的博客-CSDN博客_单调栈单调队列

单调栈一般模板：

int[] stk = new int[N] //Stack<Integer> stk;
int tt = 0;

// 模板1....
for(int i = 0; i < nums.size(); i++){
    
    while(tt != 0 && stk[tt] > nums[i]){
		tt --;// 出栈
        .....// 业务处理        
    }
	stk[++ tt] = nums[i];// 数/下标1入栈
}


// 模板2....
for(int i = 0; i < nums.size(); i++){
    
	while(tt != 0 && stk[tt] <= nums[i]) tt --;// 出栈
	if(tt == 0){
        .....
    }
	else .....// 业务：（记录左边/右边 第一个比它小/大的数等等业务）
    stk[++ tt] = nums[i];// 数/下标入栈
}

1.每日温度

题目链接：739. 每日温度 - 力扣（LeetCode）

Code

class Solution {
    /**
        思路：从右往左遍历 实现单调递减栈，记录当前每一个数 右边第一个大于它的数的位置（单调递减栈）
     */
     int N = 100010;
     int[] stk = new int[N];
     int tt;
     int[] pos = new int[N];
    public int[] dailyTemperatures(int[] a) {
        int n = a.length;
        for(int i = n - 1; i >= 0; i --){
            while(tt != 0 && a[stk[tt]] <= a[i]) tt --;
            if(tt == 0) pos[i] = 0;
            else pos[i] = stk[tt];// 记录右边大于它的第一个数的位置
            stk[++ tt] = i;
        }
        int[] res = new int[n];
        for(int i = 0; i < n; i ++){
            if(pos[i] == 0){
                res[i] = 0;
            }else {
                res[i] = pos[i] - i;// 计算位于右边的第几个
            }
        }
        return res;
    }
}

2.下一个更大元素 I

题目链接：496. 下一个更大元素 I - 力扣（LeetCode）

思路一：枚举 + 哈希表

我们用哈希表来记录，nums2[]中nums1[i]出现的位置，然后我们两重遍历，一重循环遍历nums1，二重循环从nums1[i]对应在nums2的位置j开始遍历，然后找到第一个大于nums1[i]的mums2[j]，找到则直接跳出，否则不存在。

Code

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Map<Integer, Integer> mp = new HashMap<>();
        int n = nums1.length;
        int m = nums2.length;

        int[] res = new int[n];
        int cnt = 0;
        for(int i = 0; i < m; i ++) mp.put(nums2[i], i);
        for(int i = 0; i < n; i ++){
            boolean f = false;
            for(int j = mp.get(nums1[i]); j < m; j ++){
                if(nums2[j] > nums1[i]){
                    res[cnt ++] = nums2[j];
                    f = true;
                    break;
                }
            }
            if(!f) res[cnt ++] = -1;
        }
        return res;
    }
}

思路二：单调栈 + 哈希表——跟每日温度一样求的是右边第一个大于它的数。（从右往左）遍历nums2，单调栈求得右边第一个大于它的数，然后用哈希表记录下来，最后我们在遍历nums1即可。

Code

class Solution {
    int N = 1010;
    int[] stk = new int[N];
    int tt = 0;
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        int n = nums1.length;
        int m = nums2.length;

        // 从右往左遍历 找出右边大于它的 第一个数
        Map<Integer, Integer> mp = new HashMap<>();
        for(int i = m - 1; i >= 0; i --){
            while(tt != 0 && stk[tt] <= nums2[i]) tt --;
            if(tt == 0) mp.put(nums2[i], -1);
            else mp.put(nums2[i], stk[tt]);
            stk[++ tt] = nums2[i];
        }
        int[] res = new int[n];
        for(int i = 0; i < n; i ++){
            res[i] = mp.get(nums1[i]);
        }
        return res;
    }
}

3.下一个更大元素II

题目链接：503. 下一个更大元素 II - 力扣（LeetCode）

思路：从右往左遍历实现单调递减栈，记录当前每一个数右边第一个大于它的数的位置，与上一题不同的是，本题的数组是环形的。
我们可以将原数组扩展为两倍得长度就相当于我们进行了下一个更大元素I的两次操作 —— （将循环数组变为链状）（实在不理解就手动模拟就好了）

1 2 1 —> 1 2 1 1 2 1

将环变为链，相当于我们可以考虑到当前数的左边的数（也就是当前数在环中的向右的下一个元素（其实就是在它的左边））

Code

class Solution {

     int N = 100010;
     int[] stk = new int[N];
     int tt;
    public int[] nextGreaterElements(int[] a) {
        int n = a.length;
        int[] res = new int[n];
        int cnt = 0;
        for(int i = 2 * n - 1; i >= 0; i --){
            int x = a[i % n];
            int idx = i % n;

            while(tt != 0 && stk[tt] <= x) tt --;
            if(tt == 0) res[idx] = -1;
            else res[idx] = stk[tt];// 记录右边大于它的第一个数的位置
            
            stk[++ tt] = x;// 入栈
        }
        
        return res;
    }
}

4. 接雨水

题目链接：

Code

思路一：动态规划

在这里插入图片描述

状态表示：

left[i]：表示柱子i左侧的最高柱子高度为left[i]
right[i]：表示柱子i右侧的最高柱子高度为right[i]

状态计算：

left[i] = max(left[i - 1], heigth[i - 1])
right[i] = max(right[i + 1], heigth[i + 1])

初始化：

left[0] = 0
rigth[n - 1] = 0

Code

class Solution {
    public int trap(int[] height) {
        int n = height.length;
        int[] left = new int[n + 10];
        int[] right = new int[n + 10];

        // 初始化
        // Arrays.fill(left, 0);
        // Arrays.fill(right, 0);
        left[0] = 0;
        right[n - 1] = 0;

        // 求每根柱子左右两边的最大高度
        for(int i = 1; i < n; i ++){
            left[i] = Math.max(left[i - 1], height[i - 1]);// 有点DP的意味
        }
        for(int i = n - 2; i >= 0; i --){
            right[i] = Math.max(right[i + 1], height[i + 1]);
        }

        // 求雨水面积
        int res = 0;
        for(int i = 0; i < n; i ++){// 计算每一个位置可以接收的水量
            int minH = Math.min(left[i], right[i]);
            if(minH > height[i]){
                res += (minH - height[i]);
            }    
        }
        return res;
    }
}

这种解法的积水量是一列一列求取的！

思路二：单调栈

单调递减栈

理解题目，参考图，注意题目的性质，当后面的柱子高度比前面的低时，是无法接雨水的
当找到一根比前面高的柱子，就可以计算接到的雨水，所以使用单调递减

这种解法面积是横向求取的！

Code

/**
    单调栈（递减栈）：当遇到大于栈顶元素的柱子（说明可以形成水洼），然后再获取当前洼的高度(栈顶元素就是当前元素)和左边最低的高度（栈顶元素的下一个元素（大于等于当前高度）），即可计算面积（横向的）： res += h（min(L, R) - heigth[cur]） * w，否则元素下标入栈
 */
class Solution {
    int[] stk = new int[2 * 10000 + 10];
    int tt = 0;
    public int trap(int[] height) {
        int n = height.length;
        int res = 0;
        for(int i = 0; i < n; i ++){
            while(tt != 0 && height[stk[tt]] < height[i]){
                int cur = stk[tt --];
                if(tt == 0){// 栈为空时 就break
                    break;
                }
                int l = stk[tt];
                int r = i;
                int h = Math.min(height[l], height[r]) - height[cur];
                res += h * (r - l - 1);
            }
            stk[++ tt] = i;
        }
        return res;
    }
}

5.柱状图中最大的矩形

题目链接：84. 柱状图中最大的矩形 - 力扣（LeetCode）

对于每一个位置我们怎么求它所能构成的最大矩阵呢？首先，要想找到第 i 位置最大面积是什么？

是以i 为中心（矩形的高度由height[i]决定），要使得面积最大，那么就要找到最大宽度，如何寻找最大宽度是关键：

向左找第一个小于 heights[i] 的位置 left_i（left_i后面的位置到i（(left_i,i]）都是可以参与以heigth[i]为高度矩形的构成）；
向右找第一个小于于 heights[i] 的位置 right_i（ right_i前面的位置到（[i, right_i)）i都是可以参与以heigth[i]为高度矩形的构成）

即最大面积为 heights[i] * (right_i - left_i -1)

Code

/**
    思路：单调栈
    去求每一个位置i 左右两边第一个小于当前i位置高度的位置, 当前位置的最大矩形 s = (R-L-1) * h[i]
    记录两个特殊临界值：
        当找左边时，栈为空（说明无小于它的，都可以取，我们将其位置即为-1 l[i] = -1）
        当找右边时，栈为空（说明无小于它的，都可以取，我们将其位置即为n r[i] = n）
    我们开两个数组记录每一个位置 左右两边第一个小于它的位置，然后枚举计算最大值即可
    
 */

 /**
    单调递增栈：求左/右边第一个小于它的数的位置（顺序/逆序遍历）
  */

class Solution {
    int[] stk = new int[100010];
    int tt = 0;
    int[] l = new int[100010];
    int[] r = new int[100010];
    public int largestRectangleArea(int[] heights) {
        int n = heights.length;

        for(int i = 0; i < n; i ++){
            while(tt != 0 && heights[stk[tt]] >= heights[i]) tt --;
            if(tt == 0) l[i] = -1;// 我们认为zuo边没有最小时指定为位置-1
            else l[i] = stk[tt];
            stk[++ tt] = i;// 记录左边第一个小于它的位置
        }

        Arrays.fill(stk, 0);
        tt = 0;
        for(int i = n - 1; i >= 0; i --){
            while(tt != 0 && heights[stk[tt]] >= heights[i]) tt --;
            if(tt == 0) r[i] = n;// 我们认为右边没有最小时指定为位置n
            else r[i] = stk[tt];
            stk[++ tt] = i;
        }
        // for(int i = 0; i < n; i ++){
        //     System.out.print(l[i] + " ");
        // }
        // System.out.println();
        // for(int i = 0; i < n; i ++){
        //     System.out.print(r[i] + " ");
        // }        
        int res = 0;
        for(int i = 0; i < n; i ++){
            res = Math.max(res, (r[i] - l[i] - 1) * heights[i]);
        }
        return res;
    }
}