add 769

fishercoder1534 · fishercoder1534 · commit a27f28aea2e4 · 2018-03-29T18:11:46.000-07:00
diff --git a/README.md b/README.md
@@ -33,6 +33,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |779|[K-th Symbol in Grammar](https://leetcode.com/problems/k-th-symbol-in-grammar/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_779.java) | O(logn) | O(1) | |Medium|
 |776|[Split BST](https://leetcode.com/problems/split-bst/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_776.java) | O(n) | O(n) | |Medium| Recursion
 |771|[Jewels and Stones](https://leetcode.com/problems/jewels-and-stones/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_771.java) | O(n) | O(m) | |Easy|
+|769|[Max Chunks To Make Sorted](https://leetcode.com/problems/max-chunks-to-make-sorted/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_769.java) | O(n) | O(1) | |Medium| Array
 |767|[Reorganize String](https://leetcode.com/problems/reorganize-string/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_767.java) | O(klogk) k is the number of unique characters in given String| O(k) | |Medium|
 |766|[Toeplitz Matrix](https://leetcode.com/problems/toeplitz-matrix/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_766.java) | O(m*n) | O(1) | |Easy|
 |765|[Couples Holding Hands](https://leetcode.com/problems/couples-holding-hands/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_765.java) | O(n^2) | O(1) | |Hard| 
diff --git a/src/main/java/com/fishercoder/solutions/_769.java b/src/main/java/com/fishercoder/solutions/_769.java
@@ -0,0 +1,72 @@
+package com.fishercoder.solutions;
+
+/**
+ * 769. Max Chunks To Make Sorted
+
+ Given an array arr that is a permutation of [0, 1, ..., arr.length - 1], we split the array into some number of "chunks" (partitions), and individually sort each chunk.
+ After concatenating them, the result equals the sorted array.
+
+ What is the most number of chunks we could have made?
+
+ Example 1:
+
+ Input: arr = [4,3,2,1,0]
+ Output: 1
+ Explanation:
+ Splitting into two or more chunks will not return the required result.
+ For example, splitting into [4, 3], [2, 1, 0] will result in [3, 4, 0, 1, 2], which isn't sorted.
+
+ Example 2:
+
+ Input: arr = [1,0,2,3,4]
+ Output: 4
+ Explanation:
+ We can split into two chunks, such as [1, 0], [2, 3, 4].
+ However, splitting into [1, 0], [2], [3], [4] is the highest number of chunks possible.
+
+ Note:
+
+ arr will have length in range [1, 10].
+ arr[i] will be a permutation of [0, 1, ..., arr.length - 1].
+
+ */
+public class _769 {
+  public static class Solution1 {
+    /**credit: https://leetcode.com/problems/max-chunks-to-make-sorted/discuss/113520/Java-solution-left-max-and-right-min.*/
+    public int maxChunksToSorted(int[] arr) {
+      int len = arr.length;
+
+      int[] maxOfLeft = new int[len];
+      maxOfLeft[0] = arr[0];
+      for (int i = 1; i < len; i++) {
+        maxOfLeft[i] = Math.max(arr[i], maxOfLeft[i - 1]);
+      }
+
+      int[] minOfRight = new int[len];
+      minOfRight[len - 1] = arr[len - 1];
+      for (int i = len - 2; i >= 0; i--) {
+        minOfRight[i] = Math.min(minOfRight[i + 1], arr[i]);
+      }
+
+      int result = 0;
+      for (int i = 0; i < len - 1; i++) {
+        if (maxOfLeft[i] <= minOfRight[i + 1]) {
+          result++;
+        }
+      }
+      return result + 1;
+    }
+  }
+
+  public static class Solution2 {
+    /**credit: https://leetcode.com/articles/max-chunks-to-make-sorted-i/*/
+    public int maxChunksToSorted(int[] arr) {
+      int ans = 0, max = 0;
+      for (int i = 0; i < arr.length; ++i) {
+        max = Math.max(max, arr[i]);
+        if (max == i) ans++;
+      }
+      return ans;
+    }
+  }
+}
diff --git a/src/test/java/com/fishercoder/_769Test.java b/src/test/java/com/fishercoder/_769Test.java
@@ -0,0 +1,33 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._769;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _769Test {
+  private static _769.Solution1 solution1;
+  private static _769.Solution2 solution2;
+  private static int[] arr;
+
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _769.Solution1();
+    solution2 = new _769.Solution2();
+  }
+
+  @Test
+  public void test1() {
+    arr = new int[] {4, 3, 2, 1, 0};
+    assertEquals(1, solution1.maxChunksToSorted(arr));
+    assertEquals(1, solution2.maxChunksToSorted(arr));
+  }
+
+  @Test
+  public void test2() {
+    arr = new int[] {1, 0, 2, 3, 4};
+    assertEquals(4, solution1.maxChunksToSorted(arr));
+    assertEquals(4, solution2.maxChunksToSorted(arr));
+  }
+}
