update 769 java

Author: yennanliu

leetcode_java/src/main/java/LeetCodeJava/Array/MaxChunksToMakeSorted.java

@@ -46,9 +46,42 @@
 public class MaxChunksToMakeSorted {
 
   // V0
-  //    public int maxChunksToSorted(int[] arr) {
-  //
-  //    }
+  // IDEA: prefix + problem understanding
+  /**
+   *  IDEA:
+   *
+   *    since this problem wants to find the MAX value of sub array with sort op
+   *    and concatenate can same as the SORTED ORIGINAL ARRAY
+   *
+   *    -> so all we need to do within looping is:
+   *        maintain
+   *            1) sorted prefixSum (sort all array and its prefix sum)
+   *            2) prefixSum (current array's prefix sum)
+   *
+   *    -> so, for `sorted prefixSum`, it's sortedPrefixSum + i, ... (since the array is the permutation of element within [0, n - 1])
+   *           for `prefixSum`, it's prefixSum + i ,....
+   *
+   */
+  public int maxChunksToSorted(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-1
     // https://leetcode.com/problems/max-chunks-to-make-sorted/editorial/
@@ -163,7 +196,7 @@ public int maxChunksToSorted_1_2(int[] arr) {
     // V1-3
     // https://leetcode.com/problems/max-chunks-to-make-sorted/editorial/
     // IDEA:  Monotonic Increasing Stack
-    public int maxChunksToSorted(int[] arr) {
+    public int maxChunksToSorted_1_3(int[] arr) {
         int n = arr.length;
         // Stack to store the maximum elements of each chunk
         Stack<Integer> monotonicStack = new Stack<>();

leetcode_java/src/main/java/dev/workspace6.java

@@ -1165,7 +1165,7 @@ private List<List<Integer>> getIsland(int[][] grid, int x, int y, List<List<Inte
 
     // LC 769
     // https://leetcode.com/problems/max-chunks-to-make-sorted/
-    // 3.02 pm - 3.20 pm
+    // 1.24 pm - 1.35 pm
     /**
      *
      * We split arr into some number of chunks (i.e., partitions),
@@ -1206,40 +1206,101 @@ private List<List<Integer>> getIsland(int[][] grid, int x, int y, List<List<Inte
      *
      *
      */
+    /**
+     *  IDEA V2: pre-fix sum
+     *
+     *  -> to check if the array can be split into sub array and sorted,
+     *     then finally can concatenate and as same as the original array
+     *
+     *   Exp 1: arr = [4,3,2,1,0] -> res = 1
+     *
+     *   -> sorted arr = [0,1,2,3,4]
+     *
+     *   -> arrList = [4,3,2,1,0]
+     *   -> preFixSum = [4,7,9,10,10]
+     *
+     *
+     *
+     *   Exp 2:
+     *
+     *    arr = [1,0,2,3,4] -> res = 4
+     *
+     *    -> sorted arr = [0,1,2,3,4]
+     *
+     *    [1,0,2,3,4]
+     *
+     *  ->  arrList =   [1,0,2,3,4]
+     *  ->  preFixSum = [1,0,3,6,10]
+     *
+     *
+     *
+     *
+     */
     public int maxChunksToSorted(int[] arr) {
 
       // edge
       if (arr.length == 1) {
           return 1;
       }
 
-      // copy
-      int[] arr_before = arr; // ??
-      Arrays.sort(arr);
-
-      // 2 pointers
-      int res = 1;
-      List<Integer> tmp = new ArrayList<>();
-      for (int i = 0; i < arr.length-1; i++){
-          for(int j = i+1; j < arr_before.length; j++){
-              tmp.add(arr[j]);
-              // copy
-              List<Integer> tmp_copy = tmp; // ???
-              // sort
-              tmp_copy.sort(Integer::compareTo);
-//              if(tmp_copy  == tmp_copy){
-//
-//              }
+      List<Integer> preFixSortedSum = new ArrayList<>();
+      List<Integer> arrList = new ArrayList<>(); // ??
+
+      int preSortedSum = 0;
+      int preSum = 0;
+
+      // prefix sum
+      int cnt = 0;
+      for(int i = 0; i < arr.length; i++){
+          preSum += i;
+          preSortedSum += arr[i];
+
+          if(preSum != preSortedSum){
+              cnt += 1;
+          }else{
+              arrList.add(arr[i]);
+              preFixSortedSum.add(preSum);
           }
       }
 
-      String x = "abc";
-      String[] x_ = x.split("");
-
+      return cnt;
+    }
 
 
-      return res;
-    }
+//    public int maxChunksToSorted(int[] arr) {
+//
+//      // edge
+//      if (arr.length == 1) {
+//          return 1;
+//      }
+//
+//      // copy
+//      int[] arr_before = arr; // ??
+//      Arrays.sort(arr);
+//
+//      // 2 pointers
+//      int res = 1;
+//      List<Integer> tmp = new ArrayList<>();
+//      for (int i = 0; i < arr.length-1; i++){
+//          for(int j = i+1; j < arr_before.length; j++){
+//              tmp.add(arr[j]);
+//              // copy
+//              List<Integer> tmp_copy = tmp; // ???
+//              // sort
+//              tmp_copy.sort(Integer::compareTo);
+////              if(tmp_copy  == tmp_copy){
+////
+////              }
+//          }
+//      }
+//
+//      String x = "abc";
+//      String[] x_ = x.split("");
+//
+//
+//
+//      return res;
+//    }
 
     // LC 817
     // https://leetcode.com/problems/linked-list-components/