697. 数组的度

Posted 2020-12-20 sheltonz

一、题目

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

二、题解

• 找频数最大值就是找重复次数最多的数，这个重复数中相距最远的两个构成的长度为度，找这个长度最小值
• 因此重复最多数下标最大值-最小值就是子数组的长度最小值
• 因此用三个统计数组去统计nums数组
  • 统计nums数组中每个数重复的次数——cnt[]
    • cnt数组是以nums数组中每个元素的值作为下标索引，cnt数组初始值为0，即所有数都出现了0次
    • 如nums[0] = 5，则cnt[5] ++ ，cnt[5] = 1;
    • 因此再遇到nums[2] = 5 ， cnt[5] = 2，每遇见一次重复值就+1，以此找到重复次数最多的数
  • 统计重复数的最左下标——l[]
    • l数组以nums数组中的每个元素的值作为下标索引，存的是这个索引在nums数组中的下标。
    • 如nums[0] = 5，则l[5] = 0，由于要的是重复数的最左下标，即重复最多数的下标最小值
    • 因此如果再遇到nums[2] = 5，则不更新i[5]的值
    • 由于nums数组下标可以为0，l数组初始值也为0，所以在统计前需要将l数组的值初始化到小于0的值
  • 统计重复数的最右下标——r[]
    • r数组和l数组一样，存的是索引在nums数组中的下标
    • 如nums[0] = 5，则r[5] = 0，由于要的是重复数的最右下标，即重复最多数的下标最大值
    • 因此再遇到nums[2] = 5，则r[5] = 2。
    • 由于存的是下标最大值，重复数最少有2个，因此下标最大值最小为1，不用考虑初始化r数组的值。
  • 由于nums的值为0~49999，所以定义三个数组的长度应为最大值+1
    • 因为是以给定数组的元素作为统计数组的下标，所以是0~49999，长度为50000
  • 一种特殊情况，重复最多数有多个，如[1,1,1,2,2,2,1]，这时比较其长度，留下长度较小的

class Solution {
    public int findShortestSubArray(int[] nums) {
            int n = nums.length;
            int[] cnt = new int[50000];
            int[] l = new int[50000];
            int[] r = new int[50000];

            int freNum = 0;
            int length = 0;

            Arrays.fill(l, -1);

            for (int i = 0; i < n; i++) {

                cnt[nums[i]]++;
                if (l[nums[i]] < 0) {
                    l[nums[i]] = i;
                }
                r[nums[i]] = i;
            }

            for (int i = 0; i < n; i++) {
                if (cnt[nums[i]] > freNum) {
                    freNum = cnt[nums[i]];
                    length = r[nums[i]] - l[nums[i]] + 1;
                } else if (cnt[nums[i]] == freNum && (r[nums[i]] - l[nums[i]] + 1) < length) {
                    length = r[nums[i]] - l[nums[i]] + 1;
                }
            }

            return length;
    }
}

• 时间复杂度O(n)=n
• 空间复杂度O(n) =n
• 执行用时：9 ms, 在所有 Java 提交中击败了95.24%的用户
• 内存消耗：43 MB, 在所有 Java 提交中击败了38.94%的用户