写一段代码，解决8皇后问题

### 回答1：

def is_valid(board, row, col):
    for i in range(row):
        if board[i] == col or abs(board[i] - col) == abs(i - row):
            return False
    return True

def solve_n_queens(n, row, board):
    if row == n:
        return [board[:]]
    solutions = []
    for col in range(n):
        if is_valid(board, row, col):
            board[row] = col
            for solution in solve_n_queens(n, row+1, board):
                solutions.append(solution)
    return solutions

print(solve_n_queens(8, 0, [-1 for i in range(8)]))

这段代码解决了8皇后问题，使用了回溯算法。其中，函数`is_valid`用来判断在棋盘上第`row`行第`col`列放置皇后是否合法，函数`solve_n_queens`用来递归求解所有合法解。

### 回答2：
八皇后问题是一个经典的回溯算法问题，在一个8×8的棋盘上放置8个皇后，要求每个皇后不在同一行、同一列或者同一对角线上。以下是一段可以解决八皇后问题的代码：

def solve_queens(n):
    result = []
    def backtrack(queens, xy_diff, xy_sum):
        row = len(queens)
        if row == n:
            result.append(queens[:])
            return
        for col in range(n):
            if col not in queens and row - col not in xy_diff and row + col not in xy_sum:
                queens.append(col)
                xy_diff.add(row - col)
                xy_sum.add(row + col)
                backtrack(queens, xy_diff, xy_sum)
                queens.pop()
                xy_diff.remove(row - col)
                xy_sum.remove(row + col)
                
    backtrack([], set(), set())
    return result

# 测试代码
solutions = solve_queens(8)
for solution in solutions:
    print(solution)

这段代码使用了回溯算法来解决八皇后问题。backtrack函数是核心函数，使用递归方式进行回溯。在每一行，我们尝试将皇后放置在每一列上，然后判断是否满足条件。如果满足条件，就将该皇后所在的列，以及其所在的对角线所对应的行列值加入到集合中，继续递归处理下一行。如果递归结束后，row的值等于n，说明所有皇后都已经放置完毕，将结果记录下来。最后，返回所有解。

在测试代码中，我们调用solve_queens函数，并打印出所有解。

### 回答3：
八皇后问题是一个经典的回溯算法问题，要求在一个8x8的棋盘上放置8个皇后，使得彼此之间不能互相攻击。以下是一个解决八皇后问题的示例代码：

def solve_n_queens(n):
    result = []
    board = [['.'] * n for _ in range(n)]

    def is_valid(row, col):
        # 检查同一列是否已经放置了皇后
        for i in range(row):
            if board[i][col] == 'Q':
                return False
        # 检查左上方是否已经放置了皇后
        i, j = row, col
        while i > 0 and j > 0:
            i -= 1
            j -= 1
            if board[i][j] == 'Q':
                return False
        # 检查右上方是否已经放置了皇后
        i, j = row, col
        while i > 0 and j < n - 1:
            i -= 1
            j += 1
            if board[i][j] == 'Q':
                return False
        return True

    def backtrack(row):
        if row == n:
            result.append([''.join(row) for row in board])
            return
        for col in range(n):
            if is_valid(row, col):
                board[row][col] = 'Q'
                backtrack(row + 1)
                board[row][col] = '.'

    backtrack(0)
    return result

# 测试
if __name__ == '__main__':
    solutions = solve_n_queens(8)
    for solution in solutions:
        for row in solution:
            print(row)
        print()

这段代码使用回溯的思想，在每一行放置一个皇后，通过递归和回溯的方式，尝试不同的放置方法直到找到所有合法的解。is_valid函数用于判断当前位置是否可以放置皇后，通过检查同一列、左上方和右上方是否已经放置了皇后来进行判断。backtrack函数用于回溯和递归调用。最后，将找到的所有解存储在result中，并输出结果。