递归与分治策略之棋盘覆盖Java实现

递归与分治策略之棋盘覆盖

一、问题描述

二、过程详解

1、棋盘如下图，其中有一特殊方格：16*16

 、

2、第一个分割结果:8*8

3、第二次分割结果:4*4

4、第三次分割结果:2*2

5、第四次分割结果:1*1

6、第一次分割后子棋盘的覆盖效果

三、代码实现

package cn.com.zfc.everyday.test;

import java.util.Scanner;

/**
 * 
 * @title ChessboardCoverage
 * @describe 棋盘覆盖：
 *           利用分治法，将方形棋盘分成4部分，如果该特殊点在某一部分，我们就去递归他，如果不在某一部分，我们假设一个点为特殊点，同样递归下去，知道全覆盖。
 * 
 *           左上角的子棋盘（若不存在特殊方格）：则将该子棋盘右下角的那个方格假设为特殊方格；
 *           右上角的子棋盘（若不存在特殊方格）：则将该子棋盘左下角的那个方格假设为特殊方格；
 *           左下角的子棋盘（若不存在特殊方格）：则将该子棋盘右上角的那个方格假设为特殊方格；
 *           右下角的子棋盘（若不存在特殊方格）：则将该子棋盘左上角的那个方格假设为特殊方格；
 * @author 张富昌
 * @date 2017年4月9日下午7:36:15
 */
public class ChessboardCoverage {
    // 定义棋盘的大小：2^k，需要的骨牌数是：(4^k-1)/3
    private static int BOARD_SIZE = 8;
    // 定义一个二维数组用来模拟棋盘
    private static int[][] board = new int[BOARD_SIZE][BOARD_SIZE];
    // 定义一个全局变量，用来记录骨牌的编号
    private static int tile = 0;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("棋盘的大小为：" + BOARD_SIZE);
        System.out.println("请输入特殊方格所在的行号：");
        int dr = scanner.nextInt();
        System.out.println("请输入特殊方格所在的列号：");
        int dc = scanner.nextInt();
        scanner.close();
        // 行号和列号与二位数组的下标相差 1
        chessBoard(0, 0, dr - 1, dc - 1, BOARD_SIZE);
        System.out.println("特殊方块在第 " + dr + " 行第 " + dc + "列，覆盖后的棋盘：");
        // 输出棋盘
        printBoard();
    }

    /**
     * 
     * @param tr：棋盘左上角方格的行号
     * @param tc:棋盘左上角方格的列号
     * @param dr：特殊方格所在的行号
     * @param dc：特殊方格所在的列号
     * @param size：当前棋盘的大小
     */
    private static void chessBoard(int tr, int tc, int dr, int dc, int size) {
        /* 1、当前棋盘的大小是 1 就返回 */
        if (size == 1) {
            return;
        }
        int t = tile++;
        // 分割棋盘，棋盘大小减半
        int s = size / 2;

        /* 2、覆盖左上角子棋盘 */
        if (dr < tr + s && dc < tc + s) {
            // 特殊方格在此棋盘中
            chessBoard(tr, tc, dr, dc, s);
        } else {
            // 特殊方格不在此棋盘中，用 t 号骨牌覆盖右下角
            board[tr + s - 1][tc + s - 1] = t;
            // 覆盖其余方格
            chessBoard(tr, tc, tr + s - 1, tc + s - 1, s);
        }

        /* 3、覆盖右上角子棋盘 */
        if (dr < tr + s && dc >= tc + s) {
            // 特殊方格在此棋盘中
            chessBoard(tr, tc + s, dr, dc, s);
        } else {
            // 特殊方格不在此棋盘中，用 t 号骨牌覆盖左下角
            board[tr + s - 1][tc + s] = t;
            // 覆盖其余方格
            chessBoard(tr, tc + s, tr + s - 1, tc + s, s);
        }

        /* 4、覆盖左下角子棋盘 */
        if (dr >= tr + s && dc < tc + s) {
            // 特殊方格在此棋盘中
            chessBoard(tr + s, tc, dr, dc, s);
        } else {
            // 特殊方格不在此棋盘中，用 t 号骨牌覆盖右上角
            board[tr + s][tc + s - 1] = t;
            // 覆盖其余方格
            chessBoard(tr + s, tc, tr + s, tc + s - 1, s);
        }

        /* 5、覆盖左下角子棋盘 */
        if (dr >= tr + s && dc >= tc + s) {
            // 特殊方格在此棋盘中
            chessBoard(tr + s, tc + s, dr, dc, s);
        } else {
            // 特殊方格不在此棋盘中，用 t 号骨牌覆盖右上角
            board[tr + s][tc + s] = t;
            // 覆盖其余方格
            chessBoard(tr + s, tc + s, tr + s, tc + s, s);
        }
    }

    // 输出棋盘
    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] + "	");
            }
            System.out.println("
");
        }
    }

}

测试效果：