递归（迷宫回溯问题和八皇后问题）

递归

---

一、定义

程序在运行过程调用自身（在方法中调用自身）。

二、递归的简单运用（求阶乘）

代码如下：

/**
 * 递归实现阶乘
 */
public class Factorial {
    public int getFactorial(int n){
        if (n == 1){
            return 1;
        }else {
            return getFactorial(n - 1) * n;
        }
    }
}

三、迷宫回溯问题

1.什么是迷宫回溯问题？

1.map是一个二维数组，做为迷宫地图；
2.当map[i][j]为0，表示该点没有走过；为1表示是墙，不能走；为2该点为结果通路的一个位置（也就是最后能出迷宫的结果为2连成的通路）；为3表示该点走过，但是走不通；
3.自定义 走迷宫的策略（方法）：下->右->上->左（也就是先向下走，走不通就再向右走，再走不通就向上走…）

2.代码实现（java）

/**
 * 递归解决迷宫回溯问题
 */
public class MazeBacktracking {
    public static void main(String[] args) {
        //定义一个二维数组做为迷宫地图框架
        int[][] map = new int[8][7];
        //设计地图(地图自己随意设计)，map[i][j] == 1 表示墙，不能走
        //周围全是墙
        for (int j = 0; j < 7; j++) {
            map[0][j] = 1;   //第一行
            map[7][j] = 1;   //最后一行
        }
        for (int i = 0; i < 8; i++) {
            map[i][0] = 1;   //第一列
            map[i][6] = 1;   //最后一列
        }
        //另外，迷宫中间有几块挡板不能走
        map[2][2] = 1;
        map[3][1] = 1;
        map[3][2] = 1;

        //遍历查看迷宫地图
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
        System.out.println("==========================");

        //测试
        moveMaze(map, 1, 1);
        //打印走过的迷宫
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
    }


    //迷宫玩法设计，以及走迷宫
    /**
     * map为迷宫地图
     * 当map[i][j]为0，表示该点没有走过；为1表示是墙，不能走；为2该点为结果通路的一个位置（也就是最后能出迷宫的结果为2连成的通路）；为3表示该点走过，但是走不通
     * 走迷宫的策略（方法）是：下->右->上->左（也就是先向下走，走不通就再向右走，再走不通就向上走.....）
     */
    /**
     *
     * @param map   地图
     * @param i   i和j是起始位置的坐标
     * @param j
     * @return    找到通路返回true，否者返回false
     */
    public static Boolean moveMaze(int[][] map,int i,int j){
        //设置迷宫的终点，终点为map[6][5]
        if (map[6][5] == 2){   //到达终点
            return true;   //终点为2时，说明形成通路，找到终点了，返回true结束
        }else {

            if (map[i][j] == 0){   //如果这个点还没有走过
                //没有到达终点，就要执行走迷宫策略：下->右->上->左
                map[i][j] = 2;  //先假定这个没走过的点是通路点
                if (moveMaze(map,i+1,j)){   //向下走
                    return true;
                }else if (moveMaze(map,i,j+1)){   //向右走
                    return true;
                }else if (moveMaze(map,i-1,j)){   //向上走
                    return true;
                }else if (moveMaze(map,i,j-1)){   //向左走
                    return true;
                }else {
                    //说明该点走不通，不是通路点
                    map[i][j] = 3;
                    return false;
                }
            }else {   //map[i][j] ！= 0,说明该点为1、2、3,
                return false;
            }
        }
    }
}

四、八皇后问题

程序在运行过程调用自身（在方法中调用自身）。

1.什么是八皇后问题？

八皇后问题，是由国际西洋棋棋手马克斯·贝瑟尔于1848年提出的问题，是回溯算法的典型案例。问题表述为：在8×8格的国际象棋上摆放8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。

2.代码示例

代码如下（java）：递归实现

/**
 * 八皇后问题
 */
public class Queens8 {
    public static void main(String[] args) {
        //测试
        Queens8 queens8 = new Queens8();
        queens8.getConflict(0);
        System.out.println("八皇后问题共有摆法：" + queens8.count + "种");


    }

    //特别注意！！！：我们用数组来存储8个皇后，下标从0开始，所以8个皇后分别是0,1,2,3,4,5,6,7
    //定义有多少个皇后
    int max = 8;
    //定义一个数，统计数组arr打印了多少次（及八皇后问题共有多少中摆法）
    int count = 0;
    //理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题. arr[8] = {0 , 4, 7, 5, 2, 6, 1, 3}
    // 对应arr下标 表示第几行，即第几个皇后，arr[i] = val , val 表示第i+1个皇后，放在第i+1行的第val+1列
    //注意：因为使用数组来表示的，所以起始下标为0
    int[] arr = new int[max];


    //方法：将皇后摆放进棋盘
    public void getConflict(int n){
        if (n == 8){   //n==8时，（0~7）8个皇后已经全部摆入棋盘
            put();
            return;
        }

        //依次放入第n~7个皇后，并判断是否冲突
        for (int i = 0; i < max; i++) {
            //先将第n个皇后该行的第一列（第一次循环）
            arr[n] = i;
            //判断是否与之前放入的皇后冲突
            if (isConflict(n) == true){   //不冲突
                //不冲突就接着放下一个皇后(递归)
                getConflict(n+1);
            }
            //否则接着循环，将n皇后放入该行第二列.....
        }
    }


    //方法：在我们摆放第n（注意：下标从0开始，所以实际是第n+1个皇后）个皇后时，判断这个皇后是否与之前的皇后产生冲突
    public Boolean isConflict(int n){
        //将第n个皇后与之前的摆放的皇后比较是否冲突
        for (int i = 0; i < n; i++) {
            //arr[i] == arr[n] ： 这个是与之前的皇后在同一列（冲突）
            //Math.abs(n - i) == Math.abs(arr[n] - arr[i]  ： 这个是与之前的皇后在同一斜线上（因为棋盘是8*8的矩阵，斜率为1）（冲突）
            if (arr[i] == arr[n] || Math.abs(n - i) == Math.abs(arr[n] - arr[i])){   //冲突
                return false;
            }
        }
        return true;
    }


    //方法：打印八个皇后分别可以摆放的位置
    public void put(){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        count++;
        System.out.println();
    }
}