697.数组的度

697.数组的度

给定一个非空且只包含非负数的整数数组 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 范围内的整数。
解题思路
找频率最大的数并且其的子数组长度最短，本题坑点是会存在多组数据，并且出现频率最大且相同，这就要求还需要统计起始位置和终止位置来计算最短子数组。如果不考虑最短子数组，如代码一；考虑的话就必须用带有映射关系的hash表来进行存储和遍历。
代码一
这个没考虑最短子数组

class Solution {
public:
    int findShortestSubArray(vector<int>& nums) {
        const int N = 5e4+10;
        int a[N];
        memset(a,0,sizeof a);
        int m=-1;
        int number=-1;
        for(int i=0;i<nums.size();i++){
            a[nums[i]]++;
            if(m<a[nums[i]]){
                m=a[nums[i]];
                number=nums[i];
            }
        }
        //cout<<m<<" "<<number<<endl;
        int les=0;
        bool flag=false;//标记是否遇到最大频率的数
        for(int i=0;i<nums.size();i++){
            if(number==nums[i]) flag = true;
            if(flag){
                if(m!=0){
                    if(number!=nums[i])
                    {
                        les++;
                    }
                    else{
                        m--;
                        les++;
                    }
                }
            }
        }
        return les;
    }
};

代码二

class Solution {
public:
    int findShortestSubArray(vector<int>& nums) {
        unordered_map<int,vector<int>> mp;
        int l=nums.size();
        for(int i=0;i<l;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;//maxNum表示出现频率，minlen表示最短子串
        for(auto& [_,v]:mp){//用_表示占位不会用到这个key，用v表示映射后的三维关系
            if(maxNum<v[0]){
                maxNum = v[0];
                minlen = v[2]-v[1]+1;
            }else if (maxNum==v[0]){    
                if(minlen>v[2]-v[1]+1){    
                    minlen = v[2] - v[1] + 1;    
                }
            }
        }
        return minlen;    
    }
};

auto& [_, vec] : mp 这段代码使用了C++17的结构化绑定（Structured Bindings）特性，用于遍历一个关联容器（如std::map或std::unordered_map）。具体来说，这段代码的作用是遍历mp这个容器，并将每个元素的键绑定到_，将每个元素的值绑定到vec。

auto&：表示引用类型，确保在遍历过程中不会创建临时对象，从而提高效率。
[_, vec]：结构化绑定，将当前遍历到的元素的键和值分别绑定到_和vec。
mp：被遍历的容器，通常是一个std::map或std::unordered_map。
在这段代码中，_通常是一个占位符，表示我们不关心键的值，而vec则是我们关心的值部分。这种写法在只需要访问容器中的值而不需要键时非常有用。

例如，假设mp是一个std::map<int, std::vector<int>>类型的容器，那么这段代码的作用就是遍历mp中的每一个元素，并将每个元素的值（即std::vector）绑定到vec，而忽略键。