代码随想录算法训练营第三十天 回溯算法总结、332.重新安排行程、51. N皇后、37. 解数独

代码随想录算法训练营第三十天 | 回溯算法总结、**332.重新安排行程、**51. N皇后、37. 解数独

回溯算法总结

回溯就是递归的副产品，只要有递归就会有回溯

回溯就是一个暴力搜索法，并不是什么高效的算法

回溯算法的题目分类：

• 组合：N个数里面按一定规则找出k个数的集合
• 分割：一个字符串按一定规则有几种切割方式
• 子集：一个N个数的集合里有多少符合条件的子集
• 排列：N个数按一定规则全排列，有几种排列方式
• 棋盘问题：N皇后，解数独等等
• 其他

332.重新安排行程

题目链接：332. 重新安排行程 - 力扣（LeetCode）

不太会，留着复习

class Solution {
    private Deque<String> res;
    private Map<String, Map<String, Integer>> map;

    private boolean backTracking(int ticketNum){
        if(res.size() == ticketNum + 1){
            return true;
        }
        String last = res.getLast();
        if(map.containsKey(last)){//防止出现null
            for(Map.Entry<String, Integer> target : map.get(last).entrySet()){
                int count = target.getValue();
                if(count > 0){
                    res.add(target.getKey());
                    target.setValue(count - 1);
                    if(backTracking(ticketNum)) return true;
                    res.removeLast();
                    target.setValue(count);
                }
            }
        }
        return false;
    }

    public List<String> findItinerary(List<List<String>> tickets) {
        map = new HashMap<String, Map<String, Integer>>();
        res = new LinkedList<>();
        for(List<String> t : tickets){
            Map<String, Integer> temp;
            if(map.containsKey(t.get(0))){
                temp = map.get(t.get(0));
                temp.put(t.get(1), temp.getOrDefault(t.get(1), 0) + 1);
            }else{
                temp = new TreeMap<>();//升序Map
                temp.put(t.get(1), 1);
            }
            map.put(t.get(0), temp);

        }
        res.add("JFK");
        backTracking(tickets.size());
        return new ArrayList<>(res);
    }
}

51. N皇后

题目链接：51. N 皇后 - 力扣（LeetCode）

以 行 为深度，列为广度进行搜索

递归来执行 列遍历，每一层递归内的for循环来执行 行遍历

基本可以自己手写

class Solution {
    List<List<String>> res;
    public List<List<String>> solveNQueens(int n) {
        this.res = new ArrayList<>();
        char[][] chessboard = new char[n][n];
        for(char[] c : chessboard) {
            Arrays.fill(c, '.'); // 使用 ‘.’ 表示空位
        }
        backTrack(0, n, chessboard); // 进行回溯

        return res;
    }

    private void backTrack(int row, int n, char[][] chessboard) {
        if(row == n) {
            // 满足n皇后的解决方法，添加到res中
            res.add(Array2List(chessboard));
            return;
        }
        // 遍历当前行row的每一个列col元素，探索是否可以添加Q
        for (int col = 0; col < n; ++col) {
            if (isValid (row, col, n, chessboard)) {
                // 可以添加，将其修改为Q
                chessboard[row][col] = 'Q';
                // 进入下一行的遍历
                backTrack(row + 1, n, chessboard);
                chessboard[row][col] = '.'; // 回溯，删除添加的 Q.
            }
        }
    }

    public boolean isValid(int row, int col, int n, char[][] chessboard) {
        // 检查列
        for (int i=0; i<row; ++i) { // 相当于剪枝
            if (chessboard[i][col] == 'Q') {
                return false;
            }
        }

        // 检查45度对角线
        for (int i=row-1, j=col-1; i>=0 && j>=0; i--, j--) {
            if (chessboard[i][j] == 'Q') {
                return false;
            }
        }

        // 检查135度对角线
        for (int i=row-1, j=col+1; i>=0 && j<=n-1; i--, j++) {
            if (chessboard[i][j] == 'Q') {
                return false;
            }
        }
        return true;
    }

    // 将棋盘二维数组的每一行转换成string
    public List Array2List(char[][] chessboard) {
        List<String> list = new ArrayList<>();

        for (char[] c : chessboard) {
            list.add(String.copyValueOf(c));
        }
        return list;
    }

}

37. 解数独

题目链接：37. 解数独 - 力扣（LeetCode）

class Solution {
    public void solveSudoku(char[][] board) {
        solveSudokuHelper(board);
    }
	// 1. 递归函数以及参数
    // 返回值：因为解数独找到一个符合的条件（就在树的叶子节点上）立刻就返回，相当于找从根节点到叶子节点一条唯一路径，所以需要使用bool返回值。
    private boolean solveSudokuHelper(char[][] board){
        // 2.递归终止条件：
        // 本题不需要终止条件，因为是需要搜索到叶子节点，会自动返回
        
        // 3. 单层递归搜索逻辑
        //「一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，
        // 一行一列确定下来之后，递归遍历这个位置放9个数字的可能性！」
        for (int i = 0; i < 9; i++){ // 遍历行
            for (int j = 0; j < 9; j++){ // 遍历列
                if (board[i][j] != '.'){ // 跳过原始数字
                    continue;
                }
                // 依次尝试1~9能否放入（i, j）
                for (char k = '1'; k <= '9'; k++){ // (i, j) 这个位置放k是否合适
                    if (isValidSudoku(i, j, k, board)){
                        board[i][j] = k;
                        // 如果可以，就放，然后向下递归
                        if (solveSudokuHelper(board)){ // 如果找到合适一组立刻返回
                            return true;
                        }
                        
                        board[i][j] = '.';// 回溯
                    }
                }
                // 9个数都试完了，都不行，那么就返回false
                return false;
                // 因为如果一行一列确定下来了，这里尝试了9个数都不行，说明这个棋盘找不到解决数独问题的解！
                // 那么会直接返回， 「这也就是为什么没有终止条件也不会永远填不满棋盘而无限递归下去！」
            }
        }
        // 遍历完没有返回false，说明找到了合适棋盘位置了
        return true;
    }

    /**
     * 判断棋盘是否合法有如下三个维度:
     *     同行是否重复
     *     同列是否重复
     *     9宫格里是否重复
     */
    private boolean isValidSudoku(int row, int col, char val, char[][] board){
        // 同行是否重复
        for (int i = 0; i < 9; i++){
            if (board[row][i] == val){
                return false;
            }
        }
        // 同列是否重复
        for (int j = 0; j < 9; j++){
            if (board[j][col] == val){
                return false;
            }
        }
        // 9宫格里是否重复
        // 这里 / 3 后再 * 3 不是没有变化，/ 3 其实是进行了整除
        // 比如 索引为 2， 2/3 = 0， 0 * 3 = 0
        // 又或者 索引为 5， 5 / 3 = 1， 1 * 3 = 1 
        int startRow = (row / 3) * 3; 
        int startCol = (col / 3) * 3;
        for (int i = startRow; i < startRow + 3; i++){
            for (int j = startCol; j < startCol + 3; j++){
                if (board[i][j] == val) {
                    return false;
                }
            }
        }
        return true;
    }
}

总结：目前回溯算法已经学完，明日会开始放假，计划2.9把全部回溯题做一遍！加油