D&C_棋盘覆盖问题

问题描述：

　　在一2^k*2^k个方格组成的棋盘中，有一个特殊黑格子，要求用图中四种L形骨牌不重叠地覆盖棋盘

　　　　　　　　                                       

算法思路：

　　采用分治的思想，将问题化为规模更小的子问题，如图

　　　　

程序：

  在实现算法时，可以设置个4个判断，然后再每个判断里运行4个子函数，下面的实现采用了一点小技巧，即4个"子棋盘"各管各的事，从而减少了累赘的代码量。

#include <iostream>
#include <cmath>
#include <iomanip>

using namespace std;

int num = 0;
int board[8][8] = {};

void chessBoard(int sx, int sy, int px, int py, int k)
{
    if(k == 0)  return;
    int seq = ++num;
    int sizes = pow(2, k-1);
    //左上棋盘要干的两件事
    if(px < sx + sizes && py < sy + sizes)
    {
        //黑格在左上棋盘，对左上棋盘而言它要干的事
        chessBoard(sx, sy, px, py, k-1);
    }else
    {
        //黑格不在左上棋盘，对左上棋盘而言它要干的事
        board[sx + sizes -1][sy + sizes -1] = seq;
        chessBoard(sx, sy, sx + sizes -1, sy + sizes -1, k-1);
    }

    //右上棋盘要干的两件事
    if(px >= sx + sizes && py < sy + sizes)
    {
        chessBoard(sx + sizes, sy, px, py, k-1);
    }else
    {
        board[sx + sizes][sy + sizes -1] = seq;
        chessBoard(sx + sizes, sy, sx + sizes, sy + sizes -1, k-1);
    }

    //左下棋盘要干的两件事
    if(px < sx + sizes && py >= sy + sizes)
    {
        chessBoard(sx, sy + sizes, px, py, k-1);
    }else
    {
        board[sx + sizes -1][sy + sizes] = seq;
        chessBoard(sx, sy + sizes, sx + sizes -1, sy + sizes, k-1);
    }

    //右下棋盘要干的两件事
    if(px >= sx + sizes && py >= sy + sizes)
    {
        chessBoard(sx + sizes, sy + sizes, px, py, k-1);
    }else
    {
        board[sx + sizes][sy + sizes] = seq;
        chessBoard(sx + sizes, sy + sizes, sx + sizes, sy + sizes, k-1);
    }

}

int main()
{   //测试代码
    chessBoard(0,0,4,5,3);

    for(int i = 0; i < 8; i++)
    {
        for(int j = 0; j < 8; j++)
        {
            cout<<setw(3)<<board[i][j];
        }
        cout<<endl;
    }
    return 0;
}