力扣-N皇后问题

. - 力扣（LeetCode）

开始的思路

由于n = 4情况太多我们先画一下n = 3的决策树

可以知道皇后不能在同一行,因为我的思路是每一行每一行的填写皇后,所以不考虑行的皇后会重叠,主要考虑列的皇后会不会重叠,还有斜线的

列皇后可以直接用一个数组col来标记 一列中有皇后标记为true

而斜线的需要一点数学功底

如图可以转化成截距相等,当斜线斜率为1时,可能会有负数的情况,两边同时加上n,因为我想使用下标来标记截距,截距不能为负数

而斜率为-1时可知,斜率不会为负数

代码

接下来时来实现代码,先出我最开始的思路,这个思路会比较慢,接下来会换一种更快的

class Solution {
    List<List<Integer>> ret;//存储每行放皇后的列位置
    List<Integer> path;//临时存储
    boolean[] col;//标记列
    boolean[] diag1;//斜率为1的
    boolean[] diag2;//斜率为-1的
    int n;
    public List<List<String>> solveNQueens(int _n) {
        //初始化全局变量
        ret = new ArrayList<>();
        path = new ArrayList<>();
        n = _n;
        col = new boolean[n];
        diag1 = new boolean[2 * n];
        diag2 = new boolean[2 * n];
        dfs(0);
        List<List<String>> ret1 = new ArrayList<>();//创建存储棋盘
        for(List<Integer> list: ret){//遍历每一种情况先
            List<String> path1 = new ArrayList<>();//将一个情况保存然后存储到ret1
            for(int i = 0;i < n;i++){//每一行
                StringBuilder sb = new StringBuilder();
                for(int j = 0;j < n;j++){//每一列
                    if(list.get(i) == j){//取到下标相等放置皇后
                        sb.append("Q");
                    }else{
                        sb.append(".");
                    }
                }
                path1.add(sb.toString());
            }
            ret1.add(path1);
        }
        return ret1;
    }
    public void dfs(int pos){
        if(pos == n){//当遍历函数的pos超过n - 1即有一种放置情况
            ret.add(new ArrayList<>(path));
            return;
        }
        for(int i = 0;i < n;i++){
            if(col[i] == false && diag1[pos - i + n] == false && diag2[pos + i] == false){//判断斜线和列有没有皇后出现
                path.add(i);
                col[i] = true;
                diag1[pos - i + n] = true;
                diag2[pos + i] = true;
                dfs(pos + 1);
                //回溯恢复现场
                path.remove(path.size() - 1);
                col[i] = false;
                diag1[pos - i + n] = false;
                diag2[pos + i] = false;
            }
        }
    }
}

我的思路是存储每一列的下标先,以此来找到皇后的位置,然后再填棋盘,会更慢一些

所以下一种是直接开始的path就存储棋盘,然后通过下标直接修改棋盘,返回时转换成List<String>这样会比上一种快4ms(比不上暴力枚举的0ms)

class Solution {
    List<List<String>> ret;//存储表
    char[][] path;//临时存储
    boolean[] col;//标记列
    boolean[] diag1;//斜率为1的
    boolean[] diag2;//斜率为-1的
    int n;
    public List<List<String>> solveNQueens(int _n) {
        //初始化全局变量
        ret = new ArrayList<>();
        n = _n;
        path = new char[n][n];
        col = new boolean[n];
        diag1 = new boolean[2 * n];
        diag2 = new boolean[2 * n];
        for(int i = 0;i < n;i++){
            Arrays.fill(path[i],'.');
        }
        dfs(0);
        return ret;
    }
    public void dfs(int pos){
        if(pos == n){//当遍历函数的pos超过n - 1即有一种放置情况
            List<String> tmp = new ArrayList<>();
            for(int i = 0;i < n;i++){
                tmp.add(new String(path[i]));
            }
            ret.add(tmp);
            return;
        }
        for(int i = 0;i < n;i++){
            if(col[i] == false && diag1[pos - i + n] == false && diag2[pos + i] == false){//判断斜线和列有没有皇后出现
                path[pos][i] = 'Q';
                col[i] = true;
                diag1[pos - i + n] = true;
                diag2[pos + i] = true;
                dfs(pos + 1);
                //回溯恢复现场
                path[pos][i] = '.';
                col[i] = false;
                diag1[pos - i + n] = false;
                diag2[pos + i] = false;
            }
        }
    }
}

尝试

可以去尝试一下N皇后 Ⅱ 基本一样的思路

附上代码和链接

. - 力扣（LeetCode）

class Solution {
    boolean[] col,dig1,dig2;
    int ret;
    int n;
    public int totalNQueens(int _n) {
        n = _n;
        col = new boolean[n];
        dig1 = new boolean[n * 2];
        dig2 = new boolean[n * 2];
        dfs(0);
        return ret;
    }
    public void dfs(int pos){
        if(pos == n){
            ret++;
            return;
        }
        for(int i = 0;i < n;i++){
            if(col[i] == false && dig1[pos - i + n] == false && dig2[pos + i] == false){
                col[i] = true;
                dig1[pos - i + n] = true;
                dig2[pos + i] = true;
                dfs(pos + 1);
                col[i] = false;
                dig1[pos - i + n] = false;
                dig2[pos + i] = false;
            }
        }
    }
}