数组与矩阵 - 数组的度

1.题目

LeetCode: 697. 数组的度

【easy】

给定一个非空且只包含非负数的整数数组 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 范围内的整数。

2.解题

方法一：HashMap

将数组中元素对应数量存入哈希表，然后找到最大数量，再次遍历数组，查找最短子数组的长度。

java：

class Solution {
    public int findShortestSubArray(int[] nums) {
        Map<Integer, Integer> map = new HashMap<>();
        
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
        }
        int max = 0;
        for (int k : nums) {
            max = Math.max(max, map.get(k));
        }
        int res = nums.length;
        for (int num : nums) {
            int cnt = map.get(num);
            if (cnt != max) continue;
            res = Math.min(res, get_result(nums, num) + 1);
        }
        return res;
    }

    public int get_result(int[] nums, int key) {
        int s = 0, e = 0;
        for (int i = 0; i < nums.length; i++) {
            if (key == nums[i]) {
                s = i;
                break;
            }
        }
        for (int j = nums.length - 1; j >= 0; j--) {
            if (key == nums[j]) {
                e = j;
                break;
            }
        }
        return e - s;
    }
}

时间复杂度：O(n)

空间复杂度：O(n)

方法二：方法一的优化版

class Solution {
    public int findShortestSubArray(int[] nums) {
        Map<Integer, Integer> map = new HashMap<>();
        Map<Integer, Integer> first_index = new HashMap<>();
        Map<Integer, Integer> last_index = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            map.put(nums[i], map.getOrDefault(nums[i], 0) + 1);
            last_index.put(nums[i], i);
            if(!first_index.containsKey(nums[i])) first_index.put(nums[i], i);
        }
        int max = 0;
        for (int k : nums) {
            max = Math.max(max, map.get(k));
        }
        int res = nums.length;
        for (int num : nums) {
            int cnt = map.get(num);
            if (cnt != max) continue;
            res = Math.min(res, last_index.get(num) - first_index.get(num) + 1);
        }
        return res;
    }
}