[Leetcode] 0697.数组的度

697. 数组的度

点击上方标题跳转至leetcode

题目描述

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

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

示例 1：

输入：nums = [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：

输入：nums = [1,2,2,3,1,4,2]
输出：6
解释：
数组的度是 3 ，因为元素 2 重复出现 3 次。
所以 [2,2,3,1,4,2] 是最短子数组，因此返回 6 。

提示：

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

解法

方法一：哈希表

遍历数组，用哈希表记录数组每个元素出现的次数，以及首次、末次出现的位置。然后遍历哈希表，获取元素出现次数最多(可能有多个)且首末位置差最小的数。

记原数组中出现次数最多的数为 x，那么和原数组的度相同的最短连续子数组，必然包含了原数组中的全部 x，且两端恰为 x 第一次出现和最后一次出现的位置。
因为符合条件的 x 可能有多个，即多个不同的数在原数组中出现次数相同。所以为了找到这个子数组，我们需要统计每一个数出现的次数，同时还需要统计每一个数第一次出现和最后一次出现的位置。

在实际代码中，我们使用哈希表实现该功能，每一个数映射到一个长度为 3 的数组，数组中的三个元素分别代表这个数出现的次数、这个数在原数组中第一次出现的位置和这个数在原数组中最后一次出现的位置。当我们记录完所有信息后，我们需要遍历该哈希表，找到元素出现次数最多，且前后位置差最小的数。

时间复杂度 O(n)，空间复杂度 O(n)。其中 n 为数组长度。

Python3

from typing import List

class Solution:
    def findShortestSubArray(self, nums: List[int]) -> int:
        mp = dict()
        
        for i,num in enumerate(nums):
            if num in mp:
                mp[num][0] +=1
                mp[num][2] = i
            else:
                mp[num] = [1,i,i]
        maxNum = minLen = 0
        for count, left, right in mp.values():
            span = right - left + 1
            if maxNum < count:
                maxNum = count
                minLen = span
            elif maxNum == count:
                if minLen > span:
                    minLen = span
        return minLen

nums = [1,2,2,3,1]
fun = Solution()
res = fun.findShortestSubArray(nums)
print(res)

class Solution:
    def findShortestSubArray(self, nums: List[int]) -> int:
        cnt = Counter(nums)
        degree = cnt.most_common()[0][1]
        left, right = {}, {}
        for i, v in enumerate(nums):
            if v not in left:
                left[v] = i
            right[v] = i
        ans = inf
        for v in nums:
            if cnt[v] == degree:
                t = right[v] - left[v] + 1
                if ans > t:
                    ans = t
        return ans

C++

#include<iostream>
#include<vector>
#include<unordered_map>
using namespace std;

class Solution{
public:
    int findShortestSubArray(vector<int>& nums) {
        unordered_map<int, vector<int> >mp;
        int n = nums.size();
        for(int i = 0; i < n; i++){
            if(mp.count(nums[i])){
                mp[nums[i]][0]++;
                mp[nums[i]][2] = i;
            }
            else{
                mp[nums[i]] = {1,i,i};
            }
        }
        int maxNum = 0,minLen = 0;
        for (unordered_map<int, vector<int>>::iterator i= mp.begin(); i!=mp.end();++i) {
            vector<int> vec = i-> second;
        // for (auto& [_, vec] : mp) {
            int span = vec[2] - vec[1] +1;
            if(maxNum < vec[0]){
                maxNum = vec[0];
                minLen = span;
            }
            else if (maxNum == vec[0]){
                if(minLen > span)
                    minLen = span;
            }
        }
        return minLen;
    }
};

int main(){

    vector<int> nums = {1,2,2,3,1};
    int res = Solution().findShortestSubArray(nums);
    cout << "res: " << res << endl;
    return 0;
}
//g++ 697.cpp -std=c++11

class Solution {
public:
    int findShortestSubArray(vector<int>& nums) {
        unordered_map<int, int> cnt;
        unordered_map<int, int> left;
        unordered_map<int, int> right;
        int degree = 0;
        for (int i = 0; i < nums.size(); ++i) {
            int v = nums[i];
            degree = max(degree, ++cnt[v]);
            if (!left.count(v)) {
                left[v] = i;
            }
            right[v] = i;
        }
        int ans = 1e6;
        for (int v : nums) {
            if (cnt[v] == degree) {
                int t = right[v] - left[v] + 1;
                if (ans > t) {
                    ans = t;
                }
            }
        }
        return ans;
    }
};