Degree of an Array LT697

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: [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: [1,2,2,3,1,4,2]
Output: 6

Note:

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

 Idea 1. Scan the array to build the frequency map, store the pair(nums[i], frequency), find out the max frequecy = degree, find out all candidates have the degree, build a second map with position to store the pari(nums[i], {start, end}}, loop the second map to find the max length end - start + 1.

Time complexity: O(N)

Space complexity: O(M) - unieque numbers in the array, could be O(N) if the degree is 1.

class Solution {
    public int findShortestSubArray(int[] nums) {
        Map<Integer, Integer> frequency = new HashMap<>();
        for(int num: nums) {
           frequency.put(num, frequency.getOrDefault(num, 0) + 1);
        }
        
        int degree = 0;
        for(int val: frequency.values()) {
           degree = Math.max(degree, val);
        }
        
        Set<Integer> candidates = new HashSet<>();
        for(int key: frequency.keySet()) {
            if(frequency.get(key) == degree) {
                candidates.add(key);
            }
        }
        
        Map<Integer, List<Integer>> start = new HashMap<>();
        for(int i = 0; i < nums.length; ++i) {
            if(candidates.contains(nums[i])) {
                start.putIfAbsent(nums[i], Arrays.asList(i, i));
                List<Integer> pos = start.get(nums[i]);
                pos.set(1, i);
            }
        }
        
        int result = nums.length;
        for(List<Integer> pos: start.values()) {
            result = Math.min(result, pos.get(1) - pos.get(0) + 1);
        }
        
        return result;
    }
}

Let's start refactoring the code:

1. get the degree while building frequency map, saving the loop

2. save the start position of each number in start map, update the length as loop the array, note: each number could be the candidate, not just the number currently having same degree, as the counter could be increased as the same number occurs later

Time complexity: O(N), 1 scan only

Space complexity: O(M)

class Solution {
    public int findShortestSubArray(int[] nums) {
        int degree = 0;
        int result = nums.length;
        Map<Integer, Integer> frequency = new HashMap<>();
        Map<Integer, Integer> start = new HashMap<>();
        
        for(int i = 0; i < nums.length; ++i) {
           frequency.put(nums[i], frequency.getOrDefault(nums[i], 0) + 1);
           start.putIfAbsent(nums[i], i);
           if(frequency.get(nums[i]) > degree) {
               degree = frequency.get(nums[i]);
               result = i - start.get(nums[i]) + 1;
           }
           else if(frequency.get(nums[i])  == degree) {
                result = Math.min(result, i - start.get(nums[i]) + 1);
            }
        }
        
        return result;
    }
}