Python的N-Queen问题

简介

N-Queen问题是一个著名的图论问题，在一个 n×n 的棋盘上放置 n 个皇后，使得它们互相之间不能攻击（即不能在同一行、同一列或同一条对角线上），求所有合法的摆法数量。

这个问题可以使用回溯算法（backtracking）来解决，算法枚举了所有可能的摆法，从中找出正确的摆法。

在Python语言中，利用递归的回溯算法可以非常方便地解决 N-Queen 问题。

示例代码

def is_valid(board, row, col):
    """
    Check if it is valid to place a queen at board[row][col].
    Only need to check the upper part of the board because the lower part is not filled yet.
    """
    for i in range(row):
        if board[i] == col or \
            row - i == col - board[i] or \
            row - i == board[i] - col:
            return False
    return True


def backtrack(board, row, n, res):
    """
    Backtracking function to find all valid solutions.
    """
    if row == n:
        res.append(board[:])
        return
    for col in range(n):
        if is_valid(board, row, col):
            board[row] = col
            backtrack(board, row+1, n, res)
            board[row] = -1


def solve_n_queens(n):
    """
    Solve the n queens problem.
    """
    board = [-1] * n
    res = []
    backtrack(board, 0, n, res)
    return res

针对该问题的Java解法

在Java语言中，同样可以使用回溯算法来解决 N-Queen 问题。

public class NQueen {
    public void solveNQueens(int n) {
        int[][] board = new int[n][n];
        backtrack(board, 0);
    }

    private boolean is_valid(int[][] board, int row, int col) {
        // check if there are queens on the same column
        for (int i = 0; i < row; i++) {
            if (board[i][col] == 1) {
                return false;
            }
        }

        // check if there are queens on the same diagonal
        for (int i = row-1, j = col-1; i >= 0 && j >= 0; i--, j--) {
            if (board[i][j] == 1) {
                return false;
            }
        }

        for (int i = row-1, j = col+1; i >= 0 && j < board.length; i--, j++) {
            if (board[i][j] == 1) {
                return false;
            }
        }

        return true;
    }

    private void backtrack(int[][] board, int row) {
        if (row == board.length) {
            print_board(board);
            return;
        }

        for (int col = 0; col < board.length; col++) {
            if (is_valid(board, row, col)) {
                board[row][col] = 1;
                backtrack(board, row+1);
                board[row][col] = 0;
            }
        }
    }

    private void print_board(int[][] board) {
        for (int i = 0; i < board.length; i++) {
            StringBuilder sb = new StringBuilder();
            for (int j = 0; j < board.length; j++) {
                if (board[i][j] == 1) {
                    sb.append('Q');
                } else {
                    sb.append('.');
                }
            }
            System.out.println(sb.toString());
        }
        System.out.println();
    }
}

总结

以上是Python和Java两种语言中解决 N-Queen 问题的代码。可以看到，它们在思路和实现上有很多相似之处，但具体的细节还是有所不同的。回溯算法虽然有些细节比较复杂，但已经被广泛应用于各种图论问题中，尤其是在状态搜索和遍历的问题中表现非常优异。