分而治之算法

1、经典二分法——求最大最小元素

思路分析：
1、将区间分为左右两个区间，分别得出两个区间的最大最小值。
2、将四个值做比较就可以知道整个区间的最大和最小值。

#include <bits/stdc++.h>
using namespace std;
 
int a[10]={5,3,9,7,4,1,0,8,10,-2};    //原始数组
int len=sizeof(a)/sizeof(a[0]);        //数组长度 

//形参为区间[l~r]  、  此区间的最大最小值 
void dfs(int l , int r , int &Max , int &Min){
    //取中间
    int mid = (l+r)/2;
    //左区间的最大最小值、右区间的最大最小值 
    int left_max,left_min,right_max,right_min; 

    //当次区间只有一个元素 
    if(l==r) Max=Min=a[l];    
    
    //当此区间有两个元素 
    else if(abs(r-l) == 1) a[l]<a[r] ? Max=a[r],Min=a[l] : Max=a[r],Min=a[l];  
    
    //当此区间有多个元素 
    else{
        dfs(l,mid,left_max,left_min);    //查找左区间 
        dfs(mid+1,r,right_max,right_min);    //查找右区间
        
        //更新区间的最大最小值 
        left_max < right_max ? Max=right_max : Max=left_max;
        left_min < right_min ? Min=left_min  : Min=right_min;
    }
} 

int main()
{
    int Max,Min;
    dfs(0,len,Max,Min);
    cout<<Max<<endl<<Min;     //打印结果为10、-2
}

2、二分求解不独立的问题——最大字串和

思路分析：
1、同样还是分为两个区间来不断减小范围。
2、但是由于区间当中会存在公共的子串，也就是最大子串可能会出现在中间点的两端。
3、所以应该在二分的基础之上，对中间点两端做计算，这样我们就可以有3个结果。
4、即左区间、右区间、中间的最大子串和，在这三者当中选取最大值即可。

代码如下：

#include <bits/stdc++.h>
using namespace std;
 
int a[10]={5,3,9,7,-4,1,0,8,10,-5};    //原始数组
int len=sizeof(a)/sizeof(a[0]);        //数组长度 

//表示区间[l~r]的最大子串和 
int max_sub_sum(int l , int r){
    
    int mid = (l+r)/2;    //取中间
    //这两个变量存放：左右区间最大子串和 
    int left_max_sub_sum , right_max_sub_sum;


    //当只有一个元素时 
    if(l==r) return a[l];
    
    //当有多个元素时
    else {
        left_max_sub_sum  = max_sub_sum(l,mid);
        right_max_sub_sum = max_sub_sum(mid+1,r);

        int lsum=0;        //左区间的和
        int rsum=0;        //右区间的和
        
        int temp=0;        //临时的变量 
        for(int i=mid;i>=l;i--){
            temp+=a[i];
            if(temp > lsum) lsum=temp; //更新此区间的最大值 
        }
        
        temp=0;
        for(int i=mid+1;i<=r;i++){
            temp+=a[i];
            if(temp > rsum) rsum=temp; //更新此区间的最大值 
        }
        
        //取左区间最大子串和、右区间最大子串和、中间的子串和的最大值 
        return max(lsum+rsum , max(left_max_sub_sum , right_max_sub_sum));
    }
}

int main()
{
    cout<<max_sub_sum(0,len-1);         //打印结果为39 
}

3、二分解决不相似的问题——残缺棋盘

题目介绍：
1、在棋盘当中存在一个残缺的格子，我们需要用多个三格板将次棋盘覆盖。
2、给出一个4*4的残缺棋盘摆放方法。（彩色为三格板位置，图中5种不同的颜色对应5块三格板）

分析：
1、可以将多个棋盘分解为最小棋盘（2*2），只要将中间的一块三格板假设为残缺，那么就可以将不相似的问题变为相似的问题。
2、只需要分别讨论这四个区间即可，采用模拟坐标的方法，先将中间的格子设置为原点，分别看其区间在原点的位置，下图的原点应该为[2，2]。（解释：该棋盘n=4，取中间就为4/2=2，当然其他方法也是可以的，读者可以根据具体情况使用自己的方法）

代码实现：（一个8*8的棋盘，残缺位置为第2行第1列，注意：下面代码数组下标从0开始）

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

int board[MAX][MAX];
int three_plate_num = 1;
void fun(int x,int y,int x0,int y0,int n){
    //当只有一行一列时会退出 
    if(n<=1) return;
    
    int three_plate_id = three_plate_num ++;    //三格板编号
    
    int mid = n/2;    //减小问题的规模
    
    //此时中点位置为 [x+mid][y+mid]
    /*残缺的在左上方时 */
    if(x0 < x+mid && y0 < y+mid){
        fun(x , y , x0 , y0 , mid);                    //对左上方的棋盘递归 
        fun(x , y+mid , x+mid-1 , y+mid , mid);        //对左下方的棋盘递归
        fun(x+mid , y+mid , x+mid , y+mid-1 , mid);    //对右下方的棋盘递归
        fun(x+mid , y , x+mid , y+mid , mid);          //对右上方的棋盘递归
        
        board[x+mid-1][y+mid] = three_plate_id;        //为左下方的棋盘赋值
        board[x+mid][y+mid]   = three_plate_id;        //为右下方的棋盘赋值 
        board[x+mid][y+mid-1] = three_plate_id;        //为右上方的棋盘赋值         
    }
    /*残缺的在左下方时 */
    if(x0 < x+mid && y0 >= y+mid){
        fun(x , y+mid , x0 , y0 , mid);              //对左下方的棋盘递归
        fun(x , y , x+mid-1 , y+mid-1 , mid);       //对左上方的棋盘递归
        fun(x+mid , y+mid , x+mid , y+mid , mid);    //对右下方的棋盘递归
        fun(x+mid , y , x+mid , y+mid-1 , mid);      //对右上方的棋盘递归
        
        board[x+mid-1][y+mid-1] = three_plate_id;    //为左上方的棋盘赋值
        board[x+mid][y+mid]     = three_plate_id;    //为右下方的棋盘赋值 
        board[x+mid][y+mid-1]   = three_plate_id;    //为右上方的棋盘赋值     
    }
    /*残缺的在右上方时 */
    if(x0 >= x+mid && y0 < y+mid){
        fun(x+mid , y , x0 , y0 ,mid);                //对左上方的棋盘递归
        fun(x , y+mid , x+mid-1 , y+mid , mid);       //对左下方的棋盘递归
        fun(x+mid , y+mid , x+mid , y+mid-1 , mid);   //对右下方的棋盘递归
        fun(x , y , x+mid-1 , y+mid-1 , mid);         //对左上方的棋盘递归
        
        board[x+mid-1][y+mid]   = three_plate_id;     //为左下方的棋盘赋值
        board[x+mid][y+mid]     = three_plate_id;     //为右下方的棋盘赋值 
        board[x+mid-1][y+mid-1] = three_plate_id;     //为左上方的棋盘赋值 
    }
    /*残缺的在右下方时 */
    if(x0 >= x+mid && y0 >= y+mid){
        fun(x+mid , y+mid , x0 , y0 , mid);          //对右下方的棋盘递归 
        fun(x , y+mid , x+mid-1 , y+mid ,mid);       //对左下方的棋盘递归
        fun(x , y , x+mid-1 , y+mid-1 ,mid);         //对左上方的棋盘递归
        fun(x+mid , y , x+mid , y+mid ,mid);         //对右上方的棋盘递归
        
        board[x+mid-1][y+mid]   = three_plate_id;    //为左下方的棋盘赋值
        board[x+mid-1][y+mid-1] = three_plate_id;    //为左上方的棋盘赋值 
        board[x+mid][y+mid-1]   = three_plate_id;    //为右上方的棋盘赋值         
    }
}

/*打印坐标上的点*/
void print_board(int n){
    for(int i=0 ; i<n ;i++){
        for(int j=0 ; j<n ; j++) cout<<board[i][j]<<"\t";
        cout<<endl;
    }
}


int main(){
    //以上面的样例执行一下效果
    fun(0,0,1,0,8);
    print_board(8);
}

让我们来看一下运行结果：