按照LC的尿性,最小/大化最大/小值,九成九的二分板子。暴搜一定是TLE的。
这种题都有单调性质:参数值越xxx,结果越xxx。
1. LC 2064 分配给商店的最多商品的最小值
可以发现这个分配给商店的商品数目的最大值越大,就越能把商品分配完。
比如说6家商店,两种商品[11,6],如果最大值取11的话,两家店就能把商品分完(可以存在商店的分配商品数量为0)。
但如果最大值取1,6家店顶多分6件商品,分不完的。即上述单调性质:分配商品的最大值越大,就越能在商店耗尽前将商品分配完。则二分这个最大值,求这个最大值的最小值。
下限可取1(0显然错,手动排了)。上限可取单种商品数量的最大值(再大的话不够分的,一家店最多有一种商品)
检查时对任意一种商品,先尽可能按最大值分,不够了再把剩下的分给某一家店。按这个策略如果在商品分完前商店提前耗尽,代表这个值不能取(return n≥0)。
import java.util.Arrays;
class Solution {
public int minimizedMaximum(int n, int[] quantities) {
int lp,rp,mid,ans;
ans = -1;
lp = 1;
rp = Arrays.stream(quantities).max().getAsInt()+1;
while(lp<rp){
mid = lp + (rp-lp)/2;
if(check(mid,n,quantities)){
ans = mid;
rp = mid;
}else{
lp = mid+1;
}
}
return ans;
}
private boolean check(int mid,int n,int[] quantities){
for (int quantity : quantities) {
n -= (int) Math.ceil((double)quantity/mid);
if(n<0){
break;
}
}
return n>=0;
}
}
2. LC 1760 袋子里最少数目的球
这题是不能用贪心的。举个例子:
nums=[9] maxOperation=2
9→[6,3]→[3,3,3]
但如果贪心每次分一半,则结果为[4,3,2]。对半分不一定是最优的。因为它看的不是平均值,是最大值。
因此还得是二分。单调性:对于任意最大值m
- 若可以通过max次分割得到m,则一定通过≤max次划分得到>m。
- 若可以通过max次分割不能得到m,则通过max次划分不可能得到<m。
下限:0
上限:本来应该取数组中的最大值。但题面给了数据范围1e9,那就直接用了。
检查:对于每个>mid的数,都要分割为≤mid的多个数,那就检查能容纳几个mid就行了,别忘了-1,因为是1个划分成2个,不是凭空0个变2个。
import java.util.PriorityQueue;
class Solution {
public int minimumSize(int[] nums, int maxOperations) {
int lp,rp,mid,ans;
ans = -1;
lp = 0;
rp = (int) (1e9+1);
while(lp<rp){
mid = ((rp-lp)>>>1)+lp;
if(check(nums,maxOperations,mid)){
ans = mid;
rp = mid;
}else{
lp = mid+1;
}
}
return ans;
}
private boolean check(int[] nums,int maxOps,int mid){
long cmp = 0L;
for (int num : nums) {
cmp += (int)Math.ceil((double)num/mid)-1;
}
return cmp <= maxOps;
}
}
3. LC 2439 最小化数组中的最大值
这题难在检查。
单调性:对于任意最大值m
- 若任意次操作能得到m,则一定能得到>m。(大不了少减一次)
- 若任意次操作不能得到m,则一定不能得到≤m。
下限:非负整数,0
上限:整个数组的最大值(一次不动就能得到,不可能越优化越大了)
检查:
这题检查是个难点。本质上就是可以把大于二分结果mid的元素的溢出部分转移到它前面一个元素上去。因此最好的方式是从后向前遍历,把溢出部分转移到前一个元素。那么最终所有的压力都将由nums[0]来承担。
这里的trick是,不需要对原数组进行操作以免对原有内存数据进行破坏(或者是clone一个新数组,但这样很浪费内存)。而是使用两个变量进行滚动数组,由前者承担来自后者的压力。
另外,记得开long,虽然数组是int的,但int+int可能溢出(WA的教训捏)
import java.util.Arrays;
class Solution {
public int minimizeArrayValue(int[] nums) {
long lp,rp,mid,ans;
ans = -1;
lp = 0;
rp = Arrays.stream(nums).max().getAsInt()+1;
while(lp<rp){
mid = ((rp-lp)>>>1)+lp;
if(check(nums,mid)){
ans = mid;
rp = mid;
}else{
lp = mid+1;
}
}
return (int) ans;
}
private boolean check(int[] nums, long mid){
long pre,cur;
cur = nums[nums.length-1];
pre = nums[nums.length-2]+(cur>mid?cur-mid:0);
for(int i = nums.length-1;i>=1;i--){
pre = nums[i-1];
if(cur>mid){
pre += cur-mid;
}
cur = pre;
}
return pre<=mid;
}
}
这样的复杂度就是lgn的二分里面套个n的遍历,总体O(nlgn),其实不是这题的复杂度最优解。这题的最优解是数学结论+前缀和,放到前缀和题解了。
4. LC 2560 打家劫舍Ⅳ
打家劫舍系列一般是DP,这道题是二分。
对于最小窃取能力二分:
- 单调性:对于任意窃取能力m
- 若能窃取最大值≤m的k间不连续房间,那么也能窃取最大值≤ >m的k间不连续房间
- 若不能窃取最大值≤m的k间不连续房间,那么也不能窃取最大值≤ <m的k间不连续房间
- 下限:整个数组的最小值
- 上限:整个数组的最大值
- 检查:可以把所有≤mid的数的索引挑出来,很显然从这个列表的最开始选取,并跳过与当前索引相邻的位置,直到选完k个就可以通过检查。
import java.util.Arrays;
class Solution {
public int minCapability(int[] nums, int k) {
int lp,rp,mid,ans;
lp = Arrays.stream(nums).min().getAsInt();
rp = Arrays.stream(nums).max().getAsInt()+1;
ans = rp-1;
while(lp<rp){
mid = ((rp-lp)>>>1)+lp;
if(check(nums,k,mid)){
ans = mid;
rp = mid;
}else{
lp = mid+1;
}
}
return ans;
}
private boolean check(int[] nums,int k,int mid){
int prev = 0;
for (int i = 0; i < nums.length; i++) {
if(nums[i]<=mid){
prev = i;
k--;
break;
}
}
if(k==0){
return true;
}
int index = prev+1;
while(index<nums.length){
if(index-prev>1 && nums[index]<=mid){
prev = index;
k--;
if(k==0){
return true;
}
}
index++;
}
return k==0;
}
}
复杂度O(nlogi),i是数组中的最大值(最大1e9)
5. LC 410 分割数组的最大值
每日一题,hard难度。但我感觉很明显没有hard的水平,放到周赛可能也就是1600到1700分的水平吧。
二分最小值:
-
单调性:对于任意最小值m
- 如果存在一种分割方式使得m满足题意,那么很明显>m也能满足题意(维持原样就行了)
- 如果不存在一种分割方式使得m满足题意,那么<m也不能满足题意
-
上界:整个数组和
-
下界:子数组非空,所以是数组中的最大元素
-
检查:子数组肯定是原序且连续的,所以直接消耗mid即可,消耗完了新开一轮,最终消耗的轮数应该≤k,也即k减少到最后应该≥0,不然就视为这个mid过于小导致分的组数太多,使得k不堪重负。
可能会疑惑充分性。可以这样想,因为前面的轮数全部满足子数组和≤mid,所以从前面的子数组中拆一个元素出来给k剩下的轮次,也一定满足≤mid。题目保证k≤nums.length,所以就保证了这个充分性(不至于空)
import java.util.Arrays; class Solution { public int splitArray(int[] nums, int k) { int lp,rp,mid,ans; lp = Arrays.stream(nums).max().getAsInt(); rp = Arrays.stream(nums).sum()+1; ans = rp-1; while(lp<rp){ mid = ((rp-lp)>>>1)+lp; if(check(nums,k,mid)){ ans = mid; rp = mid; }else{ lp = mid+1; } } return ans; } private boolean check(int[] nums,int k,int mid){ int rest = mid; k--; for (int i = 0; i < nums.length; ) { if(rest>=nums[i]){ rest -= nums[i]; i++; }else{ rest = mid; k--; } } return k>=0; } }
你看看这个代码量,是hard么(