学习笔记:二分法

Poki的学习笔记:二分法

  • 了解二分法
    • 整数域上的二分
    • 实数域上的二分
  • 二分查找
    • 最简单的二分查找
    • lower_bound():
    • upper_bound():
  • 二分答案
    • 模板

一直以来对二分法真的很懵逼……还是必须得系统地整理学习一下啊T_T 持续更新补题修改中……

了解二分法

对于二分来说,我们可以分为两类:
1、整数域上的二分
2、实数域上的二分

但是总的二分的条件都是一样的:需要序列具有单调性

整数域上的二分

分三步 (其中mid最好是>>1 而不是/2, 因为>>1 是向下取整,而/2是向0取整,在负数时很有用

(1)通过分析具体问题,确定左右半段哪一个是可行区间,以及mid归属那一半段。

(2)根据分析结果,选择“r=mid, l=mid+1, mid=(l+r)>>1” 和 “l=mid, r=mid-1, mid=(l+r+1)>>1”两个配套形式之一。

(3)二分终止条件是l==r, 该值就是答案所在位置。

(一定要注意区间的选择,区间[0,n] 和 [1,n+1] 这两个不能够乱用 ,0和n+1 都是越界下标,只有在特定情境下若没有找到才会等于越界下标)

例子:

在单调递增序列a中查找>=x的数中的最小的一个:

while(l<r)
{
   int mid=(l+r)>>1;
   if(a[mid]>=x) r=mid;
   else l=mid+1;  
}
return a[l];

在单调递增序列a中查找<=x的数中的最大的一个:

while(l<r)
{
    int mid=(r+l+1)>>1;
    if(a[mid]<=x) l=mid; else r=mid-1;
}
return a[l];

实数域上的二分

(重点是精度的确定)

在实数域上的二分很简单,重要的是确定好所需的精度eps,以l+eps

while(l+1e-5<r)
{
    double mid=(l+r)/2;
    if(calc(mid)) r=mid;else l=mid;
}

有时精度不容易确定或者表示,就干脆采用循环固定次数的二分方法,也是一种相当不错的策略。这种方法得到的结果的精度通常比设置eps更高。 ----摘自《算法竞赛进阶指南》

for(int i=0;i<100;i++)
{
    double mid=(l+r)/2;
    if(calc(mid)) r=mid;else l=mid;
}

二分查找

思路:
在一个不严格单调的有序集合中,我们如果要查找一个元素的位置,可以用l来存储下界,用r来存储上界,然后将整个集合分成两半,通过对集合中间元素与目标元素的比较,来判断目标元素是在集合中的左半部分还是右半部分(如果中间元素与目标元素相同,则退出函数,返回中间元素的位置),随后更新上界和下界。不断进行这样的操作,直至l>r为止。

//这里以在一个不严格单调递增数组中查找元素为例
int find(int l,int r,int v)//l存储上界,r存储下界,v即为目标元素
{
    if(l>r) return -1;//如果找不到就返回-1
    int mid=(l+r)>>1;//mid即为中间元素的位置,这里用位运算提高效率,相当于"int mid=(l+r)/2;"
    //对中间元素与目标元素进行比较
    if(sum[mid]==v) return mid;//中间元素与目标元素相同,则退出函数,返回中间元素的位置
    else if(sum[mid]>v) find(l,mid-1);//中间元素大于目标元素,将上界更新为中间元素的位置-1
    else find(mid+1,r);//中间元素小于目标元素,将下界更新为中间元素的位置+1
}

最简单的二分查找

在a[n]单调递增无重复数组里找x,存在则返回其下标,否则输出-1

#include 
using namespace std;
int n, x, a[100010];
int binary_search(int* a, int n, int x){ // 闭区间
	int ans = -1;
	int l=0, r=n-1;
	while(l <= r){
		int m = l + ((r-l)>>1);
		if(a[m]==x){
			ans = m;
			break;
		}
		if(a[m]<x){
			l=m+1;
		}else{
			r=m-1;
		}
	}
	return ans;
}
int main(){
	cin >> n >> x;
	for(int i=0; i<n; i++) cin >> a[i];
	int ans = binary_search(a, n, x);
	cout << ans << endl;
	return 0;
}

C++ STL提供了两个特别好用的函数:lower_bound()upper_bound()

lower_bound():

假设a是一个数组,n是数组长度,lower_bound(a, a+n, x)返回数组a[0]~a[n-1]中,大于等于x的数中,最小的数的指针。由于指针可以通过加减算偏移量,所以我们再减去a(数组名会被隐式转换成指针),就得到了相应的下标。我们看一下下面的例子,假设我们在a数组中找3这个数。
学习笔记:二分法_第1张图片

upper_bound():

同样假设a是一个数组,n是数组长度,upper_bound(a, a+n, x)返回数组a[0]~a[n-1]中,大于x的数中,最小的数的指针。注意lower_bound是“大于等于”,upper_bound是“大于”。我们看一下下面的例子,假设我们在a数组中找3这个数。
学习笔记:二分法_第2张图片
举例:

#include 
#include 
using namespace std;
int main(){
	int a[10] = {1,2,2,3,3,3,4,4,4,4};
	int n = 10;
	for(int i=0; i<=5; i++){
		int* lower = lower_bound(a, a+n, i);
		int* upper = upper_bound(a, a+n, i);
		cout << lower-a << " " << upper-a << endl;
	}
/*
0 0
0 1
1 3
3 6
6 10
10 10
*/

另外lower_bound和upper_bound的前两个参数是其实是待查范围的首尾指针(左闭右开区间,不包括尾指针),所以也可以写别的参数。比如下面的程序就是从a[1]开始查找:

#include 
#include 
using namespace std;
int main(){
	int a[10] = {1,2,2,3,3,3,4,4,4,4};
	int n = 10;
	for(int i=0; i<=5; i++){
		int* lower = lower_bound(a+1, a+n, i);
		int* upper = upper_bound(a+1, a+n, i);
		cout << lower-a << " " << upper-a << endl;
	}
}
/*
1 1
1 1
1 3
3 6
6 10
10 10
*/

lower_bound和upper_bound除了能用在数组上,还可以用在vector上。我们知道vector就相当于一个可以长度可变的数组。当用于vector上时,需要注意前两个参数必须是vector的迭代器,同时函数的返回值也是迭代器:

#include 
#include 
using namespace std;
int main(){
	int a[10] = {1,2,2,3,3,3,4,4,4,4};
	vector<int> b(a, a+10);
	int n = 10;
	for(int i=0; i<=5; i++){
		vector<int>::iterator lower = lower_bound(b.begin(), b.end(), i);
		vector<int>::iterator upper = upper_bound(b.begin(), b.end(), i);
		cout << lower-b.begin() << " " << upper-b.begin() << endl;
	}
	return 0;
}
/*
0 0
0 1
1 3
3 6
6 10
10 10
*/

注意my_lower_bound和C++STL自带的lower_bound有区别,my_lower_bound的第一个参数是一个数组,第二个参数是数组长度,第三个参数是待查找的值;它的返回值是“大于等于x的数中,最小的数的下标“,另一个等价的说法是“假设在a数组中插入x,并保持插入后仍然有序,最小的合法插入下标”。实现:

#include 
using namespace std;
int n, x, a[100010];
int my_lower_bound(int a[], int n, int x){
	int ans = n;
	int l=0, r=n-1;
	while(l<=r){
		int m = l + ((r-l)>>1);
		if(a[m]>=x){
			ans = m;
			r = m-1;
		}else{
			l = m+1;
		}
	}
	return ans;
}
int main(){
	cin >> n >> x;
	for(int i=0; i<n; i++) cin >> a[i];
	int lower = my_lower_bound(a, n, x);
	cout << lower << endl;
	return 0;
}

以上是my_lower_bound的代码,如果我们要实现my_upper_bound的代码,其实也很容易。my_lower_bound是找“大于等于x的数中,最小的数的下标“,所以是if(a[m] >= x)。
my_upper_bound是找“大于x的数中,最小的数的下标“,所以只需要把f(a[m] >= x)改成if(a[m]>x)即可。

#include 
using namespace std;
int n, x, a[100010];
int my_upper_bound(int a[], int n, int x){
	int ans = n;
	int l=0, r=n-1;
	while(l<=r){
		int m = l + ((r-l)>>1);
		if(a[m]>x){
			ans = m;
			r = m-1;
		}else{
			l = m+1;
		}
	}
	return ans;
}
int main(){
	cin >> n >> x;
	for(int i=0; i<n; i++) cin >> a[i];
	int lower = my_upper_bound(a, n, x);
	cout << lower << endl;
	return 0;
}

二分答案

应用前提:

二分答案要求满足条件的答案单调
否则你就不能确定下一次查找答案所在的区间

基本思想:

在答案可能的范围内[L,R]二分查找答案,检查当前答案是否满足题目的条件要求,根据判断结果更新查找区间

可以发现,二分查找是——答案所在区间为有序线性表的第一个元素到最后一个,条件为要找的那个值的二分答案。

答案的单调性:
学习笔记:二分法_第3张图片
答案的单调性大多数情况下可以转化为一个函数,其单调性证明多种多样,如下:
移动石头的个数越多,答案越大(NOIP2015跳石头)。
前i天的条件一定比前 i + 1 天条件更容易(NOIP2012借教室)。
满足更少分配要求比满足更多的要求更容易(NOIP2010关押罪犯)。
满足更大最大值比满足更小最大值的要求更容易(NOIP2015运输计划)。
时间越长,越容易满足条件(NOIP2012疫情控制)。

可以解决的问题:
求最大的最小值(NOIP2015跳石头)。
求最小的最大值(NOIP2010关押罪犯)。
求满足条件下的最小(大)值。
求最靠近一个值的值。
求最小的能满足条件的代价。

模板

 int l=1,r=ll;// 1 是答案的最小值,ll是答案的最大值
    while(l<=r)
    {
        int mid=(l+r)>>1,q=check(mid);//“>>1”相当于“/2”
        if(q>m)r=mid-1;
        else l=mid+1;
    }

参考链接:
https://blog.csdn.net/qq_35937273/article/details/82811597
https://blog.csdn.net/Mashiro_ylb/article/details/78469151
https://blog.csdn.net/qq_41157137/article/details/84074341
https://blog.csdn.net/chenxiaoran666/article/details/79937502
https://blog.csdn.net/weixin_39778570/article/details/80833217

你可能感兴趣的:(学习笔记)