LeetCode 697. 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: [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.

 

first:

class Solution {
    public int findShortestSubArray(int[] nums) {
        int[] counts = findCounts(nums);
        
        int degree = 0;
        for(int i=0; i<counts.length; i++) {
            degree = Math.max(degree, counts[i]);    
        }//find degree
        
        ArrayList<Integer> degreeNums = new ArrayList<Integer>();
        for(int i=0; i<counts.length; i++) {
            if(counts[i] == degree) {
                degreeNums.add(i);
            }
        }//find all degreeNums
        
        int minSubLength = 0;
        for(Integer degreeNum : degreeNums) {
            int count = 0, start = 0, end = 0;
            for(int i=0; i<nums.length; i++) {
                if(nums[i] == degreeNum) {
                    //start = i;
                    count++;
                }
                
                if(nums[i] == degreeNum && count == 0) {
                    start = i;
                    //count++;
                }
                if(nums[i] == degreeNum && count == counts[i] - 1) {
                    end = i;
                }
            } 
            
            minSubLength = Math.min(minSubLength, end - start + 1);
        }//find subLength
        
        
        return minSubLength;
    }
    
    
    public int[] findCounts(int[] nums) {
        int[] counts = new int[50000];
        
        for(int i=0; i<nums.length; i++) {
            counts[nums[i]]++;
        }
        
        return counts;
    }
}

分析：

java.lang.Math与java.math包不同。

 

result:

Submission Result: Wrong Answer 
Input: [1,2,2,3,1]
Output: 0
Expected: 2

 

分析：

second：

class Solution {
    public int findShortestSubArray(int[] nums) {
        int[] counts = findCounts(nums);
        
        int degree = 0;
        for(int i=0; i<counts.length; i++) {
            degree = Math.max(degree, counts[i]);    
        }//find degree
        
        ArrayList<Integer> degreeNums = new ArrayList<Integer>();
        for(int i=0; i<counts.length; i++) {
            if(counts[i] == degree) {
                degreeNums.add(i);
            }
        }//find all degreeNums
        
        int minSubLength = 0;
        for(Integer degreeNum : degreeNums) {
            int count = 0, start = 0, end = 0;
            for(int i=0; i<nums.length; i++) {
                if(nums[i] == degreeNum) {
                    //start = i;
                    count++;
                }
                
                if(nums[i] == degreeNum && count == 0) {
                    start = i;
                    //count++;
                }
                if(nums[i] == degreeNum && count == counts[i] - 1) {
                    end = i;
                }
            } 
            
            if(minSubLength == 0) {
                minSubLength = Math.max(minSubLength, end - start + 1);
            } else {
                minSubLength = Math.min(minSubLength, end - start + 1);
            }
            
        }//find subLength
        
        
        return minSubLength;
    }
    
    
    public int[] findCounts(int[] nums) {
        int[] counts = new int[50000];
        
        for(int i=0; i<nums.length; i++) {
            counts[nums[i]]++;
        }
        
        return counts;
    }
}

 

结果：

Submission Result: Wrong Answer 
Input: [1,2,2,3,1]
Output: 1
Expected: 2

 

 

third：

class Solution {
    public int findShortestSubArray(int[] nums) {
        int[] counts = findCounts(nums);
        
        int degree = 0;
        for(int i=0; i<counts.length; i++) {
            degree = Math.max(degree, counts[i]);    
        }//find degree
        
        ArrayList<Integer> degreeNums = new ArrayList<Integer>();
        for(int i=0; i<counts.length; i++) {
            if(counts[i] == degree) {
                degreeNums.add(i);
            }
        }//find all degreeNums
        
        int minSubLength = 0;
        for(Integer degreeNum : degreeNums) {
            int count = 0, start = 0, end = 0;
            
            for(int i=0; i<nums.length; i++) {
               
                /*if(nums[i] == degreeNum && count == 0) {
                    start = i;
                    //count++;
                }
                
                if(nums[i] == degreeNum) {
                    //start = i;
                    count++;
                }
                
             
                if(nums[i] == degreeNum && count == counts[i] - 1) {
                    end = i;
                }*/
                
                
                
                if(nums[i] == degreeNum) {
                    if(count == 0) {
                        start = i;
                    }
                    count++;
                    
                    if(count == counts[i]) {
                        end = i;
                    }
                }
                
             
                
                
            } 
            
            if(minSubLength == 0) {
                minSubLength = Math.max(minSubLength, end - start + 1);
            } else {
                minSubLength = Math.min(minSubLength, end - start + 1);
            }
            
        }//find subLength
        
        
        return minSubLength;
    }
    
    
    public int[] findCounts(int[] nums) {
        int[] counts = new int[50000];
        
        
        
        for(int i=0; i<nums.length; i++) {
            counts[nums[i]]++;
        }
        
        return counts;
    }
}

 

分析：

 这一步花了好长时间。 代码一多就容易出错，而且难定位。最后发现是 if(count == counts[i]) {中的数组下标出了问题。

 

fourth:

class Solution {
    public int findShortestSubArray(int[] nums) {
        int[] counts = findCounts(nums);
        
        int degree = 0;
        for(int i=0; i<counts.length; i++) {
            degree = Math.max(degree, counts[i]);    
        }//find degree
        
        
        System.out.println(degree);
        
        ArrayList<Integer> degreeNums = new ArrayList<Integer>();
        for(int i=0; i<counts.length; i++) {
            if(counts[i] == degree) {
                degreeNums.add(i);
            }
        }//find all degreeNums
        System.out.println(degreeNums);
        
        int minSubLength = 0;
        for(Integer degreeNum : degreeNums) {
            int count = 0, start = 0, end = 0;
            
            for(int i=0; i<nums.length; i++) {
         

                if(nums[i] == degreeNum) {
                    if(count == 0) {
                        start = i;
                    }
                    count++;
                    
                    if(count == counts[degreeNum]) {
                        end = i;
                    }
                }

            } 
            
            if(minSubLength == 0) {
                minSubLength = Math.max(minSubLength, end - start + 1);
            } else {
                minSubLength = Math.min(minSubLength, end - start + 1);
            }
            
        }//find subLength
        
        
        return minSubLength;
    }
    
    
    public int[] findCounts(int[] nums) {
        int[] counts = new int[50000];
        
        
        
        for(int i=0; i<nums.length; i++) {
            counts[nums[i]]++;
        }
        
        return counts;
    }
}

 

 

结果：

分析：

时间效率不是很好，但懒得再优化了。

 

总结：