二分/折半查找

如果从文件中读取的数据记录的关键字是有序排列的，则可以用一种效率比较高的查找方法来查找文件的记录，这就是折半查找法，又称为二分法搜索。

折半查找的基本思想是：减小查找序列的长度，分而治之地进行关键字的查找。

折半查找的实现过程是：先确定待查找记录的所在范围，然后逐渐缩小这个范围，直到找到该记录或查找失败（查无该记录）为止。

例如有序列：1 1 2 3 5 8 13 21 34 55 89（该序列包含 11 个元素，而且关键字单调递增。），现要求查找关键字 key 为 55 的记录。

我们可以设指针 low 和 high 分别指向关键字序列的上界和下界，指针 mid 指向序列的中间位置，即 mid = (low+high)/2。

C++中
1.binary_search(begin,end,index)：在数组中，若找到index则返回1，找不到就返回0

2.lower_bound(begin,end,index):在数组中的[begin，end)前闭后开区间内，返回大于或等于index的第一个元素位置，如果都小于index，则返回end。

3.upper_bound(begin,end,index)：在数组中的[begin，end)前闭后开区间内，返回大于index的第一个元素位置，如果都小于index，则返回end。

4.sort（）和unique（），sort（）用于对数组排序，一般在二分查找之前使用，unique（），用于对数组去重，某些情况下可用到。

int bin_search1( int key[], int low, int high, int k )//递归实现
{
	int mid;

	if( low > high )
	{
		return -1;
	}
	else
	{
		mid = (low + high) / 2;
		
		if( key[mid] == k )
		{
			return mid;
		}

		if( k > key[mid] )
		{
			return bin_search1( key, mid+1, high, k );	// 在序列的后半部分查找
		}
		else
		{
			return bin_search1( key, low, mid-1, k );	// 在序列的前半部分查找
		}

	}
}
int bin_search2( int str[], int n, int key )//迭代实现
{
    int low, high, mid;   
    low = 0;
    high = n-1;

    while( low <= high )
    {
		mid = (low+high)/2;
		if( str[mid] == key )
		{
			return mid;                // 查找成功 
		}
		if( str[mid] < key )
		{
			low = mid + 1;        // 在后半序列中查找 
		}
		if( str[mid] > key )
		{
			high = mid - 1;        // 在前半序列中查找 
		}
    }
    return -1;                                // 查找失败
}

求最大化最小值或者最小化最大值的问题可以用二分法来做

POJ 2456 Aggressive cows

http://poj.org/problem?id=2456
题意：把C头牛放到N个带有编号的隔间里，使得两头牛之间的最小距离尽可能大，求这个最大的最小距离。
分析：二分枚举这个最小值，范围为0～最大编号-最小编号，假设当前的最小值为x，如果判断出最小差值为x时可以放下C头牛，说明当前的x有点小，就先让x变大再判断；如果放不下，说明当前的x太大了，就先让x变小然后再进行判断。直到求出一个最大的x就是最终的答案。

#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;
int a[100001],N,C;
bool judge(int x)
{
    int count=1,temp=a[0];
    for(int i=1;i<N ;i++)
      if(a[i]-temp >= x)
      {
         count++;
         temp=a[i];
         if(count == C)//
            return true;
      }
      return false;
}
int main()
{
    scanf("%d%d",&N,&C);
    for(int i=0;i<N;i++)
        scanf("%d",&a[i]);
    sort(a,a+N);
    int low=0,height=a[N-1]-a[0],mid;//最大范围
    while(low <= height)
    {
        mid=(low+height)/2;
        if(judge(mid))
            low=mid+1;//说明当前x小
        else
            height=mid-1;
    }
   printf("%d\n",low-1);
}

POJ 3273 Monthly Expense

http://poj.org/problem?id=3273
题意：给出农夫在n天中每天的花费，要求把这n天分作m组，每组的天数必然是连续的，要求分得各组的花费之和应该尽可能地小，最后输出各组花费之和中的最大值。
分析：二分法枚举这个最大值，范围：最大花费～所有月花费之和，从第一天开始向下遍历每天的花费，当前i天之和<=mid时，把他们归并到一组，若 前i-1天之和 加上第i天的花费 大于mid，则把前i-1天作为一组，第i天作为下一组的第一天，此时划分的组数+1，若利用mid值划分的组数比规定的组数要多，则说明mid值偏小，否则偏大。代码为逆向。

#include <iostream>
#include <cstdio>
using namespace std;

int n,m,a[100005];
bool judge(int x)
{
    int cnt=1,t=x;//初始化将全部天数作为一组
    for (int i = 1;i <= n;i++)//从第一天开始向下遍历每天的花费
    {
        if (t < a[i])//当这一组容量无法包含某一天的花费
        {
            t=x;
            cnt++;
        }
        t -= a[i];
    }
    if (cnt <= m)
        return true;
    else
        return false;//若利用mid值划分的组数比规定的组数要多，则说明mid值偏小
}

int main()
{
    cin >> n >> m;
    int l = 0,r = 0,mid;
    for (int i = 1;i <= n;i++)
    {
        scanf("%d",&a[i]);
        r += a[i];
        if(l < a[i])
            l = a[i];//那么要求的值必然在[l,r]范围内
    }
    while(l < r)//可能在l==r之前，分组数就已经=m，但是mid并不是最优，因此要继续二分
    {
        mid=(l+r)/2;
        if (judge(mid)) r=mid;
        else l=mid+1;
    }
    printf("%d\n",r);
    return 0;
}

POJ 3122 Pie

#include <iostream>
#include <stdio.h>
#include <iomanip>
using namespace std;
int n,f;
double v[100005];//n:pie数  f:朋友数
const double pi=3.14159265359;
const double esp=1e-6;

bool j(double mid)
{
    int count = 0;
    for (int i = 0; i < n; i++)
    {
        count += (int)(v[i]/mid);//不足mid将被舍弃
    }
    if(count >= f)
        return true;
    else
        return false;
}

int main()
{
    int t;
    cin>>t;
    while (t--)
    {
        cin>>n>>f;
        f++;
        double low = 0,high = 0;
        for(int i=0;i<n;i++)
        {
            cin>>v[i];
            v[i] *= v[i];//半径平方
            if(high < v[i])
                high = v[i];
        }
        double mid;
        while (high - low > esp)
        {
            mid = (high+low)/2.0;
            if(j(mid))
                low = mid;
            else
                high = mid;
        }
        cout<<fixed<<setprecision(4)<<mid*pi<<endl;
        //printf("%.4f\n",mid*pi);
    }
}

POJ 1905

POJ 3258

其他

POJ 1064 Cable master

http://poj.org/problem?id=1064
题意：给出n条线段，以米的单位给出，小数点后两位（精确到厘米），要你对这些线段裁剪，裁剪出m条等长的线段，并且让这些线段尽可能长另外线段的长度不能小于1厘米，如果筹不够m条，输出0.00

POJ 3104 Drying

http://poj.org/problem?id=3104
题意：有一些衣服，每件衣服有一定水量，有一个烘干机，每次可以烘一件衣服，每分钟可以烘掉k滴水。每件衣服没分钟可以自动蒸发掉一滴水，用烘干机烘衣服时不蒸发。问最少需要多少时间能烘干所有的衣服。范围1～所有衣服不用烘干机(含水量最大的衣服)。比如三件衣服水分分别为2 3 6，烘干机每分钟烘掉5，则只需要把水分为6烘干1分钟（水分变为1），再烘干水分为3（此时水分为2）1分钟，共2分钟即可。

#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;
int n,k;
int a[100005];

bool j(int mid)//mid为烘干所有衣服的时间
{
    int count = 0;
    for (int i = 0; i < n; i++)
    {
        if(a[i] > mid)
        {
            //x1不用烘干机的时间x2用烘干机的时间
            //x1+x2=mid;a[i]<=x1+x2*k；联立两个得x2 >= (a[i]-mid)/(k-1)
            count += (a[i] - mid +k -2)/(k - 1);//a/b向上取整a+b-1/b
        }
        //a[i]<=x 自己烘干，不用烘干机
        if (count > mid)
            return false;
    }
    return true;//继续枚举更小的答案
}

int main()
{
    while (scanf("%d",&n)  != EOF)
    {
        for (int i = 0; i < n; i++)
        {
            scanf("%d",&a[i]);
        }
        sort(a, a+n);
        scanf("%d",&k);
        if (k == 1)
        {
            printf("%d\n",a[n-1]);
            continue;
        }
        int l = 0,r = a[n-1];
        while (l < r)
        {
            int mid = (l+r)/2;
            if(j(mid))
                r = mid;
            else
                l = mid+1;
        }
        printf("%d\n",r);
    }
}

POJ 3579 Median

http://poj.org/problem?id=3579
给n个数，他们两两之间较大数减去较小数总共有n*(n-1)/2个数，要求这些数的中位数
stl