分治的基本思想:
当要求解一个输入规模n相当大的问题时,直接求解往往是非常困难的,甚至没法求出。正确的方法是, 首先应仔细分析问题本身所具有的特性,然后根据这些特性选择适当的设计策略来求解。
在将这n个输入分成k个不同子集合的情况下,如果能得到k个不同的可独立求解的子问题,而且在求解之后,还可找到适当的方法把它们合并成整个问题的解,那么,可考虑使用分治法来求解。
分治法所能解决的问题一般具有以下几个特征:
该问题的规模缩小到一定的程度就可以容易地解决;该问题可以分解为 若干个规模较小的相同问题,即该问题具有最优子结构性质;
利用该问题分解出的子问题的解可以合并为该问题的解;
该问题所分解出的各个子问题是相互独立的,即子问题之间不包含公共的子问题。
分治法的复杂性分析:
一个分治法将规模为n的问题分成k个规模为n/m的子问题去解。设分解阀值n0=1,且adhoc解规模为1的问题耗费1个单位时间。再设将原问题分解为k个子问题以及用merge将k个子问题的解合并为原问题的解需用f(n)个单位时间。用T(n)表示该分治法解规模为|P|=n的问题所需的计算时间,则有:利用迭代法求解则有:
二分搜索:
时间复杂度为O(logn)
非递归算法:
#include<iostream>
#include<cstdio>
using namespace std;
int BinarySearch(int a[],int x,int n){//在一共有n个元素的数组a里找x
int left=0,right=n-1;
while(left<=right){
int mid=(left+right)/2;
if(x==a[mid])return mid+1;
else if(x>a[mid])left=mid+1;
else right=mid-1;
}
return 0;
}
int main(){
int x,a[]={1,3,5,6,8,10,13,17};
while(scanf("%d",&x)!=EOF){
int ans=BinarySearch(a,x,8);
if(!ans)printf("Cannot find it\n");
else printf("position is %d\n",ans);
}
}
递归算法:
#include<iostream>
#include<cstdio>
using namespace std;
int BinarySearch(int a[],int x,int left,int right){
if(right<left)return 0;
int mid=(left+right)/2;
if(x==a[mid])return mid+1;
else if(x>a[mid])BinarySearch(a,x,mid+1,right);
else BinarySearch(a,x,left,mid-1);
}
int main(){
int x,a[]={1,3,5,6,8,10,13,17};
while(scanf("%d",&x)!=EOF){
int ans=BinarySearch(a,x,0,7);
if(!ans)printf("Cannot find it\n");
else printf("position is %d\n",ans);
}
}
大整数乘法:
设X,Y是N位二进制整数,将其二者相乘,若把每两个一位数相乘或加法看做是一步运算,则要进行O(n^2)步运算才能得到乘积。
改进一:分治法(a、b、c、d分段均为n/2位!并假设n为2的幂数!)
X = a*2^(n/2) + b Y = c*2^(n/2) + d
XY = ac*2^n + (ad+bc)*2^(n/2) + bd
把两个n位数相乘换成了4个n/2位数相乘,3次加法运算,以及还要做2次移位操作( 2^n和2^(n/2) ),把加法操作和移位操作用O(n)表示。
改进二:
发现改进一的性能并不好,我们要尽量减少整数相乘的次数,所以用结合律来进行变形。
XY = ac*2^n + ((a-b)(d-c)+ac+bd) 2^(n/2) + bd
这时只用做3次n/2为整数的乘法,6次加减,和两次移位就好了
Strassen矩阵乘法:
若这样定义矩阵乘法:
则则每计算C的一个元素C[i][j],需要做n次乘法和n-1次加法。因此,算出矩阵C的n2个元素所需的计算时间为O(n3)
for(int i=0;i<ra;i++){
for(int j=0;j<cb;j++){
temp=0;
for(int k=0;k<ca;k++){
temp+=a[i][k]*b[k][j];
}
c[i]=temp;
}
}
3层for循环,O(n^3)
改进一:
可以发现并没有比原方法更有效,因为没有减少乘法的次数。
改进二:
Strassen提出了一种新的算法来计算2个二阶方阵的乘法,这用了7次乘法运算,但增加了加法、减法的运算次数:
做了7次乘法后,再做若干次加法、减法就可以得到:
棋盘覆盖:
在一个2^k×2^k 个方格组成的棋盘中,恰有一个方格与其它方格不同,称该方格为一特殊方格,且称该棋盘为一特殊棋盘。
在棋盘覆盖问题中,要用图示的4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格,且任何2个L型骨牌不得重叠覆盖,通过分析发现第一个L型骨牌的放置位置非常重要,用下图第4个放到正中间。
用到的L型骨牌数是:(4^k-1)/3个
递归算法思想是:
(1)将棋盘划分成左上,左下,右上,右下四部分
(2)若这一部分包含特殊方格,则递归分成四部分
(3)若不包含特殊方格,则加上一个特殊方格后递归
其中用一个二维整型数组board表示棋盘。
Board[0][0]是棋盘的左上角方格。
Tile是算法中的一个全局整型变量,用来表示L型骨牌的编号,其初始值为0。
算法的输入参数是:
tr:棋盘左上角方格的行号
tc:棋盘左上角方格的列号
dr:特殊方格所在的行号
dc:特殊方格所在的列号
k:棋盘边长
递归算法:
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int Board[100][100];
int tile=1;//L型骨牌号
void ChessBoard(int tr,int tc,int dr,int dc,int k){//k为棋盘的边长
if(k==1)return ;//棋盘的边长为1则退出
int t=tile++;//L型骨牌号
int s=k/2;//分割棋盘
//覆盖左上角的子棋盘
if(dr<tr+s&&dc<tc+s){//特殊方格在此棋盘中
ChessBoard(tr,tc,dr,dc,s);
}
else{//棋盘中无特殊方格,用t号L型骨牌覆盖右下角
Board[tr+s-1][tc+s-1]=t;
ChessBoard(tr,tc,tr+s-1,tc+s-1,s);//覆盖其余方格
}
//覆盖右上角的子棋盘
if(dr<tr+s&&dc>=tc+s){//特殊方格在此棋盘中
ChessBoard(tr,tc+s,dr,dc,s);
}
else{//棋盘中无特殊方格,用t号L型骨牌覆盖左下角
Board[tr+s-1][tc+s]=t;
ChessBoard(tr,tc+s,tr+s-1,tc+s,s);
}
//覆盖左下角的子棋盘
if(dr>=tr+s&&dc<tc+s){//特殊方格在此棋盘中
ChessBoard(tr+s,tc,dr,dc,s);
}
else{//棋盘中无特殊方格,用t号L型骨牌覆盖右上角
Board[tr+s][tc+s-1]=t;
ChessBoard(tr+s,tc,tr+s,tc+s-1,s);
}
//覆盖右下角的子棋盘
if(dr>=tr+s&&dc>=tc+s){//特殊方格在此棋盘中
ChessBoard(tr+s,tc+s,dr,dc,s);
}
else{//棋盘中无特殊方格,用t号L型骨牌覆盖左上角
Board[tr+s][tc+s]=t;
ChessBoard(tr+s,tc+s,tr+s,tc+s,s);
}
}
void outPut(int k){
for(int i=0;i<k;i++){
for(int j=0;j<k;j++){
printf("%4d",Board[i][j]);
}
printf("\n");
}
}
int main(){
int tr=0,tc=0;//棋盘左上角方格的行号,列号
int dr,dc;//特殊方格所在的行号,列号
int k;//棋盘边长
scanf("%d%d%d",&dr,&dc,&k);
memset(Board,0,sizeof(Board));
ChessBoard(tr,tc,dr,dc,k);
outPut(k);
}
![](https://i-blog.csdnimg.cn/blog_migrate/b14e103165ed081617708a24cd2ee993.png)