N皇后问题python实现

N皇后问题python实现

常规解法

def is_valid(board, row, col):
    """
    判断在第row行第col列放置皇后是否合法
    """
    # 检查同一列是否有皇后
    for i in range(row):
        if board[i][col] == 'Q':
            return False
    # 检查右上方是否有皇后
    i, j = row - 1, col + 1
    while i >= 0 and j < len(board[0]):
        if board[i][j] == 'Q':
            return False
        i, j = i - 1, j + 1
    # 检查左上方是否有皇后
    i, j = row - 1, col - 1
    while i >= 0 and j >= 0:
        if board[i][j] == 'Q':
            return False
        i, j = i - 1, j - 1
    return True


def backtrack(board, row, res):
    """
    回溯函数，逐行放置皇后
    """
    if row == len(board):
        # 找到一组解，添加到结果列表中
        res.append(["".join(row) for row in board])
        return
    for col in range(len(board[0])):
        if is_valid(board, row, col):
            # 在该位置放置皇后
            board[row][col] = 'Q'
            # 递归到下一行
            backtrack(board, row + 1, res)
            # 恢复原状
            board[row][col] = '.'


def solve_n_queens(n):
    """
    解决N皇后问题
    """
    board = [['.' for _ in range(n)] for _ in range(n)]
    res = []
    backtrack(board, 0, res)
    return res
n = int(input())
res = solve_n_queens(n)
print(len(res))

优化

import os
import sys

# 请在此输入您的代码
def can_place(queen, row, col):
    # 检查是否和前面的皇后在同一列或同一对角线
    for i in range(row):
        if queen[i] == col or abs(row - i) == abs(col - queen[i]):
            return False
    # 检查是否符合额外限制条件
    if row >= 2 and abs(queen[row-2] - col) == 1 and abs(queen[row-1] - col) == 1:
        return False
    return True

def backtrack(queen, row, n, count):
    if row == n:
        # 找到一个合法解法，计数器加一
        count[0] += 1
    else:
        for col in range(n):
            if can_place(queen, row, col):
                queen[row] = col
                backtrack(queen, row+1, n, count)
                queen[row] = -1

def n_queens(n):
    queen = [-1] * n
    count = [0]
    backtrack(queen, 0, n, count)
    return count[0]
n = int(input())
print(n_queens(n))  

该算法的时间复杂度为 O(n^n)，空间复杂度为 O(n)，因为需要记录每一行皇后的位置和计数器。对于较小的 n，该算法可以得到较快的解决，但对于较大的 n，算法的时间复杂度会变得非常高，不适合实际使用。因此，有必要使用更高效的算法来解决 N 皇后问题，例如基于位运算的算法或基于优化的启发式搜索算法。