697_Degree_of_an_Array

qiyuangong · qiyuangong · commit 1c62aa1346b9 · 2018-11-28T23:19:31.000+08:00
diff --git a/README.md b/README.md
@@ -145,6 +145,7 @@ Remember solutions are only solutions to given problems. If you want full study
 | 581 | [Shortest Unsorted Continuous Subarray](https://leetcode.com/problems/subtree-of-another-tree/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/581_Shortest_Unsorted_Continuous_Subarray.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/581_Shortest_Unsorted_Continuous_Subarray.java) | 1. Sort and find the difference (min and max), O(nlgn)<br>2. Using stack to find boundaries (push when correct order, pop when not correct), O(n) and O(n)<br>3. Find min and max of unordered array, O(n) and O(1)|
 | 617 | [Merge Two Binary Trees](https://leetcode.com/problems/merge-two-binary-trees/description/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/617_Merge_Two_Binary_Trees.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/617_Merge_Two_Binary_Trees.java) | Traverse both trees Recursion & Iterative (stack) |
 | 654 | [Maximum Binary Tree](https://leetcode.com/problems/maximum-binary-tree/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/654_Maximum_Binary_Tree.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/654_Maximum_Binary_Tree.java) | 1. Divide and conquer, recursive, O(n^2)<br>2. Monotonic stack, O(n) |
+| 697 | [Degree of an Array](https://leetcode.com/problems/degree-of-an-array/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/697_Degree_of_an_Array.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/697_Degree_of_an_Array.java) | 1. Find degree and value, then find smallest subarray (start and end with this value), O(n) and O(n)<br>2. Go through nums, remember left most pos and right most for each value, O(n) and O(n) |
 | 709 | [To Lower Case](https://leetcode.com/problems/to-lower-case/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/709_To_Lower_Case.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/709_To_Lower_Case.java) | String processing:<br>1. str.lower() or str.toLowerCase()<br>2. ASCII processing. O(n) and O(1) |
 | 716 | [Max Stack](https://leetcode.com/problems/max-stack/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/716_Max_Stack.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/716_Max_Stack.java) | 1. Two stacks<br> 2. Double linked list and Hash |
 | 743 | [Network Delay Time](https://leetcode.com/problems/network-delay-time/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/743_Network_Delay_Time.py) [Java](https://github.com/qiyuangong/leetcode/blob/master/java/743_Network_Delay_Time.java) | Let V == N, then: 1. DFS, O(V^V+ElgE), O(V+E)<br>2. Dijkstra, O(V^2+E), O(V+E)|
diff --git a/java/697_Degree_of_an_Array.java b/java/697_Degree_of_an_Array.java
@@ -0,0 +1,24 @@
+class Solution {
+    public int findShortestSubArray(int[] nums) {
+        Map<Integer, Integer> left = new HashMap(),
+            right = new HashMap(), count = new HashMap();
+
+        for (int i = 0; i < nums.length; i++) {
+            int x = nums[i];
+            // left most position
+            if (left.get(x) == null) left.put(x, i);
+            // right most position
+            right.put(x, i);
+            count.put(x, count.getOrDefault(x, 0) + 1);
+        }
+
+        int ans = nums.length;
+        int degree = Collections.max(count.values());
+        for (int x: count.keySet()) {
+            if (count.get(x) == degree) {
+                ans = Math.min(ans, right.get(x) - left.get(x) + 1);
+            }
+        }
+        return ans;
+    }
+}
diff --git a/python/697_Degree_of_an_Array.py b/python/697_Degree_of_an_Array.py
@@ -0,0 +1,41 @@
+class Solution(object):
+    # def findShortestSubArray(self, nums):
+    #     """
+    #     :type nums: List[int]
+    #     :rtype: int
+    #     """
+    #     res = len(nums)
+    #     counter = collections.Counter()
+    #     for num in nums:
+    #         counter[num] += 1
+    #     degree = max(counter.values())
+    #     for key, kdegree in counter.most_common():
+    #         if degree != kdegree:
+    #             break
+    #         res = min(res, self.smallestSubArray(nums, key, degree))
+    #     return res
+
+    # def smallestSubArray(self, nums, key, degree):
+    #     start = nums.index(key)
+    #     pos = start + 1
+    #     degree -= 1
+    #     while pos < len(nums) and degree != 0:
+    #         if nums[pos] == key:
+    #             degree -= 1
+    #         pos += 1
+    #     return pos - start
+
+    def findShortestSubArray(self, nums):
+        left, right, count = {}, {}, {}
+        for i, x in enumerate(nums):
+            if x not in left: left[x] = i
+            right[x] = i
+            count[x] = count.get(x, 0) + 1
+
+        ans = len(nums)
+        degree = max(count.values())
+        for x in count:
+            if count[x] == degree:
+                ans = min(ans, right[x] - left[x] + 1)
+
+        return ans
