算法与数据结构 二分查找

二分查找

参考博客:https://blog.csdn.net/weixin_43914593/article/details/103250854、
https://blog.csdn.net/slience_646898/article/details/81086695
复杂度： 经过n次二分后，区间会缩小到(b-a)/ 2^n。给定a、b和精度要求e，可以算出二分次数n，即满足(b - a)/2n <ε。所以，二分法的复杂度是O(logn)的。例如，如果函数在区间[0, 100000]内单调变化，要求根的精度是10-8，那么二分次数是44次。
　　二分非常高效。所以，如果问题是单调性的，且求解精确解的难度很高，可以考虑用二分法。
　　在算法竞赛题目中，有两种题型：整数二分、实数二分。整数域上的二分，注意终止边界、左右区间的开闭情况，避免漏掉答案或者死循环。实数域上的二分，需要注意精度问题。

例题1： 猜数字

A心里想一个1~1000的数字，让B才，B可以问A，A只能回到对或错。请问最少需要猜几次？

这题一种猜数字的方法是一个一个猜，猜1000次，显然这不是最优的方法。
B可以每次猜范围的中间值。即第一次猜500，A回答是否，如果答案是大于500，范围缩小到500~1000，B再猜750，如此循环。每次猜缩小到原来的一半，这样最多只需要猜10次。 这就是二分查找的思想。

例题2 找数字

给定一个长度为10的数组a，再给定一个数字p，在数组a中查找p，如果找到就返回数字小标，如果没有就返回-1. 要求复杂度为O(log(n))。
核心代码：

int search(int a[],int size,int p){
	int L =0;
	int R=size-1;
	while(L<=R){
		int mid=L+(R-L)/2;
		if(p==a[mid])
			return mid;
		else if(p>a[mid])
			L= mid+1;
		else
			R = mid + 1;
	}
	return -1;
}

每次在L~R的区间内查找，如果中点的数a[mid]比给定的数p大，则p在中点a[mid]的左边，否则在右边。

二分查找的前提是数组得从小到大排列，必须有序。

例题3：查找比p小的元素的最大小标

给定一个长度为10的数组a，再给定一个数字p，在数组a中查找比p小且下标最大的元素，如果找到就返回数字小标，如果没有就返回-1. 要求复杂度为O(log(n))。

核心代码：

int lowerSearch(int a[],int size, int p){
	int L =0;
	int R=size-1;
	int MaxLocation=-1;
	while(L<=R){
		int mid=L+(R-L)/2;
		if(a[mid]>=p) //如果中点元素 a[mid]大于p，说明p在中点的左边 
			R=mid-1;  //修改右边界值 
		else{  // 如果中点元素 a[mid]小于p，说明p在中点右边 
			MaxLocation = mid; //更新最大坐标 
			L=mid+1;  //修改左边界值 
		} 
	}
	return MaxLocation; 
}

例题4 用二分法求方程的根

求下列方程的一个根： x³ -5x² +10x -80 =0 ,需满足要求
|f(a)| <=10^-6

#include <iostream>
#include <math.h>
using namespace std;
double EPS = 1e-6;
double f(double x) {
	return x*x*x -5*x*x + 10*x -80;
}
int main() {
	double root,x1=0,x2=100,y;
	root = x1+(x2-x1)/2;
	y=f(root);
	while(abs(y) > EPS){
		if(y>0) x2 = root;
		else 	x1 = root;
		root = x1 + (x2-x1)/2;
		y=f(root); 
	}
	cout<<root;
	return 0;
}

并不是每一个方程都能求出根，前提是在求解区间能单调，且有解。

例题5 找一对数

输入n个整数，找出其中的两个数，它们之和等于整数m(假定肯定有解)。

#include <iostream>
#include <math.h>
#include<algorithm>
using namespace std;
int a[100000];
int search(int size,int p){
	int L =0;
	int R=size-1;
	while(L<=R){
		int mid=L+(R-L)/2;
		if(p==a[mid])
			return mid;
		else if(p>a[mid])
			L= mid+1;
		else
			R = mid + 1;
	}
	return -1;
} 
int main() {
	
	int n,m;//输入n个整数,两数和为m 
	for(int i=0;i<n;i++){
		scanf("%d",&a[i]);
	}
	sort(a,a+n);
	for(int i=0;i<n;i++){
		if(search(n,m-a[i])!=-1){
			cout<<a[i]<<' '<<m-a[i]<<endl;
			break;
		}
	}
	return 0;
}

数列分段 最大值最小化问题

题目描述
对于给定的一个长度为N的正整数数列 A-iA−i ，现要将其分成 M(M≤N)M(M≤N) 段，并要求每段连续，且每段和的最大值最小。
关于最大值最小：
例如一数列 42451 要分成 3 段
将其如下分段：
[4 2][4 5][1]
第一段和为 6 ，第 2 段和为 9 ，第 3 段和为 1 ，和最大值为 9 。
将其如下分段：
[4][2 4][5 1]
第一段和为 4 ，第 2 段和为 6 ，第 3段和为 6 ，和最大值为 6 。
并且无论如何分段，最大值不会小于 6 。
所以可以得到要将数列 4 2 4 5 1 要分成 3 段，每段和的最大值最小为 6 。
输入输出格式
输入格式：
第 1 行包含两个正整数N，M。
第 2 行包含 NN 个空格隔开的非负整数 A_iAi​ ，含义如题目所述。
输出格式：
一个正整数，即每段和最大值最小为多少。

#include<iostream>
#include<algorithm>
using namespace std;
int n, m;                              
//分m段，则要划出m-1条线
int a[100001];
bool judge(int x)                      
//x是所有段中的最大值，希望其最小
{
	int line = 0; //表示分的块数 
	int sum = 0; //每个块的和 
	for (int i = 1; i <= n; i++)
	{
		if (sum + a[i] > x)            
		//如果和超过了最大值说明需要将其分段，线段数加1，重新开始计算sum
		{
			line++; //块数+1 
			sum = a[i];
		}
		else
			sum += a[i];
	}
	if (line >= m)                     
	//所加的线段数超过了要求的m-1条，说明这个最大和是非法解
		return false;
	return true;
}
int main()
{
	int sum = 0, ans = 0, max=-1;
	cin >> n >> m;
	for (int i = 1; i <= n; i++)
	{
		cin >> a[i];
		if (a[i] > max)
			max = a[i];
		sum += a[i];
	}
	//注意二分的范围区间！！最小的和是最大的一个数，最大的和是所有数的总和！！
	int l = max, r = sum, mid;          
	//开始二分选择，合法则向左找还有没有更优解，不合法则向右找合法解
	while (l <= r)                      
	{
		mid = (l + r) / 2;
		if (judge(mid))
		{
			ans = mid;
			r = mid - 1;
		}
		else
			l = mid + 1;
	}
	cout << ans << endl;
	return 0;
}

注意，本题是对原数组进行分块，不能对原数组进行排序。

进击的奶牛 最小值最大化

题目描述
Farmer John建造了一个有N(2<=N<=100,000)个隔间的牛棚，这些隔间分布在一条直线上，坐标是x1,…,xN (0<=xi<=1,000,000,000)。

他的C(2<=C<=N)头牛不满于隔间的位置分布，它们为牛棚里其他的牛的存在而愤怒。为了防止牛之间的互相打斗，Farmer John想把这些牛安置在指定的隔间，所有牛中相邻两头的最近距离越大越好。那么，这个最大的最近距离是多少呢？

输入格式
第1行：两个用空格隔开的数字N和C。

第2~N+1行：每行一个整数，表示每个隔间的坐标。

输出格式
输出只有一行，即相邻两头牛最大的最近距离。

输入输出样例
输入：

5 3
1 
2 
8 
4 
9 

输出

3

代码：

#include<bits/stdc++.h>
using namespace std;
int n,c,x[100005];//牛棚数量，牛数量，牛棚坐标

bool check(int dis){     //当牛之间距离最小为dis时，检查牛棚够不够
    int cnt=1, place=0;  //第1头牛，放在第1个牛棚
    for (int i = 1; i < n; ++i)     //检查后面每个牛棚
        if (x[i] - x[place] >= dis){ //如果距离dis的位置有牛棚
            cnt++;      //又放了一头牛
            place = i;  //更新上一头牛的位置
        }
    if (cnt >= c) return true;   //牛棚够
    else          return false;  //牛棚不够
}

int main(){
    scanf("%d%d",&n, &c);
    for(int i=0;i<n;i++)    scanf("%d",&x[i]);
    sort(x,x+n);             //对牛棚的坐标排序
    int left=0, right=x[n-1]-x[0];  //R=1000000也行，因为是log(n)的，很快
							        //优化：把二分上限设置为1e9/c
    int ans = 0;
    while(left < right){
        int mid = left + (right - left)/2;     //二分
        if(check(mid)){       //当牛之间距离最小为mid时，牛棚够不够?
            ans = mid;        //牛棚够，先记录mid
            left = mid + 1;   //扩大距离
           }
        else
            right = mid;      //牛棚不够，缩小距离
    }

    cout << ans;              //打印答案
    return 0;
}