2020/07/13

rchen102 · rchen102 · commit 78deb2180916 · 2020-07-13T11:32:00.000-04:00
diff --git a/Java/leetcode 219.java b/Java/leetcode 219.java
@@ -1,22 +1,30 @@
-// Solution1: HashMap 
-// T: O(n) S: O(n)(worst)
+// Solution1: HashSet + Sliding Window 
+// T: O(n) S: O(k)
 class Solution {
     public boolean containsNearbyDuplicate(int[] nums, int k) {
-        if (nums == null || nums.length == 0 || k <= 0) return false;
-        HashMap<Integer, Integer> map = new HashMap<>();
+        if (nums == null || nums.length == 0) return false;
+        // helper variables
+        Set<Integer> set = new HashSet<>();
+        
+        // sliding window
+        int windowLen = k + 1;
         for (int i = 0; i < nums.length; i++) {
-            if (!map.containsKey(nums[i])) map.put(nums[i], i);
-            else {
-                int prevIdx = map.get(nums[i]);
-                if (Math.abs(prevIdx - i) <= k) return true;
-                map.put(nums[i], i);
+            // remove element
+            if (i >= windowLen) {
+                int leave = nums[i-windowLen];
+                set.remove(new Integer(leave));
             }
+            
+            // insert element
+            int n = nums[i];
+            if (!set.add(n)) return true;
         }
         return false;
     }
 }
 
 // Solution2: HashSet + Sliding Window 
+// 没用使用模板
 // T: O(n) S: O(k)
 class Solution {
     public boolean containsNearbyDuplicate(int[] nums, int k) {
@@ -28,4 +36,22 @@ public boolean containsNearbyDuplicate(int[] nums, int k) {
         }
         return false;
     }
+}
+
+// Solution3: HashMap 
+// T: O(n) S: O(n)(worst)
+class Solution {
+    public boolean containsNearbyDuplicate(int[] nums, int k) {
+        if (nums == null || nums.length == 0 || k <= 0) return false;
+        HashMap<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < nums.length; i++) {
+            if (!map.containsKey(nums[i])) map.put(nums[i], i);
+            else {
+                int prevIdx = map.get(nums[i]);
+                if (Math.abs(prevIdx - i) <= k) return true;
+                map.put(nums[i], i);
+            }
+        }
+        return false;
+    }
 }
diff --git a/Java/leetcode 239.java b/Java/leetcode 239.java
@@ -1,74 +1,60 @@
-//Own solution1: T: O(n*k) S: O(n)
+// Solution1: sliding window + Deque
+// T: O(n) S: O(k)
 class Solution {
     public int[] maxSlidingWindow(int[] nums, int k) {
-        if(nums == null) return null;
-        int len = nums.length;
-        if(len < 1) return new int[0];
-        
+        if (nums == null || nums.length == 0) return null;
+        // helper variables
         int[] res = new int[nums.length - k + 1];
-        for(int i = 0; i <= nums.length - k; i++) {
-            res[i] = getMax(nums, i, k);
-        }
-        return res;
-    }
-    
-    private int getMax(int[] nums, int start, int k) {
-        int max = nums[start];
-        for(int j = start + 1; j < start + k; j++) {
-            max = (max > nums[j] ? max : nums[j]);
-        }
-        return max;
-    }
-}
-
-//Own solution2: T: worst: O(nk) S: O(n)
-class Solution {
-    public int[] maxSlidingWindow(int[] nums, int k) {
-        if(nums == null) return null;
-        int len = nums.length;
-        if(len < 1) return new int[0];
+        Deque<Integer> queue = new LinkedList<>();
         
-        int[] res = new int[nums.length - k + 1];
-        res[0] = getMax(nums, 0, k);
-        int max = res[0];
-        
-        for(int i = 1; i <= nums.length - k; i++) {
-            if(nums[i + k -1] > nums[i-1]) max = Math.max(nums[i + k - 1], max);
-            else if(max == nums[i-1]) max = getMax(nums, i, k);
-            res[i] = max;
+        // sliding window
+        int windowLen = k;
+        int cur = 0;
+        for (int i = 0; i < nums.length; i++) {
+            int n = nums[i];
+            // insert to window
+            while (!queue.isEmpty() && nums[queue.peekLast()] <= n) {
+                queue.pollLast();
+            }
+            queue.offerLast(i);
+            // leave window
+            if (i >= windowLen) {
+                if (!queue.isEmpty() && queue.peekFirst() <= i - windowLen) queue.pollFirst();
+            }
+            // update
+            if (i == k - 1 || i >= windowLen) {
+                res[cur] = nums[queue.peekFirst()];
+                cur++;
+            }
         }
         return res;
     }
-    
-    private int getMax(int[] nums, int start, int k) {
-        int max = nums[start];
-        for(int j = start + 1; j < start + k; j++) {
-            max = (max > nums[j] ? max : nums[j]);
-        }
-        return max;
-    }
 }
 
-//Best solution: deque T: O(n) S: O(k)
+// Solution2: sliding window + heap
+// 超时
 class Solution {
     public int[] maxSlidingWindow(int[] nums, int k) {
-        int len = nums.length;
-        if(len < 1) return nums;
+        if (nums == null || nums.length == 0) return null;
+        // helper variables
+        List<Integer> res = new ArrayList<>();
+        PriorityQueue<Integer> heap = new PriorityQueue<>(k + 1, (a, b) -> b - a);
         
-        int[] res = new int[len - k + 1];
-        Deque<Integer> dq = new LinkedList<>();
-        for(int i = 0; i < len; i++) {
-            if(!dq.isEmpty() && dq.peek() < i - k + 1) {
-                dq.poll();
+        // sliding window
+        int windowLen = k;
+        for (int i = 0; i < nums.length; i++) {
+            int n = nums[i];
+            heap.add(n);
+            
+            if (i >= windowLen) {
+                int leave = nums[i - windowLen];
+                heap.remove(new Integer(leave));   // O(k)
             }
-            while(!dq.isEmpty() && nums[dq.peekLast()] <= nums[i]) {
-                dq.pollLast();
-            }
-            dq.offer(i);
-            if(i - k + 1 >= 0) {
-                res[i - k + 1] = nums[dq.peek()];
+            
+            if (i == k - 1 || i >= windowLen) {
+                res.add(heap.peek());
             }
         }
-        return res;
+        return res.stream().mapToInt(Integer :: valueOf).toArray();
     }
 }
diff --git a/Java/leetcode 567.java b/Java/leetcode 567.java
@@ -1,4 +1,6 @@
-// Solution1: sliding window T: O(n) S: O(1)
+// Solution1: sliding window
+// Array + isAllZero，固定滑动窗口模板
+// T: O(n) S: O(1)
 class Solution {
     public boolean checkInclusion(String s1, String s2) {
         if (s2 == null || s2.length() == 0 || s1 == null || s1.length() == 0) return false;
@@ -30,7 +32,9 @@ private boolean isAllZero(int[] code) {
     }
 }
 
-// Solution1: sliding window T: O(n) S: O(n)
+// Solution2: sliding window
+// Array + isAllZero，经典滑动窗口模板
+// T: O(n) S: O(1)
 class Solution {
     public boolean checkInclusion(String s1, String s2) {
         if (s2 == null || s2.length() == 0 || s1 == null || s1.length() == 0) return false;
@@ -66,3 +70,46 @@ public boolean checkInclusion(String s1, String s2) {
     }
 }
 
+// Solution3: sliding window
+// HashMap + valid，经典滑动窗口模板
+// T: O(n) S: O(1)
+class Solution {
+    public boolean checkInclusion(String s1, String s2) {
+        if (s2 == null || s2.length() == 0 || s1 == null || s1.length() == 0) return false;
+        // helper variables
+        Map<Character, Integer> need = new HashMap<>();
+        Map<Character, Integer> window = new HashMap<>();
+
+        for (char ch : s1.toCharArray()) {
+            need.put(ch, need.getOrDefault(ch, 0) + 1);
+        }
+        int valid = 0;
+        
+        // sliding window
+        int left = 0, right = 0;
+        boolean isNeedShrink = false;
+        while (right < s2.length()) {
+            char ch = s2.charAt(right);
+            right++;
+            
+            if (need.containsKey(ch)) {
+                window.put(ch, window.getOrDefault(ch, 0) + 1);
+                if ((int) window.get(ch) == (int) need.get(ch)) valid++;
+                if (valid == need.size()) return true;
+            }
+            if (right - left >= s1.length()) isNeedShrink = true;
+                        
+            while (isNeedShrink) {
+                char leave = s2.charAt(left);
+                left++;
+                
+                if (need.containsKey(leave)) {
+                    if ((int) window.get(leave) == (int) need.get(leave)) valid--;
+                    window.put(leave, window.getOrDefault(leave, 0) - 1);
+                }
+                if (right - left < s1.length()) isNeedShrink = false;
+            }
+        }
+        return false;
+    }
+}
