Added tasks 330, 331.

Author: javadev

src/main/java/g0301_0400/s0330_patching_array/Solution.java

@@ -0,0 +1,20 @@
+package g0301_0400.s0330_patching_array;
+
+public class Solution {
+    public int minPatches(int[] nums, int n) {
+        int res = 0;
+        long sum = 0;
+        int i = 0;
+        while (sum < n) {
+            // required number
+            long req = sum + 1;
+            if (i < nums.length && nums[i] <= req) {
+                sum += nums[i++];
+            } else {
+                sum += req;
+                res++;
+            }
+        }
+        return res;
+    }
+}

src/main/java/g0301_0400/s0330_patching_array/readme.md

@@ -0,0 +1,41 @@
+330\. Patching Array
+
+Hard
+
+Given a sorted integer array `nums` and an integer `n`, add/patch elements to the array such that any number in the range `[1, n]` inclusive can be formed by the sum of some elements in the array.
+
+Return _the minimum number of patches required_.
+
+**Example 1:**
+
+**Input:** nums = \[1,3\], n = 6
+
+**Output:** 1
+
+**Explanation:**
+
+    Combinations of nums are [1], [3], [1,3], which form possible sums of: 1, 3, 4.
+    Now if we add/patch 2 to nums, the combinations are: [1], [2], [3], [1,3], [2,3], [1,2,3].
+    Possible sums are 1, 2, 3, 4, 5, 6, which now covers the range [1, 6].
+    So we only need 1 patch. 
+
+**Example 2:**
+
+**Input:** nums = \[1,5,10\], n = 20
+
+**Output:** 2
+
+**Explanation:** The two patches can be \[2, 4\]. 
+
+**Example 3:**
+
+**Input:** nums = \[1,2,2\], n = 5
+
+**Output:** 0 
+
+**Constraints:**
+
+*   `1 <= nums.length <= 1000`
+*   <code>1 <= nums[i] <= 10<sup>4</sup></code>
+*   `nums` is sorted in **ascending order**.
+*   <code>1 <= n <= 2<sup>31</sup> - 1</code>

src/main/java/g0301_0400/s0331_verify_preorder_serialization_of_a_binary_tree/Solution.java

@@ -0,0 +1,18 @@
+package g0301_0400.s0331_verify_preorder_serialization_of_a_binary_tree;
+
+public class Solution {
+    public boolean isValidSerialization(String preorder) {
+        int count = 1;
+        int length = preorder.length();
+        for (int i = 1; i <= length; i++) {
+            if (i == length || preorder.charAt(i) == ',') {
+                --count;
+                if (count < 0) {
+                    return false;
+                }
+                count += preorder.charAt(i - 1) == '#' ? 0 : 2;
+            }
+        }
+        return count == 0;
+    }
+}

src/main/java/g0301_0400/s0331_verify_preorder_serialization_of_a_binary_tree/readme.md

@@ -0,0 +1,42 @@
+331\. Verify Preorder Serialization of a Binary Tree
+
+Medium
+
+One way to serialize a binary tree is to use **preorder traversal**. When we encounter a non-null node, we record the node's value. If it is a null node, we record using a sentinel value such as `'#'`.
+
+![](https://assets.leetcode.com/uploads/2021/03/12/pre-tree.jpg)
+
+For example, the above binary tree can be serialized to the string `"9,3,4,#,#,1,#,#,2,#,6,#,#"`, where `'#'` represents a null node.
+
+Given a string of comma-separated values `preorder`, return `true` if it is a correct preorder traversal serialization of a binary tree.
+
+It is **guaranteed** that each comma-separated value in the string must be either an integer or a character `'#'` representing null pointer.
+
+You may assume that the input format is always valid.
+
+*   For example, it could never contain two consecutive commas, such as `"1,,3"`.
+
+**Note: **You are not allowed to reconstruct the tree.
+
+**Example 1:**
+
+**Input:** preorder = "9,3,4,#,#,1,#,#,2,#,6,#,#"
+
+**Output:** true 
+
+**Example 2:**
+
+**Input:** preorder = "1,#"
+
+**Output:** false 
+
+**Example 3:**
+
+**Input:** preorder = "9,#,#,1"
+
+**Output:** false 
+
+**Constraints:**
+
+*   <code>1 <= preorder.length <= 10<sup>4</sup></code>
+*   `preorder` consist of integers in the range `[0, 100]` and `'#'` separated by commas `','`.

src/test/java/g0301_0400/s0330_patching_array/SolutionTest.java

@@ -0,0 +1,13 @@
+package g0301_0400.s0330_patching_array;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.Test;
+
+public class SolutionTest {
+    @Test
+    public void minPatches() {
+        assertThat(new Solution().minPatches(new int[] {1, 3}, 6), equalTo(1));
+    }
+}

src/test/java/g0301_0400/s0331_verify_preorder_serialization_of_a_binary_tree/SolutionTest.java

@@ -0,0 +1,13 @@
+package g0301_0400.s0331_verify_preorder_serialization_of_a_binary_tree;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.Test;
+
+public class SolutionTest {
+    @Test
+    public void minPatches() {
+        assertThat(new Solution().isValidSerialization("9,3,4,#,#,1,#,#,2,#,6,#,#"), equalTo(true));
+    }
+}