算法：递归与回溯算法解决八皇后问题

什么是回溯算法

在没有其他算法的加持下时，回溯算法简单来说，就是不断试错的过程。通过不断向下一个节点枚举寻找满足条件的答案，当无法寻找到时，则返回至上一个节点，然后继续向下枚举。
这句话可能看起来有点抽象，我们用一个图来演示一下。
这是一张A村到E村的地图。假设你从起点A出发到终点E（不是E1），在不知道路怎么走且时间、精力充足的情况下，你会选择一条条路走过去，直到找到终点E为止。
当你从起点A出发时，在你面前的就是B1、B2两条路。由于你你不知道哪条路是正确的，你只能通过试错来排除错误路径。当你选择B2并走到B2时，你发现接下来摆在你面前的只有C4一条路，于是你毫不犹豫的走进了C4。但很可惜，C4之后已经没有路可以走了。于是你便返回到B2，并在通往C4的路上插了面小红旗，告诉自己这条路已经走过了，无法通往E村。接着你发现，B2之后除了C4没有其他路可以走，于是你就只能继续返回到起点A，并在通往B2的路上也插了面小红旗，告诉自己只要走B2就无法通往E村。于是你就开始走B1路，如此往复：当发现路无法继续向下走时，便返回上一个路口，并把该路标记为走不通，然后走下一条路（如果没有下一条路的话，则继续返回上一个路口）。
总的流程图将会是这样的：

如果走到n=1且观察到接下来没有未标记的路（n=n-1==0），就说明没有一条路能够达到目标地点。

如何用递归实现回溯算法（八皇后问题）

八皇后问题的要求

在 8×8 格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上。
实现八皇后的目的：求出有多少种摆法。

基本思想

通过上面的找路的例子可以发现，回溯算法的核心类似于穷举法，尝试每一条不同的路径，然后记录下满足需求的，抛弃不满足的。
因此八皇后问题就可以用下面这种方式解决：

1. 创建一个8*8的二维数组来表示一个棋盘。
2. 先在array[0][0]处放置第一个皇后，然后查看array[1][0]是否满足，若不满足则继续尝试array[1][1],array[1][2]…直至满足条件后放第二个皇后，然后检索第三个皇后的位置，检索方法同第二个皇后，直到第八个皇后放完。
3. 当第八个皇后放好后（假设位于array[7][3]），则返回到第七个皇后，继续检索array[7][4]满不满足条件。直到检索出全部情况为止。

代码实现

实现八皇后问题的关键有两点：

1. 判断皇后放置的位置是否满足游戏条件
2. 利用递归和回溯放置皇后到棋盘上

因此，我们在解决八皇后问题时，最主要的就是先把判断皇后位置是否正确的方法写出来。
Tips：这里用了个小小的算法，用一维数组来实现棋盘。具体实现如下：
3. 定义int array[8]数组
4. array[n] = value 代表第n + 1个皇后（数组下标从0开始）位于棋盘的第n+1行的第value + 1 列上。

/**
 * 先定义一个类，确定棋盘大小并定义完棋盘数组array。
 * count 用于记录总共有多少种解法
 */
class EightQueens {
	int max = 8;
	int[] array = new int[max];
	int count = 0;
}

public boolean judge(int n) {
	//判断第n+1个皇后是否满足条件
	for(int i = 0; i < n; i++) {
		/*
			if语句用于判断皇后位置是否满足条件
				1.横着不能位于同一行：因为皇后按行放，所以一行只可能有一个皇后.
				这条就一定成立
				2.竖着不能位于同一列，数组的值value就代表皇后位于的列数.
				只要皇后n+1与之前的n个皇后的value值都不同，就说明成立
				3.不能位于同一斜线。仔细观察棋盘，同一斜线即斜率k=45°.
				当横坐标之差 = 纵坐标之差就说明这两个相比较的皇后不位于同一斜线上。
		 */
		if(array[i] == array[n]) || Math.abs(array[i] - array[n] == 	Math.abs(i - n)) {
			return false;
		}
	}
	return true;
}

拥有这个判断方法之后，就可以通过递归和回溯，找到正确的八皇后解法了。
接下来构写一个方法开始放第一个皇后

/**
 * 该check方法在主方法被调用时，参数n只能传入0，因为皇后只能从第0个开始放
 */
public void check(int n) {
	if(n == max) {
		/*
		当n == max时，就说明已经放完了n个（全部）皇后了（n从0开始，0->n-1有n个皇后）
		为了能够将每一种解法都输出到控制台，则规定每次正确的放完最后一个皇后时就将当前数组的值全部输出
		**在这里需要一个输出方法print，将会在完整代码中附出。
		*/
		print();
		return;
	}
	for(int i = 0; i < max; i++) {
		//用一个for循环，确保每一行的每一个格子都会被检查到
		//先把皇后n+1放到第i+1列上
		array[n] = i;
		if(judge(n)){
			//如果该皇后满足条件，则开始放下一个皇后
			check(n+1);
		}
		//当皇后n judge判断未通过而返回到皇后n-1级时，将会位于这个位置。
		//接下来将执行的操作时for循环中的i++
	}
	//当执行完for循环后，说明该行所有列都已经被judge过了，就return到上一级
}

构写一个主类和主函数检查上述方法是否正确

public class Test {
    public static void main(String[] args) {
        //测试八皇后
        EightQueens eightQueues = new EightQueens();
        eightQueues.check(0);
        System.out.println("共有：" + eightQueues.count + "解法");
    }
}

小结

其实单纯的回溯算法并不高效，简单来说就是将所有能产生的情况全部列举出来，然后找到正确答案。如果你愿意的话，在judge函数中加入一个计数器，就可以发现整个过程下来，judge函数执行了1.5w+次，所以需要加入其他算法来优化。不过这也反映出递归与回溯的本质就是试错法，或者说是穷举法。

完整代码

实现八皇后问题的完整代码

public class EightQueens {
    int max = 8;
    int[] array = new int[max];
    int count = 0;

    public boolean judge(int n) {
        for(int i = 0; i < n; i++) {
            if(array[i] == array[n] || Math.abs(array[i] - array[n]) == 	Math.abs(i - n)) {
                return false;
            }
        }
        return true;
    }

    public void check(int n) {
        if(n == max) {
            print();
            return;
        }
        for(int i = 0; i < max; i++) {
            array[n] = i;
            if(judge(n)){
                check(n+1);
            }
        }
    }

    public void print() {
        count++;
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }
}

public class Test {
    public static void main(String[] args) {
        //测试八皇后
        EightQueens eightQueues = new EightQueens();
        eightQueues.check(0);
        System.out.println("共有：" + eightQueues.count + "解法");
    }
}