feat: add the solution of Degree of an Array(697) with Java.

Author: Mukyu

README.md

@@ -78,7 +78,7 @@
 | [693][693-question] | [Binary Number with Alternating Bits][693-tips]              | [✅][693-java] | [✅][693-js] |                  |
 | [695][695-question] | [Max Area of Island][695-tips]                               | [✅][695-java] | [✅][695-js] |                  |
 | [696][696-question] | [Count Binary Substrings][696-tips]                          | [✅][696-java] | [✅][696-js] |                  |
-| [697][697-question] | [Degree of an Array][697-tips]                               |                | [✅][697-js] |                  |
+| [697][697-question] | [Degree of an Array][697-tips]                               | [✅][697-java] | [✅][697-js] |                  |
 | [717][717-question] | [1-bit and 2-bit Characters][717-tips]                       |                | [✅][717-js] |                  |
 | [720][720-question] | [Longest Word in Dictionary][720-tips]                       |                | [✅][720-js] |                  |
 | [724][724-question] | [Find Pivot Index][724-tips]                                 |                | [✅][724-js] |                  |
@@ -476,6 +476,7 @@
 [693-java]: ./src/_693/Solution.java
 [695-java]: ./src/_695/Solution.java
 [696-java]: ./src/_696/Solution.java
+[697-java]: ./src/_697/Solution.java
 [728-java]: ./src/_728/Solution.java
 [771-java]: ./src/_771/Solution.java
 [804-java]: ./src/_804/Solution.java

src/_697/Solution.java

@@ -0,0 +1,43 @@
+package _697;
+
+import java.util.HashMap;
+
+class Solution {
+    public int findShortestSubArray(int[] nums) {
+        int max = 0;
+        for (int num : nums) {
+            max = Math.max(num, max);
+        }
+
+        HashMap<Integer, Integer> firstPositions = new HashMap<>(max);
+        HashMap<Integer, Integer> degrees = new HashMap<>(max);
+        int maxDegree = 1;
+        int minLen = 1;
+
+        int degree;
+        int len;
+        for (int i = 0; i < nums.length; i++) {
+            firstPositions.putIfAbsent(nums[i], i);
+            degree = degrees.getOrDefault(nums[i], 0);
+            degrees.put(nums[i], ++degree);
+            if (degree < maxDegree) {
+                continue;
+            }
+
+            len = i - firstPositions.get(nums[i]) + 1;
+            if (degree > maxDegree) {
+                maxDegree = degree;
+                minLen = len;
+            } else if (degree == maxDegree && minLen > len) {
+                minLen = len;
+            }
+        }
+
+        return minLen;
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        System.out.println(solution.findShortestSubArray(new int[] {1, 2, 2, 3, 1, 4, 2}));
+    }
+}

tips/697/README.md

@@ -1,46 +1,81 @@
-[xxxx][title]
+[Degree of an Array][title]
 
 ## Description
-// 抄题目
+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:**
+**Example 1:**
 
 ```
-// 抄Example
+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.
 ```
 
-**Note:**
-// Note
+**Example 2:**
 
-**Tags:** // tags
+```
+Input: [1,2,2,3,1,4,2]
+Output: 6
+```
 
+**Note:**
 
-## 思路 1
-// 贴一些关键代码,说一些解题思路
-// (同一种语言可以写多种思路，与某种语言思路相同的另一种语言的思路无须赘述，但可以把代码贴在后面) 
-```java
+`nums.length` will be between 1 and 50,000.
 
-```
-```javascript
+`nums[i]` will be an integer between 0 and 49,999.
 
-```
+**Tags:** [Array](https://leetcode.com/tag/array/)
 
-## 思路 2
-// 贴一些关键代码,说一些解题思路
-```java
+## 思路
 
-```
+题目给出一个非负的整型数组，设定数组中最多的重复数字的个数为degree，要求找出最短的与原字符串有相同的degree的子字符串。遍历数组，将每个数字出现的个数、长度进行记录即可。
 
-## 思路 3
-// 贴一些关键代码,说一些解题思路
-```kotlin
+**Java:**
 
+```java
+public int findShortestSubArray(int[] nums) {
+    int max = 0;
+    for (int num : nums) {
+        max = Math.max(num, max);
+    }
+
+    HashMap<Integer, Integer> firstPositions = new HashMap<>(max);
+    HashMap<Integer, Integer> degrees = new HashMap<>(max);
+    int maxDegree = 1;
+    int minLen = 1;
+
+    int degree;
+    int len;
+    for (int i = 0; i < nums.length; i++) {
+        firstPositions.putIfAbsent(nums[i], i);
+        degree = degrees.getOrDefault(nums[i], 0);
+        degrees.put(nums[i], ++degree);
+        if (degree < maxDegree) {
+            continue;
+        }
+
+        len = i - firstPositions.get(nums[i]) + 1;
+        if (degree > maxDegree) {
+            maxDegree = degree;
+            minLen = len;
+        } else if (degree == maxDegree && minLen > len) {
+            minLen = len;
+        }
+    }
+
+    return minLen;
+}
 ```
 
 ## 结语
-   
+
 如果你同我们一样热爱数据结构、算法、LeetCode，可以关注我们 GitHub 上的 LeetCode 题解：[LeetCode-Solution][ls]
 
-[title]: https://leetcode.com/problems/xxxx
+[title]: https://leetcode.com/problems/degree-of-an-array/description/
 [ls]: https://github.com/RichCodersAndMe/LeetCode-Solution