常用算法之-回溯法

回溯法

1.回溯法简介

回溯法，又称试探法，是常用的，基本的优选搜索方法。常用于解决这一类问题：给定一定约束条件F（该约束条件常用于后面的剪枝）下求问题的一个解或者所有解。

回溯法其实是暴力枚举的一种改进，因为其会聪明的filter掉不合适的分支，大大减少了无谓的枚举。若某问题的枚举都是可行解得话，也就是没有剪枝发生，那么回溯法和暴力枚举并无二异。

该回溯法先从解空间中选取任意一个可能满足约束条件F的点x1,然后从满足F的解空间中继续选择一个点x2，直到所找到的点构成一个解S或者找不到满足约束条件F的点时，开始回溯。回溯到上一层节点f，再另选满足F的解空间中的一点，继续试探。

整个过程类似于一个递归树，因此回溯法常常采用DFS的方法来实现。不考虑约束条件F，整个递归树的任一根节点root到叶子节点leaf的路径path都是无约束条件F的原问题的一个解。

现在考虑约束条件F，实际就是在每次向下深入的时候，利用约束条件F来判断当前遍历的节点是否有必要继续搜索下去,若无必要则马上回溯；有必要则继续深入，这一个过程类似于约束条件F剪去了多余的递归分支。

回溯法解决的问题的一般特征：能够利用约束条件F去快速判断构成一个完整解的一些局部候选信息partial candidates是否可能最终构成一个正确的、完整的解。

2.回溯法的基本步骤

1. 明确问题的解空间S和约束条件F.
2. 利用深度优先搜索，试探可能构成一个完整解的候选节点，利用约束条件F进行剪枝
   2.1. 找到递归的base case
   2.2. 利用约束条件F判断是否剪枝，一旦剪枝，则开始回溯（返回）
3. 当递归到叶节点的时候，即得到原问题在约束条件F下的一个解，若要得到所有的可行解，则还需要考察根节点的其他分支。

回溯法注意事项：
1. 递归状态的存储和更新
2. 回溯点的处理（是否应该清除该回溯点之前对递归状态产生的side effect）
3. 解的搜集

3.回溯法之经典问题

回溯法之经典问题：N皇后问题

public class NQueensDemo {    public static void main(String[] args) {        // TODO Auto-generated method stub        NQueensDemo demo = new NQueensDemo();        demo.solution(8);    }    public void solution(int n) {        List<int[]> collector = new ArrayList<>();        for (int j = 0; j < n; j++)            dfs(0, j, new int[n], new int[n], new int[n], new int[n * 2 - 1], new int[n * 2 - 1], collector, n);        System.out.println("numbers of solution " + collector.size());        print(collector, n);    }    public void dfs(int i, int j, int[] solution, int[] occupiedRow, int[] occupiedCol, int[] occupiedTopBottom,            int[] occupiedBottomTop, List<int[]> collector, int size) {        solution[i] = j;        if (i >= size - 1) {            collector.add(solution.clone());            return;        }        // 8个方向        occupiedRow[i] = 1;        occupiedCol[j] = 1;        occupiedTopBottom[size - 1 + (i - j)] = 1;// 左上到右下的斜线 (i+d, j+d) 关系为i-j,                                                    // 范围为 -size + 1 ~ size - 1,                                                    // 所以左右各加size - 1归到区间                                                    // 0~2size - 2, 关系为 size - 1                                                    // + (i - j), 分配的数组大小为 2size                                                    // - 1        occupiedBottomTop[i + j] = 1;// 左下到右上的斜线(i-d, j+d)和(i+d, j-d) 关系为 i+j                                        // 分配的数组大小为 2size - 1        // 寻找下一个皇后放置的位置        i = i + 1;        for (int n = 0; n < size; n++) {            if (occupiedRow[i] == 0 && occupiedCol[n] == 0 && occupiedTopBottom[size - 1 + (i - n)] == 0                    && occupiedBottomTop[i + n] == 0)                dfs(i, n, solution, occupiedRow, occupiedCol, occupiedTopBottom, occupiedBottomTop, collector, size);        }        // 回溯后, clear flag，恢复原状        i = i - 1;        occupiedRow[i] = 0;        occupiedCol[j] = 0;        occupiedTopBottom[size - 1 + (i - j)] = 0;        occupiedBottomTop[i + j] = 0;    }    public void print(List<int[]> collector, int n) {        for (int[] s : collector) {            System.out.println();            for (int i = 0; i < n; i++) {                System.out.println();                for (int j = 0; j < n; j++) {                    if (j == s[i])                        System.out.print(1 + "  ");                    else                        System.out.print(0 + "  ");                }            }        }    }}

4.回溯法之经典问题：Sudoku（数独）

public class Solution {   public final char base = '1';    public void solveSudoku(char[][] board) {        int filledNum = 0;// 统计已填的数目，作为DFS搜索结束的条件        int m = 0, n = 0;        int[][] rowCount = new int[9][9], colCount = new int[9][9], subBoxCount = new int[9][9];        for (m = 0; m < 9; m++)            for (n = 0; n < 9; n++)                if (board[m][n] != '.') {                    rowCount[m][board[m][n] - base] += 1;                    colCount[n][board[m][n] - base] += 1;                    subBoxCount[m / 3 * 3 + n / 3][board[m][n] - base] += 1;                    filledNum++;                }        boolean found = false;        for (m = 0; m < 9; m++) {// 找到第一个待填的方格            for (n = 0; n < 9; n++)                if (board[m][n] == '.') {                    found = true;                    break;                }            if (found)                break;        }        for (int num = 0; num < 9; num++)            if (rowCount[m][num] == 0 && colCount[n][num] == 0 && subBoxCount[m / 3 * 3 + n / 3][num] == 0)                if (dfs(m, n, (char) (num + base), board, rowCount, colCount, subBoxCount, filledNum))                    break;    }    public boolean dfs(int i, int j, char c, char[][] board, int[][] rowCount, int[][] colCount, int[][] subBoxCount,            int filledNum) {        int number = c - base;// 0~8代表1~9        board[i][j] = c;        rowCount[i][number] += 1;        colCount[j][number] += 1;        subBoxCount[i / 3 * 3 + j / 3][number] += 1;        filledNum += 1;        // bas case        if (filledNum >= 81)            return true;        int m = i, n = j;        boolean found = false;        // 找到下一个待填方格        for (; m < 9; m++) {            for (; n < 9; n++) {                if (board[m][n] == '.') {                    found = true;                    break;                }            }            if (found)                break;            else                n = 0;        }        for (int num = 0; num < 9; num++) {            if (rowCount[m][num] == 0 && colCount[n][num] == 0 && subBoxCount[m / 3 * 3 + n / 3][num] == 0) {                if (dfs(m, n, (char) (num + base), board, rowCount, colCount, subBoxCount, filledNum))                    return true;            }        }        // failed 该格子无论填啥都无解,所以clear所做的更改        board[i][j] = '.';        rowCount[i][number] -= 1;        colCount[j][number] -= 1;        subBoxCount[i / 3 * 3 + j / 3][number] -= 1;        filledNum -= 1;        return false;    }}