其他分享
首页 > 其他分享> > 697. 数组的度

697. 数组的度

作者:互联网

题目描述
思路
优化toc

题目描述

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

来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/degree-of-an-array
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

思路

题目稍微有点绕,多读几遍还是可以理解的
根据题意,度即是元素出现的次数,求的度最大的数,从首次出现到最后一次出现的跨度,直接上代码吧

class Solution {
public:
    int findShortestSubArray(vector<int>& nums) {
        int iMaxDegree = 1;
        int iNumsSize = static_cast<int>(nums.size());
        std::unordered_map<int, int> unorderMapValueDegree;
        std::unordered_map<int, int> unorderMapValueLeft;
        std::unordered_map<int, int> unorderMapValueRight;
        std::unordered_map<int, int>::iterator itFind;
        for(int i = 0; i < iNumsSize; i++){
            int elem = nums[i];
            itFind = unorderMapValueDegree.find(elem);
            if(unorderMapValueDegree.end() == itFind){  //首次遇到,记录度与、元素最开始出现位置
                unorderMapValueDegree.insert(std::make_pair(elem, 1));
                unorderMapValueLeft.insert(std::make_pair(elem, i));
                unorderMapValueRight.insert(std::make_pair(elem, i));
            }else{  //已经出现过的元素,记录出现的位置,循环结束后,只记录了最后出现的位置
                itFind->second++;
                unorderMapValueRight[elem] = i;   
                iMaxDegree = max(iMaxDegree, itFind->second);     //记录下最大的度
            }
        }

        int iMinLen = iNumsSize;
        for(const auto& elem : unorderMapValueDegree){
            if(elem.second != iMaxDegree){
                continue;
            }
            iMinLen = min(unorderMapValueRight[elem.first] - unorderMapValueLeft[elem.first] + 1, iMinLen);
        }    
        return iMinLen;
    }
};

优化

上面的代码是利用map本身的key-value间的映射,将map换为数组,利用数组下标与值的对应关系,以空间换取时间的方式来提高性能

const int VALUECOUNT = 50000;
class Solution {
public:
    int findShortestSubArray(vector<int>& nums) {
        int iMaxDegree = 1, iValue = 0;
        int iNumsSize = static_cast<int>(nums.size());
        //nums元素做下标,数组元素存储元素对应度、首次出现位置、最后一次出现位置
        int iArrayDegree[VALUECOUNT] = {0}, iArrayLeftIndex[VALUECOUNT], iArrayRightIndex[VALUECOUNT];
        for(auto& elem : iArrayLeftIndex){
            elem = -1;
        }
        for(int i = 0; i < iNumsSize; i++){
            iValue = nums[i];
            iArrayDegree[iValue]++;
            if(-1 == iArrayLeftIndex[iValue]){
                iArrayLeftIndex[iValue] = i;
            }
            iArrayRightIndex[iValue] = i;   
            iMaxDegree = max(iMaxDegree, iArrayDegree[iValue]);
        }

        int iMinLen = iNumsSize;
        for(int i = 0; i < iNumsSize; i++){
            iValue = nums[i];
            if(iMaxDegree != iArrayDegree[iValue]){
                continue;
            }
            iMinLen = min(iMinLen, iArrayRightIndex[iValue] - iArrayLeftIndex[iValue] + 1);
        }
        return iMinLen;
    }
};


vector相比数组更安全、更灵活,我首次优化的时候选了vector,结果搞了个负优化。于是换成数组,并且在栈上创建,换完之后过然速度飞升。



来自为知笔记(Wiz)

标签:697,nums,int,elem,iValue,数组,iMaxDegree
来源: https://www.cnblogs.com/Keeping-Fit/p/14762914.html