1. 题目
给定一个已排序的正整数数组 nums,和一个正整数 n 。从 [1, n] 区间内选取任意个数字补充到 nums 中,使得 [1, n] 区间内的任何数字都可以用 nums 中某几个数字的和来表示。请输出满足上述要求的最少需要补充的数字个数。
示例 1:
输入: nums = [1,3], n = 6
输出: 1
解释:
根据 nums 里现有的组合 [1], [3], [1,3],可以得出 1, 3, 4。
现在如果我们将 2 添加到 nums 中, 组合变为: [1], [2], [3], [1,3], [2,3], [1,2,3]。
其和可以表示数字 1, 2, 3, 4, 5, 6,能够覆盖 [1, 6] 区间里所有的数。
所以我们最少需要添加一个数字。
示例 2:
输入: nums = [1,5,10], n = 20
输出: 2
解释: 我们需要添加 [2, 4]。
示例 3:
输入: nums = [1,2,2], n = 5
输出: 0
2.思路
这个题目是个贪心的思路,假如目前有K个数字,其任意和能够构成[1, M)这个区间的任意数,但无法构成M,那么我们需要插入一个小于等于M的数来使得可以构成M。假如我们插入一个数X(1<=X<=M)。那么我们可以得到这K+1个数能够构成[1,M+X)区间的任意数。根据贪心的思想,如果使得X尽可能的大,那么构成的区间就越大。所以这里可以选择M作为插入数。
据上所述,遍历num,找到当前能够组成的最大数M-1,判断下一个数是否小于等于M,如果大于则说明需要插入一个数(此时插入M最佳)。如果小于等于则继续累加最大值。
贪心的证明思路(取自Leetcoder):
引理
若贪婪算法需要增加 kk 个数字来覆盖 [1, n][1,n],不可能使用少于 kk 个数字来实现。
反证法
对于给定的数字
n
n
n 和数组
n
u
m
s
nums
nums,假设贪心算法找到的
k
k
k 个补充数字是
X
1
<
X
2
<
.
.
.
<
X
k
<
=
n
X_1<X_2<...<X_k<=n
X1<X2<...<Xk<=n数字集合
Y
1
<
Y
2
<
.
.
.
<
Y
k
′
<
=
n
Y_1<Y_2<...<Y_{k'}<=n
Y1<Y2<...<Yk′<=n,其中
k
′
<
k
k'<k
k′<k,则有
Y
1
<
X
1
Y_1<X_1
Y1<X1,否则
X
1
X_1
X1就无法覆盖,又因为增加
X
1
X_1
X1不能覆盖
X
2
X_2
X2,这意味着全部元素的和,包括
X
1
X_1
X1,小于
X
2
X_2
X2。因此增加
Y
1
Y_1
Y1也不能覆盖
X
2
X_2
X2,于是有:
Y 2 < = X 2 Y_2<=X_2 Y2<=X2
否则 X 2 X_2 X2无法被覆盖,以此类推。
Y i < = X i , i = 1 , 2..... k ′ Y_i<=X_i,i = 1,2.....k' Yi<=Xi,i=1,2.....k′
最终,可以看到由于 X 1 , X 2 , . . . X k ′ X_1,X_2,...X_{k'} X1,X2,...Xk′不足以覆盖 X k X_k Xk,因此 Y 1 , Y 2 , . . . Y k ′ Y_1,Y_2,...Y_{k'} Y1,Y2,...Yk′也不足以覆盖 X k < = n X_k<=n Xk<=n。这与 Y 1 < Y 2 < . . . < Y k ′ < = n Y_1<Y_2<...<Y_{k'}<=n Y1<Y2<...<Yk′<=n能覆盖[1,n]矛盾。
Q.E.D. 证毕。
因此,贪婪算法将始终返回尽可能少的补充个数。即使对于特定案例,可能有许多不同的方案。但是,没有一个解法的所用个数会比贪婪算法少。
2. 代码
class Solution {
public:
int minPatches(vector<int>& nums, int n) {
long ret = 0, k = 0, size = nums.size();
for(int i = 0; k < n;)
{
if(i >= size || nums[i] > k + 1)
{
k = (k << 1) + 1;
ret ++;
}
else
{
k += nums[i];
++i;
}
}
return ret;
}
};