棋盘覆盖问题

1590阅读　0评论2015-09-14　九阳神功爱喝茶
分类：C/C++

棋盘覆盖


（一）原理介绍

    在一个2^k * 2^k个方格组成的棋盘中，恰有一个方格与其它方格不同，称该方格为一特殊方格，且称该棋盘为以特殊棋盘。

    在棋盘覆盖问题中，要用图示的4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格之外的所有方格，且任何2个L型骨牌不得重叠覆盖。

    

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

    

    为了更加清楚了解这个原理，下面引用：

    这里我们用分治法解决该问题。分治法是把一个规模很大的问题分解为多个规模较小的类似的子问题，然后递归地解决所有子问题，最后再由子问题的解决得到原问题的解决。

    【解题思路】

    将2^k * 2^k的棋盘，先分成相等的四块子棋盘，其中特殊方格位于四个中的一个，构造剩下没特殊方格的三个字棋盘，将它们中的也假设一个方格为特殊方格。如果是：

    左上角的子棋盘（若不存在特殊方格）：则将该子棋盘右下角的那个方格假设为特殊方格；

    右上角的子棋盘（若不存在特殊方格）：则将该子棋盘左下角的那个方格假设为特殊方格；

    左下角的子棋盘（若不存在特殊方格）：则将该子棋盘右上角的那个方格假设为特殊方格；

    右下角的子棋盘（若不存在特殊方格）：则将该子棋盘左上角的那个方格假设为特殊方格；

    当然，上面四种情况，只可能且必定只有三种成立，那三个假设的特殊方格刚好构成一个L型骨牌，我们可以给它们作上相同的标志。这样四个子棋盘就分别都和原来的大棋盘类似，我们就可以用递归的算法解决了。

    感谢作者哈。


（二）代码实现

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <stdlib.h>

  4. #define SIZE 4

  6. static int title = 1;    //title表示L型骨牌的编号
  7. static int board[SIZE][SIZE];

  9. /**
  10.  * 功能：棋盘覆盖
  11.  * @param tr表示棋盘左上角行号
  12.  * @param tc表示棋盘左上角列号
  13.  * @param dr表示特殊棋盘的行号
  14.  * @param dc表示特殊棋盘的列号
  15.  * @param size = 2^k
  16.  * 棋盘的规格为2^k * 2^k
  17.  **/
  18.  void ChessBoard(int tr, int tc, int dr, int dc, int size)
  19.  {
  20.      if(1 == size)
  21.      {
  22.          return;
  23.      }
  24.     
  25.      int t = title++;    //L型骨牌号
  26.      int s = size / 2;    //分割棋盘
  27.     
  28.      //覆盖左上角子棋盘
  29.      if(dr < tr + s && dc < tc + s)
  30.      {
  31.          //特殊方格在此棋盘中
  32.          ChessBoard(tr, tc, dr, dc, s);
  33.      }
  34.      else
  35.      {
  36.          //此棋盘无特殊方格
  37.          //用t号L型骨牌覆盖右下角
  38.          board[tr + s - 1][tc + s - 1] = t;
  39.          //覆盖其余方格
  40.          ChessBoard(tr, tc, tr + s - 1, tc + s - 1, s);
  41.      }

  43.      //覆盖右上角
  44.      if(dr < tr + s && dc >= tc + s)
  45.      {
  46.          //特殊方格在此棋盘中
  47.          ChessBoard(tr, tc + s, dr, dc, s);
  48.      }
  49.      else
  50.      {
  51.          //此子棋盘中无特殊方格
  52.          //用t号L型骨牌覆盖左下角
  53.          board[tr + s - 1][tc + s] = t;
  54.          //覆盖其余方格
  55.          ChessBoard(tr, tc + s, tr + s - 1, tc + s, s);
  56.      }
  57.     
  58.      //覆盖左下角子棋盘
  59.      if(dr >= tr + s && dc < tc + s)
  60.      {
  61.          //特殊方格在此棋盘中
  62.          ChessBoard(tr + s, tc, dr, dc, s);
  63.      }
  64.      else
  65.      {
  66.          //用t号L型骨牌覆盖右上角
  67.          board[tr + s][tc + s -1] = t;
  68.          //覆盖其余方格
  69.          ChessBoard(tr + s, tc, tr + s, tc + s - 1, s);
  70.      }

  72.      //覆盖右下角子棋盘
  73.      if(dr >= tr + s && dc >= tc + s)
  74.      {
  75.          //特殊方格在此棋盘中
  76.          ChessBoard(tr + s, tc + s, dr, dc, s);
  77.      }
  78.      else
  79.      {
  80.          //用t号L型骨牌覆盖左上角
  81.          board[tr + s][tc + s] = t;
  82.          //覆盖其余方格
  83.          ChessBoard(tr + s, tc + s, tr + s, tc + s, s);
  84.      }
  85. }

  87. //打印
  88. void ChessPrint()
  89. {
  90.     int i;
  91.     int j;
  92.     for(i = 0; i < SIZE; i++)
  93.     {
  94.         for(j = 0; j < SIZE; j++)
  95.         {
  96.             printf("%d ", board[i][j]);
  97.         }
  98.         printf("n");
  99.     }
  100. }

  102. int main(int argc, char **argv)
  103. {
  104.     //方便测试，假设特殊方格位置在第三行第三列
  105.     ChessBoard(0, 0, 2, 2, SIZE);
  106.     ChessPrint();
  107.     return 0;
  108. }
    测试结果如下所示。


    



                                                                                                                                  梦醒潇湘love

                                                                                                                              2013-03-01 16:27


上一篇：数据结构之二叉树(遍历、建立、深度)
下一篇：链表基本操作API