算法 — — 单调栈技巧及常见考题

已于 2022-10-08 08:57:46 修改
阅读量234 收藏
点赞数
分类专栏： LeetCode 算法与数据结构 文章标签： 算法 java 单调栈 矩阵
于 2022-10-07 09:51:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45565886/article/details/127183591
版权

算法 — — 单调栈技巧

1 单调栈定义

在这里插入图片描述

2 单调栈的实现及算法题目

2.1 单调栈的实现

单调栈：从栈底到栈顶，值的大小是由小到大

2.1.1 没有重复值的单调栈实现
// arr = [ 3, 1, 2, 3]
//         0  1  2  3
//  [
//     0 : [-1,  1]
//     1 : [-1, -1]
//     2 : [ 1, -1]
//     3 : [ 2, -1]
//  ]
public static int[][] getNearLessNoRepeat(int[] arr){
    //存储每个位置对应结果【i位置的左边比arr[i]小的值，右边比arr[i]小的值，只存下标】
    int[][] res = new int[arr.length][2];
    Stack<Integer> stack = new Stack<>();//构建单调栈
    for(int i = 0; i < arr.length; i++){
        while(!stack.isEmpty() && arr[stack.peek()] > arr[i]) {
            //需要弹出
            int j = stack.pop();
            //左边比i位置小的值的下标[如果栈不为空，就取栈顶值，也就是之前i位置压得值]
            int leftLessIndex = stack.isEmpty() ? -1 : stack.peek();
            res[j][0] = leftLessIndex;
            res[j][1] = i;
        }
        stack.push(i);
    }
    //最后清算
    while(!stack.isEmpty()){
        int j = stack.pop();
        int leftLessIndex = stack.isEmpty() ? -1 : stack.peek();
        res[j][0] = leftLessIndex;
        res[j][1] = -1;//右边没有比其更小得值了，因此全部为-1
    }
    return res;
}
2.1.2 有重复值的单调栈实现
//有重复值：使用链表串起来
public static int[][] getNearLess(int[] arr) {
    int[][] res = new int[arr.length][2];
    Stack<List<Integer>> stack = new Stack<>();
    for(int i = 0; i < arr.length; i++){
        //栈里面存得是一个小链表
        while(!stack.isEmpty() && arr[stack.peek().get(0)] > arr[i]){
            List<Integer> popIs = stack.pop();
            int leftLessIndex = stack.isEmpty() ? -1 : stack.peek().get(stack.peek().size() - 1);
            //遍历小链表中得每一个值
            for(Integer popi : popIs){
                res[popi][0] = leftLessIndex;
                res[popi][1] = i;
            }
        }
        if(!stack.isEmpty() && arr[stack.peek().get(0)] == arr[i]){
            //值与栈顶元素相等
            stack.peek().add(Integer.valueOf(i));//存下标
        } else {
            //栈为空或值不等，则新建链表
            List<Integer> list = new ArrayList<>();
            list.add(i);
            stack.push(list);
        }
    }
    //结算栈中剩余得值
    while(!stack.isEmpty()){
        List<Integer> popIs = stack.pop();
        //小链表得最后一个值【链表中存储得是下标值】
        int leftLessIndex = stack.isEmpty() ? -1 : stack.peek().get(stack.peek().size() - 1);
        for(Integer popi : popIs){
            res[popi][0] = leftLessIndex;
            res[popi][1] = -1;
        }
    }
    return res;
}

2.2 正数数组arr中子数组sub中(sub累加和*sub最小值)，求最大值

LeetCode 1856 - Maximum Subarray Min-Product
https://leetcode.com/problems/maximum-subarray-min-product/

给定一个只包含正数的数组arr，arr中任何一个子数组sub，
一定都可以算出(sub累加和 )* (sub中的最小值)是什么，
那么所有子数组中，这个值最大是多少？

// 注意溢出的处理即可，也就是用long类型来表示累加和
// 还有优化就是，你可以用自己手写的数组栈，来替代系统实现的栈，也会快很多
public int maxSumMinProduct(int[] arr){
    int size = arr.length;
    long[] sums = new long[size];
    //[i..j]位置，累加和->前缀和数组
    //sub子数组的和 * sub子数组中最小值
    //前缀和数组
    sums[0] = arr[0];
    for(int i = 1; i < size; i++){
        sums[i] = sums[i-1] + arr[i];
    }
    long max = Long.MIN_VALUE;
    //错化处理，算错就算错，最后有正确答案覆盖错误的
    Stack<Integer> stack = new Stack<>();
    for(int i = 0; i < size; i++){
        while(!stack.isEmpty() && arr[stack.peek()] >= arr[i]){
            int j = stack.pop();
            //子数组累加和 * 子数组中最小值
            max = Math.max(max, (stack.isEmpty() ? sums[i - 1] : (sums[i - 1] - sums[stack.peek()])) * arr[j]);
        }
        stack.push(i);
    }
    while(!stack.isEmpty()){
        int j = stack.pop();
        max = Math.max(max, (stack.isEmpty() ? sums[size - 1] : (sums[size - 1] - sums[stack.peek()])) * arr[j]);
    }
    return (int) (max % 1000000007);
}

手动改写栈：

// 注意测试题目数量大，要取模，但是思路和课上讲的是完全一样的
// 注意溢出的处理即可，也就是用long类型来表示累加和
// 还有优化就是，你可以用自己手写的数组栈，来替代系统实现的栈，也会快很多
public static int maxSumMinProduct(int[] arr) {
	int size = arr.length;
	long[] sums = new long[size];
	sums[0] = arr[0];
	for (int i = 1; i < size; i++) {
		sums[i] = sums[i - 1] + arr[i];
	}
	long max = Long.MIN_VALUE;
	int[] stack = new int[size];
	int stackSize = 0;
	for (int i = 0; i < size; i++) {
		while (stackSize != 0 && arr[stack[stackSize - 1]] >= arr[i]) {
			int j = stack[--stackSize];
			max = Math.max(max,
					(stackSize == 0 ? sums[i - 1] : (sums[i - 1] - sums[stack[stackSize - 1]])) * arr[j]);
		}
		stack[stackSize++] = i;
	}
	while (stackSize != 0) {
		int j = stack[--stackSize];
		max = Math.max(max,
				(stackSize == 0 ? sums[size - 1] : (sums[size - 1] - sums[stack[stackSize - 1]])) * arr[j]);
	}
	return (int) (max % 1000000007);
}

2.3 最大矩形面积

LeetCode - 84. Largest Rectangle in Histogram
https://leetcode.com/problems/largest-rectangle-in-histogram/submissions/

给定一个非负数组arr，代表直方图
返回直方图的最大长方形面积

class Solution {
    public int largestRectangleArea(int[] heights) {
        if(heights == null || heights.length == 0){
            return 0;
        }
        int maxArea = 0;
        Stack<Integer> stack = new Stack<>();
        for(int i = 0; i < heights.length; i++){
            while(!stack.isEmpty() && heights[stack.peek()] >= heights[i]){
                //以heights[j]为高
                int j = stack.pop();
                //找到矩形左边界
                int k = stack.isEmpty() ? -1 : stack.peek();
                maxArea = Math.max(maxArea, (i - k - 1) * heights[j]);
            }
            stack.push(i);
        }
        while(!stack.isEmpty()){
            int j = stack.pop();
            int k = stack.isEmpty() ? -1 : stack.peek();
            maxArea = Math.max(maxArea, (heights.length - k - 1) * heights[j]);
        }
        return maxArea;
    }
}

2.4 二维数组，最大子矩形，内部1的个数

给定一个二维数组matrix，其中的值不是0就是1，
返回全部由1组成的最大子矩形，内部有多少个1

LeetCode - 85. Maximal Rectangle
https://leetcode.com/problems/maximal-rectangle/

class Solution {
    public int maximalRectangle(char[][] matrix) {
        if(matrix == null || matrix.length == 0 || matrix[0].length == 0){
            return 0;
        }
        //压缩数组
        int maxArea = 0;
        int[] height = new int[matrix[0].length];
        for(int i = 0; i < matrix.length; i++){
            for(int j = 0; j < matrix[0].length; j++){
                height[j] = matrix[i][j] == '0' ? 0 : height[j] + 1;
            }
            maxArea = Math.max(maxArea, maxRecFromBottom(height));
        }
        return maxArea;
    }
    
    //height是正方图数组[单调栈]
    public int maxRecFromBottom(int[] height){
        if(height == null || height.length == 0){
            return 0;
        }
        int maxArea = 0;
        Stack<Integer> stack = new Stack<>();
        for(int i = 0; i < height.length; i++){
            while(!stack.isEmpty() && height[stack.peek()] >= height[i]){
                int j = stack.pop();
                int k = stack.isEmpty() ? -1 : stack.peek();
                int curArea = (i - k - 1) * height[j];
                maxArea = Math.max(maxArea, curArea);
            }
            stack.push(i);
        }
        while(!stack.isEmpty()){
            int j = stack.pop();
            int k = stack.isEmpty() ? -1 : stack.peek();
            int curArea = (height.length - k - 1) * height[j];
            maxArea = Math.max(maxArea, curArea);
        }
        return maxArea;
    }
}

2.5 二维数组，全部由1组成的子矩阵数量

给定一个二维数组matrix，其中的值不是0就是1，
返回全部由1组成的子矩形数量

LeetCode - 1504. Count Submatrices With All Ones
https://leetcode.com/problems/count-submatrices-with-all-ones/


	// 比如
	//              1
	//              1
	//              1         1
	//    1         1         1
	//    1         1         1
	//    1         1         1
	//             
	//    2  ....   6   ....  9
	// 如上图，假设在6位置，1的高度为6
	// 在6位置的左边，离6位置最近、且小于高度6的位置是2，2位置的高度是3
	// 在6位置的右边，离6位置最近、且小于高度6的位置是9，9位置的高度是4
	// 此时我们求什么？
	// 1) 求在3~8范围上，必须以高度6作为高的矩形，有几个？
	// 2) 求在3~8范围上，必须以高度5作为高的矩形，有几个？
	// 也就是说，<=4的高度，一律不求
	// 那么，1) 求必须以位置6的高度6作为高的矩形，有几个？
	// 3..3  3..4  3..5  3..6  3..7  3..8
	// 4..4  4..5  4..6  4..7  4..8
	// 5..5  5..6  5..7  5..8
	// 6..6  6..7  6..8
	// 7..7  7..8
	// 8..8
	// 这么多！= 21 = (9 - 2 - 1) * (9 - 2) / 2
	// 这就是任何一个数字从栈里弹出的时候，计算矩形数量的方式
class Solution {
    public int numSubmat(int[][] mat) {
        if(mat == null || mat.length == 0 || mat[0].length == 0){
            return 0;
        }
        int[] height = new int[mat[0].length];//以每一行做底
        int nums = 0;
        for(int i = 0; i < mat.length; i++){
            for(int j = 0; j < mat[0].length; j++){
                height[j] = mat[i][j] == 0 ? 0 : height[j] + 1;
            }
            nums += countFromBottom(height);
        }
        return nums;
    }
    
    public int countFromBottom(int[] height){
        if(height == null || height.length == 0){
            return 0;
        }
        int nums = 0;
        //用数组模拟栈
        int[] stack = new int[height.length];
        int si = -1;
        for(int i = 0; i < height.length; i++){
            while(si != -1 && height[stack[si]] >= height[i]){
                int cur = stack[si--];
                if(height[cur] > height[i]){
                    //相等不用管，后面会有大的连通图来计算，统一计算
                    int left = si == -1 ? -1 : stack[si];//peek
                    int n = i - left - 1;
                    //不碰较大最小值的高度，后面统一算
                    int down = Math.max(left == -1 ? 0 : height[left], height[i]);
                    nums += (height[cur] - down) * num(n);
                }
            }
            stack[++si] = i;//push
        }
        while(si != -1){
            int cur = stack[si--];
            int left = si == -1 ? -1 : stack[si];
            int n = height.length - left - 1;
            int down = left == -1 ? 0 : height[left];
            nums += (height[cur] - down) * num(n);
        }
        return nums;
        
    }
    
    
    
    //等差数列求和计算公式
    public int num(int n){
        return ((n * (n + 1)) >> 1);
    }
}

2.6 所有子数组最小值的累加和

给定一个数组arr，
返回所有子数组最小值的累加和

LeetCode - 907. Sum of Subarray Minimums
https://leetcode.com/problems/sum-of-subarray-minimums/

class Solution {
    //用数组实现栈
    public static int sumSubarrayMins(int[] arr) {
		int[] stack = new int[arr.length];
		int[] left = nearLessLeft(arr, stack);
		int[] right = nearLessEqualRight(arr, stack);
		long ans = 0;
		for (int i = 0; i < arr.length; i++) {
			long start = i - left[i];
			long end = right[i] - i;
			ans += start * end * (long) arr[i];
			ans %= 1000000007;
		}
		return (int) ans;
	}
    

    //小于等于右边的范围【每个位置，以arr[i]做最小值的子数组】
    //right[i] = x : arr[i]右边，离arr[i]最近，<=arr[i]的数，位置在x
	public static int[] nearLessEqualRight(int[] arr, int[] stack) {
		int N = arr.length;
		int[] right = new int[N];
		int size = 0;
		for (int i = N - 1; i >= 0; i--) {
			while (size != 0 && arr[i] <= arr[stack[size - 1]]) {
				right[stack[--size]] = i;
			}
			stack[size++] = i;
		}
		while (size != 0) {
			right[stack[--size]] = -1;
		}
		return right;
	}

    //小于左边的范围
    //left[i] = x : arr[i]左边，离arr[i]最近，<arr[i]的数，位置在x
	public static int[] nearLessLeft(int[] arr, int[] stack) {
		int N = arr.length;
		int[] left = new int[N];
		int size = 0;
		for (int i = 0; i < N; i++) {
			while (size != 0 && arr[i] < arr[stack[size - 1]]) {
				left[stack[--size]] = i;
			}
			stack[size++] = i;
		}
		while (size != 0) {
			left[stack[--size]] = N;
		}
		return left;
	}

}

要有以确定某个元素，然后找目标的思想。
例如：找寻子数组，那么可以转化成以arr中的某个元素为起点，包含该元素的子数组有多少

NPE~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
神奇的单调栈
10-27
如果你不知道单调栈的应用,那么你就out了!赶快学习一下吧,保证你看的懂!
【栈】单调栈经典例题
SY奇星的OI博客
05-30 419
现在有一个长度为n的序列，在形成的任意子区间中，查找最小的值和此区间和的乘积的最大值。660例如在区间1-6中，最小值为1，区间和为21，积为21；在区间3-5中，最小值为4，区间和为15，积为60；再由遍历其他区间，得出值60为最大，最后您输出了60。
算法数据结构——关于单调栈（Monotone Stack）的详细讲解及应用案例
热门推荐
白话机器学习
06-04 1万+
单调栈（Monotone Stack）：一种特殊的栈。在栈的「先进后出」规则基础上，要求「从栈顶到栈底的元素是单调递增（或者单调递减）」。其中满足从栈顶到栈底的元素是单调递增的栈，叫做「单调递增栈」。满足从栈顶到栈底的元素是单调递减的栈，叫做「单调递减栈」。注意：这里定义的顺序是从「栈顶」到「栈底」。有的文章里是反过来的。本文全文以「栈顶」到「栈底」的顺序为基准来描述单调栈。
单调栈类型题合集
weixin_39248750的博客
02-15 1008
单调栈分为单调递增栈和单调递减栈。 操作规则：（下面都以单调递增栈为例） 如果新的元素比栈顶元素大，就入栈 如果新的元素较小，那就一直把栈内元素弹出来，直到栈顶比新元素小 Stack<Integer> stack = new Stack<>(); for(int i = 0; i < nums.size(); i++) { while(! stack.isEmpty() && stack.peek() > nums[i]) { st.pop(
单调栈(C/C++)
m0_73096566的博客
02-27 8668
单调栈(C/C++)
【刷题总结】单调栈系列问题
迈向年薪百万之路
03-16 202
文章目录单调栈问题特征单调栈问题解法单调栈系列题目1、下一个更大元素系列2、柱形图面积系列3、延展用法 单调栈问题特征 LeetCode官方讲解 单调栈，就是栈的应用，里面的元素的大小按照他们所在栈内的位置，满足一定的单调性。 单调栈里的元素具有单调性 元素加入栈前，会在栈顶端把破坏栈单调性的元素都删除 单调递增：栈可以找到元素向左向右遍历第一个比他小的元素，当元素出栈时，说明这个新元素是出栈元素向后找第一个比其小的元素，新栈顶元素是出栈元素向前找第一个比其小的元素 单调递减：栈可以找到元素向左享有遍历第
浅谈单调队列、单调栈
09-03
单调队列和单调栈是两种在算法中常用于优化计算效率的数据结构，它们的主要功能是维护一个单调递增或递减的数据序列，并能快速获取序列中的最大值或最小值。这两种数据结构虽然名称不同，但核心思想相似，都是基于...
C++栈stack算法 最全面
07-23
原题解析 ：见算法训练营 P74~74 */ #include using namespace std; int main() { cout栈算法"; cout初始值为 http://www.acm.org"<<'\n'; cout网址-访问 QUIT 结束 BACK 回到上一个网址 FORWARD 将当前页面变成...
南京理工大学算法考试复习重点及部分习题.zip
05-09
总之，南京理工大学的算法考试复习资料提供了全面的学习资源，帮助学生巩固理论知识，提高解题技巧，为应对考试做好充分准备。无论是否是该校的学生，都能从这些材料中受益，提升自己的算法设计与分析能力。
算法.rar，常见算法
07-10
算法.rar，常见算法算法.rar，常见算法算法.rar，常见算法算法.rar，常见算法算法.rar，常见算法算法.rar，常见算法算法.rar，常见算法算法.rar，常见算法算法.rar，常见算法算法.rar，常见算法算法.rar，常见算法...
LeetCode刷题（163）～每日温度【单调栈】
海到无边天作岸 山登绝顶我为峰
09-16 1925
题目描述 请根据每日 气温 列表，重新生成一个列表。对应位置的输出为：要想观测到更高的气温，至少需要等待的天数。如果气温在这之后都不会升高，请在该位置用 0 来代替。 例如，给定一个列表 temperatures = [73, 74, 75, 71, 69, 72, 76, 73]，你的输出应该是 [1, 1, 4, 2, 1, 1, 0, 0]。 提示：气温 列表长度的范围是 [1, 30000]。每个气温的值的均为华氏度，都是在 [30, 100] 范围内的整数。 解答 By 海轰 提交代码 vecto
单调栈问题
江上酒
12-03 196
单调栈能够求得 该数左边离他最近的大于/小于的数（其他问题也可以转换为此问题） 例如 求 a[i]左边第一个小于a[i]的数 对于a[i]每次入栈如果有大于等于a[i]的数，直接出栈 证明：如果求左侧第一个小于a[i]的数 如果a[i]入栈后左侧有大于a[i]的数，则那个数不仅是大值而且还出现的比较早，所以他永远不会被用到，所以直接出栈 单调栈板子 #include<iostream> #include<cstdio> #include<cstring&gt...
单调栈的经典例题
算法与编程之美
10-05 581
本文首发于微信公众号："算法与编程之美"，欢迎关注，及时了解更多此系列文章。前言算法中的单调栈应用十分的广泛；单调栈简单的来说就是栈内元素单调递增或者单调递减的栈，同时单调栈还可以不断的维...
算法之单调栈常见题目
ChenYiRan123456的博客
05-19 576
什么时候需要使用单调栈？ 通常是一维数组，**要寻找任意一个右边或者左边第一个比自己大或小的元素的位置，此时我们就想到可以使用单调栈了**。 单调栈的本质是空间换时间，因为在遍历的过程中需要用一个栈来记录右边第一个比当前元素高的元素，优点是整个数组只需要遍历一次。所以时间复杂度是O(n)就可以找到每一个元素的右边第一个比它大的元素位置呢？ 更直白来说，就是用一个**栈来记录我们遍历过的元素**，因为我们遍历数组的时候，我们不知道之前都遍历了哪些元素，以至于遍历一个元素找不到是不是之前遍历过一个更小的，所以我
单调栈算法大总结！！！C++解法，看完这篇文章单调栈嘎嘎乱杀！！！
最新发布
weixin_45962681的博客
08-03 888
开头添加0也是一样的，如果数组本身是降序的，[5,4,3,2,1]，5入栈后，4与5比较，这时得不到left。需要注意的是这里的出栈条件，s.pop()需要放在if语句的外面，需要确保，无论栈顶元素是否在nums1中，都将其从栈中移除，因为栈顶元素的下一个更大的元素已经被找到，只是因为不在nums1中不必被记录。因为一旦发现添加的柱子高度大于栈头元素了，此时就出现凹槽了，栈头元素就是凹槽底部的柱子，栈头第二个元素就是凹槽左边的柱子，而添加的元素就是凹槽右边的柱子。如果不存在，对应位置输出 -1。
单调栈及经典问题
qq_34603425的博客
09-25 391
单调栈的基本概念、代码演示、典型例题。
leetcode单调栈系列经典例题——接雨水
weixin_72076848的博客
07-01 1394
LeetCode单调栈系列经典例题——接雨水
单调栈详解
熊與貓v
08-22 4298
定义： 单调栈，顾名思义就是栈内元素单调按照递增(递减)顺序排列的栈。 适用问题： 要知道单调栈的适用于解决什么样的问题，我们首先需要知道单调栈的作用。单调栈分为单调递增栈和单调递减栈，通过使用单调栈我们可以访问到下一个比他大（小）的元素（或者说可以）。也就是说在队列或数组中，我们需要通过比较前后元素的大小关系来解决问题时我们通常使用单调栈。下面我们通过简单介绍单调减栈和单调增栈问题来进一步说明使用单调栈处理问题的过程。 单调栈主要解决以下问题： 寻找下一个更大元素 寻找前一个更大元素 寻找.
单调栈 & 单调队列 专题
Mr_dimple的博客
01-05 1069
上述操作通过维护单调递增栈，求出了数列中每个数左边第一个比它小的数。同理可以维护单调递减栈，求出数列中每个数左边第一个比它大的数。将枚举顺序转换，从后往前枚举，便能求出数列中每个数右边第一个比它小/大的数。求区间最小值，维护单调递增栈；求区间最大值，维护单调递减栈。把原理搞懂，能够用代码实现之后，这两种算法就掌握了。在以后的题目中，如果需要求每个位置左边/右边第一个比其大/小的元素，就要想到用单调栈；如果需要维护一个移动区间的最值，用单调队列O(n)O(n)O(n)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值