深度优先遍历练习六

例题一：N皇后

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

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

每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/n-queens
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Wbmayqnw-1652060980973)(…/Java数据结构/图片/image-20220503172354355.png)]

皇后在 同一条线就会互相攻击（行列斜线）

分析：

攻击：

​ 同一行；

​ 同一列：

​ 同一斜线：左下线（i+1，j+1），右上线（i-1，j+1）

所有排列：dfs

思路一:dfs

class Solution {
    List<List<String>> ret = new ArrayList<>();
    public List<List<String>> solveNQueens(int n) {
        char[][] board = new char[n][n];
        for(int i =0;i<n;i++)
            Arrays.fill(board[i],'.');
        dfs(board,0,n);
        return ret;
    }
    private void dfs(char[][] board,int row,int n){
        if(row==n){
            List<String> list = new ArrayList<>();
            for(int i = 0;i<n;i++){
                list.add(new String(board[i]));
            }
            ret.add(list);
            return ;
        }
        for(int i = 0;i<n;i++){
            //剪枝
            if(isTrue(board,row,i)){
                
                board[row][i] = 'Q';
                //dfs
                dfs(board,row+1,n);
                //回溯
                board[row][i] = '.';
            }
        }

    }
    //不攻击
    private boolean isTrue(char[][] board,int r,int c){
        int n = board.length;
        for(int i = 0;i<n;i++){
            for(int j =0;j<n;j++){
                if(i==r&&j==c)
                    continue;
                if(board[i][j]=='Q' && (i==r || j==c || (i+j)==(r+c) || (c-r)==(j-i)))
                    return false;
            }
        }
        return true;
    }
}

类似写法：通过定义类存储皇后坐标

class pair{
    public int x;
    public int y;
    public pair(int x,int y){
        this.x = x;
        this.y = y;
    }
}
class Solution {
    public List<List<String>> solveNQueens(int n) {
        //按坐标存放所有解决方案
        List<List<pair>> solutions = new ArrayList<>();
        //存放一种解决方案中的所有皇后的位置
        List<pair> solution = new ArrayList<>();
        dfs(solutions,solution,0,n);
        return transform(solutions,n);
    }
    private void dfs(List<List<pair>> solutions,List<pair> solution,int row,int n){
        if(row == n){
            List<pair> tmp = new ArrayList<>();
            for(pair p : solution)
                tmp.add(p);
            solutions.add(tmp);
        }
        //尝试当前行的所有放法
        for(int i = 0;i < n;i++){
            if(isSafe(solution,row,i)){
                solution.add(new pair(row,i));
                dfs(solutions,solution,row+1,n);
                solution.remove(solution.size()-1);
            }
        }
    }
    private boolean isSafe(List<pair> solution,int row,int col){
        for(pair p : solution){
            if(p.y==col || p.x+p.y==row+col || row-col==p.x-p.y)
                return false;
        }
        return true;
    }
    private List<List<String>> transform(List<List<pair>> solutions,int n){
        List<String> tmp = new ArrayList<>();
        List<List<String>> ret = new ArrayList<>();

        for(List<pair> solution : solutions){
            //n*n char: 每行有n个元素，把皇后的位置修改为Q
            List<StringBuilder> solutionString = new ArrayList<>();
            for(int i = 0; i < n; ++i){
                StringBuilder sb = new StringBuilder();
                for(int j = 0; j < n; ++j)
                    sb.append('.');
                solutionString.add(sb);
            } 
            for (pair i : solution) {
                solutionString.get(i.x).setCharAt(i.y, 'Q');
            } 
            List<String> curRet = new ArrayList<>();
            for(StringBuilder sb : solutionString)
                curRet.add(sb.toString());
            ret.add(curRet);
        } 
        return ret;
    }
    
}

例题二：N皇后II

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

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

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

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

思路一：

class Solution {
    public int totalNQueens(int n) {
        Set<Integer> columns = new HashSet<Integer>();
        Set<Integer> diagonals1 = new HashSet<Integer>();
        Set<Integer> diagonals2 = new HashSet<Integer>();
        return backtrack(n, 0, columns, diagonals1, diagonals2);
    }

    public int backtrack(int n, int row, Set<Integer> columns, Set<Integer> diagonals1, Set<Integer> diagonals2) {
        if (row == n) {
            return 1;
        } else {
            int count = 0;
            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;
                }
                columns.add(i);
                diagonals1.add(diagonal1);
                diagonals2.add(diagonal2);
                count += backtrack(n, row + 1, columns, diagonals1, diagonals2);
                columns.remove(i);
                diagonals1.remove(diagonal1);
                diagonals2.remove(diagonal2);
            }
            return count;
        }
    }
}