用c语言写棋盘覆盖问题；残缺棋盘是一个有2k×2k （k≥1）个方格的棋盘，其中恰有一个方格残缺。残缺棋盘问题就是要用这四种三格板覆盖更大的残缺棋盘。

棋盘覆盖问题是一个经典的计算机科学问题，可以使用C语言来解决。以下是一个简单的实现：

首先，我们需要定义一个结构体来表示棋盘和棋子的状态：

struct chessboard {
    int size;
    int **board;
};

struct tile {
    int row;
    int col;
    int type;
};

其中，`chessboard`结构体包含棋盘大小和二维数组表示的棋盘状态；`tile`结构体表示一个三格板的位置和类型。

接下来，我们需要实现一个函数来分割棋盘：

void divide_board(struct chessboard *board, struct tile *tile, int row, int col, int size, int type) {
    int half_size = size / 2;
    
    int t = tile->type++;
    if (row < half_size && col < half_size) { // 左上角
        divide_board(board, tile + t, row, col, half_size, t);
    } else {
        board->board[row + half_size - 1][col + half_size - 1] = t;
        if (row < half_size && col >= half_size) { // 右上角
            divide_board(board, tile + t, row, col - half_size, half_size, t);
        } else if (row >= half_size && col < half_size) { // 左下角
            divide_board(board, tile + t, row - half_size, col, half_size, t);
        } else { // 右下角
            divide_board(board, tile + t, row - half_size, col - half_size, half_size, t);
        }
    }
}

这个函数首先将棋盘分割成四个部分，然后递归地调用自己，直到每个小棋盘的大小为1x1。然后，我们将棋盘上的残缺格子标记为一种特殊的三格板类型。

接下来，我们需要实现一个函数来覆盖棋盘：

void cover_board(struct chessboard *board, struct tile *tile, int row, int col, int size) {
    if (size == 1) {
        return;
    }
    
    int t = board->board[row][col];
    struct tile *tr = tile + t;
    int half_size = size / 2;
    
    if (t == board->board[row][col + 1]) { // 横向三格板
        for (int i = 0; i < half_size; i++) {
            cover_board(board, tr, row, col + i, half_size);
            cover_board(board, tr, row + half_size, col + i, half_size);
        }
    } else if (t == board->board[row + 1][col]) { // 竖向三格板
        for (int i = 0; i < half_size; i++) {
            cover_board(board, tr, row + i, col, half_size);
            cover_board(board, tr, row + i, col + half_size, half_size);
        }
    } else { // L 形三格板
        for (int i = 0; i < half_size; i++) {
            cover_board(board, tr, row + i, col + half_size, half_size);
            cover_board(board, tr, row + half_size, col + i, half_size);
        }
    }
}

这个函数使用递归算法来覆盖棋盘。如果当前格子是一个三格板的起点，它将递归地覆盖两个相邻的子棋盘。如果当前格子是一个L形三格板的起点，则需要递归地覆盖四个相邻的子棋盘。

最后，我们可以在`main`函数中调用这些函数来求解棋盘覆盖问题：

int main() {
    struct chessboard board;
    board.size = 8;
    board.board = (int **) malloc(board.size * sizeof(int *));
    for (int i = 0; i < board.size; i++) {
        board.board[i] = (int *) malloc(board.size * sizeof(int));
        for (int j = 0; j < board.size; j++) {
            board.board[i][j] = -1;
        }
    }

    struct tile tiles[4];
    divide_board(&board, tiles, 0, 0, board.size, 0);

    board.board[3][3] = 2; // 将(3,3)标记为残缺格子

    cover_board(&board, tiles, 0, 0, board.size);

    for (int i = 0; i < board.size; i++) {
        for (int j = 0; j < board.size; j++) {
            printf("%2d ", board.board[i][j]);
        }
        printf("\n");
    }

    return 0;
}

这个程序将输出一个8x8的棋盘，其中每个数字表示对应格子被覆盖的三格板类型。