add 330

Author: fishercoder1534

README.md

@@ -231,6 +231,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |333|[Largest BST Subtree](https://leetcode.com/problems/largest-bst-subtree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_333.java)| O(n)|O(n) | Medium| Tree 
 |332|[Reconstruct Itinerary](https://leetcode.com/problems/reconstruct-itinerary/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_332.java)| O(n)|O(n) | Medium| Graph, DFS
 |331|[Verify Preorder Serialization of a Binary Tree](https://leetcode.com/problems/verify-preorder-serialization-of-a-binary-tree/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_331.java)| O(n)|O(n) | Medium| Stack
+|330|[Patching Array](https://leetcode.com/problems/patching-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_330.java)| O(m+logn)|O(1) | Hard| Greedy
 |329|[Longest Increasing Path in a Matrix](https://leetcode.com/problems/longest-increasing-path-in-a-matrix/)|[Solution](../master/src/main/java/com/fishercoder/solutions/LongestIncreasingPathInAMatrix.java)| O(?)|O(?) | Hard|
 |328|[Odd Even Linked List](https://leetcode.com/problems/odd-even-linked-list/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_328.java)| O(n)|O(1) | Medium| Linked List
 |327|[Count of Range Sum](https://leetcode.com/problems/count-of-range-sum/)|[Solution](../master/src/main/java/com/fishercoder/solutions/CountOfRangeSum.java)| O(?)|O(?) | Hard|

src/main/java/com/fishercoder/solutions/_330.java

@@ -0,0 +1,85 @@
+package com.fishercoder.solutions;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 330. Patching Array
+ *
+ * Given a sorted positive integer array nums and an integer n,
+ * add/patch elements to the array such that any number in 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:
+ nums = [1, 3], n = 6
+ Return 1.
+
+ 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:
+ nums = [1, 5, 10], n = 20
+ Return 2.
+ The two patches can be [2, 4].
+
+ Example 3:
+ nums = [1, 2, 2], n = 5
+ Return 0.
+ */
+public class _330 {
+
+    /**credit: https://leetcode.com/articles/patching-array/ and https://discuss.leetcode.com/topic/35494/solution-explanation/2
+     *
+     * Let miss be the smallest sum in [0,n] that we might be missing.
+     * Meaning we already know we can build all sums in [0,miss).
+     * Then if we have a number num <= miss in the given array,
+     * we can add it to those smaller sums to build all sums in [0,miss+num).
+     * If we don't, then we must add such a number to the array,
+     * and it's best to add miss itself, to maximize the reach.
+
+     Example: Let's say the input is nums = [1, 2, 4, 13, 43] and n = 100.
+     We need to ensure that all sums in the range [1,100] are possible.
+     Using the given numbers 1, 2 and 4, we can already build all sums from 0 to 7, i.e., the range [0,8).
+     But we can't build the sum 8, and the next given number (13) is too large.
+     So we insert 8 into the array. Then we can build all sums in [0,16).
+     Do we need to insert 16 into the array? No! We can already build the sum 3,
+     and adding the given 13 gives us sum 16.
+     We can also add the 13 to the other sums, extending our range to [0,29).
+     And so on. The given 43 is too large to help with sum 29, so we must insert 29 into our array.
+     This extends our range to [0,58).
+     But then the 43 becomes useful and expands our range to [0,101).
+     At which point we're done.*/
+
+    public int minPatches(int[] nums, int n) {
+        long misses = 1;//use long to avoid integer addition overflow
+        int patches = 0;
+        int i = 0;
+        while (misses <= n) {
+            if (i < nums.length && nums[i] <= misses) { //miss is covered
+                misses += nums[i++];
+            } else { //patch miss to the array
+                misses += misses;
+                patches++;//increase the answer
+            }
+        }
+        return patches;
+    }
+
+    public List<Integer> findPatches(int[] nums, int n) {
+        long misses = 1;//use long to avoid integer addition overflow
+        List<Integer> patches = new ArrayList<>();
+        int i = 0;
+        while (misses <= n) {
+            if (i < nums.length && nums[i] <= misses) { //miss is covered
+                misses += nums[i++];
+            } else { //patch miss to the array
+                patches.add((int) misses);//increase the answer
+                misses += misses;
+            }
+        }
+        return patches;
+    }
+
+}

src/test/java/com/fishercoder/_330Test.java

@@ -0,0 +1,32 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._330;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Created by stevesun on 6/12/17.
+ */
+public class _330Test {
+    private static _330 test;
+    private static int[] nums;
+
+    @BeforeClass
+    public static void setup(){
+        test = new _330();
+    }
+
+    @Test
+    public void test1(){
+        nums = new int[]{1, 2, 4, 13, 43};
+        List<Integer> expected = new ArrayList(Arrays.asList(8, 29));
+        assertEquals(expected, test.findPatches(nums, 100));
+        assertEquals(2, test.minPatches(nums, 100));
+    }
+}