[算法分享]每日一题1：二分

寒假每日一题

Day1-分巧克力

题目来源：第八届蓝桥杯省赛

先说算法：二分。简单讲一下二分吧。

使用二分算法的场景

1.能运用某种规则将目标序列划分为连续的两段。为表示方便，下称作A段和B段。如图将某序列划分为两段。

🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟩🟩🟩🟩🟩🟩

其中红色为A段，绿色为B段

再举个例子

1 2 3 4 5 5 5 5 6 7 8 9

这是按照规则 $>=5$ 划分的AB段

1 2 3 4 5 5 5 5 6 7 8 9

这是按照规则 $<=5$ 划分的AB段

2.所求的目标元素在A段最右边或者为B段最左边

🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟥🟩🟩🟩🟩🟩🟩

比如这个例子中的最右边的红色块，或者最左边的绿色块。

1 2 3 4 5 5 5 5 6 7 8 9

1 2 3 4 5 5 5 5 6 7 8 9

以及这两个例子中的用下划线标记出来的元素

注意⚠️只有满足以上两个条件的题目才可以考虑使用二分

代码实现

二分的算法原理大家应该已经很明白了，我就不在这赘述了，着重讲一下代码

1整数二分

绝大多数题目的目标序列元素都为下标，也即离散的数字，这种离散的元素极易产生边界问题。故将整数二分问题按情况分为两种类型，⚠️请仔细阅读接下来写的两种类型的分类特征和代码写法，并背下来，这并不困难。

❤️第一种情况为：

1.找A段最右边的元素

2.取中点 $mid=(l+r+1)/2$

3.用A段性质检验中点：若满足则 $l=mid$ 反之 $r=mid-1$

4.重复2-3直至 $l=r$ 此时 $l=r=target$

❤️第二种情况为：

1.找B段最左边的元素

2.取中点 $mid=(l+r)/2$

3.用A段性质检验中点：若满足则 $r=mid$ 反之 $l=mid+1$

4.重复2-3直至 $l=r$ 此时 $l=r=target$

💛仔细注意两种情况的代码差别，其实很好记忆，拿到问题后按照求解的目标元素是归属于A段还是B段写对应代码即可。若为A段，则每次划分解空间为 $[l,mid-1],[mid,r]$ 若为B段则每次划分为 $[l,mid],[mid+1,r]$ .

举例子来说明

1 2 3 4 5 5 5 5 6 7 8 9

要找到改序列第一个出现的5的位置，则对应的是找B段的最左元素，代码如下。

#include <iostream>
using namespace std;

int num[12] = { 1,2,3,4,5,5,5,5,6,7,8,9 };

int main() {
    int l = 0, r = 11;
    while (l < r) {
        int mid = l + r >> 1;
        if (num[mid] >= 5)r = mid;
        else l = mid + 1;
    }
    cout << l;
    return 0;
}

1 2 3 4 5 5 5 5 6 7 8 9

要找到改序列最后一个出现的5的位置，则对应的是找A段的最右元素，代码如下。

#include <iostream>
using namespace std;

int num[12] = { 1,2,3,4,5,5,5,5,6,7,8,9 };

int main() {
    int l = 0, r = 11;
    while (l < r) {
        int mid = l + r + 1 >> 1;
        if (num[mid] <= 5)l = mid;
        else r = mid - 1;
    }
    cout << l;
    return 0;
}

这两个例子也即可以解决力扣34题。代码如下

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        vector<int> ans;
		if (nums.empty()) {
			ans.push_back(-1);
			ans.push_back(-1);
			return ans;
		}
		int p1 = 0, p2 = nums.size()-1;
		while (p1 < p2) {
			int mid = p1 + p2 >> 1;
			if (nums[mid] >= target)p2 = mid;
			else p1 = mid + 1;
		}
		if (nums[p1] != target) {
			ans.push_back(-1);
			ans.push_back(-1);
			return ans;
		}
		ans.push_back(p1);
		while (nums[p1] == target) { 
			p1++;
			if (p1 == nums.size())break;
		}
		ans.push_back(p1 - 1);
		return ans;
    }
};

再拿个题举例子，力扣1889

对于这一题，我们需要用尽可能小的箱子来装包裹，也即我们将包裹序列进行排序后可以通过是否能装进箱子来把序列划分成连续的两段。从小到大枚举箱子，对于每个箱子尽可能装多的包裹，即满足题意。综上，对于每个箱子我们仅需找到包裹序列中的A段最右元素。

代码如下。

class Solution {
public:
    const long long mod = 1000000007;
    int minWastedSpace(vector<int>& packages, vector<vector<int> >& boxes) {
        long long ans = LLONG_MAX;
        sort(packages.begin(), packages.end());
        int n = packages.size();
        int m = boxes.size();

        vector<long long> sum(n + 1, 0);
        for (int i = 1; i <= n; i++)sum[i] = sum[i - 1] + packages[i - 1];	//前缀和
        for (int i = 0; i < m; i++) {   //遍历每一个供应商
            int k = boxes[i].size();
            sort(boxes[i].begin(), boxes[i].end());
            if (boxes[i][k - 1] < packages[n - 1])continue; //无法装箱的情况
            long long res = 0;
            int l = 0, r = n - 1;
            int start = 0;
            for (int j = 0; j < k; j++) {  //遍历每一个箱子
                if (boxes[i][j] < packages[start])continue; //无法装箱的情况
                l = start;
                r = n - 1;
                while (l < r) {
                    int mid = l + r + 1 >> 1;
                    if (packages[mid] <= boxes[i][j])l = mid;
                    else r = mid - 1;
                }
                if (packages[l] > boxes[i][j])continue;
                res += ((long long)boxes[i][j] * (l - start + 1) - sum[l + 1] + sum[start]);
                start = l + 1;
                if (start == n) break;
            }
            ans = min(res, ans);
        }
        if (ans != LLONG_MAX)return ans % mod;
        else return -1;
    }
};

回到今天这题上来，我们可以按照可不可以划分成K块来划分边长序列，我们要使巧克力的边长尽可能大，即找A段最右边的元素

#include <iostream>
using namespace std;

const int N = 100010;

int n, k;
int h[N], w[N];

bool isOK(int a) {
    int res = 0;
    for (int i = 1;i <= n;i++)
        res += (h[i] / a) * (w[i] / a);
    return res >= k;
}

int main() {
    cin >> n >> k;
    for (int i = 1;i <= n;i++)cin >> h[i] >> w[i];

    int l = 1, r = 100000;
    while (l < r) {
        int mid = (l + r + 1) >> 1;
        if (isOK(mid))l = mid;
        else r = mid - 1;
    }
    cout << l;
}

2实数二分

实数二分由于没有边界情况，就显得简单许多了，直接按模版来就行

while(r-l>eps){  		//这里eps通常取1e-8
  double mid = (l+r)/2;
  if(isOK(mid))l = mid;
  else r = mid;
}