按照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么（
1268
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
