策略性跳跃的 二分搜索

以下是我结合 《挑战程序设计竞赛》的二分内容的一些个人总结：

1.二分概述

二分搜索法：不断缩小解可能存在的范围，求得问题最优解的方法。大家最初接触这个方法，应该是在排序和查找这一块中，如何高效的从以某些方式排好序的数据中查找想要的值的位置。

1.1 从有序数组中查询某个值

我们常见的二分查找，只需要找到一个符合的值就行。

1.1.1 只要查询某一个符合值的位置

//默认升序
int binarySearch(int find[],int length,int value){
	int left = 0,right = lenght - 1;
	while(left <= right){
		int mid = left + (right - left) / 2;//避免溢出
		if(find[mid] == value)
			return mid; //返回第一个找到的
		else if(find[mid] < value)
			left = mid + 1;
		else if(find[mid] > value)
			right = mid - 1;
	}
	return -1;
}

1.1.2 lower_bound

STL的algorithm中帮我们实现了lower_bound函数，作用是从指定范围内，找到有序数组中第一个满足ai >= k的地址，只需要对1.1.1稍作改动：

int lower_bound(int a[],int length,int k){
	if(a[0] > k) return -1; //都小的情况,特判一下
	if(a[length - 1] > k] return length; //都大
	int left = 0,right = length - 1;
	while(left <= right){
		int mid = left + (right - left) / 2;
		if(a[mid] < k){
			left = mid + 1;
		}else right = mid - 1; //满足条件缩小范围
	}	
	return left;
}

1.1.3 另一种左右界取法

这是我在《挑战程序设计竞赛》上看到的区间二分写法，看起来国外人比较喜欢这种区间写法，既适用于int，也适用于double类的二分：

int lower_bound(int a[],int length,int k){
	if(a[0] > k) return -1; //都小的情况,特判一下
	if(a[length - 1] > k] return length; //都大
	int lb = -1,ub = length; //初始区间为(lb,ub)，而不是[left,right]
	while(ub - lb > 1){ //直到解的范围不大于1
		int mid = lb + (ub - lb) / 2;
		if(a[mid] < k){
			lb = mid; //不满足范围变为(mid,ub]
		}else ub = mid; //满足范围变为(lb,mid]
	}
	
	return ub;//此时lb + 1 = ub
}

仔细看同一个查询功能，不同的写法返回的是左界还是右界也并不统一，需要判断一下。
如果希望一劳永逸的话，不妨加一个变量保存最后一次可行解：

int lower_bound(int a[],int length,int k){
	/*··· int lb = -1,ub = length; //初始区间为(lb,ub)，而不是[lb,ub]
	int res = -1;
	while(ub - lb > 1){ //直到解的范围不大于1
		int mid = lb + (ub - lb) / 2;
		if(a[mid] < k){
			lb = mid; //不满足范围变为(mid,ub]
		}else {
		ub = mid; //满足范围变为(lb,mid]   ····*/
		res = ub;//记录可行解
	}
	if(a[ub] > num) return -1; //都小的情况
	return res;//最后一个可行解
}

1.2 判断一个解是否可行

二分法除了用来查询以外，还可以适用一些优化求解问题：比如，求满足某个条件C(x)的最小/大 值一类问题
这里给出一道《挑战》例题：
Cable master

题意：有N条绳子 (<=10000)，长度分别为Li (<=100000)，从其中切割出K条长度相同的绳子，每条绳子最长为多少，结果保留2位小数

这道题结合之前提到的： “求满足某个条件C(x)的最小/大 值一类问题”
上述题可以转化有： C(x):能否获得K条长度为x的绳子
然后我们利用二分的思想：

1. 切割绳子可能的长度(0,100000)
2. 若C(mid)满足，则切割绳子的范围在[mid,ub]中（因为求最大满足)
3. 不断缩小范围至区间精度足够输出结果

重点就在C(x)的判断了：能否获得K条长度为x的绳子 == 遍历每个绳子长度 / x 求和，和 >=k 即满足 时间复杂度为O(n),二分复杂度为O(logn） == O(nlogn)绰绰有余

还有一些细节就是：
double数据的二分，最终结果的精度要求可能有一些限制，具体看关键代码：
这里涉及到double使用区间二分就很自然。

//《挑战》解法
//判断是否满足条件 
bool C(double x) //以x长度每条绳 
{
	int num = 0;
	for(int i = 0; i < N;++i)//对每条绳子
		num += (int) (L[i] / x);
	return num >= K; 
}

void solve(){
	double lb = 0,ub = INF;//上下界
	//重复循环至解的范围足够小.....每次我们缩小一半，100次二分缩小，基本上精度没问题 
	//也可以写成 ub - lb > EPS 但是EPS太小可能由于double的精度问题进入死循环TLE
	//for(int i = 0;i < 100;++i)  需要注意某些题目循环100次可能会超时，因题而异
	while(ub - lb > 0.00001){
		double mid = lb + (ub - lb) / 2;
		if(C(mid) ) lb = mid;//符合切换区间
		else ub = mid; 
	} 
	printf("%.2f\n",floor(ub * 100) / 100); //用floor函数截取,不然是%.2f 4舍5入
}
/*
这题选lb做结果会WA，ub不会,估计是double的精度问题,测试数据过不了lb
可以使用int二分将千米转换成米，对整数进行二分,取lb能A,避免double造成的精度问题
*/

1.3 最大化最小值问题

最大化最小值 && 最小化最大值问题 == 是一类题
通常为： 希望满足某个条件C(x)的 x尽量大 或者 尽量小
例题 Aggressive cows

农夫约翰建造了一个新谷仓，里面有N (2 <= N <= 100,000)个畜栏。档位沿直线排列在X1，…，Xn (0 <= Xi <= 1,000,000,000) 他的奶牛(2 <= C <= N)不喜欢这个谷仓的布局，一旦被放进去，它们就会变得好斗。为了防止奶牛互相伤害，FJ想把奶牛分配到牛栏中，使最近两头奶牛之间的距离就尽可能的大。请问最大的最近距离是多少?

很明显的最大化最小值问题：

1. 令C(x)：使每条牛之间的间距不小于x是否可行
2. 初始区间为0~INF，用二分不断缩减可能的最短距离区间距离，至只有一个值

int d[MAX_N];
int N,K; //N 畜栏 K 牛
bool C(int x){ //每条牛之间的间距不小于x
     int before = 0;//第一头牛
     for(int i = 1;i < K;++i){ //有K头牛
          int j;
          for(j = before + 1;j < N && d[j] - d[before] < x;++j);
          if(j == N) return false;//都没找到
          before = j; //放下牛i
     }
     return true;
}

int main(){
     while(scanf("%d%d",&N,&K) != EOF){
          for(int i = 0;i < N;++i){
               scanf("%d",&d[i]);
          }
          sort(d,d+N);
          int lb = 0,ub = INF;
          while(ub - lb > 1){
               int mid = lb + (ub - lb) / 2;
               if(C(mid) ) lb = mid; //最大化最小值
               else ub = mid;
          }
          printf("%d\n",lb);
     }
}

类似的最小化最大值问题： C(x) ：满足什么什么的最大值条件

int lb = 0,ub = INF;
while(ub - lb > 1){
     int mid = lb + (ub - lb) / 2;
     if(C(mid) ) ub = mid; //最小化最大值
     else lb = mid;
}

1.4 最大化平均值

这一类题大多是：
有n个重量为Wi，价值为Vi的物品，从中选出k件使得单位重量的价值最大,即：
$$\Gamma (k)=\sum _0^{\mathbb{N}}vi/wi.$$

1. 我们令C(x)：使单位重量的价值不小于x，尽管wi，vi可能为int，x却为double~
2. 那么有： $$\sum _0^{\mathbb{N}}{v}_i/w_i\geqq x.$$ $$\sum _0^{\mathbb{N}}(v_i-w_i\ast x)\geqq 0.$$
3. C(x)转变为 ：选取按 (v - w * x) 排序的前k大的物品的和，大于等于0 是否成立

伪代码：

int N,K;
int w[N],v[N];
double y[N];

bool C(double x){
	for(int i = 0;i < N;++i){
		y[i] = v[i] - x * w[i];
	}
	sort(y,y + N);
	double sum = 0.0f;
	for(int i = 0;i < K;++i){
		sum += y[n - i - 1];
	}
	return sum >= 0;
}

void solve(){
	double lb = 0,ub = INF;
	for(int i = 0;i < 100;++i){
		double mid = (lb + ub) / 2;
		if(C(mid) ) lb = mid;
		else ub = mid;
	}
	printf("%.2f\n",ub); //lb也行,主要看精度卡的怎么样
}

2.二分习题

收录于《挑战程序设计竞赛》

2.1 最大化最小值

River Hopscotch Poj 3258
Monthly Expense Poj 3273
Drying Poj 3104
Cow Acrobats Poj 3045 可以不做，贪心题，二分其实就是半完全贪心

2.2 最大化平均值

Dropping tests Poj 2976
K Best Poj 3111

2.3 查找第K大值

Matrix Poj 3685
Median Poj 3579

2.4 最大化第K大值

Telephone Lines Poj 3662

2.5 我的题解

末地传送门