分治(详解残缺棋盘 —— Java代码实现)

Posted wx62c62b36cedf9

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了分治(详解残缺棋盘 —— Java代码实现)相关的知识,希望对你有一定的参考价值。


分治

总体思想

  • 将要求解的较大规模的问题分割成k个更小规模子问题
  • 对这k个子问题分别求解。如果子问题的规模仍然不够小,则再划分为k为子问题,如此递归进行下去,直到问题规模足够小,很容易求出其解为止
  • 将求出的小规模的问题的解合并为一个更大规模的问题的解,自底向上逐步求出原来的问题的解

使用条件

  • 该问题的规模缩小到一定的程度就可以容易地解决
  • 该问题可以分解为若干个规模较小的相同问题,即该问题具有最优子结构性质
  • 利用该问题分解出的子问题的解可以合并为该问题的解
  • 该问题所分解出的各个子问题是相互独立的,即子问题之间不包含公共的子问题

能否利用分治法完全取决于子问题是否具有这条特征,如果具备了前两条特征,而不具备第三条特征,则可以考虑贪心算法或动态规划

基本步骤

divide-and-conquer(P) 
if (|P| <= n0) abhoc(P); // 解决小规模的问题
divide P into smaller subinstances P1, P2 ,... ,Pk // 分解问题
for (i = 1; i <= k; i++)
yi = divide-and-conquer(Pi); // 递归的解各子问题
return merge(y1, ... ,yk) // 将各子问题的解合并为原问题的解

案例

覆盖残缺棋盘

  • 在一个2k×2k 个方格组成的棋盘中,恰有一个方格与其他方格不同,称该方格为一特殊方格,且称该棋盘为一特殊棋盘。
  • 用 (n2) / 3个三重格放置在 n × n 的缺陷棋盘上,正好能够覆盖所有方格

分治(详解残缺棋盘


具体步骤:

分治(详解残缺棋盘

  • 划分为四个小棋盘
  • 其中一个是 4 × 4 缺陷棋盘
  • 分治(详解残缺棋盘

  • 在其他三个 4 × 4 棋盘都都相邻的拐角上放一个三格板,使它们也成为缺陷棋盘
  • 递归地覆盖四个4×4缺陷棋盘
  • 在其它三个 4 × 4 棋盘都相邻的拐角上放一个三格板,使它们也成为缺陷棋盘。

分治(详解残缺棋盘

Java代码实现

package Chess;

public class Chess
// 表示棋盘
private int[][] board;
// 表示棋盘的大小为2的多少次方
private int boardSize;
// 棋盘中特殊方格的位置(行号,列号)
private int dr, dc;
private int tile = 1;

public Chess()
board = new int[1][1];
dr = 0;
dc = 0;
boardSize = 0;


public Chess(int r, int c, int s)
int n;
n = (int) Math.pow(2, s);
if (n <= r || n <= c)
System.out.println("初始化参数错误!");
else
board = new int[n][n];
dr = r;
dc = c;
boardSize = s;



public void Print()
for (int i = 0; i < Math.pow(2, this.boardSize); i++)
for (int j = 0; j < Math.pow(2, this.boardSize); j++)
System.out.printf("%3d|", this.board[i][j]);

System.out.println();



public static void main(String[] args)
// 2^2*2^2棋盘, 假设特殊方格位置为(3, 3)
Chess c1 = new Chess(3, 3, 2);
c1.chessBoard(0, 0, c1.dr, c1.dc, (int)Math.pow(2, c1.boardSize));
c1.Print();



/**
* @param tr:棋盘左上角方格的行号
* @param tc:棋盘左上角方格的列号
* @param dr:特殊方格所在的行号
* @param dc:特殊棋盘所在的列号
* @param size:2^k, 棋盘的规格为 2^k*2^k
**/
public void chessBoard(int tr, int tc, int dr, int dc, int size)
if (size == 1) return;

// t: L型骨牌号,s分割棋盘
int t = tile++;
int s = size / 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号骨牌覆盖左下角
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号骨牌覆盖右上角
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号骨牌覆盖左上角
board[tr + s][tc + s] = t;
chessBoard(tr + s, tc + s, tr + s, tc + s, s);


  2|  2|  3|  3|
2| 1| 1| 3|
4| 1| 5| 5|
4| 4| 5| 0|

大整数的乘法

  • 小学的方法:效率太低 O(n2)
  • 分治法:
  • 分治(详解残缺棋盘

  • X = A × 2n/2+ B
    Y = C × 2n/2+ D
    XY = (A × 2n/2+ B)(C × 2n/2+ D)
    =AC × 2n+ (AD + CB) × 2n/2+ BD
  • 分治(详解残缺棋盘

  • 实质上没有改进
    再次进行改进:
    XY = AC × 2n+ (AD + CB) × 2n/2+ BD
    =AC × 2n+ ((A - B)(D - C) + AC + BD) × 2n/2+ BD
    这样只需进行3次 n/2 位乘法
  • 分治(详解残缺棋盘

  • T(n) = O(nlog3) = O(n1.59) (有了较大的改进

如果将大整数分成更多段,用更复杂的方式把它们组合起来,将有可能得到更优的算法

Strassen矩阵乘法

分治(详解残缺棋盘


易知,时间复杂度为 O(n3)

分治法:

  • 将矩阵A、B和C中每一矩阵都分成4个大小相等的子矩阵,则 C = AB 可写为:
  • 分治(详解残缺棋盘

  • 由此可得:
  • 分治(详解残缺棋盘


  • 分治(详解残缺棋盘

  • 实际复杂度还是没有变,仍然为 O(n3)
  • 为了降低时间复杂度,要减少乘法的次数
  • 分治(详解残缺棋盘

  • 这样,复杂度得到了改进
  • 分治(详解残缺棋盘


以上是关于分治(详解残缺棋盘 —— Java代码实现)的主要内容,如果未能解决你的问题,请参考以下文章

残缺棋盘的覆盖问题

残缺棋盘的覆盖问题

分治法解决残缺棋盘

算法导论分治思想—大数乘法矩阵相乘残缺棋盘

棋盘覆盖

C++经典算法问题:棋盘覆盖问题(分治算法)!含源码示例