leetcode 第51题 N皇后问题

最新推荐文章于 2022-12-01 10:22:27 发布

flushmeteor

最新推荐文章于 2022-12-01 10:22:27 发布

阅读量233

点赞数

分类专栏：算法文章标签： N皇后 leetcode

本文链接：https://blog.csdn.net/lijianqingfeng/article/details/118244176

版权

算法专栏收录该内容

59 篇文章 0 订阅

订阅专栏

题目

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

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

每一种解法包含一个不同的 n 皇后问题的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。
示例1
在这里插入图片描述

输入：n = 4
输出：[[".Q…","…Q",“Q…”,"…Q."],["…Q.",“Q…”,"…Q",".Q…"]]
解释：如上图所示，4 皇后问题存在两个不同的解法。

示例2

输入：n = 1
输出：[[“Q”]]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/n-queens

思路

最暴力的解法就是枚举n个皇后所有可能在的位置进行组合，这种复杂度就非常非常高了。每个皇后的位置有 $n^{2}$ 种可能性，所有的组合就是 $n^{2})^{n}$

但是，我们没有必要进行暴力法，因为这里面很明显能发现一些规律。要保证所有皇后不可互相攻击，也就是所有皇后都不在同一行、同一列、同一斜线上。很明显每行只有一个皇后，那么我们就可以按行去依次放置皇后。在每次新放置皇后的时候都去判断当前位置是否无法互相攻击。当某一行无法放置新皇后的时候，就需要回溯，在上一行找新的位置放置皇后。

所以思路就是按行进行放置，通过回溯来遍历所有可能性。这个方案比暴力法的好处是在某一行如果发现不可行，就不必遍历后续的行，可以有效剪枝。我们知道每一行只能放置一个皇后，而且到下一行的时候也少了一列可以放置皇后，这样复杂度就会变成 $n!$ 。

接下来的问题就是，每次在新的一行选择位置的时候，如何判断该位置是否会造成互相攻击？

一个方法是：判断当前位置和之前行已经选好的位置，是否在同一行、同一列、同一斜线。那么我们就需要保留下之前每一行选中的列，可以用一个int[n] locations来保存。此时判断新位置的时间复杂度是 $O (n)$ 。

有一个优化方法，参考官方解法，就是：（1）如果斜线为从左上到右下方向，同一条斜线上的每个位置满足行下标与列下标之差相等。例如 (0,0)和 (3,3)在同一条方向一的斜线上。因此使用行下标与列下标之差即可明确表示每一条方向一的斜线。（2）如果斜线为从右上到左下方向，同一条斜线上的每个位置满足行下标与列下标之和相等，例如 (3,0)和 (1,2)在同一条方向二的斜线上。因此使用行下标与列下标之和即可明确表示每一条方向二的斜线。所以记录下行号、列号的同时，可以记录下行号+列号、行号-列号，这样就能在新位置的时候以 $O (1)$ 的时间复杂度判断该位置是否会产生互相攻击。

个人代码

我的代码没有考虑到保存行号+列号、行号-列号，所以复杂度会稍高一些

import java.util.ArrayList;
import java.util.List;

class Solution {
    List<List<String>> result = new ArrayList<>();

    public List<List<String>> solveNQueens(int n) {
        int[] locations = new int[n];
        ite(n, 0, locations);
        return result;
    }

    public void ite(int n, int rowIndex, int[] locations) {
        if (n == rowIndex) {
            result.add(generateBoard(locations));
            return;
        }

        for (int colIndex = 0; colIndex < n; colIndex++) {
            boolean canAttack = false;
            for (int i = 0; i < rowIndex && !canAttack; i++) {
                canAttack = checkAttack(i, locations[i], rowIndex, colIndex);
            }

            if (!canAttack) {
                locations[rowIndex] = colIndex;
                ite(n, rowIndex + 1, locations);
            }
        }
    }

    public boolean checkAttack(int x1, int y1, int x2, int y2) {
        return x1 == x2 || y1 == y2 || Math.abs(x1 - x2) == Math.abs(y1 - y2);
    }

    public List<String> generateBoard(int[] locations) {
        List<String> solve = new ArrayList<>();
        for (int i = 0; i < locations.length; i++) {
            StringBuilder sb = new StringBuilder();
            for (int j = 0; j < locations[i]; j++) {
                sb.append(".");
            }
            sb.append("Q");
            for (int j = locations[i] + 1; j < locations.length; j++) {
                sb.append(".");
            }
            solve.add(sb.toString());
        }
        return solve;
    }
}

时间复杂度： $O (N!) * O (N!)$ 。如前所述，遍历所有可能性的复杂度为 $O (N!)$ ，每个位置的判断又正好与当前层相反，如果是第一层，有N种可能，但是check次数为0，正好是一个反向的 $O (N!)$
空间复杂度：O(N)，其中 N 是皇后数量。空间复杂度主要取决于递归调用层数、记录每行放置的皇后的列下标的数组，递归调用层数不会超过 N，数组的长度为 N。

优化方案

官方优化代码如下，多了三个HashSet去保存信息

class Solution {
    public List<List<String>> solveNQueens(int n) {
        List<List<String>> solutions = new ArrayList<List<String>>();
        int[] queens = new int[n];
        Arrays.fill(queens, -1);
        Set<Integer> columns = new HashSet<Integer>();
        Set<Integer> diagonals1 = new HashSet<Integer>();
        Set<Integer> diagonals2 = new HashSet<Integer>();
        backtrack(solutions, queens, n, 0, columns, diagonals1, diagonals2);
        return solutions;
    }

    public void backtrack(List<List<String>> solutions, int[] queens, int n, int row, Set<Integer> columns, Set<Integer> diagonals1, Set<Integer> diagonals2) {
        if (row == n) {
            List<String> board = generateBoard(queens, n);
            solutions.add(board);
        } else {
            for (int i = 0; i < n; i++) {
                if (columns.contains(i)) {
                    continue;
                }
                int diagonal1 = row - i;
                if (diagonals1.contains(diagonal1)) {
                    continue;
                }
                int diagonal2 = row + i;
                if (diagonals2.contains(diagonal2)) {
                    continue;
                }
                queens[row] = i;
                columns.add(i);
                diagonals1.add(diagonal1);
                diagonals2.add(diagonal2);
                backtrack(solutions, queens, n, row + 1, columns, diagonals1, diagonals2);
                queens[row] = -1;
                columns.remove(i);
                diagonals1.remove(diagonal1);
                diagonals2.remove(diagonal2);
            }
        }
    }

    public List<String> generateBoard(int[] queens, int n) {
        List<String> board = new ArrayList<String>();
        for (int i = 0; i < n; i++) {
            char[] row = new char[n];
            Arrays.fill(row, '.');
            row[queens[i]] = 'Q';
            board.add(new String(row));
        }
        return board;
    }
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/n-queens/solution/nhuang-hou-by-leetcode-solution/

时间复杂度： $O (N!)$ 。如前所述，遍历所有可能性的复杂度为 $O (N!)$
空间复杂度：O(N)，其中 N 是皇后数量。空间复杂度主要取决于递归调用层数、记录每行放置的皇后的列下标的数组以及三个集合，递归调用层数不会超过 N，数组的长度为 N，每个集合的元素个数都不会超过 N。

进一步优化

上面的HashSet可以用一个int数字代替，斜线那个应该就更复杂了，暂未理解。

flushmeteor

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
leetcode 第51题 N皇后问题

题目n 皇后问题研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。给你一个整数 n ，返回所有不同的 n 皇后问题的解决方案。每一种解法包含一个不同的 n 皇后问题的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。示例1输入：n = 4输出：[[".Q…","…Q",“Q…”,"…Q."],["…Q.",“Q…”,"…Q",".Q…"]]解释：如上图所示，4 皇后问题存在两个不同的解法。示例2输入：n = 1输出：[[“Q
复制链接

扫一扫