算法策略 - 回溯（Back Tracking）

• 回溯可以理解为：通过选择不同的岔路口来通往目的地（找到想要的结果）
• 每一步都选择一条路出发，能进则进，不能进则退回上一步（回溯），换一条路试试
• 树、图的深度优先搜索（DFS）就是经典的回溯应用
  
• 不难看出来，回溯很适合使用递归

练习 - 八皇后问题（Eight Queens）

• 八皇后问题是一个古老而著名的问题
• 在8x8格的国际象棋上摆放八个皇后，使其不能互相攻击：任意两个皇后都不能处于同一行、同一列、同一斜线上
• 请问有多少种摆法？
  

八皇后问题的解决思路

• 思路一：暴力出奇迹
• 从64个格子中选取任意8个格子摆放皇后，检查每一种摆法的可行性
• 一共C(64，8)种摆法(大概4.4*10^9种摆法)
• 思路二：根据提议减小暴力程度
• 很显然，第一行只能放一个皇后，所以共有8^8中摆法（16777216种），检查每一种摆法的可行性
• 思路三：回溯法
• 回溯+剪枝

四皇后 - 回溯法

• 在解决八皇后问题之前，可以缩小数据规模，看看如何解决四皇后问题
  

四皇后 - 剪枝(Pruning)

八皇后 - 回溯法1

八皇后 - 回溯法2

八皇后 - 回溯法3

八皇后实现 - 合法性检查

// 数组索引是行号，数组元素是列号
private int[] queens;
// 一共有多少种合理的摆法
private int ways;

// 检查第row行第col列是否可以摆放皇后
private boolean isValid(int row, int col) {
    for (int i = 0; i < row; i++) {
        // 第col列已经有皇后
        if (queens[i] == col) return false;
        // 第i行的皇后跟第row行第col列格子处在同一斜线上
        if (row - i == Math.abs(col - queens[i])) return false;
    }
    return true;
}

八皇后实现 - 打印

// 显示皇后的摆放情况
void show() {
    for (int row = 0; row < queens.length; row++) {
        for (int col = 0; col < queens.length; col++) {
            if (queens[row] == col) {
                System.out.print(1);
            } else {
                System.out.print(0);
            }
            System.out.print(" ");
        }
        System.out.println();
    }
    System.out.println("---------------------------");
}

八皇后实现 - 从某一行开始摆放皇后

// 从第row行开始摆放皇后
void place(int row) {
    if (row == queens.length) {
        ways++; 
        show();
        return;
    }
    for (int col = 0; col < queens.length; col++) {
        if (isValid(row, col)) {
            queens[row] = col;
            place(row + 1);
        }
    }
}

八皇后实现 - 摆放所有皇后

void placeQueens(int n) {
    if (n < 1) return;
    queens = new int[n];
    
    place(0);
    System.out.println(n + "皇后一共有" + ways + "种摆法");
}

---

八皇后优化 - 成员变量

// 标记着某一列是否有皇后
boolean[] cols;
// 标记着某一斜线上是否有皇后（左上角 -> 右下角）
boolean[] leftTop;
// 标记着某一斜线上是否有皇后（右上角 -> 左下角）
boolean[] rightTop;

八皇后优化 - 从某一行开始摆放皇后

// 从第row行开始摆放皇后
void place(int row) {
    if (row == cols.length) {
        ways++;
        show();
        return;
    }
    for (int col = 0; col < cols.length; col++) {
        if (cols[col]) continue;
        int ltIndex = row - col + cols.length - 1;
        if (leftTop[ltIndex]) continue;
        int rtIndex = row + col;
        if (rightTop[rtIndex]) continue;
        cols[col] = leftTop[ltIndex] = rightTop[rtIndex] = true;
        place(row + 1);
        cols[col] = leftTop[ltIndex] = rightTop[rtIndex] = false;
     }
}

八皇后优化 - 摆放所有皇后

void placeQueens(int n) {
    if (n < 1) return;
    cols = new boolean[n];
    leftTop = new boolean[(n << 1) - 1];
    rightTop = new boolean[(n << 1) - 1];
    
    place(0);
    System.out.println(n + "皇后一共有" + ways + "种摆法");
}

八皇后优化 - 对角线

• 左上角 -> 右下角对角线索引：row - col + 7
  
• 右上角 -> 左下角对角线索引：row + col
  

八皇后优化 - 位运算

• 可以利用位运算进一步压缩八皇后的空间复杂度

// 标记着某一列是否有皇后了
byte cols;
// 标记着某一对角线是否有皇后了（左上角->右下角，left top -> right bottom）
short leftTop;
// 标记着某一对角线是否有皇后了（右上角->左下角，right top -> left bottom）
short rightTop;

// 从第row行开始摆放皇后
void place(int row) {
    if (row == 8) {
        ways++;
        return;
    }
    for (int col = 0; col < 8; col++) {
        int colV = 1 << col;
        if ((cols & colV) != 0) continue;
        int ltV = 1 << (row - col + 7);
        if((leftTop & ltV) != 0) continue;
        int rtV = 1 << (row + col);
        if ((rightTop & rtV) != 0) continue;
        cols |= colV;
        leftTop |= ltV;
        place(row + 1);
        cols ^= col;
        leftTop ^= ltV;
        rightTop ^= rtV;
    }
}
void place8Queens() {
    place(0);
    System.out.println("8皇后一共有" + ways + "种摆法");
}

---

练习

• LeetCode — 51. N皇后

• LeetCode — 52. N皇后 II