棋盘覆盖问题：Java 和 C 实现版本

最新推荐文章于 2024-03-26 23:35:18 发布
最新推荐文章于 2024-03-26 23:35:18 发布
阅读量382 收藏 6
点赞数 1
分类专栏： # 数据结构、算法
作者：何锦洋
本文链接：https://blog.csdn.net/weixin_44537669/article/details/110676529
版权

一、问题描述

棋盘覆盖问题：
	1、要求在2^k * 2^k 个方格组成的棋盘中，
	2、你给定任意一个特殊点，用一种方案实现对除该特殊点的棋盘实现全覆盖。

image-20201205071946595

二、什么是：分治算法， 棋盘中如何用？

分治算法（通俗的讲）：
	1、大问题，分解为小问题。
	2、分解的（小问题之间）互相不重叠
	3、小问题和大问题（是同类型问题），只是规模不一样。
image-20201205074909552

三、问题讲解：视频推荐

可以结合着看：第一个（视频）图很生动， 第二个视频（分析复杂度，很透彻）， 首推（第二个）

视频一：https://www.bilibili.com/video/BV1vt4y1i7VF/?spm_id_from=333.788.videocard.5

视频二：https://www.bilibili.com/video/BV1o7411Q7GV/?spm_id_from=333.788.videocard.4

四、博客推荐

博客一：注重（理解问题）
博客二：注重（实现代码）

博客一：https://blog.csdn.net/qq_30268545/article/details/80600064?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-2.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-2.control

博客二：https://blog.csdn.net/sunshine__0411/article/details/78413823?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-2.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-2.control

五、代码实现C 和 Java版本

1、C版本（visual studio 2019编译器）

注意：因为visual studio 用scanf() 被认为不安全，此处用了scanf_s(), 其余编译器，修改下，即可

①、代码

#include <stdio.h>
#include<math.h>

static int tile = 1;								//L骨牌：开始的值
const int BOARD_SIZE = 64;							//棋盘的：最大值 64 * 64
static int board[BOARD_SIZE][BOARD_SIZE] = { 0 };	//初始化棋盘：行BOARD_SIZE * 列BOARD_SIZE



//tr, tc起始点， dr，dc(特殊点), size棋盘行、列大小
void chess_board(int tr, int tc, int dr, int dc, int size) {
	//1、检验：size 是否为1， 若为1, 则说明（1 * 1）棋盘， 只有一个格子（该格子就是：特殊点），不用覆盖
	if (size == 1) {
		return;
	}

	//2、骨牌L存放的数字：自增
	int t = tile++;					//切记：t为作为标志当前骨牌（存放的数字），tile自增是因为：方便递归

	//3、将当前棋盘：分割成四块， 利用（分治算法）， 分治算法：问题划分为（同种问题、且问题不重复）
	int sz = size / 2;				//分割后的大小为：(2^k - 1) * (2^k - 1)

	//4、判断：特殊点在，左上（分块）吗？
	if (dr < tr + sz && dc < tc + sz) {		//此时（特殊点）在：左上分块
		chess_board(tr, tc, dr, dc, sz);	//继续：分割棋盘，用L型骨牌（覆盖）
	}
	else {
		board[tr + sz - 1][tc + sz - 1] = t;		//将：特殊结点外的，毗连（左上结点）赋上骨牌值
		chess_board(tr, tc, tr + sz - 1, tc + sz - 1, sz);		//将该毗连结点，作为新的特殊点：递归
	}

	//5、判断：特殊点在，右上（分块）吗？
	if (dr < tr + sz && dc >= tc + sz) {	//此时：特殊点在(右上角块)
		chess_board(tr, tc + sz, dr, dc, sz);		//初始值的变更：总在该方格的（左上角顶）
	}
	else {
		board[tr + sz - 1][tc + sz] = t;
		chess_board(tr, tc + sz, tr + sz - 1, tc + sz, sz);
	}


	//6、判断：特殊点在，左下（分块）吗？
	if (dr >= tr + sz && dc < tc + sz) {		//此时：特殊点在（左下块）
		chess_board(tr + sz, tc, dr, dc, sz);
	}
	else {
		board[tr + sz][tc + sz - 1] = t;
		chess_board(tr + sz, tc, tr + sz, tc + sz - 1, sz);
	}

	//7、判断：特殊点在，右下（分块）吗？
	if (dr >= tr + sz && dc >= tc + sz) {		//此时：特殊点在（右下块）
		chess_board(tr + sz, tc + sz, dr, dc, sz);
	}
	else {
		board[tr + sz][tc + sz] = t;
		chess_board(tr + sz, tc + sz, tr + sz, tc + sz, sz);
	}
}

void print_chess(int size) {
	for (int i = 0; i < size; i++) {
		for (int j = 0; j < size; j++) {
			printf("%4d", board[i][j]);
		}

		printf("\n");
	}
}


//通过输入k值：获取棋盘大小
int getSize() {
	//1、请输入：棋盘大小2^k中的（k值）
	int k = 0;
	printf("请输入 k = ");
	scanf_s("%d", &k);

	//2、判断：k是否大于6 (因为我：设置了最大棋盘为 64 * 64)
	int size = 1;					//棋盘：行、列值（棋盘是一个：矩阵）
	while (true) {
		if (k < 0 || k > 6) {
			printf("您的k值有误，请输入 k = ");
			scanf_s("%d", &k);
		}
		else {
			size = pow(2, k);
			break;
		}
	}

	//3、打印棋盘大小， 并返回
	printf("您的棋盘大小为：%d * %d\n", size, size);
	return size;
}

//设置：起初，棋盘的（特殊点）的坐标（从索引0开始）
void setSpecialPot(int* x1, int* y1, int size) {
	int x;
	int y;

	while (true) {
		printf("请输入(特殊点)的 x = ");
		scanf_s("%d", &x);
		printf("请输入(特殊点)的 y = ");
		scanf_s("%d", &y);

		if (x >= 0 && x <= size - 1 && y >= 0 && y <= size - 1) {
			break;
		}
		else {
			printf("您的x, y值（越界）, 请重新输入：\n");
		}
	}
	*x1 = x;
	*y1 = y;
}

int main(void) {

	//1、获取棋盘大小
	int size = getSize();

	//2、请输入：初始（特殊点）
	int x;
	int y;
	setSpecialPot(&x, &y, size);

	//3、进行棋盘覆盖
	chess_board(0, 0, x, y, size);			//覆盖棋盘


	//4、打印棋盘
	print_chess(size);

}

②、代码图

image-20201204215317865

③、运行结果

image-20201204214851802

2、Java版本（已封装, Intellij编译器）

已封装版本：看起来清爽，理解起来可能要（想一想）

①、代码

package com.yyy.test;

import java.util.Scanner;

/**
 * 分治法——棋盘覆盖问题
 * 棋盘覆盖问题：描述
 *       <1>、有一个2^k∗2^k的(方格棋盘)，(只有1个)方格是黑色的，其他为白色。
 *       <2>、你的任务是用包含3个方格的L型牌覆盖所有白色方格。黑色方格不能被覆盖，
 *       <3>、且任意一个白色方格（不能同时）被（两个或更多牌）覆盖。
 */
public class ChessBoard01 {
    public int board[][];                  //棋盘：引用
    private int boardSize;                 //棋盘大小
    private int tile;                      //L骨牌：存放值
    private int SpecialX;                  //特殊方格：行索引
    private int SpecialY;                  //特殊方格：列索引

    public ChessBoard01() {

        //获取：棋盘大小
        boardSize = getBoardSize();

        //初始化：棋盘
        board = new int[boardSize][boardSize];

        //初始化：特殊方格
        initSpecial();

        //初始化：骨牌值
        tile = 1;           //骨牌值：从1开始
    }

    /**
     * 该方法：利用分治思想，大问题分解成（同一类型的：小问题）， 小问题之间（没有交叉）进行（棋盘覆盖）
     * @param tr: 初始（查找点）行索引
     * @param tc：初始（查找点）列索引
     * @param dr：初始（特殊方格）行索引
     * @param dc：初始（特殊方格）列索引
     * @param initSize：初始（棋盘大小），initSize * initSize (矩阵棋盘)
     */
    public void chessBoard(int tr, int tc, int dr, int dc, int initSize){
        //1、判断：当棋盘只有（1个方格时），不用覆盖， 因为该方格，必为（特殊方格）
        if(initSize == 1){
            return;         //此时是：递归出口
        }

        //2、创建：骨牌序号（L骨牌由3个方格组成），这3个方格（值一样）
        int tileSeque = tile++;     //tile值：后置递增，是为了（递归覆盖）方便

        //3、将棋盘分4块： 大小变为 (2^k)-1  * (2^k)-1
        int size = initSize / 2;

        //4、判断：（特殊方格）是否在(左上分块)
        if(dr < tr+size && dc < tc+size){       //此时：（特殊方格）在（左上分块）中
            chessBoard(tr, tc, dr, dc, size);   //直接：递归（左上分块）
        }else{
            this.board[tr+size-1][tc+size-1] = tileSeque;   //此时：特殊方格（不在，左上分块中），为小问题（生成：特殊方格）
            chessBoard(tr, tc, tr+size-1, tc+size-1, size);    //小问题：分块，覆盖
        }

        //5、判断：（特殊方格）是否在(右上分块)
        if(dr < tr+size && dc >= tc+size){              //此时：（特殊方格）在（右上分块中）
            chessBoard(tr, tc+size, dr, dc, size);  //直接：递归（右上分块）
        }else{
            this.board[tr+size-1][tc+size] = tileSeque;     //此时：特殊方格（不在，右上分块中），为小问题（生成：特殊方格）
            chessBoard(tr, tc+size, tr+size-1, tc+size, size);    //小问题：分块，覆盖
        }

        //6、判断：（特殊点）是否在(左下分块)
        if(dr >= tr+size && dc < tc+size){             //此时：特殊方格，在左下分块中
            chessBoard(tr+size, tc, dr, dc, size);  //直接：递归（左下分块）
        }else{
            this.board[tr+size][tc+size-1] = tileSeque;     //此时：特殊方格（不在，左下分块中），为小问题（生成：特殊方格）
            chessBoard(tr+size, tc, tr+size-1, tc+size-1, size);     //小问题：分块，覆盖
        }

        //7、判断：（特殊点）是否在(右下分块)
        if(dr >= tr+size && dc >= tc+size){       //此时：特殊方格，在右下分块中
            chessBoard(tr+size, tc+size, dr, dc, size);   //直接：递归（右下分块）
        }else{
            this.board[tr+size][tc+size] = tileSeque;  //此时：特殊方格（不在，右下分块中），为小问题（生成：特殊方格）
            chessBoard(tr+size, tc+size, tr+size, tc+size, size);
        }
    }


    //获取：棋盘大小
    public int getBoardSize(){
        //1、设置：扫描（控制台）输入内容
        Scanner stdIn = new Scanner(System.in);

        //2、输入棋盘（2^k）*（2^k）中的：k值
        System.out.print("请输入,指数幂（整数） k = ");
        int k = stdIn.nextInt();

        //3、通过k值：获取（矩阵棋盘）大小
        int size =  (int)Math.pow(2, k);
        System.out.println("棋盘大小为：" + size + " * " + size);

        return size;
    }


    //初始化：特殊方块
    public void initSpecial(){
        Scanner stdIn = new Scanner(System.in);

        //4、输入：棋盘（特殊方格）的（索引坐标）
        System.out.print("请输入，特殊方格（行坐标） x = ");
        int x = stdIn.nextInt();

        System.out.print("请输入，特殊方格（列坐标） y = ");
        int y = stdIn.nextInt();

        while (true){
            if(x >= 0 && x <= boardSize-1 && y >= 0 && y <= boardSize-1){   //检测（特殊方格）坐标是否越界
                break;                  //坐标没有越界
            }else{
                System.out.println("特殊方格，初始化坐标越界，请重新输入：");
                System.out.print("请输入，特殊方格（行坐标） x = ");
                x = stdIn.nextInt();

                System.out.print("请输入，特殊方格（列坐标） y = ");
                y = stdIn.nextInt();
            }
        }
        SpecialX = x;
        SpecialY = y;
    }

    //间接调用：覆盖棋盘
    public void chessBoardStart(){
        chessBoard(0, 0, SpecialX, SpecialY, boardSize);
    }

    //打印：打印棋盘内容
    public void printBoard(){
        for(int i = 0; i < board.length; i++){
            for(int j = 0; j < board.length; j++){
                System.out.print(board[i][j] + "\t");
            }
            System.out.println("");                     //换行
        }
    }


    //主方法
    public static void main(String[] args){
        //1、创建：棋盘对象
        ChessBoard01 board = new ChessBoard01();

        //2、进行覆盖
        board.chessBoardStart();

        //3、打印：覆盖后的棋盘内容
        board.printBoard();

    }
}

②、代码图

image-20201204221219641

③、运行结果

image-20201204220347373

3、Java版本（未封装）

未封装版本：理解起来可能更简单

①、代码

package com.yyy.test;

import java.util.Scanner;

/**
 * 分治法——棋盘覆盖问题
 * 棋盘覆盖问题：描述
 *       <1>、有一个2^k∗2^k的(方格棋盘)，(只有1个)方格是黑色的，其他为白色。
 *       <2>、你的任务是用包含3个方格的L型牌覆盖所有白色方格。黑色方格不能被覆盖，
 *       <3>、且任意一个白色方格（不能同时）被（两个或更多牌）覆盖。
 */
public class ChessBoard {
    public int board[][];      //棋盘：大小
    private int tile;           //L骨牌：存放值

    public ChessBoard(int size, int tile) {
        this.board = new int[size][size];          //初始化棋盘大小：为2^k * 2^k 大小
        this.tile = tile;                     //初始化L骨牌：存放值
    }

    /**
     * 该方法：利用分治思想，大问题分解成（同一类型的：小问题）， 小问题之间（没有交叉）进行（棋盘覆盖）
     * @param tr: 初始（查找点）行索引
     * @param tc：初始（查找点）列索引
     * @param dr：初始（特殊方格）行索引
     * @param dc：初始（特殊方格）列索引
     * @param initSize：初始（棋盘大小），initSize * initSize (矩阵棋盘)
     */
    public void chessBoard(int tr, int tc, int dr, int dc, int initSize){
        //1、判断：当棋盘只有（1个方格时），不用覆盖， 因为该方格，必为（特殊方格）
        if(initSize == 1){
            return;         //此时是：递归出口
        }

        //2、创建：骨牌序号（L骨牌由3个方格组成），这3个方格（值一样）
        int tileSeque = tile++;     //tile值：后置递增，是为了（递归覆盖）方便

        //3、将棋盘分4块： 大小变为 (2^k)-1  * (2^k)-1
        int size = initSize / 2;

        //4、判断：（特殊方格）是否在(左上分块)
        if(dr < tr+size && dc < tc+size){       //此时：（特殊方格）在（左上分块）中
            chessBoard(tr, tc, dr, dc, size);   //直接：递归（左上分块）
        }else{
            this.board[tr+size-1][tc+size-1] = tileSeque;  //此时：特殊方格（不在，左上分块中），为小问题（生成：特殊方格）
            chessBoard(tr, tc, tr+size-1, tc+size-1, size);    //小问题：分块，覆盖
        }

        //5、判断：（特殊方格）是否在(右上分块)
        if(dr < tr+size && dc >= tc+size){              //此时：（特殊方格）在（右上分块中）
            chessBoard(tr, tc+size, dr, dc, size);  //直接：递归（右上分块）
        }else{
            this.board[tr+size-1][tc+size] = tileSeque;   //此时：特殊方格（不在，右上分块中），为小问题（生成：特殊方格）
            chessBoard(tr, tc+size, tr+size-1, tc+size, size);    //小问题：分块，覆盖
        }

        //6、判断：（特殊点）是否在(左下分块)
        if(dr >= tr+size && dc < tc+size){             //此时：特殊方格，在左下分块中
            chessBoard(tr+size, tc, dr, dc, size);  //直接：递归（左下分块）
        }else{
            this.board[tr+size][tc+size-1] = tileSeque;  //此时：特殊方格（不在，左下分块中），为小问题（生成：特殊方格）
            chessBoard(tr+size, tc, tr+size-1, tc+size-1, size);     //小问题：分块，覆盖
        }

        //7、判断：（特殊点）是否在(右下分块)
        if(dr >= tr+size && dc >= tc+size){       //此时：特殊方格，在右下分块中
            chessBoard(tr+size, tc+size, dr, dc, size);   //直接：递归（右下分块）
        }else{
            this.board[tr+size][tc+size] = tileSeque;  //此时：特殊方格（不在，右下分块中），为小问题（生成：特殊方格）
            chessBoard(tr+size, tc+size, tr+size, tc+size, size);
        }
    }

    //打印：打印棋盘内容
    public void printBoard(){
        for(int i = 0; i < board.length; i++){
            for(int j = 0; j < board.length; j++){
                System.out.print(board[i][j] + "\t");
            }
            System.out.println("");                     //换行
        }
    }

    //获取棋盘大小

    //主方法
    public static void main(String[] args){
        //1、设置：扫描（控制台）输入内容
        Scanner stdIn = new Scanner(System.in);

        //2、输入棋盘（2^k）*（2^k）中的：k值
        System.out.print("请输入,指数幂（整数） k = ");
        int k = stdIn.nextInt();

        //3、通过k值：获取（矩阵棋盘）大小
        int size =  (int)Math.pow(2, k);
        System.out.println("棋盘大小为：" + size + " * " + size);

        //4、输入：棋盘（特殊方格）的（索引坐标）
        System.out.print("请输入，特殊方格（行坐标） x = ");
        int x = stdIn.nextInt();

        System.out.print("请输入，特殊方格（列坐标） y = ");
        int y = stdIn.nextInt();

        while (true){
            if(x >= 0 && x <= size-1 && y >= 0 && y <= size-1){   //检测（特殊方格）坐标是否越界
                break;                  //坐标没有越界
            }else{
                System.out.println("特殊方格，初始化坐标越界，请重新输入：");
                System.out.print("请输入，特殊方格（行坐标） x = ");
                x = stdIn.nextInt();

                System.out.print("请输入，特殊方格（列坐标） y = ");
                y = stdIn.nextInt();
            }
        }

        //5、创建：棋盘对象
        ChessBoard board = new ChessBoard(size, 1);

        //6、进行覆盖
        board.chessBoard(0, 0, x, y, size);

        //7、打印：覆盖后的棋盘内容
        board.printBoard();

    }
}

②、代码图

image-20201204221456907

③、运行结果

image-20201204221616675

4、总结：复杂度

image-20201205075209762

漫漫求
关注
专栏目录
棋盘覆盖问题[Java]
weixin_54986763的博客
01-20 761
当四等分后为2*2的棋盘且特殊方格在其中，则刚好用一个L填满棋盘。 解题思路：先将棋盘按中间点四等分为左上，右上，左下，右下四部分。 当四等分后为2*2的棋盘且特殊方格在其中，则刚好用一个L填满棋盘。 若四等分后特殊方格不在其中，则将中心四格除了特殊方格在的部分其他三个格子涂同一颜色，并标记为特殊方格。 //棋盘覆盖问题 public class ChessBoardCoverage { private static int BOARD_SIZE = 4;//例举4*4的棋盘 pr...
棋盘覆盖java
weixin_59337031的博客
03-20 146
public class chessBoard { int tile=1; int[][]board=new int[4][4]; public static void main(String[] args) { chessBoard c=new chessBoard(); c.chessBoard(0,0,1,1,4); for(int i=0;i<4;i++) { for(int j=0;i<4;...
棋盘覆盖问题（JAVA）
落叶为了归根
10-11 1268
   在一个2k×2k 个方格组成的棋盘中，恰有一个方格与其它方格不同，称该方格为一特殊方格，且称该棋盘为一特殊棋盘。在棋盘覆盖问题中，要用图示的4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。 参数说明： 子棋盘：由棋盘左上角的坐标tr，tc和棋盘大小size表示。 特殊方格：在二维数组中的坐标位置是（dr，dc）。  代码如下： ...
棋盘覆盖问题（Java）
CSDN2022博客之星Top39；华为云博主7&，CSDN、稀土掘金、微信公众号、阿里云开发者社区、腾讯云社区、博客园、知乎、51CTO同名博主WHYBIGDATA；
11-21 1600
棋盘覆盖问题（Java）
棋盘覆盖问题 ——java版
qq_55624776的博客
09-16 212
棋盘覆盖问题——Java版 原理 ：利用递归分治思想 将大问题转化为小问题 进行求解 直接上代码 private static int title = 1; public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("请输入k的值"); //其中的输入 K为 2^k int k = scanner.nextInt()
棋盘覆盖问题（Java实现）
Z5550的博客
06-13 669
在一个2k×2k的棋盘中，有一个特殊方格，要求用L型骨牌覆盖满除特殊方格外的所有其他方格，且骨牌不得重叠（骨牌可以旋转放置） 代码： package stest; import java.util.Scanner; import org.junit.Test; public class Test1 { int num = 0; static int[][] board; /** * 棋盘覆盖函数 * @param tr：表示当前所在棋盘的左上角的行位置 *
Java实现图形化棋盘覆盖算法设计与应用
资源摘要信息:"TestChess.rar是一个包含测试用的Java程序压缩包，该程序实现了棋盘覆盖问题的图形化界面算法。此算法主要是用来解决棋盘覆盖问题的一种有效的计算机算法。棋盘覆盖问题是指给定一个MxN的棋盘，在其上...
7-3 棋盘覆盖 (10 分)(思路加详解)Come baby，Java月薪过万要掌握的技能
最新发布
2201_75604341的博客
03-26 687
既然是要面试，那么就少不了刷题，实际上春节回家后，哪儿也去不了，我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。//tr，tc:表示棋盘左上角的初始位置的行列号 ，dr dc 表示特殊方格的行列号 size = 2^k;else{//如果方格不在左上角的子棋盘中，那么的话在子棋盘的最右下角 覆盖一个方格。else{//如果方格不在右上角的子棋盘中，那么的话在子棋盘的最左下角 覆盖一个方格。
棋盘覆盖执行文件
09-16
java实现棋盘覆盖，该文件为可执行文件
残缺棋盘覆盖仿真，完成调整速度和自动计数功能！！！
ANAN永不败315的博客
12-06 326
问题描述： 残缺棋盘是一个有2k∗2k2^k*2^k2k∗2k个方格的棋盘，其中恰有一个方格残缺。现在要求用三格板覆盖残缺棋盘，覆盖过程中两个三格板不能重叠，不能覆盖残缺方格，但必须覆盖其它的所有方格。问如何去覆盖该残缺棋盘（给出覆盖方案）？ 为了完成这个作业，我找了很多代码。找到了两个我觉得比较有用的代码，在这个基础上进行了功能的改进。 残缺棋盘覆盖分治算法仿真软件及源码 棋盘覆盖过程演示 它们的代码标注很少，我在读的时候增加了不少自己的标注，可以帮助更好的理解，但也有些标注可能有错误。 界面： 详细代
java解决棋盘覆盖问题
04-09
当k>0时，将2k×2k棋盘分割为4个2k-1×2k-1 子棋盘(a)所示。 特殊方格必位于4个较小子棋盘之一中，其余3个子棋盘中无特殊方格。为了将这3个无特殊方格的子棋盘转化为特殊棋盘，可以用一个L型骨牌覆盖这3个较小棋盘的会合处，如 (b)所示，从而将原问题转化为4个较小规模的棋盘覆盖问题。递归地使用这种分割，直至棋盘简化为棋盘1×1。
分治法案例-残缺棋盘覆盖问题-JAVA实现
12-03
使用JAVA解决残缺棋盘覆盖问题：一个n*n的棋盘上有一个缺陷点，该点不能被覆盖，剩下的格子全部用三盒板覆盖。应用的是分治法。
棋盘覆盖问题(C++版)
03-12
用C++实现的棋盘覆盖问题，可以运行，应用到了面向对象的思想、算法设计、程序系统设计方法等，内含源代码。
C语言编写的棋盘覆盖问题
05-06
在一个2k*2k个方格组成的棋盘中，若恰有一个方格与其他方格不同，则称该方格位一特殊方格，且称该棋盘为宜特殊棋盘。在棋盘覆盖问题中，要用4种不同形态的L型骨牌覆盖一个给定的特殊棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。
棋盘覆盖问题c代码
03-23
在一个2^k * 2^k个方格组成的棋盘中，有一个方格与其它的不同，若使用以下四种L型骨牌覆盖除这个特殊方格的其它方格，如何覆盖。 c语言实现代码
【Java】棋盘覆盖问题
weixin_43927892的博客
04-27 751
棋盘覆盖问题抓住两点即可： 1.我们将一个大棋盘C分为四块，C的左上角是坐标是（0，0） 这个左上角坐标是用来区分在哪一个小棋盘的，抓住这个左上角的坐标变化 2.我们需要将没有特殊数字的其他三块继续分治，但是他没有特殊数字， 如果在第一象限，则将右下作为特殊 如果在第二象限，则将左下作为特殊 如果在第三象限，则将右上作为特殊 如果在第四象限，则将左上作为特殊 抓住这两点，问题则迎刃而解 代码： ...
棋盘覆盖问题详解
CAI_Ambassador的博客
04-25 1728
棋盘覆盖问题 每个棋盘里面有一个特殊方格，用L型的骨牌覆盖棋盘上除特殊方格的部分。 思路分析 代码实现 void ChessBoard(int tr,int tc,int dr,int dc,int size) /*tr，tc左上角行号列号 dr,dc特殊方格行号列号 size为边长*/ { if(size==1) return; int tile...
java 实现棋盘覆盖问题
weixin_34381687的博客
03-31 203
2019独角兽企业重金招聘Python工程师标准>>> ...
分治学习之棋盘覆盖问题（java）
pioneer的博客
12-18 404
package FZ; /* 2 0 3 3 2 2 1 3 4 1 1 1 4 4 1 1 棋盘一个特殊点用L型的棋子进行覆盖 //进行分治法计算 然后分成更小的 比如4分成2,2,2,2 的矩阵 然后进行继续分 分成1,1,1,1的标明其他非特殊点 */ public class ChessBoradProblem { private int[][] board;//棋盘 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

漫漫求

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值