棋盘覆盖问题 算法分析和C++实现

（写在前面：还有一种方法是先在棋盘中间构造一个L形骨牌，从而实现简单的分治，那个方法也很好！）

问题描述：

在一个$2^k\times 2^k$个方格组成的棋盘中，恰有一个方格与其他方格不同，称该方格为一特殊方格，且称该棋盘为一特殊棋盘。如图所示，蓝色的为特殊方格：

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

解决过程：

代码实现：

/*
棋盘覆盖问题

输入：三个整数：k, i, j
      k >= 1，表示边长为2^k；
      0 <= i <2^k, 表示特殊方格的x坐标；
      0 <= j <2^k, 表示特殊方格的y坐标。
从而可以构建一个2^k * 2^k的二维数组A，A[i][j] = 0 表示此处为正常方格，A[i][j] = 1表示此处为特殊方格
A[i][j] = {0, 1}, sum(A) = 1, 即整个二维数组中只有一个位置为1，其余都为0

输出为一个二维数组B，特殊方格的位置用0表示；每个小的L形用相同数字表示。如对于 k = 2 的数组，有如下表示（示例）：

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

*/

# include<iostream>
using namespace std;


void div(int **B, int X1, int Y1, int X2, int Y2, int K, int& cnt) {
    //X1 Y1是外面的点，X2 Y2是里面的点.
    if (X1 - X2 == 1) {
        if (Y1 > Y2) {
            B[X2][Y2] = cnt;
            B[X2][2 * Y2 - Y1] = cnt;
            B[2 * X2 - X1][Y2] = cnt++;
        }
        else {
            B[X2][Y2-1] = cnt;
            B[X2][Y2] = cnt;
            B[X2-1][Y2-1] = cnt++;
        }
    }
    else if (X2 - X1 == 1) {
        if (Y2 > Y1) {
            B[X1][Y1] = cnt;
            B[X1][Y2] = cnt;
            B[X2][Y1] = cnt++;
        }
        else{
            B[X1][Y1-1] = cnt;
            B[X1][Y1-2] = cnt;
            B[X2][Y1-1] = cnt++;
        }
    }
    else {
        div(B,X1,Y1,(X1+X2)>>1,(Y1+Y2)>>1, K - 1, cnt);
        div(B, (X1+X2)>>1, (Y1+Y2)>>1, X2, Y2, K - 1, cnt);
        div(B, X1, 2*Y2-Y1, (X1+X2)>>1, (3*Y2-Y1)>>1, K - 1, cnt);
        div(B, 2*X2-X1, Y1, (3*X2-X1)>>1, (Y1+Y2)>>1, K - 1, cnt);
    }
}

void cover(int** B, int x, int y, int K, int I, int J, int& cnt) {
    int half = 1 << (K - 1), full = 1 << K;
    int X = (I < x+half) ? 0 : half;
    int Y = (J < y+half) ? 0 : half;
    if (K > 1)
        cover(B, x + X, y + Y, K - 1, I, J, cnt);
    div(B, x+full-2*X, y+full-2*Y, x+half, y+half, K - 1, cnt);
}


int main(){
    int K, I, J;
    cin >> K >> I >> J;
    int n = 1 << K;
    int** B = new int*[n];
    for (int i = 0; i < n; i++)
        B[i] = new int[n];
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            B[i][j] = 0;
    cout << "Result:" <<endl;

    int cnt = 1;
    cover(B, 0, 0, K, I, J, cnt);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++)
            cout << B[i][j] << "\t";
        cout << endl << endl;
    }
}