二分搜索——不光是查找值

摘要：

　　本文主要讲述了二分搜索算法的基本思想和实现原理，着重讲解了二分搜索法在编程竞赛中的一些典型应用。

• 基本思想
• 实现原理
• 典型应用
• 例题解析

---

　  基本思想

　　二分搜索法的基本思想是通过不断的缩小解可能存在的范围，从而求得问题最优解的方法。比如一个直观的问题是在一个由小到大的数列a中找到一个数ai，使得ai满足ai>=k的同时，i最小。由于此数列是有序的，所以找到中间位置的数amid和k比较，如果k<=amid，证明k在左半区域，区间左边界变为mid，否则在右半区域,区间右边界变为mid。如此下来，直至区间长度小于1，结束循环，最小的i就是右边界的值。

　　二分搜索的优势在于时间上的高效，每次去掉一半的搜索区间，可以在O(logn)的时间复杂度求得最终的解。但是这种高效是建立在事先将数排好序的基础上的。

　  实现原理

　　反复与区间的中点进行比较，不断的将解的范围缩小到原来的一半，直至满足一定的条件后结束算法。简单起见，直接看一道VJudge上的例题Lower Bound ，具体细节参考如下代码：

#include <cstdio>

const int maxn = 100000 + 10;
int a[maxn];
int n, q;

void query(int k) {
    int lb = -1, ub = n;//初始化区间短点 
    while(ub - lb > 1) {//结束条件是当区间的长度小于1的时候 
        int mid = (ub + lb) / 2;
        //通过判断缩小区间为原来的一半 
        if(a[mid] >= k)
            ub = mid;
        else
            lb = mid;
    }
    
    printf("%d
", ub);
}

int main()
{
    while(scanf("%d", &n) != EOF) {
        for(int i = 0; i < n; i++) {
            scanf("%d", &a[i]);
        }
        
        scanf("%d", &q);
        while(q--) {
            int k;
            scanf("%d", &k);
            query(k);//查询k 
        }
    }
    return 0;
}

　　当然C++中的STL以lower_bound函数的形式实现了二分搜索，直接可以调用。参考代码如下：

#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;

const int maxn = 100000 + 10;
int n, q;
vector<int> v;

int main () {
    while(scanf("%d", &n) != EOF) {
        v.clear();
        for(int i = 0; i < n; i++) {
            int tmp;
            scanf("%d", &tmp);
            v.push_back(tmp);
        }
        
        scanf("%d", &q);
        while(q--) {
            int k;
            scanf("%d", &k);
            
            printf("%d
", lower_bound(v.begin(), v.end(), k) - v.begin());
        }
    }    
    return 0;
}

　　在编程竞赛中的典型应用

　　二分搜索算法除了在有序数组中查找值之外，在求解最优解的问题上也非常有用。比如求满足某个条件C(x)的最小x,我们可以假定一个区间，取该区间的中点值为mid，如果满足C(mid)，左边界等于区间中点，即将范围缩小在右侧（最大化），如果不满足，那么右边界等于区间中点，即将范围缩小在左侧。直到将区间缩小到一定的程度后，在此精度下的问题最优解就求出来了。

　　1.假定一个解并判断是否可行，例如POJ 1064 Cable master

　　2.最大化最小值，例如POJ 2456 Aggressive cows

　　3.最大化平均值，例如POJ 3111 K Best

　　例题解析

　　POJ 1064 Cable master

　　有N条绳子，长度分别是Li，如果从它们中切割出K条长度相同的绳子的话，每条绳子最长是多少

　   我们将区间设为0到INF（最大），然后尝试区间的中点，向满足条件的最大值逼近（循环100次精度大概是1e-30）。条件C(x)：Li/x的总和是否大于K，代码如下：（坑点是最后输出保留两位小数，不进位）

#include <cstdio>
#include <cmath>
const int maxn = 10000 + 10;
const int inf = 99999999;

int N, K;
double L[maxn];

bool C(double 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;
    for(int i = 0;i < 100; i++) {
        double mid = (ub + lb) / 2;
        if(C(mid))
            lb = mid;
        else 
            ub = mid;
    }
    
    printf("%.2f
", floor(ub * 100) / 100);
}
int main()
{
    while(scanf("%d%d", &N, &K) != EOF) {
        for(int i = 0; i < N; i++) {
            scanf("%lf", &L[i]);
        }
        
        solve();
    }    
    return 0;
} 

　　POJ 2456 Aggressive cows

　　将M头牛放在N个牛舍里，使得这M头牛之间的举例尽可能的大。

　　意即求解满足C(d)的最大d。而其中的d表示M头牛之间的举例均不小于d。区间的结束条件就是区间长度大于等于1，关键是如何判断满足条件，其实也好判，采用贪心的方法，一次往后使用即可，如果M头牛安排完了，满足，否则不满足。代码如下：

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

const int maxn = 100000 + 10;
const int inf = 1000000000 + 10;
int N, M;
int x[maxn];

bool C(int d) {
    int last = 0; 
    for(int i = 1; i < M; i++) {
        int crt = last + 1;
        while(crt < N && x[crt] - x[last] < d) {
            crt++;
        }
        
        if(crt == N)    return false;
        last = crt;
    }
    return true;
}
void solve() {
    sort(x, x + N);
    
    int lb = 0, ub = inf;
    while(ub - lb > 1) {
        int mid = (ub + lb) / 2;
        if(C(mid))
            lb = mid;
        else
            ub = mid;
    }     
    
    printf("%d
", lb);
}
int main()
{
    while(scanf("%d%d", &N, &M) != EOF) {
        for(int i = 0; i < N; i++) {
            scanf("%d", &x[i]);
        }
        
        solve();
    }
    return 0;
} 

　　POJ 3111 K Best

　　有n个物品的价值和重量分别是vi和mi，从中选出k件物品使得单位重量的价值最大。

　　C(x)=（(vi - x * wi) 从大到小排列中的前k个的和不小于0）

　　精度1e-30

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

const int maxn = 100000 + 10;
const double inf = 0x3f3f3f3f;
const double EPS = 1.0e-6;

int N, K;
int v[maxn], w[maxn];
struct Node {
    double val;
    int id;
} y[maxn];

bool cmp(struct Node a, struct Node b) {
    return a.val > b.val;
}
bool C(double x) {
    for(int i = 0; i < N; i++) {
        y[i].id = i + 1;
        y[i].val = (v[i] - x * w[i]);
    }
    
    sort(y, y + N, cmp);
    double sum = 0;
    for(int i = 0; i < K; i++) {
        sum += y[i].val;
    }
    return sum >= 0;
}
void solve() {
    double lb = 0, ub = inf;
    
    while(ub - lb > EPS) {
        double mid = (ub + lb) / 2;
        if(C(mid))
            lb = mid;
        else
            ub = mid;
    }    
    
    for(int i = 0; i < K - 1; i++) {
        printf("%d ", y[i].id);
    }
    printf("%d ", y[K - 1].id);
}

int main()
{
    while(scanf("%d%d", &N, &K) != EOF) {
        for(int i = 0; i < N; i++) {
            scanf("%d%d", &v[i], &w[i]);
        }
        
        solve();
    }    
    return 0;
}

　　至此，二分搜索算法就讲完了，二分的思想就是一次去一半，寻找满足条件的最优，在解决最优解问题的时候要找好结束条件和满足的条件。算法不难，关键是思考问题和实现算法的过程。