回溯法：也称为试探法，它并不考虑问题规模的大小，而是从问题的最明显的最小规模开始逐步求解出可能的答案，并以此慢慢地扩大问题规模，迭代地逼近最终问题的解。这种迭代类似于穷举并且是试探性的，因为当目前的可能答案被测试出不可能可以获得最终解时，则撤销当前的这一步求解过程，回溯到上一步寻找其他求解路径。

为了能够撤销当前的求解过程，必须保存上一步以来的求解路径，这一点相当重要。

光说不做没意思，用学过的算法题来运用一下。

N 皇后问题：在一个 N * N 的国际象棋棋盘中，怎样放置 N 个皇后才能使 N 个皇后之间不会互相有威胁而共同存在于棋局中，即在 N * N 个格子的棋盘中没有任何两个皇后是在同一行、同一列、同一斜线上。

求解思路：最容易想到的方法就是有序地从第 1 列的第 1 行开始，尝试放上一个皇后，然后再尝试第 2 列的第几行能够放上一个皇后，如果第 2 列也放置成功，那么就继续放置第 3 列，如果此时第 3 列没有一行可以放置一个皇后，说明目前为止的尝试是无效的（即不可能得到最终解），那么此时就应该回溯到上一步（即第 2 步），将上一步（第 2 步）所放置的皇后的位置再重新取走放在另一个符合要求的地方…如此尝试性地遍历加上回溯，就可以慢慢地逼近最终解了。

需要解决的问题：如何表示一个 N * N 方格棋盘能够更有效？怎样测试当前所走的试探路径是否符合要求？这两个问题都需要考虑到使用怎样的数据结构，使用恰当的数据结构有利于简化编程求解问题的难度。

为此，我们使用以下的数据结构：

int column[col] = row 表示第 col 列的第 row 行放置一个皇后

boolean rowExists[i] = true 表示第 i 行有皇后

boolean a[i] = true 表示右高左低的第 i 条斜线有皇后（按 →  ↓ 顺序从1~ 2*N -1 依次编号）

boolean b[i] = true 表示左高右低的第 i 条斜线有皇后（按 →  ↑ 顺序从1~ 2*N -1 依次编号）

对应这个数据结构的算法实现如下：

1. /**
2. * 回溯法求解 N 皇后问题
3. * @author haolloyin
4. */
5. public class N_Queens {
6. // 皇后的个数
7. private int queensNum = 4;
8. // column[i] = j 表示第 i 列的第 j 行放置一个皇后
9. private int[] queens = new int[queensNum + 1];
10. // rowExists[i] = true 表示第 i 行有皇后
11. private boolean[] rowExists = new boolean[queensNum + 1];
12. // a[i] = true 表示右高左低的第 i 条斜线有皇后
13. private boolean[] a = new boolean[queensNum * 2];
14. // b[i] = true 表示左高右低的第 i 条斜线有皇后
15. private boolean[] b = new boolean[queensNum * 2];
16. // 初始化变量
17. private void init() {
18. for (int i = 0; i < queensNum + 1; i++) {
19. rowExists[i] = false;
20. }
21. for(int i = 0; i < queensNum * 2; i++) {
22. a[i] = b[i] = false;
23. }
24. }
25. // 判断该位置是否已经存在一个皇后,存在则返回 true
26. private boolean isExists(int row, int col) {
27. return (rowExists[row] || a[row + col - 1] || b[queensNum + col - row]);
28. }
29. // 主方法：测试放置皇后
30. public void testing(int column) {
31. // 遍历每一行
32. for (int row = 1; row < queensNum + 1; row++) {
33. // 如果第 row 行第 column 列可以放置皇后
34. if (!isExists(row, column)) {
35. // 设置第 row 行第 column 列有皇后
36. queens[column] = row;
37. // 设置以第 row 行第 column 列为交叉点的斜线不可放置皇后
38. rowExists[row] = a[row + column - 1] = b[queensNum + column - row] = true;
39. // 全部尝试过，打印
40. if(column == queensNum) {
41. for(int col = 1; col <= queensNum; col++) {
42. System.out.print("("+col + "," + queens[col] + ")  ");
43. }
44. System.out.println();
45. }else {
46. // 放置下一列的皇后
47. testing(column + 1);
48. }
49. // 撤销上一步所放置的皇后，即回溯
50. rowExists[row] = a[row + column - 1] = b[queensNum + column - row] = false;
51. }
52. }
53. }
54. // 测试
55. public static void main(String[] args) {
56. N_Queens queen = new N_Queens();
57. queen.init();
58. // 从第 1 列开始求解
59. queen.testing(1);
60. }
61. }

当 N = 8 时，求解结果如下（注：横坐标为 列数， 纵坐标为 行数）：