leetcode刷题打卡 ---- 697数组的度

题目描述：

给定一个非空且只包含非负数的整数数组 nums，数组的度的定义是指数组里任一元素出现频数的最大值。

你的任务是在 nums 中找到与 nums 拥有相同大小的度的最短连续子数组，返回其长度。

示例 1：
输入：[1, 2, 2, 3, 1]
输出：2
解释：
输入数组的度是2，因为元素1和2的出现频数最大，均为2.
连续子数组里面拥有相同度的有如下所示:
[1, 2, 2, 3, 1], [1, 2, 2, 3], [2, 2, 3, 1], [1, 2, 2], [2, 2, 3], [2, 2]
最短连续子数组[2, 2]的长度为2，所以返回2.

示例 2：
输入：[1,2,2,3,1,4,2]
输出：6

提示：

• nums.length 在1到 50,000 区间范围内。
• nums[i] 是一个在 0 到 49,999 范围内的整数。

---

解题思路：

• 题意：

  • 数组的度：数组中各元素出现次数的最大值。对于示例二 [1,2,2,3,1,4,2] ：数组中各元素出现的次数为： 1 出现 2 次， 2 出现 3 次， 3 出现 1 次， 4 出现 1 次，所以数组的度为 3（就是元素 2 出现的次数）。
  • 题目要求的是与 nums 拥有相同大小的度的最短连续子数组的长度。比如对于示例二 [1,2,2,3,1,4,2]，数组的度为 3，它的度为 3 的最短连续子数组是 [2,2,3,1,4,2] ，返回该子数组长度 6。

• 方法1：哈希表 + 数组一次遍历
  使用哈希表记录每一个数字出现的次数、最左边的位置、最右边的位置，计算数组的度；对满足要求的数字计算其长度，取最小值。

  求数组的度：本质还是求各个元素的出现次数，我们可以用 字典（哈希表）计数，字典的 key 是元素，value 是该元素出现的次数。因此，字典中所有 value 的最大值就是数组的度 degree。

  求与原数组相同度的最短子数组：
  要求的子数组的度与原数组相同度的相同，那么该子数组中也得有 degreedegree 个重复的元素。比如对于示例二[1,2,2,3,1,4,2]，出现次数最多的元素是 2，它的出现次数为 3， 所以数组的度为 3；我们要求的子数组得有 3 个 2 ，所以最短的子数组是 [2,2,3,1,4,2]。注意到了吗？我们要求的最短子数组的起始和终止位置，由出现次数最多的元素 第一次和最后一次出现的位置 确定。

  另外，需要注意的是出现次数最多的元素可能不止一个，比如示例一[1, 2, 2, 3, 1]，数字 1 和数字 2 都出现了 2 次。此时，我们必须分别对每个出现次数为 2 的元素（即数字 1 和数字 2 ）都求一次包含2个它的最短子数组的长度（分别为5和2），最终对所有最短子数组长度取 min，得到结果为 2。

  class Solution {
  	public int findShortestSubArray(int[] nums) {
      	Map<Integer, int[]> map = new HashMap<Integer, int[]>();
      	int n = nums.length;
      	for (int i = 0; i < n; i++) {
              if (map.containsKey(nums[i])) {
              	map.get(nums[i])[0]++;
              	map.get(nums[i])[2] = i;
          	} else {
              	map.put(nums[i], new int[]{1, i, i});
          	}
      	}
      	int maxNum = 0, minLen = 0;
      	for (Map.Entry<Integer, int[]> entry : map.entrySet()) {
          	int[] arr = entry.getValue();
          	if (maxNum < arr[0]) {
              	maxNum = arr[0];
              	minLen = arr[2] - arr[1] + 1;
          	} else if (maxNum == arr[0]) {
              	if (minLen > arr[2] - arr[1] + 1) {
                  	minLen = arr[2] - arr[1] + 1;
              	}
          	}
      	}
      	return minLen;
  	}
  }
  

• 方法2：滑动窗口
  仍然先计算数组的度，然后以每一个位置作为左边界，尝试移动右端点，当满足时再移动左端点直到不满足，这时可以得到以当前左端点左边所有位置作为左边界的子数组的最小长度；按照这个思路继续进行右、左端点的移动。

  计算数组的度：遍历一遍数组，使用一个Map保存数组中每个数字出现的次数，再用一个整数更新最大的度

  计算最小连续子数组长度：

  • 这里使用滑动窗口的方法计算最小连续子数组长度。
  • 需要再对数组进行一次滑动窗口的遍历。
  • 使用一个map保存当前滑动窗口中每个数字出现的情况。
  • 每次将窗口右边界向右移动1，这样会有一个新的数字进入窗口。
    检查新的数字当前出现次数是否等于maxDegree
    如果等于，说明这个新的数字可以构成最大的度，尝试将滑动窗口左边界右移，寻找最小的满足条件的数组长度。

  public class Solution {
  	public int findShortestSubArray(int[] nums) {
      	HashMap<Integer, Integer> degreeMap = new HashMap<>();
      	// 计算度
      	int maxDegree = 0;
      	for (int num : nums) {
          	degreeMap.put(num, degreeMap.getOrDefault(num, 0) + 1);
          	maxDegree = Math.max(maxDegree, degreeMap.get(num));
      	}
  
      	// 滑动窗口 计算最小连续子数组长度
      	int ans = Integer.MAX_VALUE;
      	int l = 0, r = 0;
      	HashMap<Integer, Integer> map = new HashMap<>();
      	while (r < nums.length) {
          	map.put(nums[r], map.getOrDefault(nums[r], 0) + 1);
          	while (map.get(nums[r]) == maxDegree) {
              	map.put(nums[l], map.get(nums[l]) - 1);
              	ans = Math.min(ans, r - l + 1);
              	l++;
          }
          r++;
      }
      return ans;
  	}
  }