二分查找
二分查找
1.普通的二分查找 - 查找某数在数组里的坐标,如果不存在返回 -1
- 该方式不稳定(可能找到的是重复元素的几个当中不确定的一个)
int binarySearch(vector<int> nums, int target) {
int left = 0;
int right = nums.size() - 1;
while (left <= right) {
int mid = left + (right - left) / 2;
if (nums[mid] == target) {
return mid;
}
else if (nums[mid] < target) {
left = mid + 1;
}
else if (nums[mid] > target) {
right = mid - 1;
}
}
return -1;
}
2.1.查找小于target的数的坐标
int binarySearch(vector<int> nums, int target) {
int right = nums.size();
if (right == 0)
return -1;
int left = 0;
while (left < right) {
int mid = left + (right - left) / 2;
if (nums[mid] == target) {
right = mid;
}
else if (nums[mid] < target) {
left = mid + 1;
}
else if (nums[mid] > target) {
right = mid;
}
}
return left;
这里return left的判断条件在于right = mid(也就是取得等号的时候的条件),最终终止循环的条件会是left == right,所以实际上我们可以得到可能出现在哪个位置的target(也就是说,我们没有漏掉任何一个区间)。
3.1 .查找大于target的数的坐标
int binarySearch(vector<int> nums, int target) {
int right = nums.size();
if (right == 0)
return -1;
int left = 0;
while (left < right) {
int mid = left + (right - left) / 2;
if (nums[mid] == target) {
left = mid + 1;//等于的时候left要复制加一,所以最终返回**left-1**
}
else if (nums[mid] < target) {
left = mid + 1;
}
else if (nums[mid] > target) {
right = mid;
}
}
return left-1;
}
这里所要返回的left-1是因为我们赋值的时候是left=mid+1也就是mid=left-1,所以最后可能得到的target的位置不可能是left,只可能是left-1,也就是mid的位置。
2.2.根据「小于target的数的坐标」改进的稳定的二分查找
int binarySearch(vector<int> nums, int target) {
int right = nums.size();
if (right == 0)
return -1;
int left = 0;
while (left < right) {
int mid = left + (right - left) / 2;
if (nums[mid] == target) {
right = mid;
}
else if (nums[mid] < target) {
left = mid + 1;
}
else if (nums[mid] > target) {
right = mid;
}
}
return (nums[left] == target) ? left : -1;//区间终止条件**left==right**,所以要判断最后的left位置是否合理。
}
3.2. 根据「大于target的数的坐标」改进的稳定的二分查找
int binarySearch(vector<int> nums, int target) {
int right = nums.size();
if (right == 0)
return -1;
int left = 0;
while (left < right) {
int mid = left + (right - left) / 2;
if (nums[mid] == target) {
left = mid+1;
}
else if (nums[mid] < target) {
left = mid + 1;
}
else if (nums[mid] > target) {
right = mid;
}
}
return (nums[left-1] == target) ? left-1 : -1;//区间终止条件**left==right**,所以要判断最后的left-1位置是否合理。
}
4. 注意
-
left + right 可能会超出 INT_MAX,为了防止溢出:
c int mid = (left + right) / 2
修改为c int mid = left + (right - left) / 2
; -
right 的初始化
- right = nums.size()
- 用于搜索小于或者大于target的一个范围
- 搜索区间为 [left, right)
- while(left < right)
- 结束条件为 left == right
- 结束区间为[left, right],非空有一个值
- left = mid + 1;
- right = mid;
-
right = nums.size() - 1
- 用于搜索target的坐标
- 搜索区间为 [left, right]
- while(left <= right)
- 结束条件为left == right + 1
- 结束区间为 [right + 1, right],区间为空
- left = mid + 1;
- right = mid - 1;
二分搜索:各种二分
- 由于常年二分写成死循环,所以是时候有必要总结一下二分搜索了,这里声明一下本人的二分风格是左闭右开也就是[L,R)。
- 这里就不解释什么是二分搜索了,这里将会介绍4种二分搜索,和二分搜索常用来解决的最小值最大化或者最大值最小化的问题,我们都知道使用二分的最基本条件是,我们二分的序列需要有单调性,这里的序列是广义性如:
- 一个排好序的数组;
- 一个区间[L,R);
- 其他(暂时想不到)。
- 所以下面介绍的时候会用v来代表我们二分的目标,用第一个大于v,第一个大于等于v,最后一个小于v,最后一个小于等于v来描述,这里可以看到我即将要介绍的4种二分搜索。
1.第一个大于等于v
这就是我们常说的lower_bound()了,这是系统里面自带的库函数,在数组或者一个vector容器中二分的时候,也就是不是必须手写二分的时候首推使用这个,优点代码少,稳定(建议少装逼,动不动手写二分)。这里我们来介绍lower_bound()的使用方式。
首先是这个函数原型:
ForwardIterator lower_bound (ForwardIterator first, ForwardIterator last,const T& val, Compare comp)
其中first代表左边界迭代器,last代表右边界迭代器(注意左闭右开),val代表你要搜索的值,comp代表排序规则(这个参数在你对非结构体数组二分的时候并不需要,有默认规则)
实例:
int a[100]={1,2,3,3,4,5,5,6,8,9,22},n; while(cin>>n){ int p=lower_bound(a,a+11,n)-a; //如果a是vector,那么lower(a.begin(),a.end(),v)-a.begin(); //你也可以在指定在[L,R)区间内二分lower_bound(a.begin()+L,a.begin()+R,v)-a.begin(),数组也是同理的 cout<<p<<endl;//这里输出的是第一个大于等于n的数的下标 }
当对结构体数组进行二分搜索时(我们可以在这里继续输入上面代码的初始化的数据)
#include<bits/stdc++.h> using namespace std; struct node{ int x; }; int cmp(node a,node b){ return a.x<b.x;//注意这里不可以a.x<=b.x不然lower_bound就变成upper_bound了 } int main(){ int n;cin>>n; vector<node>a(n); node b; for(int i=0;i<n;i++) cin>>a[i].x; while(cin>>b.x){ int p=lower_bound(a.begin(),a.end(),b,cmp)-a.begin(); cout<<p<<endl;//输出还是下标 } return 0; }
这里我们介绍的是当数组是升序的时候的情况,如果数组是降序的,我们则需要重新定义排序规则,我们这里在使用lower_bound()就是寻找第一个小于等于v的下标。
学会了如何使用库函数,现在我们来学习一下如何手写一个lower_bound(),我们知道二分有一个左边界L和右边界R,我们定义[L,R)内的下标都小于v,我们假设L为当前区间的答案,R为当前区间的实际答案(因为R是第一个大于等于v的下标),我们每次二分的实际上是为了让L和R不断靠近,所以当L==R的时候,我们假设的答案等于实际的答案,那么就结束循环了,返回答案L。
#include<bits/stdc++.h> using namespace std; int main(){ int a[100]={1,2,3,3,4,5,5,6,8,9,22},v; while(cin>>v){ int L=0,R=11; while(L<R){ int M=(L+R)/2; if(a[M]>=v) R=M; else L=M+1; } cout<<L<<endl; } return 0; }
注:1.当a[M]>=n时,由于R是第一个大于等于v下标,那么R最大只能是m
2.当a[M]<n时,说明[M,R)区间内的下标都是小于v的,L作为最后的答案最小只能是M+1
2.第一个大于v
这就是我们常说的upper_bound()了,这是系统里面自带的库函数,这里我们来介绍upper_bound()的使用方式,和lower_bound()在可以使用的时候推荐使用。
首先函数原型:
ForwardIterator upper_bound (ForwardIterator first, ForwardIterator last,const T& val, Compare comp);
其中first代表左边界迭代器,last代表右边界迭代器(注意左闭右开),val代表你要搜索的值,comp代表排序规则(这个参数在你对非结构体数组二分的时候并不需要,有默认规则)
实例:
int a[100]={1,2,3,3,4,5,5,6,8,9,22},n; while(cin>>n){ int p=upper_bound(a,a+11,n)-a; //如果a是vector,那么upper_bound(a.begin(),a.end(),v)-a.begin(); //你也可以在指定在[L,R)区间内二分upper_bound(a.begin()+L,a.begin()+R,v)-a.begin(),数组也是同理的 cout<<p<<endl;//这里输出的是第一个大于等于n的数的下标 }
当对结构体数组进行二分搜索时(我们可以在这里继续输入上面代码的初始化的数据)
#include<bits/stdc++.h> using namespace std; struct node{ int x; }; int cmp(node a,node b){ return a.x<=b.x;//注意这里不可以a.x<=b.x不然upper_bound就变成lower_bound了 } int main(){ int n;cin>>n; vector<node>a(n); node b; for(int i=0;i<n;i++) cin>>a[i].x; while(cin>>b.x){ int p=upper_bound(a.begin(),a.end(),b,cmp)-a.begin(); cout<<p<<endl;//输出还是下标 } return 0; }
这里我们介绍的是当数组是升序的时候的情况,如果数组是降序的,我们则需要重新定义排序规则,我们这里在使用upper_bound()就是寻找第一个小于v的下标。
学会了如何使用库函数,现在我们来学习一下如何手写一个upper_bound(),同样的,我们定义[L,R)内的下标都小于等于v,我们假设L为当前区间的答案,R为当前区间的实际答案(因为R是第一个大于v的下标),我们每次二分的实际上是为了让L和R不断靠近,所以当L==R的时候,我们假设的答案等于实际的答案,那么就结束循环了,返回答案L。
#include<bits/stdc++.h> using namespace std; int main(){ int a[100]={1,2,3,3,4,5,5,6,8,9,22},v; while(cin>>v){ int L=0,R=11; while(L<R){ int M=(L+R)/2; if(a[M]>v) R=M; else L=M+1; } cout<<L<<endl; } return 0; }
注:1.当a[M]>n时,由于R是第一个大于v下标,那么R最大只能是M
2.当a[M]<=n时,说明[M,R)区间内的下标都是小于等于v的,L作为最后的答案最小只能是M+1
3.最后一个小于等于v
上面说过了,当数组为降序的,使用lower_bound就是返回第一个小于等于下标,若一开始数组是升续的时候,那么应该先reverse一下,再用lower_bound返回下标p,则在原数组中的下标为n-p-1(假设数组有n个元素)。
这里来介绍一下如何在如果手写一个last_less_equal()。和lower_bound二分区间[L,R)左闭右开不同,last_less_equal()的二分区间为(L,R]右闭左开。
同样的,我们定义(L,R]内的下标都大于v,我们假设R为当前区间的答案,L为当前区间的实际答案(因为L是最后一个小于等于v的下标),我们每次二分的实际上是为了让L和R不断靠近,所以当L==R的时候,我们假设的答案等于实际的答案,那么就结束循环了,返回答案L。
#include<bits/stdc++.h> using namespace std; int main(){ int a[100]={1,2,3,3,4,5,5,6,8,9,22},v; while(cin>>v){ int L=-1,R=10; while(L<R){ int M=(L+R+1)/2; if(a[M]<=v) L=M; else R=M-1; } cout<<L<<endl; } return 0; }
注:1.当a[M]<=n时,由于L是最后一个小于等于v下标,那么L最小只能是M。
2.当a[M]>n时,说明(L,M]区间内的下标都是大于v的,R作为最后的答案最大只能是M-1。
4.最后一个小于v
上面说过了,当数组为降序的,使用upper_bound就是返回第一个大于下标,若一开始数组是升续的时候,那么应该先reverse一下,再用upper_bound返回下标p,则在原数组中的下标为n-p-1(假设数组有n个元素)。
这里来介绍一下如何在如果手写一个last_less()。和upper_bound二分区间[L,R)左闭右开不同,last_less_equal()的二分区间为(L,R]右闭左开。
同样的,我们定义(L,R]内的下标都大于等于v,我们假设R为当前区间的答案,L为当前区间的实际答案(因为L是最后一个小于v的下标),我们每次二分的实际上是为了让L和R不断靠近,所以当L==R的时候,我们假设的答案等于实际的答案,那么就结束循环了,返回答案L。
#include<bits/stdc++.h> using namespace std; int main(){ int a[100]={1,2,3,3,4,5,5,6,8,9,22},v; while(cin>>v){ int L=-1,R=10; while(L<R){ int M=(L+R+1)/2; if(a[M]<v) L=M; else R=M-1; } cout<<L<<endl; } return 0; }
注:1.当a[M]<n时,由于L是最后一个小于v下标,那么L最小只能是M。
2.当a[M]>=n时,说明(L,M]区间内的下标都是大于等于v的,R作为最后的答案最大只能是M-1。
我们发现lower_bound()和upper_bound()的M=(L+R)/2,而last_less()和last_less_equal()的M=(L+R+1)/2,(L+R)/2和(L+R+1)/2的区别在于前者是向下取整,后者是向上取整,这和我们定义L或者R是实际的答案有关。
有一类常见问题叫做最小值最大化或者最大值最小化。这类问题一般是用二分搜索来解决。
- 首先二分搜索解决的问题必须具备单调性这个性质,这是使用二分搜索的必要条件,我们分析两个问题。
- **最小值最大化:****我们假设x为最大的最小值,那么x-1是满足条件的,但他并不满足最大,x+1是不满足条件的,假设我们左边界是L,右边界是R,我们二分一个答案ans,ans为最后一个满足条件的数,我们是不是可以类比二分搜索(一)中的last_less_equal()或者last_less()这个问题和这两者是差不多的。可以先阅读我的另一篇博文:二分搜索(一)——各种二分
- 最大值最小化:我们假设x为最小的最大值,那么x-1是不满足条件的,x+1是满足条件的,但他不满足最小,假设我们左边界是L,右边界是R,我们二分一个答案ans,ans为第一个满足条件的数,我们是不是可以类比二分搜索(一)中的lower_bound()或者upper_bound()这个问题和这两者是差不多的。
- 所以综上所述并根据我在二分搜索(一)——各种二分中的描述:最小值最大化的二分区间是右闭左开(L,R],每次二分的中心为M=(L+R+1)/2;最大值最小化的二分区间是左闭右开,[L,R),每次二分的中心为M=(L+R)/2。
例题1:LA3971-3971——Assemble
题目意思:你有b块钱,想要组装一台电脑。给出n个配件格子的种类,品质因子和价格,要求每种类型的配件各买一个,总价格不超过b,且品质最差的配件的品质因子尽量大。
思路:这很明显是一个最小值最大化的问题,这道题还用到map对物品按名称进行分类,注意多组输入,要对上一组的数据进行清空,我们可以看出二分边界L=-1,R=maxq(所有商品中品质因子的最大值。),也就是右闭左开区间(L,R],我们搜索最后一个满足条件的ans值,具体看代码吧。
代码:
#include<bits/stdc++.h> using namespace std; const int N=1000+7; map<string,int>mp; struct node{ int p,q; }; vector<node>a[N]; int cnt=0,n,b; int check(int M){ long long sum=0; for(int i=0;i<cnt;i++){ int minn=b+10; for(int j=0;j<(int)a[i].size();j++){ if(a[i][j].q>=M){ minn=min(minn,a[i][j].p); } } sum+=minn; if(sum>b) return 0; } return 1; } int main(){ int T;cin>>T; while(T--){ cin>>n>>b; for(int i=0;i<cnt;i++) a[i].clear(); cnt=0; int L=-1,R=0; for(int i=0;i<n;i++){ string type,name; int p,q; cin>>type>>name>>p>>q; if(mp.count(type)==0){ mp[type]=cnt++; } R=max(R,q); a[mp[type]].push_back({p,q}); } while(L<R){ int M=(L+R+1)/2; if(check(M)) L=M; else R=M-1; } cout<<R<<endl; } return 0; }
例题2:openjudge-2456——Aggressive cows
题目意思:农民约翰有用C只牛,然后他有N个隔间,每个隔间都有自己的坐标位置(一维的)pos,如何安排把牛安排进隔间才能使,所有牛之间距离的最小值最大,我们不需要求这个分配方案,我们只需要求这个最小距离的最大值,很裸的最小值最大化。
思路:直接看代码吧
代码:
#include<bits/stdc++.h> using namespace std; typedef long long LL; const int N=1e5+7; LL n,c,a[N]; int check(int M){ LL t=c-1,pre=0; for(int i=1;i<n;i++){ if(a[i]-a[pre]>=M){ t--; pre=i; } if(t==0) break; } return t==0; } int main(){ cin>>n>>c; long long minn=0x3f3f3f3f,maxx=-0x3f3f3f3f; for(int i=0;i<n;i++){ cin>>a[i]; minn=min(a[i],minn); maxx=max(a[i],maxx); } sort(a,a+n); int L=0,R=maxx-minn; while(L<R){ int M=(L+R+1)/2; if(check(M)) L=M; else R=M-1; } cout<<R<<endl; return 0; }
例题3:openjudge-4135——Monthly Expense
题目意思:共n个月,给出每个月的开销.将n个月划分成m个时间段,求m个时间段中开销最大的时间段的最小开销值。
思路:最大值最小化,直接看代码吧
代码:
#include<bits/stdc++.h> using namespace std; int n,m; vector<int>a; int check(int M){ int ct=0,now=0; for(int i=0;i<n;i++){ if(a[i]>M) return 0; if(now+a[i]>M){ ct++; now=0; } now+=a[i]; } return ct<m; } int main(){ cin>>n>>m; a.resize(n); int R=0,L=0; for(int i=0;i<n;i++){ cin>>a[i]; R+=a[i]; L=max(L,a[i]); } R++; while(L<R){ int M=(L+R)/2; if(check(M)) R=M; else L=M+1; } cout<<L<<endl; return 0; }