算法基础学习笔记 二分算法

二分算法的基本思想就是每一次缩小查找范围的一半。

最常见的应用就是折半（二分）查找函数：

int BinarySearch(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;
} //复杂度O(log(n))

一个小技巧是为了防止  int mid = (L + R) / 2;的L + R的值超出int数值范围。

因此改为int mid = L+(R-L)/2;

应用例题一：

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

int LowerBound(int a[],int size,int p) //复杂度O(log(n))
{
    int L = 0; //查找区间的左端点
    int R = size - 1; //查找区间的右端点
    int lastPos = -1; //到目前为止找到的最优解
    while( L <= R) { //如果查找区间不为空就继续查找
        int mid = L+(R-L)/2; //取查找区间正中元素的下标
        if(a[mid]>= p)
            R = mid - 1;
        else {
            lastPos = mid;
            L = mid+1;
        }
    }
    return lastPos;
}

应用例题二：

输入n ( n<= 100,000)个整数，找出其中的两个数，它们之和等于整数m(假定肯定有解)。题中所有整数都能用 int 表示。

解法1：用两重循环，枚举所有的取数方法，复杂度是O(n 2 )的。
for(int i = 0;i < n-1; ++i)
for(int j = i + 1; j < n; ++j)
 if( a[i]+a[j] == m)
break;
100,000*100，000 = 100亿，在各种OJ上提交或参加各种程序设计竞赛，这样的复杂度都会超时！

解法2：
1) 将数组排序，复杂度是O(n×log(n))
2) 对数组中的每个元素a[i],在数组中二分查找m-a[i]，看能否找到。复杂度log(n)，最坏要查找n-2次，所以查找这部分的复杂度也是O(n×log(n))。
这种解法总的复杂度是O(n×log(n))的。

解法3：
1) 将数组排序，复杂度是O(n×log(n))
2) 查找的时候，设置两个变量i和j,i初值是0,j初值是n-1.看a[i]+a[j],如果大于m，就让j减1，如果小于m,就让i加1，直至a[i]+a[j]=m。
这种解法总的复杂度是O(n×log(n))的。

JAVA编程实现一：

public static void expectSum_bySort(int []arr, int expectSum){
        Arrays.sort(arr);
        int left = 0;
        int right = MaxCapacity - 1;
        while(left < right){
            if(arr[left] + arr[right] == expectSum){
                System.out.println(arr[left]+" + "+arr[right]+" = "+expectSum);
                left++;
                right--;
            }
            else if(arr[left] + arr[right] < expectSum){
                left++;
            }else{
                right--;
            }
        }
    }

JAVA编程实现二：时间复杂度为O（n）

    public static void expectSum_byHashSet(int []arr, int expectSum){
        HashSet<Integer> intSets = new HashSet<Integer>(arr.length);

        int suplement;
        for(int i : arr){
            suplement = expectSum - i;
            if(!intSets.contains(suplement)){
                intSets.add(i);
            }else{
                System.out.println(i + "+" +suplement + " = " +expectSum);
            }
        }
    }

应用例题三：POJ2456

农夫 John 建造了一座很长的畜栏，它包括N (2≤N≤100,000)个隔间，这些小隔间的位置为x 0 ,...,x N-1  (0≤x i ≤1,000,000,000,均为整数,各不相同).John的C (2≤C≤N)头牛每头分到一个隔间。牛都希望互相离得远点省得互相打扰。怎样才能使任意两头牛之间的最小距离尽可能的大，这个最大的最小距离是多少呢？

解法1：
先得到排序后的隔间坐标 x 0 ,...,x N-1从1,000,000,000/C到1依次尝试这个“最大的最近距离”D，找到的第一个可行的就是答案。
尝试方法：
1) 第1头牛放在x 0
2) 若第k头牛放在x i  ，则找到x i+1 到x N-1 中第一个位于[x i +D, 1,000,000,000]中的X j第k+1头牛放在X j 。找不到这样的X j ,则 D=D-1,转 1)再试     。若所有牛都能放下，则D即答案
复杂度 1,000,000,000/C *N，即 1,000,000,000, 超时!

解法2：
先得到排序后的隔间坐标 x 0 ,...,x N-1
在[L,R]内用二分法尝试“最大最近距离”D = (L+R)/2 (L,R初值为[1, 1,000,000,000/C]
若D可行，则记住该D，然后在新[L,R]中继续尝试(L= D+1)若D不可行，则在新[L,R]中继续尝试(R= D-1)
复杂度 log(1,000,000,000/C) * N

具体帖子详见：POJ 百练 2456:Aggressive cows

课后习题详见：北京大学MOOC 算法基础第五周 二分算法 测试