八皇后启发式算法

Question

八皇后启发式算法

javaartificial-intelligenceheuristicsn-queens

5

我正在开发一种方法，将8个皇后放在8x8的棋盘上。每个格子都有自己的“消除数字”（表示如果一个皇后放在该方格中，会“消除”多少个空棋盘格），每个皇后都应该放在具有最低消除数字的方格中。

我的问题是我不知道如何保持特定的方格的消除数字不断减少，如果您能帮忙解决这个问题，我会非常感激。

另一个问题是，我感觉我的代码非常复杂，如果您有任何建议使其更简单易懂，我也会很感激。

以下是我的代码：

public class Queen {
private final int SIZE = 8;
private int board[][] = new int[SIZE][SIZE]; // 8x8 board
private int hor[] = new int[SIZE]; // horizontal moves
private int ver[] = new int[SIZE]; // vertical moves
private int lowestValue = 22;
private int[][] queens = new int[SIZE][2]; // 8 queens 

public Queen () {
    // initialize each square with its own elimination number
    for (int row = 0; row < board.length; row++) {
        for (int col = 0; col < board[row].length; col++) {
            if (row == 0 || row == 7 || ((row >= 1 && row <= 6) && (col == 0 || col == 7))) {
                board[row][col] = 22;
            } 
            else if ((row == 1 || row == 6) && (col >= 1 && col <= 6) || (row > 1 && row < 6) && (col == 1 || col == 6)) {
                board[row][col] = 24;
            }
            else if ((row == 2 || row == 5) && (col >= 2 && col <= 5)|| (row > 2 && row < 5) && (col == 2 || col == 5)){
                board[row][col] = 26;
            }
            else if ((row == 3 || row == 4) && (col >= 3 && col <= 4)){
                board[row][col] = 28;
            }

        }
    }// end initializing

    // initialize moves
    //right
    hor[0] = 1;
    ver[0] = 0;
    //left
    hor[1] = -1;
    ver[1] = 0;
    //up
    hor[2] = 0;
    ver[2] = -1;
    //down
    hor[3] = 0;
    ver[3] = 1;
    //up right
    hor[4] = 1;
    ver[4] = -1;
    hor[7] = -1;
    ver[7] = 1;
    //up left
    hor[5] = -1;
    ver[5] = -1;
    //down right
    hor[6] = 1;
    ver[6] = 1;
    // down left

    for (int queen = 0; queen < queens.length; queen++) {
        placeQueens(queen);
    }
    displayBoard();
}// end constructor

// eliminate squares according to the place of the queen
private void eliminate (int queen_row, int queen_col) {

    // eliminate diagonal
    int rowCopy = queen_row;// helper row
    int colCopy = queen_col;// helper column
    try {
        // eliminate up right
        for (int move = 0; move < 8; move++) {
            rowCopy += ver[4];
            colCopy += hor[4];
            if (board[rowCopy][colCopy] > 0) {
                board[rowCopy][colCopy] = 0;
            }
        }
    } 
    catch (ArrayIndexOutOfBoundsException e) {      
    }

    try {
        rowCopy = queen_row;
        colCopy = queen_col;
        // eliminate up left
        for (int move = 0; move < 8; move++) {
            rowCopy += ver[5];
            colCopy += hor[5];
            if (board[rowCopy][colCopy] > 0) {
            board[rowCopy][colCopy] = 0;
            }
        }
    } 
    catch (ArrayIndexOutOfBoundsException e) {
    }

    try {
        rowCopy = queen_row;
        colCopy = queen_col;
        // eliminate down right
        for (int move = 0; move < 8; move++) {
            rowCopy += ver[6];
            colCopy += hor[6];
            if (board[rowCopy][colCopy] > 0) {
            board[rowCopy][colCopy] = 0;
            }
        }
    } 
    catch (ArrayIndexOutOfBoundsException e) {
    }
    try {
        rowCopy = queen_row;
        colCopy = queen_col;
        // eliminate down left
        for (int move = 0; move < 8; move++) {
            rowCopy += ver[7];
            colCopy += hor[7];
            if (board[rowCopy][colCopy] > 0) {
            board[rowCopy][colCopy] = 0;
            }
        }
    } 
    catch (ArrayIndexOutOfBoundsException e) {
    }

    // eliminate row
    for (int col = 0; col < 8;col++) {
        if (board[queen_row][col] > 0) {
        board[queen_row][col] = 0;
        }
    }
    // eliminate col
    for (int row = 0; row < 8; row++) {
        if (board[row][queen_col] > 0) {
        board[row][queen_col] = 0;
        }
    }

}// end elimination

// decrease elimination number of each square
public void decreaseElimination () {


}// end decrease elimination

public void countEliminated () {
    int counter = 0;
    for (int row = 0; row < board.length; row++) {
        for (int col = 0; col < board[row].length; col++) {
            if (board[row][col] == 0) {
                counter++;
            }

        }
    }
    System.out.printf("%d squares eliminated\n", counter);

}

public void placeQueens(int queenNum) {
    int targetRow;
    int targetCol;
    // find lowest elimination number
    for (int row = 0; row < board.length; row++) {
        for (int col = 0; col < board[row].length; col++) {
            if (board[row][col] > 0 && board[row][col] < lowestValue) {
                lowestValue = board[row][col];
                targetRow = row;
                targetCol = col;

                queens[queenNum][0] = targetRow;
                queens[queenNum][1] = targetCol;
            }
        }
    }

    System.out.printf("queen %d has been placed in [%d][%d]\n", queenNum + 1, queens[queenNum][0], queens[queenNum][1]);
    eliminate(queens[queenNum][0], queens[queenNum][1]);
    decreaseElimination();
    countEliminated();

}

// display board
public void displayBoard () {

    for (int row = 0; row < board.length; row++) {
        for (int col = 0; col < board[row].length; col++) {
                System.out.printf("|%2d|", board[row][col]); // display elimination number of each square
        }
        System.out.println();
    }

}// end displayBoard

我的主方法在单独的类中。

- kzidane

你不需要自己开发，只需在谷歌上搜索，你就能找到它。 - Bhavik Ambani

实际上我正在尝试解决Java编程第9版中的一个练习。 - kzidane

@BhavikAmbani：请阅读作业标签维基。 - Mat

@BhavikAmbani：我知道。请阅读标签维基。不要添加作业标签。 - Mat

@Bohemian 使用暴力破解方法是我以后要解决的另一个练习。 - kzidane

显示剩余4条评论

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Geoffrey De Smet · Accepted Answer

这段代码本质上存在缺陷:

for (int queen = 0; queen < queens.length; queen++) {
    placeQueens(queen);
}

您必须同时决定将皇后1到8放在哪里，才能决定将皇后0放在哪里。您已经实现了“首次适配”算法： First Fit

如上面的示例所示，“首次适配”算法不能得出可行解。此手册中提供了更多信息（包括有效的算法）。以下是一个有效的算法（但不易扩展）： Backtracking