分治的基本思想：

当要求解一个输入规模n相当大的问题时，直接求解往往是非常困难的，甚至没法求出。正确的方法是, 首先应仔细分析问题本身所具有的特性，然后根据这些特性选择适当的设计策略来求解。

在将这n个输入分成k个不同子集合的情况下，如果能得到k个不同的可独立求解的子问题，而且在求解之后，还可找到适当的方法把它们合并成整个问题的解，那么，可考虑使用分治法来求解。

分治法所能解决的问题一般具有以下几个特征：

该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子问题。 

分治法的复杂性分析：

利用迭代法求解则有：

二分搜索：

时间复杂度为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^k-1)/3个

递归算法：

#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);
}