分治算法详解及经典例题

一、基本概念

    在计算机科学中，分治法是一种很重要的算法。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础，如排序算法(快速排序，归并排序)，傅立叶变换(快速傅立叶变换)……

    任何一个可以用计算机求解的问题所需的计算时间都与其规模有关。问题的规模越小，越容易直接求解，解题所需的计算时间也越少。例如，对于n个元素的排序问题，当n=1时，不需任何计算。n=2时，只要作一次比较即可排好序。n=3时只要作3次比较即可，…。而当n较大时，问题就不那么容易处理了。要想直接解决一个规模较大的问题，有时是相当困难的。

二、基本思想及策略

    分治法的设计思想是：将一个难以直接解决的大问题，分割成一些规模较小的相同问题，以便各个击破，分而治之。

    分治策略是：对于一个规模为n的问题，若该问题可以容易地解决（比如说规模n较小）则直接解决，否则将其分解为k个规模较小的子问题，这些子问题互相独立且与原问题形式相同，递归地解这些子问题，然后将各子问题的解合并得到原问题的解。这种算法设计策略叫做分治法。

    如果原问题可分割成k个子问题，1

三、分治法适用的情况

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

1) 该问题的规模缩小到一定的程度就可以容易地解决

2) 该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质。

3) 利用该问题分解出的子问题的解可以合并为该问题的解；

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

第一条特征是绝大多数问题都可以满足的，因为问题的计算复杂性一般是随着问题规模的增加而增加；

第二条特征是应用分治法的前提它也是大多数问题可以满足的，此特征反映了递归思想的应用；、

第三条特征是关键，能否利用分治法完全取决于问题是否具有第三条特征，如果具备了第一条和第二条特征，而不具备第三条特征，则可以考虑用贪心法或动态规划法。

第四条特征涉及到分治法的效率，如果各子问题是不独立的则分治法要做许多不必要的工作，重复地解公共的子问题，此时虽然可用分治法，但一般用动态规划法较好。

四、可使用分治法求解的一些经典问题

（1）二分搜索

（2）大整数乘法

（3）Strassen矩阵乘法

（4）棋盘覆盖

（5）合并排序

（6）快速排序

（7）线性时间选择

（8）最接近点对问题

（9）循环赛日程表

（10）汉诺塔

 

五、分治法的基本步骤

分治法在每一层递归上都有三个步骤：

step1 分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题；

step2 解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题

step3 合并：将各个子问题的解合并为原问题的解。

它的一般的算法设计模式如下：

Divide-and-Conquer(P)

1. if |P|≤n0

2. then return(ADHOC(P))

3. 将P分解为较小的子问题 P1 ,P2 ,…,Pk

4. for i←1 to k

5. do yi ← Divide-and-Conquer(Pi) △ 递归解决Pi

6. T ← MERGE(y1,y2,…,yk) △ 合并子问题

7. return(T)

    其中|P|表示问题P的规模；n0为一阈值，表示当问题P的规模不超过n0时，问题已容易直接解出，不必再继续分解。ADHOC(P)是该分治法中的基本子算法，用于直接解小规模的问题P。因此，当P的规模不超过n0时直接用算法ADHOC(P)求解。算法MERGE(y1,y2,…,yk)是该分治法中的合并子算法，用于将P的子问题P1 ,P2 ,…,Pk的相应的解y1,y2,…,yk合并为P的解。

六、分治法的复杂性分析

   一个分治法将规模为n的问题分成k个规模为n／m的子问题去解。设分解阀值n0=1，且adhoc解规模为1的问题耗费1个单位时间。再设将原问题分解为k个子问题以及用merge将k个子问题的解合并为原问题的解需用f(n)个单位时间。用T(n)表示该分治法解规模为|P|=n的问题所需的计算时间，则有：

T（n）= k T(n/m)+f(n)

通过迭代法求得方程的解

七、依据分治法设计程序时的思维过程

实际上就是类似于数学归纳法，找到解决本问题的求解方程公式，然后根据方程公式设计递归程序。

1、一定是先找到最小问题规模时的求解方法

2、然后考虑随着问题规模增大时的求解方法

3、找到求解的递归函数式后（各种规模或因子），设计递归程序即可。

八、算法举例

（1）二分查找

二分查找也是典型的分治算法的有应用。二分查找需要一个默认的前提，那就是查找的数列是有序的。 
二分查找的思路比较简单： 
1） 选择一个标志i将集合分为二个子集合 
2） 判断标志L(i)是否能与要查找的值des相等，相等则直接返回 
3） 否则判断L(i)与des的大小 
4） 基于判断的结果决定下步是向左查找还是向右查找 
5） 递归记性上面的步骤

 

（2）输油管道问题

解题思路 
本题目可以分为两个步骤： 

　　1、找出主管道的位置； 
　　2、根据主管道的位置，计算各个油井到主管道的长度之和。

根据题意，设主管道贯穿东西，与y 轴平行。而各个子油井则分布在主输油管道的上下两侧。如下图：

由上图，其实只需要确定主管道的y 坐标，而与各个子油井的x 坐标无关！

根据猜测，易知：主管道的y 坐标就是所有子油井y 坐标的中位数。（可以用平面几何知识证明，略）

求中位数的方法可以用排序后取a[(left+right)/2]，当然更推荐用书上的线性时间选择算法解决。记求得的主管道为Ym，

最后要输出的结果只需要计算,每个油井与中位数的差值之和。

#include  

#include  

void swap(int &a,int &b)

{ 
 int tmp = a; 

        a = b;  

        b = tmp; 

}

 //(此处的划分就体现了分治的思想)本函数求arr[p:q]的一个划分i，使arr[p:i-1]都小于arr[i]，arr[i+1,q]都大于arr[i]

int partition(int *arr,int p,int q) { 

 　　int index = p-1,

　　　　start = p,

　　　　base = arr[q];

　　for(;start)  { 
  　　　　if(arr[start]<=base) {

　　　　　　　　swap(arr[start],arr[++index]);

　　　　　　}

　　　　}

　　　　swap(arr[++index],arr[q]);
　　　　return index;

}

 

//快速排序

void qsort (int *arr,int p ,int q) {

　　if (p<=q) {

　　　　int pos = partition(arr,p,q);

　　　　qsort(arr,p,pos-1);

　　　　qsort(arr,pos+1,q);

　　　}

}

int arr[1000];

int main() {

　　int n;

　　while(scanf("%d",&n)!=EOF){

　　　　for(int i=0;i){

　　　　　　scanf("%d %d",&arr[i],&arr[i]);

　　　　}

　　　　qsort(arr,0,n-1);

　　　　long long sum = 0;

　　　　int mid = arr[n/2];

　　　　for(int i=0;i){

　　　　　　sum+=abs(mid - arr[i]);

　　　　}

　　　　printf("%I64d\n",sum);

　　}

return 0;

}

 说明：类似的还有邮局选址问题：与之类似，这次是要找出在居民点中邮局的最佳位置。很容易想到，这次不仅要确定y的坐标，还要确定x的坐标。当然均为其对应坐标的中位数；最终的计算结果，要求距离之和，即向量模的计算方法加和即可。

 （3）集合的划分

F（n,m）表示把n个元素的集合分为m个子集，有多少种分法？

 

n个元素的集合可以划为F（n,m）个不同的由m个非空子集组成的集合。

考虑3个元素的集合，可划分为：

① 1个子集的集合：{ {1，2，3} }

② 2个子集的集合：{{1，2} ，{3}}  ，  {{1，3}，{2}}  ，  {{2，3}，{1}}

③ 3个子集的集合：{{1}，{2}，{3}}

所以 F（3，1）=1

　　 F（3，2）=3

　　 F（3，3）=1

 如果要求F（4，2）该怎么办呢？

A.往①里添加一个元素 {4} ，得到{{1，2，3}，{4}}

B.往②里的任意一个子集添一个4，得到

{{1，2，4}，{3}}  ，  {{1，2}，{3，4}}

{{1，3，4}，{2}}  ，  {{1，3}，{2，4}}

{{2，3，4}，{1}}  ，  {{2，3}，{1，4}}

所以F（4，2） = F（3，1）+2*F（3，2） = 7

以此推广得，F（n，m） =  F （n-1，m-1）+ m * F（n-1，m）

#include 

long long divide( int  n,int  m) {

　　if (m==1 || m ==n){

　　　　return 1;
　　}else{

　　　　return divide(n-1,m-1)+m*divide(n-1,m);
　　}

}

int main(){

　　int  n,m;

　　while (scanf("%d%d",&n,&m) != EOF){

　　　　printf("%I64d\n",divide(n,m));
　　}

　　return 0;

}

（4）求复杂度为O（lg n）的X的 n 次幂

 

#include "stdio.h"
#include "stdlib.h"

int power(int x, int n)
{
    int result;
    if(n == 1)
        return x;
    if( n % 2 == 0)
        result = power(x, n/2) * power(x, n / 2);
    else
        result = power(x, (n+1) / 2) * power(x, (n-1) / 2);

    return result;
}

int main()
{
    int x = 5;
    int n = 3;

    printf("power(%d,%d) = %d \n",x, n, power(x, n));
}

（5）二路归并排序

描述：
时间复杂度是O(NlogN)，空间复制度为O(N)（归并排序的最大缺陷）
归并排序（Merge Sort）完全遵循上述分治法三个步骤：
1、分解：将要排序的n个元素的序列分解成两个具有n/2个元素的子序列；
2、解决：使用归并排序分别递归地排序两个子序列；
3、合并：合并两个已排序的子序列，产生原问题的解。

数组代码实现：

#include "stdio.h"
#include "stdlib.h"
#include "assert.h"
#include "string.h"

void print_arr(int *arr, int len)
{
    int i = 0;

    for(i = 0; i < len; i ++)
        printf("%d ",arr[i]);
    printf("\n");
}

void merge(int *arr, int low, int mid, int hight, int *tmp)
{
    assert(arr && low >= 0 && low <= mid && mid <= hight);


    int i = low;
    int j = mid + 1;
    int index = 0;

    while(i <= mid && j <= hight)
    {
        if(arr[i] <= arr[j])
            tmp[index++] = arr[i++];
        else
            tmp[index++] = arr[j++];
    }

    while(i <= mid) //拷贝剩下的左半部分
        tmp[index++] = arr[i++];

    while(j <= hight) //拷贝剩下的右半部分
        tmp[index++] = arr[j++];


    memcpy((void *)(arr + low), (void *)tmp, (hight - low + 1) * sizeof(int));



}

void mergesort(int *arr, int low, int hight, int *tmp)
{
    assert(arr && low >= 0);
    int mid;
    if(low < hight)
    {
        mid = (hight + low) >> 1;
        mergesort(arr, low, mid,tmp);
        mergesort(arr, mid + 1, hight,tmp);
        merge(arr, low, mid, hight,tmp);
    }
}
//只分配一次内存，避免内存操作开销
void mergesort_drive(int *arr, int len)
{
    int *tmp = (int *)malloc(len * sizeof(int));
    if(!tmp)
    {
        printf("out of memory\n");
        exit(0);
    }

    mergesort(arr, 0, len - 1, tmp);

    free(tmp);
}

int main()
{
    int data[10]={8,7,2,6,9,10,3,4,5,1};

    int len = sizeof(data)/sizeof(data[0]);
    mergesort_drive(data, len);
    print_arr(data,len);

    return 0;
}

（6）整数划分问题

/*
整数划分问题
：将一个整数划分为若干个数相加
例子：
整数4 最大加数 4
4=4
1+3=4
1+1+2=4
2+2=4
1+1+1+1=4
一共五种划分方案
注意：1+3=4，3+1=4被认为是同一种划分方案
*/

#include
int q(int n,int m)//n表示需要划分的数字，m表示最大的加数不超过m
{
    if(m==1||n==1)//只要存在一个为1，那么划分的方法数肯定只有一种，那就是n个1相加
    {
        return 1;
    }else if(n==m&&n>1)//二者相等且大于1的时候，问题等价于：q(n,n-1)+1;意味着将最大加数减一之后n的划分数，然后加一，最后面那个一代表的是：0+n，这个划分的方案
    {
        return q(n,n-1)+1;
    }else if(n//如果m>n,那么令m=n就ok，因为最大加数在逻辑上不可能超过n
    {
        return q(n,n);
    }else if(n>m)
    {
        return q(n,m-1)+q(n-m,m);//分为两种：划分方案没有m的情况+划分方案有m的情况
    }
    return 0;
}
int main()
{
    printf("请输入需要划分的数字和最大家数：\n");
    int n,m;
    scanf("%d %d",&n,&m);
    int r=q(n,m);
    printf("%d\n",r);
    return 0;
}

给你一个数，问你所有的划分方式，比如4，4=1+3，4=1+1+2，4=2+2，4=1+1+1+1

我们来分析一下，我们想用分治的话，就要找子问题，假设n是要划分的数，m说最大的加数，n=4，m=3

分解成两类的子问题，一个是：一个是有m的情况，一个是没有m的情况，然后将有m的情况继续划分，分

解成有m-1和没有m-1的情况，一直划分下去，直到m=1。比如n=4，m=3，划分成的子问题：有3，无

3，有2，无2，有1，无1（没有意义，除非0+4=4），将这些子问题合并起来大问题就解决了。

九、总结   

    分治算法的一个核心在于子问题的规模大小是否接近，如果接近则算法效率较高。

    分治算法和动态规划都是解决子问题，然后对解进行合并；但是分治算法是寻找远小于原问题的子问题（因为对于计算机来说计算小数据的问题还是很快的），同时分治算法的效率并不一定好，而动态规划的效率取决于子问题的个数的多少，子问题的个数远小于子问题的总数的情况下（也就是重复子问题多），算法才会很高效。