算法笔记：二分算法

程序或算法的时间复杂度

• 一个程序或算法的时间效率，也称“时间复杂度”，有时简称“复杂度”
• 复杂度常用大的字母O和小写字母n来表示，比如O(n),O()等。n代表问题的规模
• 时间复杂度是用算法运行过程中，某种时间固定的操作需要被执行的次数和n的关系来度量的。在无序数列中查找某个数，复杂度是O(n)
• 计算复杂度的时候，只统计执行次数最多的(n足够大时)那种固定操作的次数。比如某个算法需要执行加法次，除法n次，那么就记其复杂度是O()的。

计算复制度一般不考虑n的系数 ；

如果复杂度是多个n的函数之和，则只关心随n的增长增长得最快的那个函数；

O(+）=> O()；

O(+）=> O()；

O(n!+ )  => O(n!)；

常数复杂度：O(1)           时间(操作次数)和问题的规模无关；

对数复杂度：O(log(n))；

线性复杂度：O(n)；

多项式复杂度：O();

指数复杂度：O();

阶乘复杂度：O(n!) ;

复杂度有“平均复杂度”和“最坏复杂度”两种，两者可能一致也可能不一致。

几种程序的复杂度

一个问题的复杂度是解决这个问题最好方法的复杂度;

• 在无序数列中查找某个数(顺序查找) O(n)
• 平面上有n个点，要求出任意两点之间的距离O()
• 插入排序、选择排序、冒泡排序 O()
• 快速排序 O(n*log(n))
• 二分查找 O(log(n))

二分查找适用于有顺序的查找

二分查找函数

• 写一个函数BinarySearch，在包含的size个元素的、从小到大排列的数组a里查找元素p，找到返回下标，找不到返回-1。要求复杂度O(log(n))

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

• 写一个函数LowerBound，在包含的size个元素的、从小到大排列的数组a里查找比给定整数p小的、下标最大的元素，找到返回下标，找不到返回-1。

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

注意

为防止(L+R)过大溢出,查找区间正中下标不应写为 int mid=(L+R)/2; 应写为int mid = L + (R - L) / 2;

二分查找求方程的根

求方程的一个根，若求出的根是a,则要求。

思想：易知该函数在[0,100]单调递增，f(0)<0,f(100)>0,那么在0到100上必有一根，用二分查找即可。

double f(double x)
{
	return x * x * x - 5 * x * x + 10 * x - 80;
}
int main()
{
	double EPS = 1e-6;
	double L = 0, R = 100, root,y;
	root = L + (R - L) / 2;
	y = f(root);
	while (abs(y) > EPS)
	{
		if (y < 0)
			L = root;
		else
			R = root;
		root = L + (R - L) / 2;
		y = f(root);
	}
	printf("%.8f", root);
	return 0;
}

运行结果

 例题1：

 程序

#include <stdio.h>
#include <iostream>
using namespace std;
int BinarySearch(int a[], int size, int p)//二分查找
{
	int L = 0, R = size - 1;
	while (L <= R)
	{
		int mid = L + (R - L) / 2;
		if (a[mid] == p)
			return mid;
		if(a[mid]<p)
			L = mid+1;
		else
			R = mid-1;
	}
	return -1;
}
void QuickSort(int *a, int begin, int end)//快速排序
{
	if (begin > end)
		return;
	int tmp = a[begin];
	int i = begin, j = end;
	while (i != j)
	{
		while (tmp <= a[j]&&i<j)
			j--;
		while (tmp >= a[i]&&i<j)
			i++;
		if (i < j)
		{
			int t = a[j];
			a[j] = a[i];
			a[i] = a[j];
		}
	}
	a[begin] = a[i];
	a[i] = tmp;
	QuickSort(a, begin, i - 1);
	QuickSort(a, i + 1, end);
}
int main()
{
	int a[100000], m, n;
	scanf_s("%d",&n);
	for (int i = 0; i < n; i++)
		scanf_s("%d", &a[i]);
	scanf_s("%d", &m);
	QuickSort(a, 0, n - 1);
	for (int i = 0; i < n - 1; i++)
	{
		 int x = BinarySearch(a, n, m - a[i]);
		if (x != -1)
		{
			printf("%d+%d", a[i], a[x]);
			break;
		}
	}
	return 0;
}

运行结果

 例题2：

 程序

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
long long room[100005];
bool f(long long x, long long N, long long room[], long long cow) 
{
	cow--;
	long long left = 0;
	for (long long i = 0; i < N; i++) 
	{
		if (room[i] - room[left] >= x) 
		{
			left = i;
			cow--;
		}
		if (cow == 0)return true;
	}
	return false;
}
int main()
{
	long long N, cow;
	cin >> N >> cow;
	for (long long i = 0; i < N; i++)
		scanf_s("%lld", &room[i]);
	sort(room, room + N);

	long long left = 1, right = room[N - 1] / cow, mid;
	mid = left + (right - left) / 2;
	while (left < right) 
	{
		if (f(mid, N, room, cow))
			left = mid;
		else 
			right = mid - 1;
		mid = left + (right - left) / 2;

		if (right - left == 1)
		{ 
			if (f(right, N, room, cow))
				mid = right;
			else
				mid = left;
			break;
		}
	}
	printf("%d", mid);
	return 0;
}

运行结果