分治算法

Posted 2020-09-08

　　

分治算法

一、大话分治

    分治算法，Divide-and-Conquer Method，我给他它的字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。也正对应着它的单词Devide—分，Conquer—治。

    分支思想是很多高效算法的基础，如排序算法(快速排序，归并排序)，傅立叶变换(快速傅立叶变换)……

二、基本思想及策略实现

   设计思想

    将一个难以直接解决的大问题，分割成若干个不可再分割且相互独立的原子级问题，这些原子级问题与原问题形式相同并且可以直接求出解，然后把这些原子级问题各个击破，最后把所有原子级问题的解收集起来即原问题的解。

    算法准备

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

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

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

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

    分治的策略分为三步

1、Divide—分解：将原问题分解为若干个与原问题形式相同的子问题；

2、Conquer—解决：如果这些子问题可以直接解决，则解决并返回解，否则继续    分解；

3、Combine—合并：将各个子问题的解合并为原问题的解。

   递归实现

    分治算法的不断分解和收集解一般需要用递归实现，其实分治与递归像一对孪生兄弟，经常同时应用在算法设计之中，并由此产生许多高效算法。

三、分治法的应用场景

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

    ① 该问题可以分解为若干个规模较小的且相互对立的相同问题，即该问题具有最优子结构性质；（这是分治应用的前提）

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

    ③ 利用该问题分解出的子问题的解可以合并为该问题的解；（这是分治算法的关键，如果不满足，则分治毫无意义。若果不满足这一条时，可考虑动态规划）

    以下经典问题常用分治方法解决

（1）二分搜索

（2）大整数乘法

（3）Strassen矩阵乘法

（4）棋盘覆盖

（5）归并排序

（6）快速排序

（7）线性时间选择

（8）最接近点对问题

（9）循环赛日程表

（10）汉诺塔

四、分治法的具体实现

1、棋盘覆盖问题

问题描述：

    在一个2^k×2^k 个方格组成的棋盘中，恰有一个方格与其他方格不同，称该方格为一特殊方格，且称该棋盘为一特殊棋盘。在棋盘覆盖问题中，要用图示的4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。

 

 

 

解题思路：

   当k>0时，将2k×2k棋盘分割为4个2^k-1×2^k-1 子棋盘(a)所示。特殊方格必位于4个较小子棋盘之一中，其余3个子棋盘中无特殊方格。为了将这3个无特殊方格的子棋盘转化为特殊棋盘，可以用一个L型骨牌覆盖这3个较小棋盘的会合处，如 (b)所示，从而将原问题转化为4个较小规模的棋盘覆盖问题。递归地使用这种分割，直至棋盘简化为棋盘1×1。

 

 

   每次都对分割后的四个小方块进行判断，判断特殊方格是否在里面。这里的判断的方法是每次先记录下整个大方块的左上角（top left coner）方格的行列坐标，然后再与特殊方格坐标进行比较，就可以知道特殊方格是否在该块中。如果特殊方块在里面，这直接递归下去求即可，如果不在，这根据分割的四个方块的不同位置，把右下角、左下角、右上角或者左上角的方格标记为特殊方块，然后继续递归。在递归函数里，还要有一个变量s来记录边的方格数，每次对方块进行划分时，边的方格数都会减半，这个变量是为了方便判断特殊方格的位置。其次还要有一个变nCount来记录L型骨牌的数量。

Java代码实现

public class CoverChessBoard {

   static int n=0;

   static int k=4;

   static int [][] board;

   static int len=1;

   {

      while(k>0) {

         len*=2;

         k--;

      }

      board = new int[len][len];

   }

   //xy为当前数组起始坐标，len是当前块的长度，xs ys是标记点坐标

   void cover(int x,int y,int len,int xs,int ys){

      if(len == 1) return;

      n++;

      //定义中间坐标，方便运算

      int xc=x+len/2-1,yc=y+len/2-1;

      len/=2;

      //标记点位于左上方区域

      if(xs<=xc&&ys<=yc){

         //先把其他三个区域的相邻角定点设为标记点并填充

         //board[xc][yc]=n;

         board[xc][yc+1] = n;

         board[xc+1][yc] = n;

         board[xc+1][yc+1] = n;

         //把这个大区域分成四个相同大小的小区域，分别填充

         cover(x,y,len,xs,ys);

         cover(x,yc+1,len,xc,yc+1);

         cover(xc+1,y,len,xc+1,yc);

         cover(xc+1,yc+1,len,xc+1,yc+1);

      }

      //标记点位于右上区域

      if(xs<=xc&&ys>yc){

         //先把其他三个区域的相邻角定点设为标记点并填充

         board[xc][yc]=n;

         //board[xc][yc+1] = n;

         board[xc+1][yc] = n;

         board[xc+1][yc+1] = n;

         //把这个大区域分成四个相同大小的小区域，分别填充

         cover(x,y,len,xc,yc);

         cover(x,yc+1,len,xs,ys);

         cover(xc+1,y,len,xc+1,yc);

         cover(xc+1,yc+1,len,xc+1,yc+1);

      } 

      //标记点位于左下区域

      if(xs>xc&&ys<=yc){

         //先把其他三个区域的相邻角定点设为标记点并填充

         board[xc][yc]=n;

         board[xc][yc+1] = n;

         //board[xc+1][yc] = n;

         board[xc+1][yc+1] = n;

         //把这个大区域分成四个相同大小的小区域，分别填充

         cover(x,y,len,xc,yc);

         cover(x,yc+1,len,xc,yc+1);

         cover(xc+1,y,len,xs,ys);

         cover(xc+1,yc+1,len,xc+1,yc+1);

      }

      //标记点位于右下区域

      if(xs>xc&&ys>yc){

         //先把其他三个区域的相邻角定点设为标记点并填充

         board[xc][yc]=n;

         board[xc][yc+1] = n;

         board[xc+1][yc] = n;

         //board[xc+1][yc+1] = n;

         //把这个大区域分成四个相同大小的小区域，分别填充

         cover(x,y,len,xc,yc);

         cover(x,yc+1,len,xc,yc+1);

         cover(xc+1,y,len,xc+1,yc);

         cover(xc+1,yc+1,len,xs,ys);

      }

   }

   public static void main(String[] args) {

      CoverChessBoard cc = new CoverChessBoard();

      System.out.println(len);

      //数据测试，假设（10,10）是标记点

      cc.cover(0, 0, len, 10, 10);

      for (int i = 0; i < board.length; i++) {

         for (int j = 0; j < board.length; j++) {

            if(cc.board[i][j]<10) System.out.print(0);

            System.out.print(cc.board[i][j]+" ");

         }System.out.println();

      }

   }

}

2、Strassen矩阵乘法

题目描述：矩阵m*n的A矩阵和n*p的B矩阵相乘，他们的乘积AB是个m*p的矩阵，求这个AB矩阵。

普通的暴力破解方法：直接通过三个for循环来模拟我们矩阵就算的过程，这样当然可以做出来，但是这样做的时候时间复杂度是O(n³)，效率比较低。

Strassen矩阵乘法：

    1969年，德国的一位数学家Strassen证明O（N^3）的解法并不是矩阵乘法的最优算法，他做了一系列工作使得最终的时间复杂度降低到了O(n^2.80)。他把矩阵分成多个块并定义了多个变量来便于计算，比如矩阵A={{a，b}{c，d}}，矩阵B={{e，f}{g，h}}，

那么两矩阵相乘的结果AB={{ae+bg，ag+bh}{ce+df，cg+dh}}；

Strassen先生通过定义了7个变量来方便运算，变量如下

P1 = a ( f - h ) ;

P2 =(a + b ) h;

P3 = (c + d) e;

P4 = d (g - e );

P5 = ( a + d ) (e + h);

P6 = (b - d ) ( e + h);

P7 = (a - c) (e + f );

那么两矩阵乘积AB={{P5+P4-P2+P6 ，P1+P2} {P3+P4 ，P1+P5-P3-P7 }}；

如此便完成了计算，如果我们我们遇到更大的矩阵时，我们先把矩阵等分成四部分，就比如是矩阵A中的a,b,c,d,按照Strassen方法模拟整个过程就可以实现了。因为只是个模拟的过程我就不在这里实现了。