Question

我已经获得了一块2 ^ k * 2 ^ k大小的电路板，其中一块瓷砖被随机移除，使其成为一块不足的电路板。任务是填充“trominos”，这是一个由3个瓷砖组成的L形图形。

解决它的过程并不太难。如果电路板是2x2，那么只需要一个tromino来填充它。对于任何更大的尺寸，它必须被分成四个部分（制作四个2 ^（k-1）尺寸的板），其中一个tromino放置在中心点，因此每个象限有一个填充的瓷砖。之后，可以递归填充板，直到每个瓷砖都填充了随机颜色的tromino。

我的主要问题是实际执行代码。我在Java编程方面的技能通常很差，而且我常常无法找到一个起点。唯一要做的工作是在平铺类中的tile方法，它将缺陷板作为输入作为输入，开始平铺的行和列以及要填充的平铺数量。这是一个家庭作业问题，所以我只是寻找一些指导或一个地方开始 - 任何帮助将不胜感激。

public class BoardViewer extends JFrame {

private static final int WIDTH = 1024;
private static final int HEIGHT = 768;
private static final int OFFSET = 30;

public static final int UPVERT = 1;
public static final int DNVERT = 2;
public static final int RHORIZ = 4;
public static final int LHORIZ = 8;
public static final int FILL = 16;

private Color [][] board;

public BoardViewer(DeficientBoard db) {
    super();
    setSize(WIDTH + (OFFSET*2), HEIGHT + (OFFSET*2));
    setDefaultCloseOperation(EXIT_ON_CLOSE);
    setResizable(false);

    board = db.getBoardColor();
}

public void paint(Graphics g) {
    super.paint(g);

    int width = WIDTH/board[0].length;
    int height = HEIGHT/board.length;

    for (int r = 0; r < board.length; r++)
        for (int c = 0; c < board[r].length; c++) {
            g.setColor(board[r][c]);

            int x = c*width + OFFSET;
            int y = r*height + OFFSET + (OFFSET/2);

            g.fillRect(x+1, y+1, width-1, height-1);
        }
}

}

public class DeficientBoard {

private int n;
private Color board[][];

// The four rotations of the tile.
// UL is XX
//       X
// UR is XX
//        X
// LL is X
//       XX
// LR is  X
//       XX
public final int UL = 0;
public final int UR = 1;
public final int LL = 2;
public final int LR = 3;

/**
 * Create a 2^k x 2^k deficient board.
 * 
 * @param k power
 */
public DeficientBoard(int k) {
    n = (int)Math.pow(2, k);
    createBoard(Color.LIGHT_GRAY);
}

/**
 * Actually create an n x n deficient board.
 * 
 * @param color background color
 */
private void createBoard(Color color) {
    board = new Color[n][n];
    for (int r = 0; r < board.length; r++)
        for (int c = 0; c < board[0].length; c++)
            board[r][c] = color;

    int d_row = (int)(Math.random() * n);
    int d_col = (int)(Math.random() * n);
    board[d_row][d_col] = Color.BLACK;
}

/**
 * Given a row and column and shape based on that point
 * place a tromino of the given color.
 * 
 * @param r row
 * @param c column
 * @param s shape (UL, UR, LL, LR)
 * @param theColor a Color
 */
public void placeTromino(int r, int c, int s, Color theColor) {
    if (s == UL) {
        board[r][c] = theColor; 
        board[r][c+1] = theColor;
        board[r+1][c] = theColor;
    } else if (s == UR) {
        board[r][c] = theColor;
        board[r][c+1] = theColor;
        board[r+1][c+1] = theColor;
    } else if (s == LL) {
        board[r][c] = theColor;
        board[r+1][c] = theColor;
        board[r+1][c+1] = theColor;
    } else {
        board[r+1][c] = theColor;
        board[r+1][c+1] = theColor;
        board[r][c+1] = theColor;
    }
}

/**
 * Get the 2^k x 2^k board.
 * 
 * @return the Color board.
 */
public Color[][] getBoardColor() {
    return board;
}

/**
 * Find and return the deficient row.
 * 
 * @param row row
 * @param col column
 * @param sz size of the baord
 * @return the row the deficient block is located
 */
public int getDeficientRow(int row, int col, int sz) {

    for (int r = row; r < (row + sz); r++)
        for (int c = col; c < (col + sz); c++)
            if (board[r][c] != Color.LIGHT_GRAY)
                return r;

    return -1;
}

/**
 * Find and return the deficient column.
 * 
 * @param row row
 * @param col column
 * @param sz size of the baord
 * @return the row the deficient block is located
 */
public int getDeficientCol(int row, int col, int sz) {
    for (int r = row; r < (row + sz); r++)
        for (int c = col; c < (col + sz); c++)
            if (board[r][c] != Color.LIGHT_GRAY)
                return c;

    return -1;
}

/**
 * Get the size of the deficient board.
 * 
 * @return the size
 */
public int getSize() {
    return n;
}

/**
 * Display information about the deficient board.
 */
public String toString() {
    return ("Deficient board of size " 
             + n + "x" + n
             + " with position missing at (" 
             + getDeficientRow(0, 0, n) + "," + getDeficientCol(0, 0, n) +").");
}

}

public class Tiling {

private static Color randColor() {
    int r = (int)(Math.random() * 256);
    int g = (int)(Math.random() * 256);
    int b = (int)(Math.random() * 256);

    return new Color(r, g, b);
}

public static void tile(DeficientBoard db, int row, int col, int n) {


}

public static void main(String[] args) {

    DeficientBoard db = new DeficientBoard(3);
    System.out.println(db);

    tile(db, 0, 0, db.getSize());

    BoardViewer bv = new BoardViewer(db);
    bv.setVisible(true);

}

}

Answer 1

通常，当递归函数实现分而治之算法时，它必须处理两种基本情况：

基本情况。这是你完成分裂，需要征服一点的情况。在您的作业中，基本情况是 n = 2的情况，在这种情况下，您只需要找到丢失/绘制的四个图块中的哪一个（使用DefectiveBoard.getDeficientRow和{ {1}}）并添加适当的triomino以覆盖其他三个瓷砖。
递归案例。这是你不完成分割的情况，所以你需要划分（即，递归），并且（取决于算法）可能需要在之前或之后进行一些征服。递归。在您的作业中，递归情况是 n ＆gt;在这种情况下，你需要做两件事：
- 找出四个象限中的哪一个有丢失/涂漆的瓷砖，并添加适当的三角形以覆盖其他三个象限中的每一个的一个瓷砖。
- 递归，称自己四次（每个象限一次）。

一个好的起点是写下“这是基本情况吗？”检查，并实施基本案例。

之后，如果你没有看到如何编写递归的情况，一种方法是临时写一个“高于基础”的情况（ n = 4），看看你是否可以概括它。如果没有，您可能会暂时写一个“高于基数”的情况（ n = 8），依此类推。（一旦你的递归算法工作，你就会删除这些特殊情况，因为它们完全被一般的递归情况所覆盖。）

Answer 2

这有点难以解决。但是，我会说你掌握了多少代码，所以我不会自觉。

我没有制定完整的解决方案，但我想如果你从拆下的瓷砖开始并在其两侧放置一个trominos。然后继续把trominos放在最后一个trominos的两边。你正在“舀”你最后放在板上的tromino。一旦你做到了董事会的边缘。剩下的就是多米诺骨牌形状的位置。这是我的意思的一个例子（X是掉落的瓷砖，即间隙，Y是trominos）：

 _ _ _ _
|_|_|_|_|
|_|Y|Y|_|
|_|Y|X|Y|
|_|_|Y|Y|

 _ _ _ _
|Y|Y|_|_|
|Y|Y|Y|_|
|_|Y|X|Y|
|_|_|Y|Y|

一旦板子填满了边缘，你就可以开始在板子的其余部分开始像炸弹一样掉落。我觉得这里有一个模式，你可以填充对角线trominos，同时在可重复的同时填充第二部分。但是如果你找不到它然后创建一个递归的例程来解决与边缘的差距，那么转换为在对角线模式中添加trominos。提示你必须只在第一个堆栈帧中进行转换。

祝你好运。

分而治之的算法

2 个答案: