OI退役笔记-012：基础算法（五）二分与三分

二分

二分，即折半查找。首先，二分必须满足顺序结构、有序储存。
抽象一点，就是 F(x) 且 对 x 满足单调性，用 F(x) 接近 target 来二分。

先看一道简单的例题：

这是道明显的二分题：求最小值中的最大值。解决此类问题需要用二分答案。但首先要明白，二分答案不是用那邪恶的 l 和 r 来算出答案，而是在一定区间内试出答案：

在本题样例中中，4 是答案，则有：

也就是说，每次确定一个值，再配合贪心、DP 等算法验证答案是否正确。若正确，则可能还有更正确的；若错误，则调整去找正确的。
本题程序（来自网络）

从此题中，我们抽象出来二分的经典问法：
最小值中的最大值、最大值中的最小值

下面是这两种情况的模板：

最小值中的最大值

// `最小值中的最大值`的基本结构
while (r - l <= eps)
// eps 是所谓的精确度，一般写成 r < l 即可，也有 1e-5 的情况
{
	int mid = (l + r + 1) / 2;
	// 这里的 +1 避免 r == l + 1 时 mid 一直等于l，从而死循环
	if (check(mid))
		l = mid + 1;
	else
		r = mid;
}

最大值中的最小值

while (r - l <= eps)
{
	int mid = (l + r + 1) / 2;
	if (check(mid))
		r = mid;
	else
		l = mid + 1;
}
// 恰好相反

在看完模板后看一下例题：

不难发现，l = a[1]，r = a[n] - a[1]。每次确定答案，用一个 check() 函数验证一下所选答案是否能实现即可。

#include <cstdio>
#include <algorithm>

int n, c, x[100010], l, r, mid, ans;

bool check(int m)
{
	int last = 1, sum = c - 1;
	// 令第一头牛在最左边，每隔超过 m 的距离放置一头牛
	// 看最后没有牛剩下说明答案合理
	// 有牛剩下则说明答案不合理
	for (int i = 2; i <= n; ++i)
	{
		if (x[i] - x[last] >= m)
		{
			--sum;
			last = i;
		}
		// 一个小小的剪枝，下一章具体讲解深搜剪枝
		if (sum <= 0)	break;
	}
	
	return !sum;
}

int main()
{
	scanf("%d%d", &n, &c);
	for (int i = 1; i <= n; ++i)
	{
		scanf("%d", &x[i]);
	}
	
	// 给的是位置，且无序
	std::sort(x + 1, x + n + 1);
	
	// 确定 r、l 初值
	l = 0;
	r = x[n] - x[1];
	
	// 二分结构
	while (l < r)
	{
		mid = (r + l + 1) >> 1;
		if (check(mid))
		{
			// 当当前答案合法时，该答案一定是比前一个答案更好的
			// 而且此时不存，可能后续所有判断的答案都不对，
			// 无论 l 还是 r 都不是我们想要的，而是之前的 mid
			// 所以要在此处储存 ans
			l = mid, ans = mid;
		}
		else
			r = mid - 1;
	}
	
	printf("%d", ans);
}

基本思路便如此，接下来看一道难一点的例题：

// 这个代码是好久之前写的了，虽然过了但可能有的地方实现的不好，见谅
#include <cstdio>
#include <algorithm>
 
#define L int(1E5 + 10)
 
int n, m;
long long a[L], b[L], c[L], s[L], l = 0, r = 1E9, mid = (l + r) / 2;
// 这里的 l 和 r 就不好，可以用数列里的最小值和最大值

bool ck()
{
    for (int i = 1; i <= n; ++i)
    {
    	// 存储每个数与平均值的差值，方便计算
        b[i] = a[i] - mid;
        // 前缀和，防止超时
        s[i] = s[i - 1] + b[i];
        // 一个巧妙的小算法
        // 用于表示这个数取不取，若取则有新数比原数小
        c[i] = std::min(s[i], c[i - 1]);
    }
         
    for (int i = m; i <= n; ++i)
    {
	    // 判定`是否存在一个长度不小于 L 段且平均数不小于 M 的值的子列 "
		// 如果把数列中的每个数都减去 M，就转化成：
		// 判定`是否存在一个长度不小于 L 的子段, 子段和非负`
		// 而且，此处 return 1; 表示还有更优解 
        if (s[i] - c[i - m] >= 0)    return 1;
    }
     
    return 0;
}
 
int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i)
    {
        scanf("%lld", &a[i]);
        a[i] *= 1000;
    }
     
    while (l < r)
    {
        if (ck())   l = mid + 1;
        // 上面已经说了 ck() == 1 表示可能还有更优解，因此这里的 ck()
        // 与之前的 check() 意义不同
        else        r = mid;
        // 没有更有的答案，说明这里的答案不行
        mid = (l + r) / 2;
    }
    
    // 结果是 l - 1，不懂的话试一下 l、l - 1、r 等的区别
    printf("%lld", l - 1);
}

三分
与二分类似，三分也是采取相同的思路。只不过二分只适用于单调的情况（类似一次函数），三分还适用于如二次函数的情况。

对于这样的情况，二分显然不适用：

因此需要换一种思路：三分


AC 代码：

#include <cstdio>
#define INF	0x3f3f3f3f
#define max(a, b)	(((a) > (b)) ? (a) : (b))

struct func
{
    double a, b, c;	
} f[10010];

int n, t;

double fun(double x)
{
	double ans = -INF;
	// 计算最大值
	for (int i = 1; i <= n; ++i)
		ans = max(ans, f[i].a * x * x + f[i] . b * x + f[i].c);
	return ans;
}

int main()
{
	scanf("%d", &t);
	while(t--)
	{
		scanf("%d", &n);
		for (int i = 1; i <= n; i++)
			scanf("%lf%lf%lf", &f[i].a, &f[i].b, &f[i].c);
		
		// [0, 1000]
		double l = 0.0, r = 1000.0;
		// 对精确值要求大，因此用 1e-11
		while (r - l > 1e-11)
		{
			// 两个三分点
			double midl = l + (r - l) / 3, midr = r - (r - l) / 3;
			if (fun(midl) < fun(midr))
				r = midr;
			else l = midl;
		}
		
		// l ≈ r，l 和 r 都可以（测试均可过）
		printf("%.4lf\n", fun(l));
	}
}

三分具体就这样，不多罗列例题，还要大家自己思考 （太复杂，懒得写）
但是三分会了，四分不会吗？五分不会吗？一百分不会吗？真不错。
（颇有俺们数学老师卢xiu軍的感觉）

作者：Rotch
日期：2021-05-04
修改：2020-05-04