• 2021-03-15 12:47:59

import java.util.Scanner;

public class chessBoard

{

private  int dr,dc,size; // dr: 特殊方格的排号。dc: 特殊方格的列号。size:棋盘规格

private  int[][]board;

public chessBoard(int size,int dc,int dr){

this.size=size;

this.dc=dc;

this.dr=dr;

board=new int[this.size][this.size];

init();

}

private void init() {

for(int i=0;i< size;i++)

for(int j=0;j< size;j++) board[i][j]=0;

}

public void chessBoard(int tr,int tc,int dr,int dc,int size){

if(size==1) return;

int s=size/2;

//特殊方格在左上角

if(dr< tr+s && dc< tc+s){//覆盖第四个L型骨牌

board[tr+s-1][tc+s]=4; //右上

board[tr+s][tc+s-1]=4;//左下

board[tr+s][tc+s]=4;//右下

chessBoard(tr,tc,dr,dc,s);//左上

chessBoard(tr,tc+s,tr+s-1,tc+s,s);//右上

chessBoard(tr+s,tc,tr+s,tc+s-1,s);//左下

chessBoard(tr+s,tc+s,tr+s,tc+s,s);//右下

}

//特殊方格在右上角

if(dr< tr+s && dc>=tc+s){//覆盖第3个L型骨牌

board[tr+s-1][tc+s-1]=3; //左上

board[tr+s][tc+s-1]=3;//左下

board[tr+s][tc+s]=3;//右下

chessBoard(tr,tc,tr+s-1,tc+s-1,s);//左上

chessBoard(tr,tc+s,dr,dc,s);   //右上

chessBoard(tr+s,tc,tr+s,tc+s-1,s);//左下

chessBoard(tr+s,tc+s,tr+s,tc+s,s);//右下

}

//特殊方格在左下角

if(dr>=tr+s && dc< tc+s){//覆盖第2个L型骨牌

board[tr+s-1][tc+s-1]=2; //左上

board[tr+s-1][tc+s]=2;//右上

board[tr+s][tc+s]=2;//右下

chessBoard(tr,tc,tr+s-1,tc+s-1,s);//左上

chessBoard(tr,tc+s,tr+s-1,tc+s,s);//右上

chessBoard(tr+s,tc,dr,dc,s);//左下

chessBoard(tr+s,tc+s,tr+s,tc+s,s);//右下

}

//特殊方格在右下角

if(dr>=tr+s && dc>=tc+s){//覆盖第1个L型骨牌

board[tr+s-1][tc+s-1]=1; //左上

board[tr+s-1][tc+s]=1;//右上

board[tr+s][tc+s-1]=1;//左下

chessBoard(tr,tc,tr+s-1,tc+s-1,s);//左上

chessBoard(tr,tc+s,tr+s-1,tc+s,s);//右上

chessBoard(tr+s,tc,tr+s,tc+s-1,s);//左下

chessBoard(tr+s,tc+s,dr,dc,s);//右下

}

}

public void showChess(){

for (int i = 0; i < size; i++) {

for (int j = 0; j < size; j++)

{ System.out.print(board[i][j]+" ");}

System.out.println();       }

}

public static void main(String[] args) {

int size,dr,dc;

System.out.println("请输入棋盘的边长 ");

System.out.println("请输入棋盘特殊方格的具体位置(排号    列号)：");

chessBoard chess=new chessBoard(size,dr,dc);

chess.chessBoard(0, 0, dr, dc, size);

chess.showChess();}

}

更多相关内容
• 文章目录问题描述问题分析算法设计java代码 问题描述 在一个2k × 2k个放个中，恰好只有一个方格是残缺的。也就是在这个棋盘中有一个方格与其它的格子不同， 我们称这种棋盘为残缺棋盘。 下图所示k=2时，也就是一个...

问题描述

在一个2k × 2k个放个中，恰好只有一个方格是残缺的。也就是在这个棋盘中有一个方格与其它的格子不同， 我们称这种棋盘为残缺棋盘。

下图所示k=2时，也就是一个22 × 22的棋盘，其中第一行第二列这个方格为一个与众不同的方格。

覆盖是指，用L型骨牌覆盖残缺棋盘上所有方格，覆盖是要求二任何两个L型骨牌不能重叠。

问题分析

首先分析一下用于覆盖的骨牌的情况，那么L型骨牌有几种了？
观察发现，L型骨牌是可以旋转的。经过旋转后有四种情况，如下图所示，

残缺方格共有2k × 2k种，对于任何k>=0,残缺棋盘有2k × 2k种。

2k × 2k的棋盘中有一个是残缺方格，因此有4k个方格，除去一个残缺的方格，共有4k - 1个方格要覆盖，而每个骨牌有三个格子，因此，用到的骨牌数量应该是（4k -1)/3个。

下图给出了一个覆盖的实例。在这个棋盘中，共有15空格要覆盖，15/3=5。5个L型骨牌进行覆盖。

算法设计

采用分治的策略，第一个关键问题为分割，将原问题分割为若干个小规模的问题。那么怎么分割呢？
当k>0时，将2k × 2k棋盘分割为4个2k -1× 2k-1的子棋盘。
问题规模由原来的2k 变为2k-1 。子问题的规模是原问题的一半。

那么对应的四个子问题分别是什么情况呢？
此时，残缺方格一定位于四个子棋盘之一，因为残缺方格只有一个。问题规模由原来的2k 变为2k-1 ，子问题的规模是原问题规模的一半。

对于2k × 2k的棋盘有如下的特点：
1、正方形
是否能将问题分治为多个子问题。
2、棋盘上有一个残缺方格
分解后的子问题汇中应该有一个残缺方格

通过观察我们可以发现，分解后的子问题中，有三个棋盘没有残缺，与原问题不同。而分治法要求，子问题相互独立且与原问题相同，因此将剩余三个棋盘转换为残缺棋盘用L型骨牌覆盖这三个较小棋盘的结合处。
L型骨牌恰好有三个方格，我们用这三个方格覆盖3个子棋盘的结合处。这三个棋盘上被L型骨牌覆盖的方格，就成为该棋盘上的残缺方格。这样就将原问题分解为4个较小规模的棋盘覆盖问题。

对于子问题怎么求解了？
每一次分割都可以将原问题的规模缩小二分之一，针对这类问题，可以递归的使用这种分割方法吗，知道把问题化简到一个可解的状态。

java代码

package com.java2;

public class ChessBoard
{
int tile=1;//表示L型骨牌的编号
int[][] board = new int[4][4];//表示棋盘
//处理带有特殊棋子的棋盘.tr、tc表示棋盘的入口即左上角的行列号，dr、dc表示特殊棋子的行列位置，size表示棋盘的行数或者列数
public void chessBoard(int tr, int tc, int dr, int dc, int size)
{
if(size == 1) return;
int t = tile++;
System.out.println(t);
int s = size/2;//每一次化大棋盘为一半的子棋盘
//要处理带有特殊棋子的棋盘，第一步先处理左上棋盘
if(dr < tr + s && dc< tc + s)//左上角子棋盘有特殊棋子
chessBoard(tr,tc,dr,dc,s);//处理有特殊棋子的左上角子棋盘
else//处理无特殊棋子的左上角子棋盘
{
board[tr+s-1][tc+s-1] = t;//设左上角子棋盘的右下角为特殊棋子，用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
{
board[tr+s-1][tc+s] =t;//设右上角子棋盘的左下角为特殊棋子，用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
{
board[tr+s][tc+s-1] = t;//设左下角子棋盘的右上角为特殊棋子，用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
{
board[tr+s][tc+s] = t;//设子棋盘右下角的左上角为特殊棋子，用t型的骨牌覆盖。由于骨牌有三种，当处理过程中同一级设置的特殊棋子用相同的骨牌覆盖
chessBoard(tr+s,tc+s,tr+s,tc+s,s);//处理有用 骨牌覆盖的格子作为特殊棋子的右下角子棋盘
}
}

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; j <4; j++)
System.out.print(c.board[i][j]+"  ");
System.out.println();
}
}

}


展开全文
• 当四等分后为2*2的棋盘且特殊方格在其中，则刚好用一个L填满棋盘。 解题思路：先将棋盘按中间点四等...//棋盘覆盖问题 public class ChessBoardCoverage { private static int BOARD_SIZE = 4;//例举4*4的棋盘 pr...

当四等分后为2*2的棋盘且特殊方格在其中，则刚好用一个L填满棋盘。

解题思路：先将棋盘按中间点四等分为左上，右上，左下，右下四部分。
**当四等分后为22的棋盘且特殊方格在其中，则刚好用一个L填满棋盘。
若四等分后特殊方格不在其中，则将中心四格除了特殊方格在的部分其他三个格子涂同一颜色（如特殊方格在右上部分，则将左上、左下、右下涂色），并标记为特殊方格。然后再将每个部分四等分，若每部分大于2
2则继续标记，直到等分后为2*2的棋盘，用一个L填满棋盘。

//棋盘覆盖问题
public class ChessBoardCoverage {
private static int BOARD_SIZE = 8;//例举8*8的棋盘
private static int[][] board = new int[BOARD_SIZE][BOARD_SIZE];
private static int title = 0;

public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println(">输入特殊方格的角标：");
int dr = input.nextInt();
int dc = input.nextInt(); //dr，dc为特殊点的下标
//tr，tc为基准点，用于标记每个部分并进行操作
chessBoard(0, 0, dr, dc, BOARD_SIZE);
printBoard();
}
//输出二维数组内容
private static void printBoard() {
for (int i = 0;i < BOARD_SIZE;i++){
for (int j = 0;j < BOARD_SIZE;j++){
System.out.print(board[i][j] + "\t");
}
System.out.println();
}
}
//chessBoard（基准点行下标，基准点列下标，特殊点行下标，特殊点列下标，当前部分是size*size）
private static void chessBoard(int tr, int tc, int dr, int dc, int size) {
if (size == 1) {
return;//返回上一层，从哪里调用chessBoard进来的就返回哪里
}
int num = ++title; //因为title是static型，所以在返回上一层时num是当前层的值不变，但进入新的一层时都会是上一次递进时的num+1且不变
int s = size / 2;
//左上 四个方向在同一层是并列关系
if (dr < tr + s && dc < tc + s) {
chessBoard(tr,tc,dr,dc,s);
} else {
board[tr + s - 1][tc + s - 1] = num;
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 {
board[tr + s - 1][tc + s] = num;
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 {
board[tr + s][tc + s - 1] = num;
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 {
board[tr + s][tc + s] = num;
chessBoard(tr + s,tc + s,tr + s,tc + s,s);
}
}
}


测试结果：

展开全文
• 棋盘覆盖问题中，要用图示的4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。 2.思路 1.当k>0时，将2k*2k棋盘分割为4个2(k-1)*2(k-1)子棋盘 2.将这三个无...

6.2 棋盘覆盖

1.问题描述

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

2.思路

1.当k>0时，将2k*2k棋盘分割为4个2(k-1)*2(k-1)子棋盘

2.将这三个无特殊方格的子棋盘转换为特殊棋盘，用一个L型骨盘覆盖这三个较小棋盘的会和处

3.递归地使用这种分割方法，直至棋盘简化为1*1棋盘，就结束递归。

3.注意

1.每次都对分割后的四个小棋盘进行判断，判断特殊方格是否在里面。

这里的判断的方法是每次先记录下整个大棋盘的左上角方格的行列坐标，然后再与特殊方格坐标进行比较，就可以知道特殊方格是否在该块棋盘中。

1. 如果特殊方块在里面，这直接递归下去求即可，
2. 如果不在，这根据分割的四个棋盘的不同位置，把右下角、左下角、右上角或者左上角的方格标记为特殊方块，然后继续递归。在递归函数里，还要有一个变量s来记录边的方格数，每次对棋盘进行划分时，边的方格数都会减半，这个变量是为了方便判断特殊方格的位置。

左上角方格的行列坐标是确定的，根据棋盘的大小和要判断在哪个区域确定

实现细节：

用4*4的棋盘举例

要判断特殊的方格在哪一个区域：

根据传入的参数size,leftRow,leftCol可以将棋盘划分为四个区域，然后和特殊点比较

1. 左上角:specialRow < leftRow+size && specialCol < leftCol+size
2. 右上角:specialRow < leftRow+size && specialCol >= leftCol+size
3. 左下角:specialRow >= leftRow+size && specialCol < leftCol+size
4. 右下角:specialRow >= leftRow+size && specialCol >= leftCol+size


填充的特殊点也可以用这几个参数来确定

​ 如果特殊点不在左上角，填充的特殊点在该区域的右下角leftRow+size-1,leftRol+size-1

​ 如果特殊点不在右上角，填充的特殊点在该区域的左下角leftRow+size-1,leftRol+size

​ 如果特殊点不在左下角，填充的特殊点在该区域的右上角leftRow+size,leftCol+size-1

​ 如果特殊点不在右下角，填充的特殊点在该区域的左下角leftRow+size,leftCol+size

2.递归的结束条件

1. size为1时
//大小为1时，结束递归
if (1 == size) {
return;
}

1. size为2时
//大小为2时，结束递归
if(size == 2){
number++;
if(specialCol != leftCol || specialRow != leftRow)
board[leftRow][leftCol] = number;
if(specialCol != leftCol+1 || specialRow != leftRow+1)
board[leftRow+1][leftCol+1] = number;
if(specialCol != leftCol+1 || specialRow != leftRow)
board[leftRow][leftCol+1] = number;
if(specialCol != leftCol || specialRow != leftRow+1)
board[leftRow+1][leftCol] = number;
return;
}


4.代码

package com.java.test;

public class ChessProblem {

int size;//容量
int[][] board;//棋盘
int specialRow;//特殊点横坐标
static int number = 0;//L形编号，这个一定要是静态的，可以在任何地方访问到
int specialCol;//特殊点纵坐标

public ChessProblem(int specialRow, int specialCol, int size) {
this.size = size;
this.specialCol = specialCol;
this.specialRow = specialRow;
board = new int[size][size];
}

//specialRow   特殊点的行下标
//specialCol   特殊点的列下标
//leftRow      矩阵的左边起点行下标
//leftCol      矩阵左边起点的列下标
//size         棋盘的宽或者高

public void setBoard(int specialRow, int specialCol, int leftRow, int leftCol, int size) {
//大小为1时，结束递归
if (1 == size) {
return;
}

int subSize = size / 2;
number++;
int n = number;//注意这里一定要吧number存在当前的递归层次里，否则进入下一层递归全局变量会发生改变

//假设特殊点在左上角区域
if (specialRow < leftRow + subSize && specialCol < leftCol + subSize) {
setBoard(specialRow, specialCol, leftRow, leftCol, subSize);
}
else {
//不在左上角，设左上角矩阵的右下角就是特殊点（和别的一起放置L形）
board[leftRow + subSize - 1][leftCol + subSize - 1] = n;
setBoard(leftRow + subSize - 1, leftCol + subSize - 1, leftRow, leftCol, subSize);
}

//假设特殊点在右上方
if (specialRow < leftRow + subSize && specialCol >= leftCol + subSize) {
setBoard(specialRow, specialCol, leftRow, leftCol + subSize, subSize);
}
else {
//不在右上方，设右上方矩阵的左下角就是特殊点（和别的一起放置L形）
board[leftRow + subSize -1][leftCol + subSize] = n;
setBoard(leftRow + subSize -1, leftCol + subSize, leftRow, leftCol + subSize, subSize);
}

//特殊点在左下方
if (specialRow >= leftRow + subSize && specialCol < leftCol + subSize) {
setBoard(specialRow, specialCol, leftRow + subSize, leftCol, subSize);
}
else {
//不在左下方，设左下方矩阵的右上角就是特殊点（和别的一起放置L形）
board[leftRow + subSize][leftCol + subSize - 1] = n;
setBoard(leftRow + subSize, leftCol + subSize - 1, leftRow + subSize, leftCol, subSize);
}

//特殊点在右下角
if (specialRow >= leftRow + subSize && specialCol >= leftCol + subSize) {
setBoard(specialRow, specialCol, leftRow + subSize, leftCol + subSize, subSize);
}
else {
//不在右下角，设右下角矩阵的左上就是特殊点（和别的一起放置L形）
board[leftRow + subSize][leftCol + subSize] = n;
setBoard(leftRow + subSize, leftCol + subSize, leftRow + subSize, leftCol + subSize, subSize);
}
}

//输出棋盘
public void printBoard(int specialRow,int specialCol,int size) {
setBoard(specialRow, specialCol, 0, 0, size);
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) {
//棋盘的大小
int N = 8;
//特殊点的坐标
int specialRow = 0;
int specialCol = 1;
ChessProblem chessProblem = new ChessProblem(specialRow , specialCol , N);
chessProblem.printBoard(specialRow, specialCol, N);
}

}


5.运行截图

展开全文
• 主要介绍了Java基于分治算法实现的棋盘覆盖问题,简单描述了棋盘覆盖问题,并结合具体实例形式分析了java基于分治算法实现棋盘覆盖问题的相关操作技巧,需要的朋友可以参考下
• 棋盘覆盖问题中，要用到 4 种不同形态的 L 型骨牌覆盖特殊棋盘中出去特殊方格的所有方格，并且任意两个骨牌不能有任何重叠部分。因此，在任意一个2^k × 2^k的特殊棋盘中，要用到的 L 型骨牌个数恰为（4^k-1）/3。...
• 字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法...
• 在一个2k×2k的棋盘中，有一个特殊方格，要求用L型骨牌覆盖满除特殊方格外的所有其他方格，且骨牌不得重叠（骨牌可以旋转放置） ... * 棋盘覆盖函数 * @param tr：表示当前所在棋盘的左上角的行位置 *
• JAVA算法：棋盘覆盖算法（经典算法问题） 经典算法问题：在一个2^k×2^k （k≥0）个方格组成的棋盘中，恰有一个方格与其他方格不同，称该方格为特殊方格。显然，特殊方格在棋盘中可能出现的位置有4^k种，因而有4^k...
• 为了将这3个无特殊方格的子棋盘转化为特殊棋盘，可以用一个L型骨牌覆盖这3个较小棋盘的会合处，如 (b)所示，从而将原问题转化为4个较小规模的棋盘覆盖问题。递归地使用这种分割，直至棋盘简化为棋盘1×1。
• public class 棋盘覆盖问题{ // 定义棋盘的大小：2^k，需要的骨牌数是：(4^k-1)/3 private static int BOARD_SIZE = 8; // 定义一个二维数组用来模拟棋盘 private static int[][] board = new int[BOARD_SIZE]...
• 棋盘覆盖问题抓住两点即可：1.我们将一个大棋盘C分为四块，C的左上角是坐标是(0，0)这个左上角坐标是用来区分在哪一个小棋盘的，抓住这个左上角的坐标变化2.我们需要将没有特殊数字的其他三块继续分治，但是他没有...
• java 实现棋盘覆盖问题

千次阅读 2018-03-14 03:00:55
问题描述：在一个2k*2k的棋盘中，有一个特殊方格，要求用L型骨牌覆盖满除特殊方格外的所有其他方格，且骨牌不得重叠.（骨牌可以旋转放置）输入：棋盘的边长、特殊方格坐标输出：骨牌放法.其中用0表示特殊方格，同...
• 棋盘覆盖方块版输出Java棋盘覆盖数字版输出Java 问题描述 在一个2^k×2^k 个方格组成的棋盘中，恰有一个方格与其他方格不同，称该方格为一特殊方格，且称该棋盘为一特殊棋盘。在棋盘覆盖问题中，要用图示的4种...
• public classChessBroad {private static int SIZE = 8;private static String arr[][] = newString[SIZE][SIZE];private staticTable table;static{for (int i = 0; i < SIZE; i++) {for (int j = 0;...
• 棋盘覆盖问题——Java版 原理 ：利用递归分治思想 将大问题转化为小问题 进行求解 直接上代码 private static int title = 1; public static void main(String[] args) { Scanner scanner = new Scanner...
• 使用JAVA解决残缺棋盘覆盖问题：一个n*n的棋盘上有一个缺陷点，该点不能被覆盖，剩下的格子全部用三盒板覆盖。应用的是分治法。
• 棋盘覆盖-Java

2018-11-02 09:02:31
问题描述】 2k*2k个方格的一个棋盘，有一个方格残缺； 要求： 用三格板覆盖棋盘， 三格板不重叠， 不覆盖残缺方格， 覆盖所有其它方格。 当 k&gt;0 时，将2k*2k棋盘分割为 4 个 2k-1*2k-1子棋盘 ； ...
• 算法系列(一)：棋盘覆盖 博客地址：http://blog.csdn.net/qq_22145801/article/
• 棋盘覆盖问题：给定一个大小为2n2n个小方格的棋盘，其中有一个位置已经被填充，现在要用一个L型（22个小方格组成的大方格中去掉其中一个小方格）形状去覆盖剩下的小方格。求出覆盖方案，即哪些坐标下的小方格使用同...
• package Hell.hao;...//棋盘左上角方格的行列int dr;int dc;//分别是特殊方格的行和列*/int SIZE;int [][]board;int count=1;ChessBoard(){}ChessBoard(int size){SIZE=size;board=new int[SIZE][S...
• 棋盘覆盖java实现代码..........超好的.....欢迎大家来下载.....
• 这学期的算法课后作业，也是用java实现了动态的覆盖 代码不多 import java.awt.BorderLayout; import java.awt.Color; import java.awt.EventQueue; import javax.swing.JFrame; import javax.swing.JPanel; import...
• 1、问题描述：在一个2k×2k...图2-4中的特殊棋盘是当k=2时16个特殊棋盘中的一个.2、编程任务：在棋盘覆盖问题中,要用图2-5所示的4种不同形态的L型骨牌覆盖一个给定的特殊棋盘上除特殊方格以外的所有方格,且任何2个L...
• 棋盘一个特殊点用L型的棋子进行覆盖 //进行分治法计算 然后分成更小的 比如4分成2,2,2,2 的矩阵 然后进行继续分 分成1,1,1,1的标明其他非特殊点 */ public class ChessBoradProblem { private int[][] board;//...
• * 棋盘覆盖问题 * * 2 2 3 3 * 2 1 1 3 * 4 1 0 1 * 4 4 1 1 * */ public class ChessBoradProblem { private int[][] board; //棋盘 private int specialRow; //特殊点的行下标 priv...
• 棋盘覆盖问题中，要用图示的4种不同形态的L型骨牌覆盖给定的特殊棋盘上除特殊方格以外的所有方格，且任何2个L型骨牌不得重叠覆盖。 参数说明： 子棋盘：由棋盘左上角的坐标tr，tc和棋盘大小size表示。 特殊方格...
• 分治法实现棋盘的“3-L形”完全覆盖java实现。
• 程序演示：https://www.bilibili.com/video/BV1Ff4y1576m 包含整个工程源码

...

java 订阅