数据结构与算法（七）：迷宫回溯和八皇后问题

1、迷宫回溯问题

1.问题

一个7*8的数组模拟迷宫，障碍用1表示，通路使用0表示，给定起点（1,1）和终点（6,5），要求给出起点到终点的通路

2.解题思路

1. 首先，咱们须要给程序一个寻向的基本策略，咱们先假定寻向顺序为“下-右-上-左”，也就是说从起点出发，先往下走，往下走不通就往右.....以此类推
2. 而后咱们须要给走过的路一个标记，暂记为2
3. 而当从一个方向走到一个只能原路返回的死胡同时，就给这段路标记为3
4. 当抵达终点坐标（6,5）时程序结束

3.代码实现

3.1生成地图

/**
 * 建立一个二维数组,用于模拟8*7迷宫
 * 使用1表示不可经过的实心方块，0表示可经过砖块
 * （6,5）为默认终点，（1,1）为默认起点
 * @return
 */
public static int[][] getMap(){
    int[][] map = new int[8][7];
    //上下全置为1
    for(int i = 0;i <7 ;i++){
        map[0][i] = 1;
        map[7][i] = 1;
    }
    //左右全置为1
    for(int i = 0;i < 8;i++){
        map[i][0] = 1;
        map[i][6] = 1;
    }
    //设置挡板
    map[3][1] = 1;
    map[3][2] = 1;

    //输出地图
    System.out.println("地图的初始状况:");
    showMap(map);

    return map;
}

/**
 * 展现地图
 * @param map
 */
public static void showMap(int[][] map) {
    for(int i = 0;i < 8;i++){
        for(int j = 0;j < 7;j++){
            System.out.print(map[i][j] + " ");
        }
        System.out.println();
    }
}

3.2 寻路逻辑的实现

对于这个寻路程序，咱们能够看见，往四个方向走的过程实际上除了方向外动做上是同样的；而具体分析同一个方向，每走过一个坐标的动做也是同样的，咱们对流程进行分析：

1. 出发，先往下走，判断下一格有没有障碍（int[x][y]==1）
2. 若是没有障碍，就继续往下走，而后重复步骤1到碰到障碍为止
3. 若是有障碍，就按“下-右-上-左”的顺序，换个方向，而后重复步骤1到碰到障碍为止
4. 若是找到了（6,5）就结束

表现为代码实际上就是一个递归的过程：

• 找路是方法体
• 找到了（6,5）或者死胡同是终止条件

/**
 * 给定起始点，根据地图找路
 * 使用2表示能够走通的路，使用3表示走过可是不通的路
 * @param map 地图二维数组
 * @param x 起始点横坐标
 * @param y 起始点纵坐标
 * @return
 */
public static boolean findWay(int[][] map, int x, int y) {
    //若是走到了终点就终止
    if (map[6][5] == 2){
        return true;
    }else {
        //只有为0的路才能经过
        if (map[y][x] == 0) {
            //若是该点能够走通就打上标记
            map[y][x] = 2;
            if (findWay(map, x, y + 1)) {
                //向下递归
                return true;
            } else if (findWay(map, x + 1, y)) {
                //向右递归
                return true;
            } else if (findWay(map, x, y - 1)) {
                //向上递归
                return true;
            } else if (findWay(map, x - 1, y)) {
                //向左递归
                return true;
            } else {
                //都走不通说明是死胡同
                map[y][x] = 3;
                return false;
            }
        }else {
            //不为0说明要么是死路要么是障碍
            return false;
        }
    }
}

3.3 运行结果

将findWay()方法中的终止条件从map[6][5] == 2换成其余坐标便可更换终点位置，

棋盘大小和障碍物位置不影响findWay()方法寻路。

2、八皇后问题

1.问题

皇后问题，一个古老而著名的问题，是回溯算法的典型案例。该问题由国际西洋棋棋手马克斯·贝瑟尔于 1848 年提出：

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

2.解题思路

1. 首先，咱们先使用一个长度为8数组来表示八皇后的摆放位置，数组下标+1即表示棋盘的第几行，数组下标对应的存放的数字+1即为棋盘的第几列。举个例子：

   arr = {0,2,3,8,4,6,2,7}

   其中，元素0下标为0，即表示第一行第一列；元素2下标为1，即表示第二行第三列......以此类推。

2. 任意假设任意坐标分标为(x1,y1)，(x2,y2)，也就是用数组表示为arr[x1]=y1，arr[x2]=y2的两个皇后不容许在同一列，咱们能够理解为：

   arr[x1] != arr[x2];

   而任意坐标的皇后不容许在同一斜线，即(x2-x1)=(y2-y1)，也就是斜率不该当相同，咱们能够理解为：

   Math.abs(x2-x1) != Math.abs(arr[x2]-arr[x1])

   （注：Math.abs()为求绝对值方法）

3.代码实现

3.1 检查摆放位置的代码实现

在前面明确了如何用数组表示位置，以及如何检查皇后是否容许摆放后，咱们有以下代码：

//表示皇后位置的数组
int[] arr = new int[8];

/**
 * 检查第n个皇后是否与前面摆放的皇后冲突
 * @param n
 * @return
 */
public boolean check(int n) {
    //检查第n层以前的皇后位置
    for (int i = 0; i < n; i++) {
        // arr[i] == arr[n] 检查是否同一列
        // Math.abs(n - i) == Math.abs(arr[n] - arr[i]) 检查是否同一斜线
        if (arr[i] == arr[n] ||
            Math.abs(n - i) == Math.abs(arr[n] - arr[i])) {
            return false;
        }
    }
    return true;
}

3.2 完整代码

接着咱们须要考虑如何使用递归方法来作到如下效果：

使用一个方法遍历第n行的每一列，检查每一列是否能够放置皇后：

1. 若是能够放置皇后，将位置出入arr[n]中，而后递归调用本身，传入n+1开始遍历下一行.....以此类推
2. 若是不能够放置皇后，就跳过该列检查下一列，若是能够就重复步骤1
3. 若n行中所有位置都不合适，则结束本层返回上一层n-1层，重复步骤1
4. 若是最后n=8，即八个皇后所有放置完毕，记一次完成摆放，而后结束递归返回第一层，继续检查第一层的下一列

最终代码实现结果以下：

/**
 * @Author：黄成兴
 * @Date：2020-06-26 20:53
 * @Description：八皇后问题
 */
public class EightQueens {

    public static void main(String[] args) {
        EightQueens eightQueens = new EightQueens();
        eightQueens.set(0);
        System.out.println("共有摆法：" + eightQueens.count);
    }

    //记录八皇后有几种摆法
    int count = 0;

    //表示皇后位置的数组
    int[] arr = new int[8];

    /**
     * 摆放皇后
     * @param n 第几个皇后
     */
    private void set(int n) {
        //若是放置好了第8个皇后
        if (n == 8){
            show();
            //记录一种摆放方式
            count++;
            //回到第一层继续递归
            return;
        }

        //遍历第n行的每一列
        for (int i = 0; i < 8; i++) {
            //将该皇后放置在第n行第i列
            arr[n] = i;
            //检查放置位置是否合适
            if (check(n)){
                //若是位置合适，就递归找下一个（n+1）皇后的摆放位置
                set(n + 1);
            }
            //若是位置不合适，就跳过这一列检查下一列
        }
    }

    /**
     * 检查第n个皇后是否与前面摆放的皇后冲突
     * @param n
     * @return
     */
    public boolean check(int n) {
        //检查第n层以前的皇后位置
        for (int i = 0; i < n; i++) {
            // arr[i] == arr[n] 检查是否同一列
            // Math.abs(n - i) == Math.abs(arr[n] - arr[i]) 检查是否同一斜线
            if (arr[i] == arr[n] ||
                Math.abs(n - i) == Math.abs(arr[n] - arr[i])) {
                return false;
            }
        }
        return true;
    }
    

    /**
     * 展现某一摆法中八皇后的摆放位置
     */
    public void show() {
        for (int i : arr) {
            System.out.print(i + " ");
        }
        System.out.println();
    }
}