N皇后问题

在 N*N 的棋盘上放置 N 个皇后（n<=10）而彼此不受攻击（即在棋盘的任一行，任一列和任一对角线上不能放置 2 个皇后），编程求解所有的摆放方法。

输入

输入：n

输出

每行输出一种方案，每种方案顺序输出皇后所在的列号，各个数占5个字符。若无方案，则输出
no solute!

样例输入

4

样例输出

2    4    1    3
3    1    4    2

C语言实现

#include <stdio.h>
#include <math.h>

#define MAX_N 10 // 定义棋盘最大尺寸

int n; // 棋盘大小
int queen[MAX_N]; // 用于记录每行皇后放置的列位置

// 检查当前位置是否可以放置皇后
int is_safe(int row, int col) {
for (int i = 0; i < row; i++) {
// 检查列冲突
if (queen[i] == col) return 0;
// 检查对角线冲突（主对角线和副对角线）
if (abs(row - i) == abs(col - queen[i])) return 0;
}
return 1;
}

// 深度优先搜索函数，用于放置皇后
void dfs(int row) {
if (row == n) { // 如果已经成功放置了n个皇后，输出一种方案
for (int i = 0; i < n; i++) {
printf(“%5d”, queen[i] + 1); // 输出皇后所在列号，从1开始计数所以加1
}
printf(“\n”);
return;
}
for (int col = 0; col < n; col++) { // 尝试在当前行的每一列放置皇后
if (is_safe(row, col)) {
queen[row] = col;
dfs(row + 1);
queen[row] = -1; // 回溯，撤销当前位置的皇后放置
}
}
}

int main() {
scanf(“%d”, &n); // 输入棋盘大小
for (int i = 0; i < n; i++) {
queen[i] = -1; // 初始化皇后位置为无效值
}
if (n < 4) {
printf(“no solute!\n”);
} else {
dfs(0); // 从第0行开始深度优先搜索放置皇后
}
return 0;
}

C++实现

#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;

const int MAX_N = 10; // 定义棋盘最大尺寸

int n; // 棋盘大小
int queen[MAX_N]; // 用于记录每行皇后放置的列位置

// 检查当前位置是否可以放置皇后
bool is_safe(int row, int col) {
for (int i = 0; i < row; i++) {
// 检查列冲突
if (queen[i] == col) return false;
// 检查对角线冲突（主对角线和副对角线）
if (abs(row - i) == abs(col - queen[i])) return false;
}
return true;
}

// 深度优先搜索函数，用于放置皇后
void dfs(int row) {
if (row == n) { // 如果已经成功放置了n个皇后，输出一种方案
for (int i = 0; i < n; i++) {
cout << setw(5) << queen[i] + 1; // 输出皇后所在列号，从1开始计数所以加1
}
cout << endl;
return;
}
for (int col = 0; col < n; col++) { // 尝试在当前行的每一列放置皇后
if (is_safe(row, col)) {
queen[row] = col;
dfs(row + 1);
queen[row] = -1; // 回溯，撤销当前位置的皇后放置
}
}
}

int main() {
cin >> n; // 输入棋盘大小
for (int i = 0; i < n; i++) {
queen[i] = -1; // 初始化皇后位置为无效值
}
if (n < 4) {
cout << “no solute!” << endl;
} else {
dfs(0); // 从第0行开始深度优先搜索放置皇后
}
return 0;
}

Java实现

import java.util.Scanner;

public class NQueens {
static final int MAX_N = 10; // 定义棋盘最大尺寸
static int n; // 棋盘大小
static int[] queen = new int[MAX_N]; // 用于记录每行皇后放置的列位置

// 检查当前位置是否可以放置皇后
static boolean is_safe(int row, int col) {
    for (int i = 0; i < row; i++) {
        // 检查列冲突
        if (queen[i] == col) return false;
        // 检查对角线冲突（主对角线和副对角线）
        if (Math.abs(row - i) == Math.abs(col - queen[i])) return false;
    }
    return true;
}

// 深度优先搜索函数，用于放置皇后
static void dfs(int row) {
    if (row == n) {  // 如果已经成功放置了n个皇后，输出一种方案
        for (int i = 0; i < n; i++) {
            System.out.printf("%5d", queen[i] + 1);  // 输出皇后所在列号，从1开始计数所以加1
        }
        System.out.println();
        return;
    }
    for (int col = 0; col < n; col++) {  // 尝试在当前行的每一列放置皇后
        if (is_safe(row, col)) {
            queen[row] = col;
            dfs(row + 1);
            queen[row] = -1;  // 回溯，撤销当前位置的皇后放置
        }
    }
}

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    n = scanner.nextInt();  // 输入棋盘大小
    for (int i = 0; i < n; i++) {
        queen[i] = -1;  // 初始化皇后位置为无效值
    }
    if (n < 4) {
        System.out.println("no solute!");
    } else {
        dfs(0);  // 从第0行开始深度优先搜索放置皇后
    }
}

}

Python实现

n = 0  # 棋盘大小
queen = []  # 用于记录每行皇后放置的列位置

# 检查当前位置是否可以放置皇后
def is_safe(row, col):
    for i in range(row):
        # 检查列冲突
        if queen[i] == col:
            return False
        # 检查对角线冲突（主对角线和副对角线）
        if abs(row - i) == abs(col - queen[i]):
            return False
    return True


# 深度优先搜索函数，用于放置皇后
def dfs(row):
    global n, queen
    if row == n:  # 如果已经成功放置了n个皇后，输出一种方案
        for i in range(n):
            print(f"{queen[i] + 1:5}", end="")  # 输出皇后所在列号，从1开始计数所以加1
        print()
        return
    for col in range(n):  # 尝试在当前行的每一列放置皇后
        if is_safe(row, col):
            queen.append(col)
            dfs(row + 1)
            queen.pop()  # 回溯，撤销当前位置的皇后放置


n = int(input())  # 输入棋盘大小
if n < 4:
    print("no solute!")
else:
    dfs(0)  # 从第0行开始深度优先搜索放置皇后