Middle-题目69：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.
题目大意：
给出一个列表nums和一个目标值n，计算至少还需要补充几个数，才能使得列表nums中的数可以组合成[1,n]的所有整数（不允许重复）。
题目分析：
算法思路来自http://www.bubuko.com/infodetail-1345277.html这篇文章，大致是这样的：
算法先定义miss代表目前[1,n]之间不能表示的最小数（或者表述为[1,miss-1]都能表示出来），因为数组还没遍历，所以目前连1都表示不了。接下来遍历数组，如果当前的数num<=miss，则更新miss为miss+num(道理很简单，1~miss-1都可表示，那必然包含了1~num，那么必然1~miss-1+num都可表示了)，如果num>miss,则我们就需要补充一个数，为了补充的数最少，我们补充miss这个数，这样就能表示到miss*2这么多了，故更新miss=miss*2(因为我们补充了miss，所以现在不能表示的最小数就是miss*2)以此类推直到miss>n。
源码：（language：java）

public class Solution {
    public int minPatches(int[] nums, int n) {
        long miss = 1;
        int add = 0;
        int i = 0;
        while (miss <= n) {
            if (i < nums.length && nums[i] <= miss){
                miss += nums[i++];
            } else {
                miss += miss;
                add += 1;
            }
        }

        return add;
    }

}

成绩：
1ms,beats 15%,众数1ms，85%
Cmershen的碎碎念：
这是一个很巧妙的贪心算法，不参考博客我是想不到。有一个需要注意的就是miss声明为long，这是因为n很大时，计算miss*2可能会溢出。
其实贪心法的题都挺难。。。。。。。。。。。。。。。