[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
;
double s
,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） 再算有多少逆序是由左半边取一个数和右半边取一个数构成