[leetcode] 52. N 皇后 II

会飞的大鱼人

已于 2024-04-15 17:43:57 修改

阅读量843

点赞数 27

分类专栏： leetcode题解文章标签： leetcode 算法 java

于 2024-04-11 15:23:30 首次发布

本文链接：https://blog.csdn.net/lvhao123456789/article/details/137637297

版权

leetcode题解专栏收录该内容

68 篇文章 0 订阅

订阅专栏

文章目录

题目描述
解题方法
相似题目

题目描述

n 皇后问题 研究的是如何将 n 个皇后放置在 n × n 的棋盘上，并且使皇后彼此之间不能相互攻击。

给你一个整数 n ，返回 n 皇后问题 不同的解决方案的数量。

示例 1：
在这里插入图片描述

输入：n = 4
输出：2
解释：如上图所示，4 皇后问题存在两个不同的解法。

示例 2：

输入：n = 1
输出：1

提示：

1 <= n <= 9

解题方法

方法一：dfs回溯

这道题和第51题几乎一样，结果只需要提供解决方案的数量。我们可以稍微改动一下代码，实现上述功能。（没看过第51题的童鞋可以先看这道）。

java代码

public int totalNQueens(int n) {
    if (n == 0) {
        return 0;
    }
    // 以下数组记录列、对角线是否已被棋子占用
    // 列
    int[] col = new int[n];
    // 右上到左下的对角线
    int[] dpos = new int[2 * n - 1];
    // 左上到右下的对角线
    int[] dneg = new int[2 * n - 1];
    // total数组引用传参，total[0]记录结果，total[0]初始化时默认值为0
    int[] total = new int[1];
    dfs(total, col, dpos, dneg, n, 0);
    return total[0];
}

// index代表当前遍历深度，即棋盘行数
public void dfs(int[] total, int[] col, int[] dpos, int[] dneg, int n, int index) {
    if (index == n) {
        total[0]++;
        return;
    }
    // i代表列
    for (int i = 0; i < n; i++) {
        // 检查该列和对角线是否已被前面放置的棋子占用
        if (col[i] == 1 || dpos[index + i] == 1 || dneg[index - i + n - 1] == 1) {
            continue;
        }
        col[i] = 1;
        dpos[index + i] = 1;
        dneg[index - i + n - 1] = 1;
        dfs(total, col, dpos, dneg, n, index + 1);
        col[i] = 0;
        dpos[index + i] = 0;
        dneg[index - i + n - 1] = 0;
    }
}

复杂度分析

时间复杂度： $O(N^2)$ ，需要遍历整个n×n棋盘。
空间复杂度： $O (N)$ ，一是需要提供三个数组，二是dfs会遍历n层。

方法二：交换位置递归

下面我来提供另一种dfs的思路，我们可以用nums数组记录每一行的棋子放置的位置，假设nums数组下标为i，下标i代表行，nums[i]的值代表列，nums[i]代表第i行的棋子放置在第nums[i]列，我们初始时给nums数组按照下标从0到n-1赋值，即nums[0] = 0，nums[1] = 1 ... nums[n - 1] = n - 1。

这样我们每次递归时，只需要按行交换某一列放置棋子的位置。例如，nums[0]与后面的列nums[i](0 <= i < n)交换位置后，nums[1]再与后面的列nums[i](1 <= i < n)交换位置，直到所有的行都与对应列交换位置后，我们需要验证交换位置后的数组是否符合n皇后问题的规则。那么怎么验证呢？

我们可以看出行和列规则不需要验证了，只需要验证对角线的规则。可以看下图。
在这里插入图片描述
如上图，我们设一个皇后的位置为 $x_{1},y_{1})$ ，另一个皇后的位置为 $x_{2},y_{2})$ 。如果 $x_{2},y_{2})$ 出现在 $x_{1},y_{1})$ 对应左上、右上、左下、右下的方向上，那么此时必然不符合n皇后问题的规则。

由此我们可以得出以下规律，当 $x_{1} - x_{2}| = |y_{1} - y_{2}|$ 时，不符合n皇后问题的规则。

有了上面的规律，我们就可以写代码实现了。

java代码

public int totalNQueens(int n) {
    if (n == 0) {
        return 0;
    }
    // nums[i]下标i代表行，nums[i]的值代表列，nums[i]代表第i行的棋子放置在第nums[i]列
    int[] nums = new int[n];
    // 初始化每一行放置棋子后对应列的位置，实际上nums[0...n-1]的值只要不重复就行，毕竟不同行的棋子不能放在同一列
    for (int i = 0; i < n; i++) {
        nums[i] = i;
    }
    // total数组引用传参，total[0]记录结果
    int[] total = new int[1];
    swapCore(total, nums, 0, n);
    return total[0];

}

public void swapCore(int[] total, int[] nums, int index, int n) {
    if (index == n) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < i; j++) {
                // Math.abs(第i行 - 第j行) == Math.abs(第nums[i]列 - 第nums[j]列)，表示第i行放置的棋子和第j行放置的棋子在同一条对角线上，不符合规定
                if (Math.abs(i - j) == Math.abs(nums[i] - nums[j])) {
                    return;
                }
            }
        }
        total[0]++;
        return;
    }
    for (int i = index; i < n; i++) {
        // 第index行选择某一列放置棋子
        swapArray(nums, index, i);
        // 后面的行就不能再选择前面的行放置棋子对应的列了，因为下标index + 1 ~ n - 1之间的nums数组对应的值里没有前面选择过的值
        swapCore(total, nums, index + 1, n);
        // 第index行回退到选择某一列放置棋子前的状态
        swapArray(nums, index, i);
    }
}

// 数组值交换
public void swapArray(int[] nums, int i, int j) {
    int temp = nums[i];
    nums[i] = nums[j];
    nums[j] = temp;
}