update

Author: OneCodeMonkey

Diff for: contest/leetcode_week_249/leetcode_1929_Concatenation_of_Array.java

@@ -0,0 +1,16 @@
+// AC: Runtime: 2 ms, faster than 100.00% of Java online submissions for Concatenation of Array.
+// Memory Usage: 47.7 MB, less than 100.00% of Java online submissions for Concatenation of Array.
+// .
+// T:O(n), S:O(1)
+// 
+class Solution {
+    public int[] getConcatenation(int[] nums) {
+        int size = nums.length;
+        int[] ret = new int[2 * size];
+        for (int i = 0; i < 2 * size; i++) {
+            ret[i] = nums[i % size];
+        }
+
+        return ret;
+    }
+}

Diff for: contest/leetcode_week_249/leetcode_1930_Unique_Length-3_Palindromic_Subsequences.java

@@ -0,0 +1,45 @@
+// AC: Runtime: 74 ms, faster than 100.00% of Java online submissions for Unique Length-3 Palindromic Subsequences.
+// Memory Usage: 51.5 MB, less than 50.00% of Java online submissions for Unique Length-3 Palindromic Subsequences.
+// thought: record the start-index and end-index of every char, and count the distinct char between (start-index, end-index)
+// T:O(n^2), S:O(1)
+// 
+class Solution {
+    public int countPalindromicSubsequence(String s) {
+        int size = s.length(), ret = 0;
+        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> tempList = new LinkedList<>();
+                tempList.add(i);
+                charIndex.put(c, tempList);
+            }
+        }
+        for (int i = 0; i < 26; i++) {
+            char c = (char) (i + 'a');
+            if (charIndex.get(c) != null && charIndex.get(c).size() == 2) {
+                HashSet<Character> tempRecord = new HashSet<>();
+                int startIndex = charIndex.get(c).get(0), endIndex = charIndex.get(c).get(1);
+                if (endIndex - startIndex == 1) {
+                    continue;
+                }
+                for (int j = startIndex + 1; j <= endIndex - 1; j++) {
+                    tempRecord.add(s.charAt(j));
+                    // reach max possible value, break
+                    if (tempRecord.size() == 26) {
+                        break;
+                    }
+                }
+                ret += tempRecord.size();
+            }
+        }
+
+        return ret;
+    }
+}

Diff for: leetcode_solved/[editing]leetcode_0042_Trapping_Rain_Water.cpp

@@ -0,0 +1,64 @@
+// Solution1: for every element(except first and last), get the left max and right max, 
+//          and if min(leftMax, rightMax) > cur, then can trap water: min(leftMax, rightMax) - cur
+// AC: Runtime: 70 ms, faster than 5.29% of Java online submissions for Trapping Rain Water.
+// Memory Usage: 38 MB, less than 99.03% of Java online submissions for Trapping Rain Water.
+// .
+// T:O(n^2), S:O(1)
+// 
+class Solution {
+    public int trap(int[] height) {
+        int size = height.length, ret = 0;
+        if (size >= 3) {
+            // the first element and last element cannot trap water.
+            for (int i = 1; i < size - 1; i++) {
+                int leftMax = 0, rightMax = 0;
+                for (int j = 0; j < i; j++) {
+                    leftMax = Math.max(leftMax, height[j]);
+                }
+                for (int j = i + 1; j < size; j++) {
+                    rightMax = Math.max(rightMax, height[j]);
+                }
+
+                int temp = Math.min(leftMax, rightMax);
+                ret += temp > height[i] ? (temp - height[i]) : 0;
+            }
+        }
+
+        return ret;
+    }
+}
+
+// Solution2: DP, we store every element's left max element, and right max element, then 
+//           the complexity we reduce to O(n)
+// AC: Runtime: 1 ms, faster than 85.19% of Java online submissions for Trapping Rain Water.
+// Memory Usage: 38.6 MB, less than 47.90% of Java online submissions for Trapping Rain Water.
+// dp: to store the left max and right max
+// T:O(n), S:O(n)
+// 
+class Solution {
+    public int trap(int[] height) {
+        int size = height.length, ret = 0;
+        if (size < 3) {
+            return ret;
+        }
+        int[] leftMax = new int[size], rightMax = new int[size];
+        leftMax[0] = 0;
+        for (int i = 1; i < size; i++) {
+            leftMax[i] = Math.max(leftMax[i - 1], height[i - 1]);
+        }
+        rightMax[size - 1] = 0;
+        for (int i = size - 2; i >= 0; i--) {
+            rightMax[i] = Math.max(rightMax[i + 1], height[i + 1]);
+        }
+
+        for (int i = 1; i < size - 1; i++) {
+            int temp = Math.min(leftMax[i], rightMax[i]);
+            ret += temp > height[i] ? (temp - height[i]) : 0;
+        }
+
+        return ret;
+    }
+}
+
+
+// Solution3: todo- 单调栈解法

Diff for: leetcode_solved/[editing]leetcode_0162_Find_Peak_Element.cpp

@@ -0,0 +1,29 @@
+// AC: Runtime: 0 ms, faster than 100.00% of Java online submissions for Find Peak Element.
+// Memory Usage: 38.4 MB, less than 77.63% of Java online submissions for Find Peak Element.
+// binary search, before next iteration we can judge element's neighbors and may return in advance.
+// T:O(logn), S:O(1)
+// 
+class Solution {
+    public int findPeakElement(int[] nums) {
+        int start = 0, end = nums.length - 1;
+        return binarySearch(nums, start, end);
+    }
+
+    private int binarySearch(int[] arr, int start, int end) {
+        if (start == end) {
+            return start;
+        }
+        int mid = (start + end) / 2, mid2 = mid + 1;
+        if (arr[mid] > arr[mid2]) {
+            if (mid - 1 > 0 && arr[mid - 1] < arr[mid]) {
+                return mid;
+            }
+            return binarySearch(arr, start, mid);
+        } else {
+            if (mid2 + 1 <= end && arr[mid2 + 1] < arr[mid2]) {
+                return mid2;
+            }
+            return binarySearch(arr, mid2, end);
+        }
+    }
+}

Diff for: leetcode_solved/[editing]leetcode_0413_Arithmetic_Slices.cpp

@@ -0,0 +1,33 @@
+// AC: Runtime: 0 ms, faster than 100.00% of Java online submissions for Arithmetic Slices.
+// Memory Usage: 36.7 MB, less than 80.00% of Java online submissions for Arithmetic Slices.
+// thoughts: find the consecutive subarray, then it could contribute (len - 1) * (len - 2) / 2 slices, 
+//        then start from the end of last consecutive +1, and go ahead to find the next consecutive.
+// T:O(n), S:O(1)
+// 
+class Solution {
+    public int numberOfArithmeticSlices(int[] nums) {
+        int size = nums.length, ret = 0;
+        if (size >= 3) {
+            for (int i = 0; i < size - 2;) {
+                int diff1 = nums[i + 1] - nums[i], diff2 = nums[i + 2] - nums[i + 1];
+                if (diff1 == diff2) {
+                    int end = i + 2;
+                    while (end < size && nums[end] - nums[end - 1] == diff1) {
+                        end++;
+                    }
+                    // length of the consecutive subarray that has same adjacent diff.
+                    int len = end - i;
+                    // may produce such amount amount of `arithmetic slices`.
+                    ret += (len - 1) * (len - 2) / 2;
+                    
+                    // forwarding to the sequence's end + 1
+                    i = end - 2;
+                } else {
+                    i++;
+                }
+            }
+        }
+
+        return ret;
+    }
+}