[PKU暑课笔记] 二分查找 分治

一、二分查找

●写一个函数BinarySeach，在包含size个元素的、从小到大排序的int数组a里查找元素 p,

如果找到，则返回元素下标，如果找不到，则返回-1。

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)) 

//注意：为了防止 (L+R)过大溢出，对mid取 int mid = L+(R-L)/2;

●POJ2456 Aggressive cows 最小值最大化

解法【复杂度 log(1,000,000,000/C) * N】

先得到排序后的隔间坐标 x0,...,xN-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) 

#include<iostream>
#include<string>
#include<cmath>
#include<cstdio>
#include<algorithm>
using namespace std;

int n,c;
int a[100005];

bool jud(int d)//判断是否可以放下c头牛
{
    int cnt=1;
    int tmp=a[0];
    for(int i=1; i<n; i++)
    {
        if(a[i]-tmp>=d)
        {
            cnt++;
            tmp=a[i];
            if(cnt>=c)
                return true;
        }
    }
    return false;
}

int main()
{
    while(~scanf("%d%d",&n,&c))
    {
        for(int i=0; i<n; i++)
        {
            cin>>a[i];
        }
        sort(a,a+n);
        int l=0,r=(1000000000/c);//二分
        while(l<=r)
        {
            int mid=l+(r-l)/2;
            if(jud(mid))l=mid+1;
            else r=mid-1;
        }
        cout<<l-1<<endl;
    }
    return 0;
}

●NOI 派

# include <bits/stdc++.h>
using namespace std;

const double PI = acos(-1.0);
const int N = 10005;

int n,f;
double a[N];
double s[N],maxx=0;

bool jud(double ss)
{
    int cnt=0;
    for(int i=1;i<=n;i++)
    {
        cnt+=(int)(s[i]/ss);
        if(cnt>=f+1)return true;
    }
    return false;
}

int main ()
{
    cin>>n>>f;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
        s[i]=(double)a[i]*a[i]*PI;
        if(maxx<s[i])maxx=s[i];
    }
    double l=0,r=maxx;
    while(r-l>=1e-5)
    {
        double mid=l+(r-l)/2;
        if(jud(mid))l=mid;
        else r=mid;
    }
    printf("%.3f",l);
    return 0;
}

二、分治

把一个任务，分成形式和原任务相同，但规模更小的 几个部分任务（通常是两个部分），分别完成，或只 需要选一部完成。然后再处理完成后的这一个或几个 部分的结果，实现整个任务的完成。

●典型应用：归并排序

1)  把前一半排序

2)  把后一半排序 

3)  把两半归并到一个新的有序数组，然后再拷贝回原数组，排序完成

#include <iostream>
using namespace std;

void Merge(int a[],int s,int m, int e,int tmp[])
{
//将数组a的局部a[s,m]和a[m+1,e]合并到tmp,并保证tmp有序，然后再拷贝回a[s,m]
//归并操作时间复杂度：O（e-m+1),即O（n)
    int pb = 0;
    int p1 = s,p2 = m+1;
    while( p1 <= m && p2 <= e)
    {
        if( a[p1] < a[p2])
            tmp[pb++] = a[p1++];
        else
            tmp[pb++] = a[p2++];
    }
    while(p1 <= m)
        tmp[pb++] = a[p1++];
    while(p2 <= e)
        tmp[pb++] = a[p2++];
    for(int i = 0; i < e-s+1; ++i)
        a[s+i] = tmp[i];
}

void MergeSort(int a[],int s,int e,int  tmp[])
{
    if(s < e)
    {
        int m = s + (e-s)/2;
        MergeSort(a,s,m,tmp);
        MergeSort(a,m+1,e,tmp);
        Merge(a,s,m,e,tmp);
    }
}

int a[10] = {13,27,19,2,8,12,2,8,30,89};
int b[10];

int main()
{
    int size = sizeof(a)/sizeof(int);
    MergeSort(a,0,size-1,b);
    for(int i = 0; i < size; ++i)
        cout << a[i] << ",";
    cout << endl;
    return 0;
}

●输出前m大的数

●求排列的逆序数MergeSortAndCount

考虑1,2,…,n (n <= 100000)的排列i1，i2，…，in，如果其中存在j,k，满足 j < k 且 ij > ik， 那么就称(ij,ik)是这个排列的一个逆序

【每次递归数列的长度都会减半，所以递归的深度为O（logn），而每层总的操作都是O（n），所以总的复杂度为O（nlogn）】

1） 将数组分成两半，分别求出左半边的逆序数和右半边的逆序数

2） 再算有多少逆序是由左半边取一个数和右半边取一个数构成