697 Degree of an Array

最新推荐文章于 2021-02-20 17:43:31 发布

原创最新推荐文章于 2021-02-20 17:43:31 发布 · 331 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#hashmap #leetcode-java #array

LeetCode 专栏收录该内容

137 篇文章

订阅专栏

本文介绍了一种算法，用于寻找给定数组中具有相同度的最短连续子数组。通过使用两个HashMap来记录元素频率及它们的起始和结束位置，从而实现了高效查找。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

697 Degree of an Array JAVA实现

题目描述：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

题目大意：给定一个非空数组，数组中的“度”表示数组中的元素出现最多次数的一个元素的次数，目的是在nums数组中去寻找小的子数组（必须连续），使子数组的度与原数组相同。
思路：使用hashmap，建立两个hasmap，一个存储各个元素出现的次数，以寻找最大度，另一个存储，数组中每个元素出现的初始位置与结束位置，找到最大的度之后，再次遍历数组

代码

package Array;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Solution {
  public int findShortestSubArray(int[] nums) {
      int degree = 0;
      int minSize = nums.length;
      Map<Integer, Integer> map = new HashMap<>();
      Map<Integer, Integer[]> map2 = new HashMap<>();
      for(int i=0;i<nums.length;i++) {
          map.put(nums[i], map.getOrDefault(nums[i],0) + 1);
          degree = Math.max(degree, map.get(nums[i]));
          if (map2.get(nums[i]) == null) {
              map2.put(nums[i], new Integer[2]);
          }
          Integer[] numsRange = map2.get(nums[i]);
          if(numsRange[0]==null) numsRange[0] = i;
          numsRange[1] = i;
      }
      for (Integer key : map.keySet()) {
          if (map.get(key) != degree) {
              continue;
          }
          Integer[] rang = map2.get(key);
          minSize = Math.min(minSize, rang[1] - rang[0] + 1);
      }

      return minSize;

  }


}