单调栈的应用

滑动窗口最大值

此题是滑动窗口中的数字个数是固定的,如果窗口中的数字个数在动态变化,比如R右边界增加,L不变…
那有没有一种数据结构结构,可以让我们以O(1)的复杂度得到此时滑动窗口中的最大值或者最小值呢???
有,那就是单调栈!!!
可以使用双端队列来是实现

该单调栈中保证从头部到尾部保证数据的严格递增或递减;
(不允许存在相等的)

当R往右移动一个位置时,如果此时R位置的数,满足单调中的严格递增或递减顺序,则放入到队列尾部
如果不满足,则依次弹出队列尾部的值,直到放入的数满足严格递增或递减的顺序

当L往右动时,如果L此时的位置,是双端队列头部的值,则删除头部的值

单调栈为什么能以O(1)的复杂度得到滑动窗口中的最大值或者最小值呢???
因为它维护的是信息是:

当R不往右动时,L此时位置的数过期,该窗口中谁会成为最大值的顺序;

比如 6 5 4 3 5 ,此时L下标为-1, R下标为3

此时队列为
6 5 4 3
如果L往右动,那么滑动窗口中成为最大值为5
再往右动最大值为4

分析一下为什么?
当R往右动,即窗口此时又包含了5,此时单调栈中需要把3,4移除队列
因为根据单调栈维护的信息,知道
我5比3,4都要大,而且我要晚过期,所以,只要有我5在,3,4就可能成为此时窗口的最大值,因此可以把它们移除
分析一下时间复杂度:
所有元素进出单调栈(双端队列一次),因此是O(n),每个元素评价下来就是O(n)/n相对于O(1)

以下是通用代码,即窗口值不固定,当我们R往右移动时,调用addNumFromRight方法即可
当L往右移动时,调用WindoxMax中的RemovenumFromLeft

单调栈的应用①

如果给定一个数组,我们想知道每一个数,左边比它大的且离它最近,右边比它的且离它最近的数分别是什么???

常规方法是,遍历这个数的左边和右边,可以得到结果,但是这样时间复杂度是O(n2)
这题我们可以利用单调栈把整体复杂度降低为O(n)

先考虑数组中不出现重复值的情况
由于这里是要找左边,右边最近且最大的值,因此这里维护一个从底部到顶部从大到小的顺序,如果满足单调栈的递减顺序,就压入栈,如果不满足,则弹出栈顶元素,并且生成栈顶元素的信息,左边离你最近且最大的就是该元素下面一个(这里是4),右边最近最大的就是让你弹出的那个元素(这里是6)

接着由于6比4大,继续弹出,生成信息

6比5大,继续弹出生成信息

…
如果到最后栈中还有元素,则进入清算阶段
从栈顶开始弹出元素,右边最近最大的没有,左边最近最大的就是该元素下面的元素;

这样的时间复杂度是O(n)的,因为数组中元素只会进出单调栈一次

接下来证明:
假设此时数组中没有重复值,数组时从左往右进入栈
此时要压入c,c比a大,此时要弹出a并且生成a的信息
①为什么当a弹出时,数组右边离a最近且最大的一定是c

假设如果数组中,a 和 c之间有比a大的数k,由于数组时从左往右遍历的,当我们遍历到k的时候,就会把a弹出了,并且生成a的信息,但是现在是轮到c来把a弹出,这就说明此时c已经是a右边最近且最大的值了

②为什么当a弹出时,数组左边离a最近且最大的一定是b
同样假设如果原数组中中a和b之间有其他数,假设存在一个k
b … k …a
那么k有可能有以下3种情况:

1. k > b : 这种情况不可能存在,因为如果k>b,那么k就已经把b给替换了
2. a < k < b : 这种情况也不可能,因为此时a,b不可能挨着一起,你也许回想,有可能来了一个比k大的数,然后把k给替换了,但是我们这里是无重复值的情况,因此你无论怎么替换最终不可能把b给替换了,即单调栈在a,b之间夹了一个数,因此这种情况不存在
3. k < a: 这种情况就允许存在了,因为如果原数组中b,a之间全是比a小的数,那么最终就会形成单调栈的情况 a在b之上;
   所以: 可证明,当弹出a时,a左边比a大的且最近的就是b,即单调栈维护的信息时正确的!!

代码
这里代码展示的是找一个数字,左边小于它并且最近的数,右边小于它并且最近的数,那么我们只需要保持单调栈从底部到头部是递增即可

public static int[][] getNearLessNoRepeat(int[] arr) {
		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 popIndex = stack.pop();
				int leftLessIndex = stack.isEmpty() ? -1 : stack.peek();
				res[popIndex][0] = leftLessIndex;
				res[popIndex][1] = i;
			}
			stack.push(i);
		}
		while (!stack.isEmpty()) {
			int popIndex = stack.pop();
			int leftLessIndex = stack.isEmpty() ? -1 : stack.peek();
			res[popIndex][0] = leftLessIndex;
			res[popIndex][1] = -1;
		}
		return res;
	}

此时来看看如果数组中有重复值
如果有重复值,那么只需要把相同值的下标放在一起,串成一个链表!!

比如: 此时来了一个6位置的5,此时要弹出5位置的3,那么右边比3大的数且最近的 就是6位置的5
左边比3大的就是相同值为5串成的链表的最后一个,也就是4位置的5

代码:

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 {
				ArrayList<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;
	}

单调栈的应用②

一个数组中子数组的累计和与最小值的乘积叫作指标A,给定一个正数数组,
请返回这个数组中,A的最大值

算法部分看max2方法,max1方法是用的暴力法,用对数器来验证max2是否是正确的!!!

public class Code03_AllTimesMinToMax {

	public static int max1(int[] arr) {
		int max = Integer.MIN_VALUE;
		for (int i = 0; i < arr.length; i++) {
			for (int j = i; j < arr.length; j++) {
				int minNum = Integer.MAX_VALUE;
				int sum = 0;
				for (int k = i; k <= j; k++) {
					sum += arr[k];
					minNum = Math.min(minNum, arr[k]);
				}
				max = Math.max(max, minNum * sum);
			}
		}
		return max;
	}

	public static int max2(int[] arr) {
		int size = arr.length;
		int[] sums = new int[size];
		sums[0] = arr[0];
		for (int i = 1; i < size; i++) {
			sums[i] = sums[i - 1] + arr[i];
		}
		int max = Integer.MIN_VALUE;
		Stack<Integer> stack = new Stack<Integer>();
		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 max;
	}

	public static int[] gerenareRondomArray() {
		int[] arr = new int[(int) (Math.random() * 20) + 10];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int) (Math.random() * 101);
		}
		return arr;
	}

	public static void main(String[] args) {
		int testTimes = 2000000;
		for (int i = 0; i < testTimes; i++) {
			int[] arr = gerenareRondomArray();
			if (max1(arr) != max2(arr)) {
				System.out.println("FUCK!");
				break;
			}
		}
	}