2022.03.24 学习回溯算法力扣51，37

学习：回溯算法

follow：代码随想录

---

51. N皇后

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

• 不能同一列
• 不能同一行
• 不能对角线

解析：
回溯也是一种暴力算法：遍历所有棋盘上的位置，如果出现了冲突，就放弃该位置，重点是如何判断发生了冲突。

方法一：
使用一个额外的二维数组record来记录，如果为0代表着可以使用该位置，如果为1代表该位置有一个皇后，负数代表该位置有冲突，绝对值代表有几个与该位置冲突的皇后。
遍历时，固定行，更改每个皇后的列

	int[][] record;
    List<List<String>> res = new ArrayList<>();
    List<String> element = new ArrayList<>();
    public List<List<String>> solveNQueens(int n) {
        record = new int[n][n];
        backTracking(n, 0);
        return res;
    }

    public void backTracking(int n, int cur){
        if(cur == n){
            //int[][] - String
            if(element.size() == n) res.add(new ArrayList<>(element));
            return;
        }
        //对于每个皇后：固定行，更改列
        for(int i = 0; i < n; i++){
            if(record[cur][i] != 0) continue;
            record[cur][i] = 1;
            String temp = "";
            for(int j = 0; j < n; j++){
                if(j != i) temp += ".";
                else temp += "Q";
            }
            element.add(temp);
            
            //处理该列
            for(int j = 0; j < n; j++){
                if(j != cur){
                    record[j][i] --;
                }
            }
            //处理对角线
            for(int i_temp = cur + 1, j_temp = i + 1; i_temp < n && j_temp < n; i_temp++, j_temp++){
                record[i_temp][j_temp] --;
            }
            for(int i_temp = cur + 1, j_temp = i - 1; i_temp < n && j_temp >= 0; i_temp++ ,j_temp --){
                record[i_temp][j_temp] --;
            }
            backTracking(n, cur + 1);
            record[cur][i] = 0;
            //处理该列
            for(int j = 0; j < n; j++){
                if(j != cur){
                    record[j][i]  ++;
                }
            }
            //处理对角线
            for(int i_temp = cur + 1, j_temp = i + 1; i_temp < n && j_temp < n; i_temp++, j_temp++){
                record[i_temp][j_temp]  ++;
            }
            
            
            for(int i_temp = cur + 1, j_temp = i - 1; i_temp < n && j_temp >= 0; i_temp++ ,j_temp --){
                record[i_temp][j_temp]  ++;
            }
            element.remove(element.size() - 1);
        }
    }

方法二：
依然使用record记录，但是不用填充数，而是直接判断

char[][] record;
    List<List<String>> res = new ArrayList<>();
    public List<List<String>> solveNQueens(int n) {
        record = new char[n][n];
        //初始元素都是.
        for(char[] c : record){
            Arrays.fill(c, '.');
        }
        backTracking(n, 0);
        return res;
    }

    public void backTracking(int n, int cur){
        if(cur == n){
            //int[][] - String
            List<String> list = new ArrayList<>();
            for(char[] c : record){
                //char[] -> string
                list.add(String.copyValueOf(c));
            }
            res.add(list);
            return;
        }
        //对于每个皇后：固定行，更改列
        for(int i = 0; i < n; i++){
            if(!isValid(n, cur, i)) continue;
            record[cur][i] = 'Q';
            backTracking(n, cur + 1);
            record[cur][i] = '.';
        }
    }
    public boolean isValid(int n, int cur, int i){
        //处理该列
        for(int j = 0; j < n; j++){
            if(record[j][i] == 'Q'){
                return false;
            }
        }
        //处理对角线：检查的是上面行的对角线
        for(int i_temp = cur - 1, j_temp = i - 1; i_temp >= 0 && j_temp >= 0; i_temp--, j_temp--){
            if(record[i_temp][j_temp] == 'Q'){
                return false;
            }
        }

        for(int i_temp = cur - 1, j_temp = i + 1; i_temp >= 0 && j_temp < n; i_temp-- ,j_temp ++){
            if(record[i_temp][j_temp] == 'Q'){
                return false;
            }
        }
        return true;
    }

37 解数独

public void solveSudoku(char[][] board) {
        int n = board.length;
        backTracking(board, n);
    }

    //因为该问题，只有一个可行解，所以使用boolean返回值，只要找到一个答案即可以返回
    public boolean backTracking(char[][] board, int n){
        //不需要终止条件，因为只要结束了最后一个数字的for循环，证明已经找到答案，此时返回true
        //使用了二维递归，因为要遍历二维数组的每一个数
        for(int i = 0; i < n; i++){
            for(int j = 0; j < n; j++){
                if((board[i][j] != '.')) continue;
                for(char ch = '1'; ch <= '9'; ch++){
                    if(isValid(board, i, j, ch)){
                        board[i][j] = ch;
                        if(backTracking(board, n)) return true;
                        board[i][j] = '.';
                    }
                }
                //证明10个数都不好用
                return false;
            }
        }
        //最外层循环结束 可用
        return true;
    }
    //只需判断可行不， 而不是在二维数组中找可行解！！！！！！！
    public boolean isValid(char[][] board, int i, int j, char ch){
        for(int i_temp = 0; i_temp < 9; i_temp++){
            if(i_temp != i && board[i_temp][j] == ch) return false;
        }
        for(int j_temp = 0; j_temp < 9; j_temp++){
            if(j_temp != j && board[i][j_temp] == ch) return false;
        }
        //判断在正方形中有没有重复的数字
        for(int i_temp = (i / 3) * 3, count1 = 0; count1 < 3; i_temp++, count1++ ){
            for(int j_temp = (j / 3) * 3, count2 = 0; count2 < 3; j_temp++, count2++){
                if(i_temp != i && j_temp != j && board[i_temp][j_temp] == ch) return false;
            }
        }
        
        return true;
    }