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

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

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>

<pre>
<strong>Input:</strong> nums = [1,2,2,3,1]
<strong>Output:</strong> 2
<strong>Explanation:</strong> 
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.
</pre>

<p><strong class="example">Example 2:</strong></p>

<pre>
<strong>Input:</strong> nums = [1,2,2,3,1,4,2]
<strong>Output:</strong> 6
<strong>Explanation:</strong> 
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.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>nums.length</code> will be between 1 and 50,000.</li>
	<li><code>nums[i]</code> will be an integer between 0 and 49,999.</li>
</ul>

class Solution {
public:
    int findShortestSubArray(vector<int>& nums) {
        

        // unordered_map<int,int> mp;
        // int freq=0;
        // int num=0;
        // int index=-1;
        // for(int i=0;i<nums.size();i++){
        //         mp[nums[i]]+=1;
        //         if(freq<mp[nums[i]]){
        //         freq=max(mp[nums[i]],freq);
        //         num=nums[i];
        //         index=i;
        //         }
        // }

        // int start=-1;
        // for(int i=0;i<nums.size();i++){
        //         if(nums[i]==num){
        //             start=i;
        //             break;
        //         }
        // }

        // return index-start+1;
       int n=nums.size();
        unordered_map<int,int> freq;   
        unordered_map<int,int> firstIndex;   
        unordered_map<int,int> lastIndex;   
        int m=0;
        for(int i=0;i<nums.size();i++){
                freq[nums[i]]+=1;
                int num=nums[i];
                m=max(freq[nums[i]],m);
                if(firstIndex.find(num)==firstIndex.end()){
                    firstIndex[num]=i;
                }
                
                lastIndex[num]=i;
        }

        int mini=n;
        for(int i=0;i<n;i++){
            if(m==freq[nums[i]]){
                int n1=firstIndex[nums[i]];
                int n2=lastIndex[nums[i]];
                mini=min(mini,n2-n1+1);
            }
            freq.erase(nums[i]);
        }

        return mini;
        

        
    }
};
36262