update

Author: OneCodeMonkey

leetcode_solved/[editing]leetcode_0080_Remove_Duplicates_from_Sorted_Array_II.cpp

@@ -0,0 +1,42 @@
+// AC: Runtime: 1 ms, faster than 30.57% of Java online submissions for Remove Duplicates from Sorted Array II.
+// Memory Usage: 38.9 MB, less than 85.24% of Java online submissions for Remove Duplicates from Sorted Array II.
+// since the nums[i] ∈ [-10^4, 10^4], if we find three or above duplicates, we sign it as -10001, then move the element in O(n) complexity.
+// T:O(n), S:O(1)
+// 
+class Solution {
+    public int removeDuplicates(int[] nums) {
+        int size = nums.length, dup = 0, tempCount = 1, prev = -10001;
+        if (size > 1) {
+            for (int i = 1; i < size; i++) {
+                if (nums[i] == nums[i - 1] || nums[i] == prev) {
+                    tempCount++;
+                    prev = nums[i];
+                    if (tempCount >= 3) {
+                        dup++;
+                        // sign as a unique num.
+                        nums[i] = -10001;
+                    }
+                } else {
+                    prev = -10001;
+                    tempCount = 1;
+                }
+            }
+
+            int pos = 0;
+            for (int i = 0; i < size; i++, pos++) {
+                if (nums[i] == -10001) {
+                    while (pos < size && nums[pos] == -10001) {
+                        pos++;
+                    }
+                    if (pos >= size) {
+                        break;
+                    }
+                    nums[i] = nums[pos];
+                    nums[pos] = -10001;
+                }
+            }
+        }
+
+        return size - dup;
+    }
+}

leetcode_solved/[editing]leetcode_0082_Remove_Duplicates_from_Sorted_List_II.cpp

@@ -0,0 +1,39 @@
+// AC: Runtime: 1 ms, faster than 27.17% of Java online submissions for Remove Duplicates from Sorted List II.
+// Memory Usage: 38.6 MB, less than 34.10% of Java online submissions for Remove Duplicates from Sorted List II.
+// .
+// T:O(n), S:O(n)
+// 
+class Solution {
+    public ListNode deleteDuplicates(ListNode head) {
+        HashSet<Integer> dup = new HashSet<>();
+        ListNode headCopy = head;
+        int prev = Integer.MIN_VALUE;
+        while (headCopy != null) {
+            if (headCopy.val == prev) {
+                dup.add(headCopy.val);
+            }
+            prev = headCopy.val;
+            headCopy = headCopy.next;
+        }
+
+        ListNode headCopy2 = head, prevNode = head;
+        while (headCopy2 != null && headCopy2.next != null) {
+            if (dup.contains(headCopy2.val)) {
+                headCopy2.val = headCopy2.next.val;
+                headCopy2.next = headCopy2.next.next;
+            } else {
+                prevNode = headCopy2;
+                headCopy2 = headCopy2.next;
+            }
+        }
+        // handle the head pointer itself
+        if (headCopy2 != null && dup.contains(headCopy2.val)) {
+            if (headCopy2 == head) {
+                return null;
+            }
+            prevNode.next = null;
+        }
+
+        return head;
+    }
+}

leetcode_solved/[editing]leetcode_0189_Rotate_Array.cpp

@@ -0,0 +1,24 @@
+// AC: Runtime: 0 ms, faster than 100.00% of Java online submissions for Rotate Array.
+// Memory Usage: 56.2 MB, less than 55.69% of Java online submissions for Rotate Array.
+// a reverse trick, to remember.
+// T:O(n), S:O(1)
+// 
+class Solution {
+    public void rotate(int[] nums, int k) {
+        int size = nums.length;
+        k = k % size;
+        reverse(nums, 0, size - 1);
+        reverse(nums, 0, k - 1);
+        reverse(nums, k, size - 1);
+    }
+
+    public void reverse(int[] nums, int start, int end) {
+        while (start < end) {
+            int temp = nums[start];
+            nums[start] = nums[end];
+            nums[end] = temp;
+            start++;
+            end--;
+        }
+    }
+}

leetcode_solved/[editing]leetcode_0223_Rectangle_Area.cpp

@@ -0,0 +1,20 @@
+// AC: Runtime: 2 ms, faster than 100.00% of Java online submissions for Rectangle Area.
+// Memory Usage: 38.1 MB, less than 88.56% of Java online submissions for Rectangle Area.
+// Depart into several situations and analyse respectively, and we can get the regularity about the overlapped area.
+// T:O(1), S:O(1)
+// 
+class Solution {
+    public int computeArea(int ax1, int ay1, int ax2, int ay2, int bx1, int by1, int bx2, int by2) {
+        int overlapArea, sumArea = (ay2 - ay1) * (ax2 - ax1) + (by2 - by1) * (bx2 - bx1);
+        
+        // no-overlapping area.
+        if (bx1 >= ax2 || bx2 <= ax1 || by1 >= ay2 || by2 <= ay1) {
+            overlapArea = 0;
+        } else {
+            // the overlapped area
+            overlapArea = (Math.min(bx2, ax2) - Math.max(bx1, ax1)) * (Math.min(by2, ay2) - Math.max(by1, ay1));
+        }
+        
+        return sumArea - overlapArea;
+    }
+}

leetcode_solved/[editing]leetcode_0739_Daily_Temperatures.cpp

@@ -0,0 +1,56 @@
+// 方法一：原始暴力，可以pass。。
+// Runtime: 977 ms, faster than 10.10% of Java online submissions for Daily Temperatures.
+// Memory Usage: 47.1 MB, less than 54.24% of Java online submissions for Daily Temperatures.
+// 略。
+// T:O(n^2), S:O(n)
+//
+class Solution {
+    public int[] dailyTemperatures(int[] T) {
+        int[] ret = new int[T.length];
+        ret[T.length - 1] = 0;
+
+        for (int i = 0; i < T.length - 1; i++) {
+            int count = 0;
+            boolean hasBigger = false;
+            for (int j = i + 1; j < T.length; j++) {
+                count++;
+                if (T[j] > T[i]) {
+                    hasBigger = true;
+                    break;
+                }
+            }
+            if (hasBigger) {
+                ret[i] = count;
+            }
+        }
+
+        return ret;
+    }
+}
+
+// 优化：单调栈解法
+// AC: Runtime: 40 ms, faster than 30.34% of Java online submissions for Daily Temperatures.
+// Memory Usage: 48.3 MB, less than 54.37% of Java online submissions for Daily Temperatures.
+// 单调栈解法
+// T:O(n), S:O(n)
+// 
+class Solution {
+    public int[] dailyTemperatures(int[] temperatures) {
+        Stack<Integer> record = new Stack<>();
+        int size = temperatures.length;
+        int[] ret = new int[size];
+        for (int i = 0; i < size; i++) {
+            if (record.empty() || temperatures[i] <= temperatures[record.peek()]) {
+                record.push(i);
+            } else {
+                while (!record.empty() && temperatures[i] > temperatures[record.peek()]) {
+                    ret[record.peek()] = i - record.peek();
+                    record.pop();
+                }
+                record.push(i);
+            }
+        }
+
+        return ret;
+    }
+}

leetcode_solved/[editing]leetcode_0763_Partition_Labels.cpp

@@ -0,0 +1,59 @@
+// AC: Runtime: 21 ms, faster than 5.46% of Java online submissions for Partition Labels.
+// Memory Usage: 40.2 MB, less than 5.08% of Java online submissions for Partition Labels.
+// start from 0-index, record the max substring that meets the requirement, until reach the end of string.
+// T:O(n), S:O(1)
+// 
+class Solution {
+    public List<Integer> partitionLabels(String S) {
+        List<Integer> ret = new LinkedList<>();
+        int size = S.length();
+        HashMap<Character, List<Integer>> charIndex = new HashMap<>();
+        for (int i = 0; i < size; i++) {
+            char c = S.charAt(i);
+            if (charIndex.get(c) != null) {
+                if (charIndex.get(c).size() == 1) {
+                    charIndex.get(c).add(i);
+                } else {
+                    charIndex.get(c).set(1, i);
+                }
+            } else {
+                List<Integer> temp = new LinkedList<>();
+                temp.add(i);
+                charIndex.put(c, temp);
+            }
+        }
+
+        // one char's first occur index and last occur index
+        int startPos = 0, endPos = 0;
+        while (startPos < size) {
+            char c = S.charAt(startPos);
+            List<Integer> tempIndex = charIndex.get(c);
+            // appear only once
+            if (tempIndex.size() == 1) {
+                startPos++;
+                ret.add(1);
+            } else {
+                endPos = tempIndex.get(1);
+                int startPosCopy = startPos, endPosCopy = endPos;
+                while (true) {
+                    int maxOtherCharIndex = -1;
+                    for (int i = startPosCopy + 1; i <= endPosCopy - 1; i++) {
+                        if (charIndex.get(S.charAt(i)).size() == 2) {
+                            maxOtherCharIndex = Math.max(maxOtherCharIndex, charIndex.get(S.charAt(i)).get(1));
+                        }
+                    }
+                    if (maxOtherCharIndex > endPosCopy) {
+                        startPosCopy = endPos;
+                        endPosCopy = maxOtherCharIndex;
+                    } else {
+                        ret.add(endPosCopy - startPos + 1);
+                        startPos = endPosCopy + 1;
+                        break;
+                    }
+                }
+            }
+        }
+
+        return ret;
+    }
+}

leetcode_solved/[editing]leetcode_0933_Number_of_Recent_Calls.cpp

@@ -0,0 +1,30 @@
+// AC: Runtime: 2 ms, faster than 91.18% of Java online submissions for Letter Tile Possibilities.
+// Memory Usage: 36.6 MB, less than 99.51% of Java online submissions for Letter Tile Possibilities.
+// DP
+// T:O(n), S:O(1)
+// 
+class Solution {
+    public int numTilePossibilities(String tiles) {
+        int[] record = new int[26];
+        for (char c: tiles.toCharArray()) {
+            record[c - 'A']++;
+        }
+        
+        return dfs(record);
+    }
+
+    public int dfs(int[] arr) {
+        int sum = 0;
+        for (int i = 0; i < 26; i++) {
+            if (arr[i] == 0) {
+                continue;
+            }
+            sum++;
+            arr[i]--;
+            sum += dfs(arr);
+            arr[i]++;
+        }
+
+        return sum;
+    }
+}

leetcode_solved/[editing]leetcode_1079_Letter_Tile_Possibilities.cpp

@@ -0,0 +1,46 @@
+// AC: Runtime: 17 ms, faster than 37.69% of Java online submissions for All Elements in Two Binary Search Trees.
+// Memory Usage: 41.7 MB, less than 80.19% of Java online submissions for All Elements in Two Binary Search Trees.
+// .
+// T:O(len1 + len2)), S:O(len1 + len2)
+// 
+class Solution {
+    public List<Integer> getAllElements(TreeNode root1, TreeNode root2) {
+        List<Integer> list1 = new ArrayList<>();
+        List<Integer> list2 = new ArrayList<>();
+        List<Integer> ret = new ArrayList<>();
+        inOrderTravel(root1, list1);
+        inOrderTravel(root2, list2);
+        int pos1 = 0, pos2 = 0;
+        while (pos1 < list1.size() || pos2 < list2.size()) {
+            if (pos1 >= list1.size()) {
+                while (pos2 < list2.size()) {
+                    ret.add(list2.get(pos2++));
+                }
+            } else if (pos2 >= list2.size()) {
+                while (pos1 < list1.size()) {
+                    ret.add(list1.get(pos1++));
+                }
+            } else {
+                if (list1.get(pos1).equals(list2.get(pos2))) {
+                    ret.add(list1.get(pos1++));
+                    ret.add(list2.get(pos2++));
+                } else if (list1.get(pos1) > list2.get(pos2)) {
+                    ret.add(list2.get(pos2++));
+                } else {
+                    ret.add(list1.get(pos1++));
+                }
+            }
+        }
+
+        return ret;
+    }
+
+    public void inOrderTravel(TreeNode root, List<Integer> out) {
+        if (root == null) {
+            return;
+        }
+        inOrderTravel(root.left, out);
+        out.add(root.val);
+        inOrderTravel(root.right, out);
+    }
+}