递归与分治笔记（2）

分治法的基本思想
分治法的基本思想是将一个规模为n的问题分解为k个规模较小的子问题，这些子问题互相独立且与原问题相同。
对这k个子问题分别求解。如果子问题的规模仍然不够小，则再划分为k个子问题，如此递归的进行下去，直到问题规模足够小，很容易求出其解为止。
将求出的小规模的问题的解合并为一个更大规模的问题的解，自底向上逐步求出原来问题的解。
分治法所能解决的问题一般具有以下几个特征：
1.该问题的规模缩小到一定的程度就可以容易地解决；
2.该问题可以分解为若干个规模较小的相同问题
3.利用该问题分解出的子问题的解可以合并为该问题的解；
4.该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子问题。
分治策略的算法设计模式
Divide_and_Conquer（P）{
if (|P|＜＝n0 ) return adhoc§；
divide P into smaller substances P1，P2，…，Pk；
for (i＝1; i＜＝k; k＋＋)
yi＝Divide-and-Conquer（Pi） //递归解决Pi
Return merge（y1，y2，…，yk） //合并子问题
}
二分搜索技术
给定已按升序排好序的n个元素a[0:n-1]，现要在这n个元素中找出一特定元素x。
适用分治法求解问题的基本特征：
该问题的规模缩小到一定的程度就可以容易地解决；
该问题可以分解为若干个规模较小的相同问题;
分解出的子问题的解可以合并为原问题的解；
分解出的各个子问题是相互独立的。
例题一：给出若干个整数,询问其中是否有一对数的和等于给定的数.
#include
#include
using namespace std;
int binsearch(int a[],int low,int high,int k){
int mid;
if(low>high)
return 0;
mid=(low+high)/2;
if(a[mid]==k)
return mid;
else if(k>a[mid])
return binsearch(a,mid+1,high, k);
else
return binsearch(a,low,mid-1, k);
}
int main(){
int i,n,a[1000],sum;
cin>>n;
for(i=1;i<=n;i++)
cin>>a[i];
sort(a+1,a+n+1);
cin>>sum;
for(i=1;i<n;i++) {
if(binsearch(a,i+1,n,sum-a[i])) {
cout<<a[i]<<" “<<sum-a[i]<<endl;
break;
}
}
return 0;
}
例题二：输入n个数，从小到大将他们输出，重复的数只输出一次
#include
#include
using namespace std;
void compute(int a[], int s, int e){
int mid,num,i,j,f,l;
if(s>e) { return ;}
mid=(s+e)/2; num=a[mid];
i=mid-1;
while(a[i]==num && i>=s) i–;
f=i;
i=mid+1;
while(a[i]==num && i<=e) i++;
l=i;
compute(a,s,f);
cout<<num<<” “;
compute(a,l,e);
}
int main(){
int a[]={0,1,2,2,4,6,3,2,3};
sort(a+1,a+sizeof(a)/sizeof(int) );
compute(a,1,sizeof(a)/sizeof(int)-1);
return 0;
}
例题三：众数和重数
#include
#include
using namespace std;
int num=0; //定义全局变量n用来存储众数
int sum=0; //定义一个全局变量sum用来存储重数
int count(int a[],int s,int e){//定义一个统计数组中间数出现的次数，a为待统计的集合，参数s为待递归数组第一个数的索引，e为带递归数组最后一个数的索引
int n=a[(s+e)/2];
int counts=0;
for(int i=s;i<e;i++) { //从待统计数组的第一个数的索引开始统计，直 到q结束
if(a[i]==n)
counts++;
}
return counts;
}
int start(int a[],int s,int e){
int x=0;
for(in t i=s;i<e;i++) {
if(a[i]a[(p+q)/2]) {
x=i;
break;
}
}
return x;
}
void mode( int a[],int s,int e){
int tnum=(s+e)/2; //tnum为当前数组中间数的索引
int tsum=count(a,s,e); //统计中间数的重数
int left=start(a,s,e); //找到当前数组中间数第一次出现的位置
if(tsum>sum) { //如果中间数的重数大于sum，将中间数赋给num
sum=tsum; num=a[tnum];
}
if(q-(left+tsum)>sum) /如果右边元素的个数大于重数sum,向右寻找
mode(a,left+tsum,e);
if(left>sum) //如果当前数组左边元素的个数大于重数sum，向左递归寻找
mode(a,s,left);
}
例题四：区间合并
#include
#include
using namespace std;
struct block{
int s,e;
};
bool cmp(block f, block e){
if (f.s<e.s)
return true;
return false;
}
block unionn(block b[], int f,int l){
if(fl)
return b[f];
block temp1,temp2;
temp1=unionn(b,f,(f+l)/2);
temp2=unionn(b,(f+l)/2+1,l);
if(temp1.e>=temp2.s){
block temp;
temp.s=temp1.s;
temp.e=temp1.e>temp2.e?temp1.e:temp2.e;
return temp;
}
else{
block temp;
temp.s=0; temp.e=0; return temp;
}
}
int main(){
block b[10000],temp;
int n,i,s,e;
cin>>n;
for(i=1;i<=n;i++){
cin>>b[i].s>>b[i].e;
}
sort(b+1,b+n+1,cmp);
temp=unionn(b,1,n);
cout<<temp.s<<” “<<temp.e<<endl;
return 0;
}
例题五：循环赛日程表
void Table(int k){ //k为分割次数
int i,r;
int n=1; //n为参赛人数
for(i=1;i<=k;i++)
n=n2;
for(i=0;i<n;i++)
a[0][i]=i+1;
//k次拷贝,r矩形区域的宽度
for(r=1;r<n;r=r2)
for(i=0;i<n;i+=2*r) {//1次拷贝，通过多对矩阵的拷贝完成
Copy(r, r+i, 0, i, r); //左上角拷贝到右下角
Copy(r, i, 0, r+i, r); //右上交角拷贝到左下角
}
}
int main(){
Table(3);
for(int i=0;i<=7;i++) {
for(int j=0;j<=7;j++)
cout<<a[i][j]<<” ";
cout<<endl;
} return 0; }
例题六：棋盘覆盖
void CB(int tr,tc,dr,dc,size){
if (size == 1) return;
int t = tile++; // L型骨牌顺序号
s = size/2; // 分割棋盘
// 处理左上角子棋盘
if (dr < tr + s && dc < tc + s) // 特殊方格在此棋盘中
CB(tr, tc, dr, dc, s);
else {
// 用 t 号L型骨牌覆盖右下角
board[tr + s - 1][tc + s - 1] = t;
// 覆盖其余方格
CB(tr, tc, tr+s-1, tc+s-1, s);
}
// 处理右上角子棋盘
if (dr < tr + s && dc >= tc + s)
// 特殊方格在此棋盘中
CB(tr, tc+s, dr, dc, s);
else {// 此棋盘中无特殊方格
// 用 t 号L型骨牌覆盖左下角
board[tr + s - 1][tc + s] = t;
// 覆盖其余方格
CB(tr,tc+s,tr+s-1,tc+s, s);
}
// 处理左下角子棋盘
if (dr >= tr + s && dc < tc + s)
// 特殊方格在此棋盘中
CB(tr+s, tc, dr, dc, s);
else {
board[tr + s][tc + s - 1] = t;
// 覆盖其余方格
CB(tr+s, tc, tr+s, tc+s-1, s);
}
// 处理右下角子棋盘
if (dr >= tr + s && dc >= tc + s)
// 特殊方格在此棋盘中
CB(tr+s, tc+s, dr, dc, s);
else {
board[tr + s][tc + s] = t;
// 覆盖其余方格
CB(tr+s, tc+s, tr+s, tc+s, s);}
}