算法与数据结构进阶课第九节笔记

数组累积和问题三连

例1、给定一个正整数组成的无序数组arr，给定一个正整数值K，找到arr的所有子数组里，哪个子数组的累加和等于K，并且是长度最大的，返回其长度。

准备一个窗口[L..R] 的累积和是windowSum

windowSum > K, R++  因为都是正数，已经大于 ，那么之后再累加不可能再小于等于K

windowSum < K, L ++

windowSum = K, max = Math.max(R-L+1,max)

未排序正数数组中累加和为给定值的最长子数组的长度

      public static int getMaxLength(int[] arr, int K) {
		if (arr == null || arr.length == 0 || K <= 0) {
			return 0;
		}
		// 具体实现时，左闭右闭
		int left = 0;
		int right = 0;
		int sum = arr[0];
		int len = 0;
		while (right < arr.length) {
			if (sum == K) {
				len = Math.max(len, right - left + 1);
				sum -= arr[left++];
			} else if (sum < K) {
				right ++; // 要先移动再加，
				if (right == arr.length){
					break;
				}
				sum += arr[right];
			} else {
				sum -= arr[left++];
			}
		}
		return len;
	}

求子数组个数这个算法不适用

例2：

给定一个整数组成的无序数组arr，值可能正、可能负、可能0，给定一个整数值K，找到arr的所有子数组里，哪个子数组的累加和等于K，并且是长度最大的，返回其长度

换一种思路找以i位置结尾累加和刚好是K的最早位置，假设i位置上的累加和是1000，k=800，那么就是要找到i的前缀和为800的最长，也就是i前面最早某个位置的累加和为200，记为x，最长就是i-x，要从x的下一个位置开始计数

使用一个map，key是累加和，value是这个累加和最早出现的位置

未排序数组中累加和为给定值的最长子数组长度

和为K的子数组个数   （注意初始值的设定与题目要求是数量，需要记录每个和的个数，总个数就是 sum - k 的个数）

      public static int maxLength(int[] arr, int k) {
		if (arr == null || arr.length == 0) {
			return 0;
		}
		HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
		map.put(0, -1); // important
		int len = 0;
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
			if (map.containsKey(sum - k)) {
				len = Math.max(i - map.get(sum - k), len);
			}
			if (!map.containsKey(sum)) {
				map.put(sum, i);
			}
		}
		return len;
	}

例3：

给定一个整数组成的无序数组arr，值可能正、可能负、可能0，给定一个整数值K，找到arr的所有子数组里，哪个子数组的累加和<=K，并且是长度最大的返回其长度

以i开头哪个子数组的累加和最小  minSum[i..j]

以i开头哪个子数组的累加和最小序号  minSumEnd[j]

未排序数组中累加和小于或等于给定值的最长子数组长度

    public static int maxLengthAwesome(int[] arr, int k) {
		if (arr == null || arr.length == 0) {
			return 0;
		}
		int[] minSums = new int[arr.length];
		int[] minSumEnds = new int[arr.length];
		minSums[arr.length - 1] = arr[arr.length - 1];
		minSumEnds[arr.length - 1] = arr.length - 1;
		for (int i = arr.length - 2; i >= 0; i--) {
			if (minSums[i + 1] <= 0) {// 可以只判断小于0，加上等于0可以扩大右边界
				minSums[i] = arr[i] + minSums[i + 1];
				minSumEnds[i] = minSumEnds[i + 1];
			} else {
				minSums[i] = arr[i];
				minSumEnds[i] = i;
			}
		}
		
		int end = 0; // end 往下就会超
		int sum = 0;
		int res = 0;
		// i是窗口的最左的位置，end扩出来的最右有效块儿的最后一个位置的，再下一个位置
		// end也是下一块儿的开始位置
		// 窗口：[i~end)
		for (int i = 0; i < arr.length; i++) {
			// while循环结束之后：
			// 1) 如果以i开头的情况下，累加和<=k的最长子数组是arr[i..end-1]，看看这个子数组长度能不能更新res；
			// 2) 如果以i开头的情况下，累加和<=k的最长子数组比arr[i..end-1]短，更新还是不更新res都不会影响最终结果；
			while (end < arr.length && sum + minSums[end] <= k) {
				sum += minSums[end];
				end = minSumEnds[end] + 1;
			}
                        // end的位置扩不进来了
			res = Math.max(res, end - i);
			if (end > i) { // 窗口内还有数 [i~end) [4,4)
				sum -= arr[i];
			} else { // 窗口内已经没有数了，说明从i开头的所有子数组累加和都不可能<=k
				end = i + 1;
			}
		}
		return res;
	}

题目一主要技巧：利用单调性优化

题目二主要技巧：利用预处理结构优化

题目三主要技巧：假设答案法+淘汰可能性（很难，以后还会见到）