sub arr num

Author: dairongpeng

13-《进阶》单调栈和窗口.md

@@ -120,111 +120,120 @@ func main() {
 
 ### 1.1.5 高频题二：达标子数组数量问题
 
-给定一个整形数组arr，和衣蛾整数num。某个arr中的子数组sub，如果想达标，必须满足:sub中最大值-sub中最小值<=num，返回arr中达标子数组的数量
+给定一个整形数组arr，和一个整数num。某个arr中的子数组sub，如果想达标，必须满足: sub中最大值-sub中最小值<=num，返回arr中达标子数组的数量
 
 > 子数组是连续的
 
-> 结论1：对于[L...R]范围达标，那么[L...R]上的子数组都达标。max[L...R]肯定比其子数组的max要大，min[L...R]肯定比其范围内的子数组要小，那么[L...R]上满足max - min < num，则其子数组必定满足
+> 结论1：对于[L,R]范围达标，那么[L,R]上的子数组都达标。max[L...R]肯定比其子数组的max要大，min[L...R]肯定比其范围内的子数组要小，那么[L...R]上满足max - min < num，则其子数组必定满足
 
 > 同理可得结论2：对于[L...R]范围不达标，那么扩展范围后的[L'...R']也不达标
 
 > 我们建立两个双端队列，一个是窗口最大值的双端队列，一个是窗口最小值的双端队列。我们扩展我们的窗口R加1，每扩展一个判断是否仍然达标，达标继续扩展，不达标就停，可以得到本次子数组的达标情况，接着缩小我们的窗口L加1，继续...。窗口滑动不会回退，整体O(N)
 
-```Java
-package class01;
+```Go
+package main
 
-import java.util.LinkedList;
+import (
+	"container/list"
+	"fmt"
+)
 
-public class Code02_AllLessNumSubArray {
+// 达标子数组数量问题
 
-	public static int getNum(int[] arr, int num) {
-		if (arr == null || arr.length == 0) {
-			return 0;
-		}
-		// 窗口内最小值的更新结构
-		LinkedList<Integer> qmin = new LinkedList<Integer>();
-		// 窗口内的最大值的更新结构
-		LinkedList<Integer> qmax = new LinkedList<Integer>();
-		int L = 0;
-		int R = 0;
-		// [L..R) -> [0,0) 窗口内无数 [1,1)
-		// [0,1) -> [0~0] 窗口里只有一个数
-		int res = 0;
-		// L是开头位置，尝试每一个开头
-		while (L < arr.length) {
-
-			// 如果此时窗口的开头是L,下面的while工作是:R向右扩到违规为止
-
-            // R是最后一个达标位置的再下一个，通过下文的break终止
-			while (R < arr.length) { 
-				// R位置的数进入窗口后，最小值的更新结构和最大值的更新结构都要更新
-				while (!qmin.isEmpty() && arr[qmin.peekLast()] >= arr[R]) {
-					qmin.pollLast();
-				}
-				qmin.addLast(R);
-				// R -> arr[R],
-				while (!qmax.isEmpty() && arr[qmax.peekLast()] <= arr[R]) {
-					qmax.pollLast();
-				}
-				qmax.addLast(R);
+// getNum 给定样本数组，和一个目标数值num。求arr中达标的子数组，达标的要求为子数组中最大值减去子数组中最小值小于等于num
+func getNum(arr []int, num int) int {
+	if len(arr) == 0 {
+		return 0
+	}
 
-                // 如果此时不满足了，break。说明窗口已经成长到了第一个不达标的数进来了
-				if (arr[qmax.getFirst()] - arr[qmin.getFirst()] > num) {
-					break;
+	// 窗口内最小值的更新结构
+	qmin := list.List{}
+	// 窗口内的最大值的更新结构
+	qmax := list.List{}
+
+	// 最小值双端队列的头部元素
+	var minfe = &list.Element{}
+	// 最小值双端队列的尾部元素
+	var minee = &list.Element{}
+
+	// 最大值双端队列的头部元素
+	var maxfe = &list.Element{}
+	// 最小值双端队列的尾部元素
+	var maxee = &list.Element{}
+
+	L := 0
+	R := 0
+	// [L..R) -> [0,0) 窗口内无数 [1,1)
+	// [0,1) -> [0~0] 窗口里只有一个数
+	res := 0
+	// L是开头位置，尝试每一个开头
+	for L < len(arr) {
+		// 如果此时窗口的开头是L,下面的for工作是:R向右扩到违规为止
+
+		// R是最后一个达标位置的再下一个，通过下文的break终止
+		for R < len(arr) {
+			// R位置的数进入窗口后，最小值的更新结构和最大值的更新结构都要更新
+			for qmin.Len() != 0 && arr[qmin.Back().Value.(int)] >= arr[R] {
+				// 尾部移除
+				qmin.Remove(minee)
+				if qmin.Len() > 0 {
+					minfe = qmin.Front()
+					minee = qmin.Back()
 				}
-				R++;
 			}
 
-			// R是最后一个达标位置的再下一个，第一个违规的位置
-			res += R - L;
-
-            // 检查最小值和最大值的更新结构有没有过期
-			if (qmin.peekFirst() == L) {
-				qmin.pollFirst();
-			}
-			if (qmax.peekFirst() == L) {
-				qmax.pollFirst();
+			qmin.PushBack(R)
+			minee = qmin.Back()
+			minfe = qmin.Front()
+
+			// R -> arr[R],
+			for qmax.Len() != 0 && arr[qmax.Back().Value.(int)] <= arr[R] {
+				// 尾部移除
+				qmax.Remove(maxee)
+				if qmax.Len() > 0 {
+					maxfe = qmax.Front()
+					maxee = qmax.Back()
+				}
 			}
 
-            // 窗口左边界向右滑动，窗口容量此时减1
-			L++;
-
-		}
-		return res;
-	}
+			qmax.PushBack(R)
+			maxee = qmax.Back()
+			maxfe = qmax.Front()
 
-	// for test
-	public static int[] getRandomArray(int len) {
-		if (len < 0) {
-			return null;
+			if arr[qmax.Front().Value.(int)]-arr[qmin.Front().Value.(int)] > num {
+				break
+			}
+			R++
 		}
-		int[] arr = new int[len];
-		for (int i = 0; i < len; i++) {
-			arr[i] = (int) (Math.random() * 10);
+		// R是最后一个达标位置的再下一个，第一个违规的位置
+		res += R - L
+		// 检查最小值和最大值的更新结构有没有过期
+		if qmin.Front().Value.(int) == L {
+			qmin.Remove(minfe)
+			if qmin.Len() > 0 {
+				minfe = qmin.Front()
+				minee = qmin.Back()
+			}
 		}
-		return arr;
-	}
 
-	// for test
-	public static void printArray(int[] arr) {
-		if (arr != null) {
-			for (int i = 0; i < arr.length; i++) {
-				System.out.print(arr[i] + " ");
+		if qmax.Front().Value.(int) == L {
+			qmax.Remove(maxfe)
+			if qmax.Len() > 0 {
+				maxfe = qmax.Front()
+				maxee = qmax.Back()
 			}
-			System.out.println();
 		}
+		// 窗口左边界向右滑动，窗口容量此时减1
+		L++
 	}
-
-	public static void main(String[] args) {
-		int[] arr = getRandomArray(30);
-		int num = 5;
-		printArray(arr);
-		System.out.println(getNum(arr, num));
-
-	}
-
+	return res
 }
 
+func main() {
+	arr := []int{4, 2, 1, 5, 6, 1, 7, 22, 53, 16, 24, 65, 72, 17, 21, 42}
+	num := 5
+	fmt.Println(getNum(arr, num))
+}
 ```
 
 > 本题根据窗口滑动建立了单调性，上文的结论