sliding window

Author: rchen102

Java/leetcode 209.java

@@ -4,24 +4,30 @@
 class Solution {
     public int minSubArrayLen(int s, int[] nums) {
         if (nums == null || nums.length == 0) return 0;
+        // helper vars
+        int sum = 0, len = nums.length + 1;
+        
+        // sliding window
         int left = 0, right = 0;
-        int sum = 0, minLen = nums.length + 1;
+        boolean isNeedShrink = false;
         while (right < nums.length) {
-            sum += nums[right];
-            if (sum >= s) {
-                while (sum >= s) {
-                    minLen = Math.min(minLen, right - left + 1);
-                    sum -= nums[left];
-                    left++;
-                }
-                right++;
-            }
-            else {
-                right++;
+            int n = nums[right];
+            right++;
+            
+            sum += n;
+            if (sum >= s) isNeedShrink = true;
+            
+            while (isNeedShrink) {
+                len = Math.min(len, right - left);
+                
+                int toRemove = nums[left];
+                left++;
+                
+                sum -= toRemove;
+                if (sum < s) isNeedShrink = false;
             }
         }
-        if (minLen <= nums.length) return minLen;
-        return 0;
+        return len > nums.length ? 0 : len;
     }
 }
 

Java/leetcode 3.java

@@ -1,50 +1,56 @@
-/* Solution: sliding window + set
+/* Solution: sliding window + Map
  * T: O(n) S: O(1)
  */
 class Solution {
     public int lengthOfLongestSubstring(String s) {
         if (s == null || s.length() == 0) return 0;
-        int left = 0, right = 0; // sliding window
+        Map<Character, Integer> map = new HashMap<>();  // 判断是否重复使用
+        int left = 0, right = 0;
+        boolean isNeedShrink = false;
         int res = 0;
-        Set<Character> set = new HashSet<>();
         while (right < s.length()) {
             char ch = s.charAt(right);
-            if (!set.contains(ch)) {
-                set.add(ch);
-                res = Math.max(res, set.size());
-                right++;
-            } else {
-                while (set.contains(ch)) {
-                    set.remove(s.charAt(left));
-                    left++;
-                }
+            right++;
+            map.put(ch, map.getOrDefault(ch, 0) + 1);
+            if (map.get(ch) > 1) isNeedShrink = true;
+           
+            while (isNeedShrink) {
+                char toRemove = s.charAt(left);
+                left++;
+                map.put(toRemove, map.get(toRemove) - 1);
+                if (toRemove == ch) isNeedShrink = false;
             }
+            res = Math.max(right - left, res);
         }
         return res;
     }
 }
 
-/* Solution: sliding window + array -> hashmap
+/* Solution: sliding window + array -> hashmap 更快
  * T: O(n) S: O(1)
  */
 class Solution {
     public int lengthOfLongestSubstring(String s) {
-        int[] map = new int[256];
+        if (s == null || s.length() == 0) return 0;
+        int[] map = new int[256];  // 判断是否重复使用
         int left = 0, right = 0;
-        int maxLen = 0;
+        boolean isNeedShrink = false;
+        int res = 0;
         while (right < s.length()) {
-            if (map[s.charAt(right)] == 0) {
-                maxLen = Math.max(right - left + 1, maxLen);
-                map[s.charAt(right)]++;
-                right++;
-            }
-            else {
-                while (map[s.charAt(right)] != 0) {
-                    map[s.charAt(left)] = 0;
-                    left++;
-                }
+            char ch = s.charAt(right);
+            right++;
+            
+            map[ch]++;
+            if (map[ch] > 1) isNeedShrink = true;
+            
+            while (isNeedShrink) {
+                char toRemove = s.charAt(left);
+                left++;
+                map[toRemove]--;
+                if (toRemove == ch) isNeedShrink = false;
             }
+            res = Math.max(right - left, res);
         }
-        return maxLen;
+        return res;
     }
 }

Java/leetcode 35.java

@@ -6,11 +6,11 @@ public int searchInsert(int[] nums, int target) {
         if (nums == null || nums.length == 0) return 0;
         int lo = 0, hi = nums.length - 1;
         while (lo <= hi) {
-            int mid = lo + (hi - lo) / 2;
-            if (nums[mid] < target) lo = mid + 1;
+            int mid = lo + ((hi - lo) >> 1);
+            if (nums[mid] < target)  lo = mid + 1;
             else if (nums[mid] > target) hi = mid - 1;
             else return mid;
-        } 
+        }
         return lo;
     }
 }

Java/leetcode 39.java

@@ -1,6 +1,30 @@
 /* Solution: backtrace
  *
  */
+class Solution {
+    public List<List<Integer>> combinationSum(int[] candidates, int target) {
+        List<List<Integer>> res = new ArrayList<>();
+        if (candidates == null || candidates.length == 0) return res;
+        Arrays.sort(candidates);
+        backtrace(candidates, target, 0, new ArrayList<>(), res);
+        return res;
+    }
+    
+    private void backtrace(int[] candidates, int remain, int start, List<Integer> tmp, List<List<Integer>> res) {
+        if (remain == 0) {
+            res.add(new ArrayList<>(tmp));
+            return;
+        }
+        for (int i = start; i < candidates.length; i++) {
+            if (candidates[i] > remain) break;
+            tmp.add(candidates[i]);
+            backtrace(candidates, remain - candidates[i], i, tmp, res);
+            tmp.remove(tmp.size() - 1);
+        }
+    }
+}
+
+// 未排序
 class Solution {
     public List<List<Integer>> combinationSum(int[] candidates, int target) {
         List<List<Integer>> res = new ArrayList<>();

Java/leetcode 40.java

@@ -1,6 +1,32 @@
 /* Solution: backtrace
  *
  */
+class Solution {
+    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
+        List<List<Integer>> res = new ArrayList<>();
+        if (candidates == null || candidates.length == 0) return res;
+        Arrays.sort(candidates); // log(n)
+        backtrace(candidates, target, 0, new ArrayList<>(), res);
+        return res;
+    }
+    
+    private void backtrace(int[] candidates, int remain, int start, List<Integer> tmp, List<List<Integer>> res) {
+        if (remain == 0) {
+            res.add(new ArrayList<>(tmp));
+            return;
+        }
+        for (int i = start; i < candidates.length; i++) {
+            if (candidates[i] > remain) break;
+            if (i != start && candidates[i] == candidates[i-1]) continue;  // avoid duplicate solution
+            tmp.add(candidates[i]);
+            backtrace(candidates, remain - candidates[i], i + 1, tmp, res);
+            tmp.remove(tmp.size() - 1);
+        }
+    }
+}
+
+
+
 class Solution {
     public List<List<Integer>> combinationSum2(int[] candidates, int target) {
         List<List<Integer>> res = new ArrayList<>();

Java/leetcode 438.java

@@ -0,0 +1,32 @@
+// Solution1: sliding window T: O(n) S: O(1)
+class Solution {
+    public List<Integer> findAnagrams(String s, String p) {
+        List<Integer> res = new ArrayList<>();
+        if (s == null || s.length() == 0) return res;
+        // helper variables
+        int[] code = new int[26];
+        for (char ch : p.toCharArray()) {
+            code[ch-'a'] += 1;
+        }
+        // sliding window
+        int windowLen = p.length();
+        for (int i = 0; i < s.length(); i++) {
+            char ch = s.charAt(i);
+            code[ch-'a'] -= 1;
+            
+            if (i >= windowLen) {
+                char leave = s.charAt(i-windowLen);
+                code[leave-'a'] += 1;
+            }
+            if (isAllZero(code)) res.add(i-windowLen+1);
+        }
+        return res;
+    }
+    
+    private boolean isAllZero(int[] code) {
+        for (int i = 0; i < code.length; i++) {
+            if (code[i] != 0) return false;
+        }
+        return true;
+    }
+}

Java/leetcode 567.java

@@ -0,0 +1,68 @@
+// Solution1: sliding window 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
+        int[] code = new int[26];
+        for (char ch : s1.toCharArray()) {
+            code[ch-'a'] += 1;
+        }
+        
+        // sliding window
+        int windowLen = s1.length();
+        for (int i = 0; i < s2.length(); i++) {
+            char ch = s2.charAt(i);
+            code[ch-'a'] -= 1;
+            if (i >= windowLen) {
+                char leave = s2.charAt(i - windowLen);
+                code[leave-'a'] += 1;   
+            }
+            if (isAllZero(code)) return true;
+        }
+        return false;
+    }
+    
+    private boolean isAllZero(int[] code) {
+        for (int i = 0; i < code.length; i++) {
+            if (code[i] != 0) return false;
+        }
+        return true;
+    }
+}
+
+// Solution1: sliding window T: O(n) S: O(n)
+class Solution {
+    public boolean checkInclusion(String s1, String s2) {
+        if (s2 == null || s2.length() == 0 || s1 == null || s1.length() == 0) return false;
+        // helper variables
+        char[] code = new char[26];
+        for (char ch : s1.toCharArray()) {
+            code[ch-'a'] += 1;
+        }
+        String need = String.valueOf(code);
+        code = new char[26];
+        
+        // sliding window
+        int left = 0, right = 0;
+        boolean isNeedShrink = false;
+        while (right < s2.length()) {
+            char ch = s2.charAt(right);
+            right++;
+            
+            code[ch-'a'] += 1;
+            if (right - left == s1.length()) isNeedShrink = true;
+            
+            while (isNeedShrink) {
+                if (need.equals(String.valueOf(code))) return true;
+                
+                char leave = s2.charAt(left);
+                left++;
+                
+                code[leave - 'a'] -= 1;
+                if (right - left < s1.length()) isNeedShrink = false;
+            }
+        }
+        return false;
+    }
+}
+

Java/leetcode 76.java

@@ -0,0 +1,48 @@
+// Solution1: sliding window T: O(n) S: O(n)
+class Solution {
+    public String minWindow(String s, String t) {
+        if (s == null || s.length() == 0 || t == null || t.length() == 0) return "";
+        
+        // helper vars
+        Map<Character, Integer> need = new HashMap<>();
+        Map<Character, Integer> window = new HashMap<>();
+        int valid = 0;
+        for (char ch : t.toCharArray()) {
+            need.put(ch, need.getOrDefault(ch, 0) + 1);
+        }
+        int start = -1, len = s.length() + 1;  // final result
+        
+        // sliding window
+        int left = 0, right = 0;
+        boolean isNeedShrink = false;
+        while (right < s.length()) {
+            // 右移
+            char c = s.charAt(right);
+            right++;
+            
+            if (need.containsKey(c)) {
+                window.put(c, window.getOrDefault(c, 0) + 1);
+                if ((int) window.get(c) == (int) need.get(c)) valid++;
+            }
+            if (valid == need.size()) isNeedShrink = true;
+            
+            while (isNeedShrink) {
+                // update result
+                if (right - left < len) {
+                    start = left;
+                    len = right - left;
+                }
+                // 左移
+                char d = s.charAt(left);
+                left++;
+                
+                if (need.containsKey(d)) {
+                    if ((int) window.get(d) == (int) need.get(d)) valid--;
+                    window.put(d, window.get(d) - 1);
+                }
+                if (valid != need.size()) isNeedShrink = false;
+            }
+        }
+        return start == -1 ? "" : s.substring(start, start + len);
+    }
+}