题目描述
给你一个正整数数组 price ，其中 price[i] 表示第 i 类糖果的价格，另给你一个正整数 k 。
商店组合 k 类 不同 糖果打包成礼盒出售。礼盒的 甜蜜度 是礼盒中任意两种糖果 价格 绝对差的最小值。
返回礼盒的 最大 甜蜜度。
示例 1：
输入：price = [13,5,1,8,21,2], k = 3
输出：8
解释：选出价格分别为 [13,5,21] 的三类糖果。
礼盒的甜蜜度为 min(|13 - 5|, |13 - 21|, |5 - 21|) = min(8, 8, 16) = 8 。
可以证明能够取得的最大甜蜜度就是 8 。
示例 2：
输入：price = [1,3,1], k = 2
输出：2
解释：选出价格分别为 [1,3] 的两类糖果。
礼盒的甜蜜度为 min(|1 - 3|) = min(2) = 2 。
可以证明能够取得的最大甜蜜度就是 2 。
示例 3：
输入：price = [7,7,7,7], k = 2
输出：0
解释：从现有的糖果中任选两类糖果，甜蜜度都会是 0 。
提示：
2 <= k <= price.length <= 1051 <= price[i] <= 109
解法
方法一：贪心 + 二分查找
我们注意到，如果一个甜蜜度为 $x$ 的礼盒是可行的，那么甜蜜度小于 $x$ 的礼盒也是可行的，这存在着单调性，因此我们可以使用二分查找的方法，找到最大的可行甜蜜度。
我们首先将数组 $price$ 排序，然后定义二分查找的左边界 $l=0$, $r=price[n-1]-price[0]$。每一次，我们计算出当前的中间值 $mid = \lfloor \frac{l+r+1}{2} \rfloor$，以 $mid$ 作为甜蜜度，判断是否可行。若可行，那么我们将左边界 $l$ 更新为 $mid$，否则将右边界 $r$ 更新为 $mid-1$。最后返回 $l$ 即可。
那么问题的关键转化为：判断一个甜蜜度是否可行，我们通过函数 $check(x)$ 来实现。函数 $check(x)$ 的执行逻辑如下：
定义一个变量 $cnt$ 表示当前已经选取的糖果的数量，初始值为 $0$，定义一个变量 $pre$ 表示上一个选取的糖果的价格，初始值为 $-x$。然后我们遍历排好序的数组 $price$，对于每一个糖果的价格 $cur$，如果 $cur-pre \geq x$，那么我们就选取这个糖果，将 $pre$ 更新为 $cur$，并将 $cnt$ 加一。最后判断 $cnt$ 是否大于等于 $k$，如果是，那么返回 $true$，否则返回 $false$。
时间复杂度 $O(n \times (\log n + \log M))$，空间复杂度 $O(\log n)$。其中 $n$ 是数组 $price$ 的长度；而 $M$ 是数组 $price$ 中的最大值，本题中 $M \leq 10^9$。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 | class Solution:
def maximumTastiness(self, price: List[int], k: int) -> int:
def check(x: int) -> bool:
cnt, pre = 0, -x
for cur in price:
if cur - pre >= x:
pre = cur
cnt += 1
return cnt >= k
price.sort()
l, r = 0, price[-1] - price[0]
while l < r:
mid = (l + r + 1) >> 1
if check(mid):
l = mid
else:
r = mid - 1
return l
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 | class Solution {
public int maximumTastiness(int[] price, int k) {
Arrays.sort(price);
int l = 0, r = price[price.length - 1] - price[0];
while (l < r) {
int mid = (l + r + 1) >> 1;
if (check(price, k, mid)) {
l = mid;
} else {
r = mid - 1;
}
}
return l;
}
private boolean check(int[] price, int k, int x) {
int cnt = 0, pre = -x;
for (int cur : price) {
if (cur - pre >= x) {
pre = cur;
++cnt;
}
}
return cnt >= k;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 | class Solution {
public:
int maximumTastiness(vector<int>& price, int k) {
sort(price.begin(), price.end());
int l = 0, r = price.back() - price[0];
auto check = [&](int x) -> bool {
int cnt = 0, pre = -x;
for (int& cur : price) {
if (cur - pre >= x) {
pre = cur;
++cnt;
}
}
return cnt >= k;
};
while (l < r) {
int mid = (l + r + 1) >> 1;
if (check(mid)) {
l = mid;
} else {
r = mid - 1;
}
}
return l;
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13 | func maximumTastiness(price []int, k int) int {
sort.Ints(price)
return sort.Search(price[len(price)-1], func(x int) bool {
cnt, pre := 0, -x
for _, cur := range price {
if cur-pre >= x {
pre = cur
cnt++
}
}
return cnt < k
}) - 1
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 | function maximumTastiness(price: number[], k: number): number {
price.sort((a, b) => a - b);
let l = 0;
let r = price[price.length - 1] - price[0];
const check = (x: number): boolean => {
let [cnt, pre] = [0, -x];
for (const cur of price) {
if (cur - pre >= x) {
pre = cur;
++cnt;
}
}
return cnt >= k;
};
while (l < r) {
const mid = (l + r + 1) >> 1;
if (check(mid)) {
l = mid;
} else {
r = mid - 1;
}
}
return l;
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 | public class Solution {
public int MaximumTastiness(int[] price, int k) {
Array.Sort(price);
int l = 0, r = price[price.Length - 1] - price[0];
while (l < r) {
int mid = (l + r + 1) >> 1;
if (check(price, mid, k)) {
l = mid;
} else {
r = mid - 1;
}
}
return l;
}
private bool check(int[] price, int x, int k) {
int cnt = 0, pre = -x;
foreach (int cur in price) {
if (cur - pre >= x) {
++cnt;
pre = cur;
}
}
return cnt >= k;
}
}
|