update

Author: OneCodeMonkey

leetcode_solved/[editing]leetcode_0076_Minimum_Window_Substring.cpp

@@ -0,0 +1,71 @@
+// AC: Runtime: 122 ms, faster than 5.02% of Java online submissions for Minimum Window Substring.
+// Memory Usage: 39.9 MB, less than 32.04% of Java online submissions for Minimum Window Substring.
+// sliding window
+// T:O(26 * n + m) ~ O(m + n), S:O(26 * 2) ~ O(1)
+// 
+class Solution {
+    public String minWindow(String s, String t) {
+        int sizeS = s.length(), sizeT = t.length(), minSize = Integer.MAX_VALUE, left = -1, right = -1;
+        if (sizeS < sizeT) {
+            return "";
+        }
+
+        HashMap<Character, Integer> recordS = new HashMap<>(), recordT = new HashMap<>();
+        for (char c : t.toCharArray()) {
+            recordT.merge(c, 1, Integer::sum);
+        }
+        for (char c : s.toCharArray()) {
+            recordS.merge(c, 1, Integer::sum);
+        }
+
+        for (char c : recordT.keySet()) {
+            if (!recordS.containsKey(c) || recordS.get(c) < recordT.get(c)) {
+                return "";
+            }
+        }
+
+        int leftPos = 0, rightPos = 0;
+        HashMap<Character, Integer> tempRecord = new HashMap<>();
+        tempRecord.merge(s.charAt(rightPos), 1, Integer::sum);
+
+        while (leftPos <= sizeS - 1) {
+            // right pointer forwarding
+            while (rightPos < sizeS - 1 && !check(tempRecord, recordT)) {
+                rightPos++;
+                tempRecord.merge(s.charAt(rightPos), 1, Integer::sum);
+            }
+            if (check(tempRecord, recordT)) {
+                if (rightPos - leftPos + 1 < minSize) {
+                    minSize = rightPos - leftPos + 1;
+                    left = leftPos;
+                    right = rightPos;
+                }
+            } else {
+                break;
+            }
+
+            // left pointer forwarding
+            while (leftPos <= sizeS - 1 && check(tempRecord, recordT)) {
+                if (rightPos - leftPos + 1 < minSize) {
+                    minSize = rightPos - leftPos + 1;
+                    left = leftPos;
+                    right = rightPos;
+                }
+                tempRecord.merge(s.charAt(leftPos), -1, Integer::sum);
+                leftPos++;
+            }
+        }
+
+        return left == -1 ? "" :s.substring(left, right + 1);
+    }
+
+    private boolean check(HashMap<Character, Integer> h1, HashMap<Character, Integer> h2) {
+        for (char c : h2.keySet()) {
+            if (!h1.containsKey(c) || h2.get(c) > h1.get(c)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

leetcode_solved/[editing]leetcode_0143_Reorder_List.cpp

@@ -0,0 +1,31 @@
+// Solution: space O(n) method
+// AC: Runtime: 2 ms, faster than 38.26% of Java online submissions for Reorder List.
+// Memory Usage: 41.5 MB, less than 81.90% of Java online submissions for Reorder List.
+// .
+// T:O(n), S:O(n)
+// 
+class Solution {
+    public void reorderList(ListNode head) {
+        List<ListNode> record = new ArrayList<>();
+        while (head != null) {
+            record.add(head);
+            head = head.next;
+        }
+        int size = record.size(), left = 1, right = size - 1;
+        ListNode temp = record.get(0);
+        ListNode ret = temp;
+        while (left <= right) {
+            temp.next = record.get(right);
+            temp = temp.next;
+            right--;
+            if (left < right) {
+                temp.next = record.get(left);
+                temp = temp.next;
+                left++;
+            }
+        }
+        temp.next = null;
+
+        head = ret;
+    }
+}

leetcode_solved/[editing]leetcode_0146_LRU_Cache.cpp

@@ -0,0 +1,25 @@
+// AC: Runtime: 46 ms, faster than 89.97% of Java online submissions for LRU Cache.
+// Memory Usage: 109.2 MB, less than 87.04% of Java online submissions for LRU Cache.
+// implement with java's native LinkedHashMap container.
+// T:O(1), S:O(n)
+//
+class LRUCache {
+    private HashMap<Integer, Integer> map;
+
+    public LRUCache(int capacity) {
+        map = new LinkedHashMap<Integer, Integer>(capacity, 0.75f, true) {
+            @Override
+            protected boolean removeEldestEntry(Map.Entry eldest) {
+                return size() > capacity;
+            }
+        };
+    }
+
+    public int get(int key) {
+        return map.getOrDefault(key, -1);
+    }
+
+    public void put(int key, int value) {
+        map.put(key, value);
+    }
+}