算法：回溯算法笔记

一、回溯算法

• 回溯问题，实际上就是一个决策树的遍历过程，需要思考以下问题：

1. 路径：也就是已经做出的选择
2. 选择列表：当前可以作出的选择
3. 结束条件：到达决策树底层，无法再作出选择

• 代码框架
• 在做选择的时候，要特别注意选择从哪里开始，如果是全排列的问题，那么需要从头开始做选择

result = []
def backtrack(路径，选择列表):
    if(满足结束条件):
        result.add(路径)
        return
    for 选择 in 选择列表:
        做选择
        backtrack(路径，选择列表)
        撤销选择

• 核心就是先做选择，然后进入递归，最后撤销选择

二、N皇后问题（八皇后）

• 问题描述：n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击（即任意两个皇后都不能处于同一行、同一列或同一斜线上）。给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 'Q' 和 '.' 分别代表了皇后和空位。（力扣链接：https://leetcode-cn.com/problems/n-queens/）

public List<List<String>> solveNQueens(int n) {
        List<List<String>> res = new ArrayList<>();
        int[] board = new int[n];//使用board来记录皇后的位置，下标指行数，所存数字为列数
        Arrays.fill(board, -1);
        backtrack(res, board, 0);
        return res;
    }
    public void backtrack(List<List<String>> res, int[] board, int row){//row行
        if(row == board.length){
            res.add(generateBoard(board, board.length));
            return;
        }
        for (int col = 0; col < board.length; col++) {//col列
            //在这里加这个判断，其实也是相当于剪枝了
            //如果当前位置(row, col)有冲突，不能放置Q皇后，那么换到下一个位置(row, col+1)
            if(!isValid(board, row, col)){
                continue;
            }
            //如果当前位置(row, col)无冲突，那么尝试作出选择
            board[row] = col;
            backtrack(res, board, row+1);
            board[row] = -1;//撤销选择
        }
    }

    /**
     * 判断当前位置是否冲突
     * @param board
     * @param row
     * @param col
     * @return
     */
    public boolean isValid(int[] board, int row, int col){
        int n = board.length;
        // 检查列是否有皇后互相冲突
        for (int i = 0; i < row; i++) {
            if (board[i] == col)
                return false;
        }
        // 检查右上方是否有皇后互相冲突
        int temp = col;
        for (int i = row-1; i >= 0; i--) {
            if(board[i] == ++temp){
                return false;
            }
        }
        // 检查左上方是否有皇后互相冲突
        temp = col;
        for (int i = row-1; i >= 0; i--) {
            if(board[i] == --temp){
                return false;
            }
        }
        return true;
    }

    /**
     * 生成题目要求格式的答案
     * @param queens
     * @param n
     * @return
     */
    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;
    }

• 其实，可以这样认为，动态规划的暴力破解就是回溯算法，但是动态规划一般可以进行剪枝或者自底向上解决重叠子问题。如果解题时找不到动态规划的转换方程，那么可以使用回溯算法（可能会超时，毕竟是暴力破解）