update 769 java, cheatsheet

yennanliu · yennanliu · commit ecaace9470d0 · 2024-12-31T16:08:17.000+08:00
diff --git a/README.md b/README.md
@@ -275,7 +275,7 @@
 747 | [Largest Number At Least Twice of Others](https://leetcode.com/problems/largest-number-at-least-twice-of-others/) | [Python](./leetcode_python/Array/largest-number-at-least-twice-of-others.py) | _O(n)_ | _O(1)_ | Easy |`good basic`, `data structure`| OK* 
 755 | [Pour Water](https://leetcode.com/problems/pour-water/) | [Python](./leetcode_python/Array/pour-water.py) | _O(v * n)_ | _O(1)_ | Medium |`complex`| AGAIN (not start)
 766 | [Toeplitz Matrix](https://leetcode.com/problems/toeplitz-matrix/) | [Python](./leetcode_python/Array/toeplitz-matrix.py)  | _O(m * n)_ | _O(1)_ | Easy |`basic`, `matrix`, `google`| AGAIN* (2)
-769 | [Max Chunks To Make Sorted](https://leetcode.com/problems/max-chunks-to-make-sorted/) | [Python](./leetcode_python/Array/max-chunks-to-make-sorted.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Array/MaxChunksToMakeSorted.java)| _O(n)_ | _O(1)_ | Medium |stack, array, google| AGAIN*** (1)
+769 | [Max Chunks To Make Sorted](https://leetcode.com/problems/max-chunks-to-make-sorted/) | [Python](./leetcode_python/Array/max-chunks-to-make-sorted.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Array/MaxChunksToMakeSorted.java)| _O(n)_ | _O(1)_ | Medium |good trick, prefix sum, stack, array, google| AGAIN*** (1)
 792 | [Number of Matching Subsequences](https://leetcode.com/problems/number-of-matching-subsequences/) | [Python](./leetcode_python/Array/number-of-matching-subsequences.py), [Java](./leetcode_java/src/main/java/LeetCodeJava/Array/NumberOfMatchingSubsequences.java) | _O(n + w)_ | _O(1)_ | Medium |basic, hash map, google| AGAIN**** (2)
 794 | [Valid Tic-Tac-Toe State](https://leetcode.com/problems/valid-tic-tac-toe-state/) | [Python](./leetcode_python/Array/valid-tic-tac-toe-state.py) | _O(1)_ | _O(1)_ | Medium |`complex`| AGAIN 
 795 | [Number of Subarrays with Bounded Maximum](https://leetcode.com/problems/number-of-subarrays-with-bounded-maximum/) | [Python](./leetcode_python/Array/number-of-subarrays-with-bounded-maximum.py) | _O(n)_ | _O(1)_ | Medium || AGAIN (not start*)
diff --git a/doc/cheatsheet/prefix_sum.md b/doc/cheatsheet/prefix_sum.md
@@ -43,6 +43,8 @@ We can use prefix sums. Say P[i+1] = A[0] + A[1] + ... + A[i], where A[i] = 1 if
         - LC 974
 - get count of overlap intervals
     LC 253
+- Max Chunks To Make Sorted
+    - LC 769
 
 ### 0-2) Pattern
 
@@ -303,4 +305,64 @@ public boolean checkSubarraySum_1(int[] nums, int k) {
 
     return false;
 }
+```
+
+### 2-7) Max Chunks To Make Sorted
+
+```java
+// java
+// LC 769
+// V1-1
+// https://leetcode.com/problems/max-chunks-to-make-sorted/editorial/
+// IDEA: Prefix Sums
+/**
+ *  IDEA:
+ *
+ *  An important observation is that a segment of the
+ *  array can form a valid chunk if, when sorted,
+ *  it matches the corresponding segment
+ *  in the fully sorted version of the array.
+ *
+ * Since the numbers in arr belong to the range [0, n - 1], we can simplify the problem by using the property of sums. Specifically, for any index, it suffices to check whether the sum of the elements in arr up to that index is equal to the sum of the elements in the corresponding prefix of the sorted array.
+ *
+ * If these sums are equal, it guarantees that the elements in the current segment of arr match the elements in the corresponding segment of the sorted array (possibly in a different order). When this condition is satisfied, we can form a new chunk — either starting from the beginning of the array or the end of the previous chunk.
+ *
+ * For example, consider arr = [1, 2, 0, 3, 4] and the sorted version sortedArr = [0, 1, 2, 3, 4]. We find the valid segments as follows:
+ *
+ * Segment [0, 0] is not valid, since sum = 1 and sortedSum = 0.
+ * Segment [0, 1] is not valid, since sum = 1 + 2 = 3 and sortedSum = 0 + 1 = 1.
+ * Segment [0, 2] is valid, since sum = 1 + 2 + 0 = 3 and sortedSum = 0 + 1 + 2 = 3.
+ * Segment [3, 3] is valid, because sum = 1 + 2 + 0 + 3 = 6 and sortedSum = 0 + 1 + 2 + 3 = 6.
+ * Segment [4, 4] is valid, because sum = 1 + 2 + 0 + 3 + 4 = 10 and sortedSum = 0 + 1 + 2 + 3 + 4 = 10.
+ * Therefore, the answer here is 3.
+ *
+ * Algorithm
+ * - Initialize n to the size of the arr array.
+ * - Initialize chunks, prefixSum, and sortedPrefixSum to 0.
+ * - Iterate over arr with i from 0 to n - 1:
+ *    - Increment prefixSum by arr[i].
+ *    - Increment sortedPrefixSum by i.
+ *    - Check if prefixSum == sortedPrefixSum:
+ *        - If so, increment chunks by 1.
+ * - Return chunks.
+ *
+ */
+public int maxChunksToSorted_1_1(int[] arr) {
+    int n = arr.length;
+    int chunks = 0, prefixSum = 0, sortedPrefixSum = 0;
+
+    // Iterate over the array
+    for (int i = 0; i < n; i++) {
+        // Update prefix sum of `arr`
+        prefixSum += arr[i];
+        // Update prefix sum of the sorted array
+        sortedPrefixSum += i;
+
+        // If the two sums are equal, the two prefixes contain the same elements; a chunk can be formed
+        if (prefixSum == sortedPrefixSum) {
+            chunks++;
+        }
+    }
+    return chunks;
+}
 ```
diff --git a/leetcode_java/src/main/java/LeetCodeJava/Array/MaxChunksToMakeSorted.java b/leetcode_java/src/main/java/LeetCodeJava/Array/MaxChunksToMakeSorted.java
@@ -45,15 +45,95 @@
  */
 public class MaxChunksToMakeSorted {
 
-    // V0
-//    public int maxChunksToSorted(int[] arr) {
-//
-//    }
+  // V0
+  //    public int maxChunksToSorted(int[] arr) {
+  //
+  //    }
 
     // V1-1
     // https://leetcode.com/problems/max-chunks-to-make-sorted/editorial/
-    // IDEA: PrefixMax and SuffixMin Arrays
+    // IDEA: Prefix Sums
+    /**
+     *  IDEA:
+     *
+     *  An important observation is that a segment of the
+     *  array can form a valid chunk if, when sorted,
+     *  it matches the corresponding segment
+     *  in the fully sorted version of the array.
+     *
+     * Since the numbers in arr belong to the range [0, n - 1], we can simplify the problem by using the property of sums. Specifically, for any index, it suffices to check whether the sum of the elements in arr up to that index is equal to the sum of the elements in the corresponding prefix of the sorted array.
+     *
+     * If these sums are equal, it guarantees that the elements in the current segment of arr match the elements in the corresponding segment of the sorted array (possibly in a different order). When this condition is satisfied, we can form a new chunk — either starting from the beginning of the array or the end of the previous chunk.
+     *
+     * For example, consider arr = [1, 2, 0, 3, 4] and the sorted version sortedArr = [0, 1, 2, 3, 4]. We find the valid segments as follows:
+     *
+     * Segment [0, 0] is not valid, since sum = 1 and sortedSum = 0.
+     * Segment [0, 1] is not valid, since sum = 1 + 2 = 3 and sortedSum = 0 + 1 = 1.
+     * Segment [0, 2] is valid, since sum = 1 + 2 + 0 = 3 and sortedSum = 0 + 1 + 2 = 3.
+     * Segment [3, 3] is valid, because sum = 1 + 2 + 0 + 3 = 6 and sortedSum = 0 + 1 + 2 + 3 = 6.
+     * Segment [4, 4] is valid, because sum = 1 + 2 + 0 + 3 + 4 = 10 and sortedSum = 0 + 1 + 2 + 3 + 4 = 10.
+     * Therefore, the answer here is 3.
+     *
+     * Algorithm
+     * - Initialize n to the size of the arr array.
+     * - Initialize chunks, prefixSum, and sortedPrefixSum to 0.
+     * - Iterate over arr with i from 0 to n - 1:
+     *    - Increment prefixSum by arr[i].
+     *    - Increment sortedPrefixSum by i.
+     *    - Check if prefixSum == sortedPrefixSum:
+     *        - If so, increment chunks by 1.
+     * - Return chunks.
+     *
+     */
     public int maxChunksToSorted_1_1(int[] arr) {
+        int n = arr.length;
+        int chunks = 0, prefixSum = 0, sortedPrefixSum = 0;
+
+        // Iterate over the array
+        for (int i = 0; i < n; i++) {
+            // Update prefix sum of `arr`
+            prefixSum += arr[i];
+            // Update prefix sum of the sorted array
+            sortedPrefixSum += i;
+
+            // If the two sums are equal, the two prefixes contain the same elements; a chunk can be formed
+            if (prefixSum == sortedPrefixSum) {
+                chunks++;
+            }
+        }
+        return chunks;
+    }
+
+  // V1-2
+  // https://leetcode.com/problems/max-chunks-to-make-sorted/editorial/
+  // IDEA: PrefixMax and SuffixMin Arrays
+  /**
+   *  IDEA:
+   *
+   *
+   *  Building on the above observation, we further notice that for each number in the array, we have two options: we can either include it in the same chunk as the previous number or create a new chunk for it. However, we must consider the limitation that a new chunk at index i can only be created if all the numbers in the current and previous chunks (the "prefix" of the array) are smaller than all the numbers in the following chunks (the "suffix" of the array). This is equivalent to checking whether:
+   *
+   * max(prefix[0:i])<min(suffix[i:n]).
+   * ​
+   *
+   * Since we aim to find the largest possible number of chunks, we will choose the second option (i.e., create a new chunk) whenever the above condition is satisfied. Therefore, the problem reduces to counting how many indices in the array satisfy this condition.
+   *
+   * Algorithm
+   * - Initialize n to the size of the arr array.
+   * - Initialize prefixMax and suffixMin arrays to arr.
+   * - Iterate over arr with i from 1 to n - 1:
+   *    - Set prefixMax[i] = max(prefixMax[i], prefixMax[i-1]).
+   * - Iterate over arr with i from n - 2 to 0:
+   *    - Set suffixMin[i] = min(suffixMin[i], suffixMin[i+1]).
+   * - Initialize chunks to 0.
+   * - Iterate over arr with i from 0 to n - 1:
+   *    - Check if i == 0 (create a chunk for the first element) or suffixMin[i] > prefixMax[i - 1].
+   *    - If true, increment chunks by 1.
+   * - Return chunks.
+   *
+   *
+   */
+  public int maxChunksToSorted_1_2(int[] arr) {
         int n = arr.length;
         int[] prefixMax = arr.clone();
         int[] suffixMin = arr.clone();
@@ -79,27 +159,6 @@ public int maxChunksToSorted_1_1(int[] arr) {
         return chunks;
     }
 
-    // V1-2
-    // https://leetcode.com/problems/max-chunks-to-make-sorted/editorial/
-    // IDEA: Prefix Sums
-    public int maxChunksToSorted_1_2(int[] arr) {
-        int n = arr.length;
-        int chunks = 0, prefixSum = 0, sortedPrefixSum = 0;
-
-        // Iterate over the array
-        for (int i = 0; i < n; i++) {
-            // Update prefix sum of `arr`
-            prefixSum += arr[i];
-            // Update prefix sum of the sorted array
-            sortedPrefixSum += i;
-
-            // If the two sums are equal, the two prefixes contain the same elements; a chunk can be formed
-            if (prefixSum == sortedPrefixSum) {
-                chunks++;
-            }
-        }
-        return chunks;
-    }
 
     // V1-3
     // https://leetcode.com/problems/max-chunks-to-make-sorted/editorial/
