棋盘覆盖问题分治递归求解

棋盘覆盖问题描述

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

求解思路

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

问题求解

下面介绍棋盘覆盖问题中数据结构的设计：

• （1）棋盘：用二维数组Board[size][size]表示一个棋盘， Board[0][0]是棋盘的左上角方格。其中，size=2^k 。为了在递归处理的过程中使用同一个棋盘，将数组Board设为全局变量；
• （2）子棋盘：在棋盘数组Board[size][size]中，由子棋盘左上角的下标tr、tc和棋盘边长s表示；
• （3）特殊方格：用Board[dr][dc]表示，dr和dc是该特殊方格在棋盘数组Board中的下标；
• （4）L型骨牌：一个2^k×2^k的棋盘中有一个特殊方格，所以用到L型骨牌的个数为(4^k-1)/3将所有L型骨牌从1开始连续编号，用一个全局整型变量tile表示，其初始值为0。要全部覆盖棋盘需要(4^k-1)/3个L型骨牌。
  

算法描述

执行4次if-else语句，每次调用都将棋盘划分成四个大小相同的子区域棋盘。
当棋盘大小为1时，递归出口。

int title =1;//用作标记L型骨牌编号
int a[101][101];//用以表示棋盘
//tr，tc表示棋盘的起始位置(第tr行，第tc列)，dr，dc表示特殊格子所在位置(第dr行，第dc列)，4*4的棋盘tr，tc取值范围为0,1,2,3
//size表示棋盘大小，4*4的棋盘size为4
void ChessBoard(int tr,int tc,int dr,int dc,int size)
{
    if(size==1)  return;//递归出口
    
    int s = size/2;
    int t = title++;
    //如果特殊点的位置在左上方
    if(dr<tr+s&&dc<tc+s){
        ChessBoard(tr,tc,dr,dc,s);
    }else{
        //填充其右下角格子
        a[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{
        //填充其左下角格子
        a[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{
        //填充其右上角格子
        a[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{
        //填充其左上角格子
        a[tr+s][tc+s] = t;
        ChessBoard(tr+s,tc+s,tr+s,tc+s,s);
    }
}

输入输出

输入

输入有一行，分别为M，x，y
M表示棋盘宽度(M=2^k)
x表示棋盘所在的行数
y表示棋盘所在的列数

输出

输出有M行，即输出棋盘，棋盘中每个小格占2个字符间距

样例输入

8 2 3
表示8*8的棋盘，特殊点在第2行，第3列的位置上

样例输出

完整代码

#include <iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
using namespace std;
int title =1;//用作标记L型骨牌编号
int a[101][101];//用以表示棋盘
//tr，tc表示棋盘的起始位置(第tr行，第tc列)
//dr，dc表示特殊格子所在位置(第dr行，第dc列)，4*4的棋盘tr，tc取值范围为0,1,2,3
//size表示棋盘大小，4*4的棋盘size为4
void ChessBoard(int tr,int tc,int dr,int dc,int size)
{
    if(size==1)  return;//递归出口

    int s = size/2;
    int t = title++;
    //如果特殊点的位置在左上方
    if(dr<tr+s&&dc<tc+s){
        ChessBoard(tr,tc,dr,dc,s);
    }else{
        //填充其右下角格子
        a[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{
        //填充其左下角格子
        a[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{
        //填充其右上角格子
        a[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{
        //填充其左上角格子
        a[tr+s][tc+s] = t;
        ChessBoard(tr+s,tc+s,tr+s,tc+s,s);
    }
}
int main()
{
    int size;
    //cout<<"请输入棋盘大小：";
    scanf("%d",&size);
    //初始化
    for(int i=0;i<size;i++)
        for(int j=0;j<size;j++)
            a[i][j] = 0;
    //cout<<"特殊点所在位置为：";
    int x,y;
    cin>>x>>y;
    ChessBoard(0,0,x-1,y-1,size);//因为chessBoard算法是从0行，0列开始算起的，所以对输入的x,y都进行自减操作
    //输出棋盘
    for(int i=0;i<size;i++)
    {
        for(int j=0;j<size;j++)
            printf("%2d ",a[i][j]);
        printf("\n");
    }
    return 0;
}

运行结果

算法时间复杂度分析

设T(k)为覆盖2^k*2^k棋盘的时间， (1)k=0 覆盖它需要常数时间O(1) (2)k>0
测试哪个子棋盘特殊以及形成3个特殊子棋盘需要O(1) 覆盖4个特殊子棋盘需四次递归调用,共需时间4T(k-1)

所以棋盘覆盖的时间复杂度为O(4^k)。