LeetCode-697. Degree of an Array [C++][Java]

LeetCode-697. Degree of an Arrayhttps://leetcode.com/problems/degree-of-an-array/

Given a non-empty array of non-negative integers nums, the degree of this array is defined as the maximum frequency of any one of its elements.

Your task is to find the smallest possible length of a (contiguous) subarray of nums, that has the same degree as nums.

Example 1:

Input: nums = [1,2,2,3,1]
Output: 2
Explanation: 
The input array has a degree of 2 because both elements 1 and 2 appear twice.
Of the subarrays that have the same degree:
[1, 2, 2, 3, 1], [1, 2, 2, 3], [2, 2, 3, 1], [1, 2, 2], [2, 2, 3], [2, 2]
The shortest length is 2. So return 2.

Example 2:

Input: nums = [1,2,2,3,1,4,2]
Output: 6
Explanation: 
The degree is 3 because the element 2 is repeated 3 times.
So [2,2,3,1,4,2] is the shortest subarray, therefore returning 6.

Constraints:

• nums.length will be between 1 and 50,000.
• nums[i] will be an integer between 0 and 49,999.

【C++】

class Solution {
public:
    int findShortestSubArray(vector<int>& nums) {
        unordered_map<int, vector<int>> hash;
        for (int i = 0; i < nums.size(); i++) hash[nums[i]].push_back(i);
        int deg = 0;
        for (auto it : hash) {if (it.second.size() > deg) {deg = it.second.size();}}
        int ans = nums.size();
        for (auto it : hash)  {
            if (it.second.size() == deg) {
                int tmpLen = it.second.back() - it.second[0] + 1;
                if (tmpLen < ans) {ans = tmpLen;}
            }
        }
        return ans;
    }
};

【Java】

class Solution {
    public int findShortestSubArray(int[] nums) {
        Map<Integer, List<Integer>> hash = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            hash.putIfAbsent(nums[i], new ArrayList<>());
            hash.get(nums[i]).add(i);
        }
        int deg = 0;
        for (Map.Entry<Integer, List<Integer>> it : hash.entrySet()) {
            int vs = it.getValue().size();
            if (vs > deg) {deg = vs;}
        }
        int ans = nums.length;
        for (Map.Entry<Integer, List<Integer>> it : hash.entrySet())  {
            int vs = it.getValue().size();
            if (vs == deg) {
                List<Integer> tmp = it.getValue();
                int tmpLen = tmp.get(vs-1) - tmp.get(0) + 1;
                if (tmpLen < ans) {ans = tmpLen;}
            }
        }
        return ans;
    }
}