递归（迷宫、八皇后）

递归

回顾

package com.dg_recursion;

/**
 * @author ming
 * @create 2020-02-17 15:24
 */
public class RecursionDemo {
    public static void main(String[] args) {
        test(4);
    }

    private static void test(int i) {
        if (i > 2) {
            test(i -1);
        }
        System.out.println("i=" + i);
        //i=2
        //i=3
        //i=4
    }
}

---

• 递归规则：

1. 当程序执行到一个方法时，就会开辟一个独立的空间(栈)

2. 每个空间的数据(局部变量)，是独立的

• 递归需要遵守的重要规则

1. 执行一个方法时，就创建一个新的受保护的独立空间(栈空间)

2. 方法的局部变量是独立的，不会相互影响。

3. 如果方法中使用的是引用类型变量(比如数组)，就会共享该引用类型的数据.

4. 递归必须向退出递归的条件逼近，否则就是无限递归,出现StackOverflowError，死龟了:)

5. 当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。

---

迷宫问题

package com.dg_recursion;

/**
 * @author ming
 * @create 2020-02-17 16:24
 * <p>
 * 迷宫问题
 */
public class MGong {
    public static void main(String[] args) {
        //创建二维数组模拟地图
        int[][] map = new int[8][7];
        //使用 1 为墙
        //上下
        for (int i = 0; i < 7; i++) {
            map[0][i] = 1;
            map[7][i] = 1;
        }
        //左右
        for (int i = 0; i < 8; i++) {
            map[i][0] = 1;
            map[i][6] = 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("\t" + map[i][j]);
            }
            System.out.println();
        }

        //
        setWay(map, 1, 1);
        System.out.println("路径找到：");
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.print("\t" + map[i][j]);
            }
            System.out.println();
        }
    }


    /**
     * 使用递归寻找路径
     *
     * @param map 模拟地图
     * @param i
     * @param j   （i,j）代表起始坐标
     * @return 找到路径返回true，未找到返回false
     * <p>
     * 说明：
     * 0：该点未走  1：该点为墙
     * 2：该点已走，并通过  3：该点试探，未通过
     * 规定：下-右-上-左，依次试探
     */
    public static boolean setWay(int[][] map, int i, int j) {
        if (map[6][5] == 2) {//路径找到
            return true;
        } else if (map[i][j] == 0) { // 0：该点未走
//            //规定：下-右-上-左，依次试探
//            map[i][j] = 2;
//            if (setWay(map, i+1, j)){//下
//                return true;
//            }else if (setWay(map, i, j+1)) {//右
//                return true;
//            }else if (setWay(map, i-1, j)) {//上
//                return true;
//            }else if (setWay(map, i, j-1)) {//左
//                return true;

            //上右左下
            map[i][j] = 2;
            if (setWay(map, i - 1, j)) {//上
                return true;
            } else if (setWay(map, i, j + 1)) {//右
                return true;
            } else if (setWay(map, i, j - 1)) {//左
                return true;
            } else if (setWay(map, i + 1, j)) {//下
                return true;
            } else {
                //此路不通
                map[i][j] = 3;
                return false;
            }
        } else {//如果map[i][j] != 0   可能为1，2，3
            return false;
        }
    }
}

---

规定：下-右-上-左

规定：上-右-左-下

---

八皇后问题

任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。

思路分析

1. 第一个皇后先放第一行第一列

2. 第二个皇后放在第二行第一列、然后判断是否合法， 如果不合法，继续放在第二列、第三列、依次把所有列都放完，找到一个合适

3. 继续第三个皇后，还是第一列、第二列……直到第8个皇后也能放在一个不冲突的位置，算是找到了一个正确解

4. 当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，将第一个皇后，放到第一列得到的所有正确解，全部得到.

5. 然后回头继续第一个皇后放第二列，后面继续循环执行 1-4的步骤 .

说明：理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题.例如： arr[8] = {0 , 4, 7, 5, 2, 6, 1, 3} ;对应arr下标索引表示第几行，下标索引对应的值表示第几列，arr[i] = val , 表示皇后放在第i+1行的第val+1列。

package com.dg_recursion;

/**
 * @author ming
 * @create 2020-02-17 21:45
 */
public class Queue8 {
    int max = 8;
    int[] array = new int[max];
    static int count = 0;

    public static void main(String[] args) {
        //
        Queue8 queue8 = new Queue8();
        queue8.check(0);
        System.out.println("总摆法：" + count);
    }

    /**
     * @param n 当前放置皇后的行对应的索引
     */
    //摆放皇后
    private void check(int n) {
        if (n == max) {//第9个皇后
            print();
            return;
        }
        //依次按规则放入8个皇后
        for (int i = 0; i < max; i++) {
            //将当前行的皇后，放到第一列
            array[n] = i;
            //判断当放置第 n+1 个皇后到第 i+1 列，是否合法
            if (judge(n)) {//合法
                //开始放置第 n+2 个皇后
                check(n + 1);
                //例：当n = 4；此时进行check(5);array[5] = i; i:0-7全部不合法
                //此时回到n = 4时的循环体中，继续向下执行
            }
            //不合法，正常执行for循环
        }
    }

    /**
     * @param n 当前放置皇后的行对应的索引
     * @return 摆放第 n+1 行的皇后，将此皇后与之前所有行皇后进行规则判断
     */
    private boolean judge(int n) {
        for (int i = 0; i < n; i++) {
            //array[i] == array[n] 此等式成立代表在同一列
            //n-i == Math.abs(array[n] - array[i]) 此等式成立代表在同一斜线（同一斜线横纵坐标成比例）
            if (array[i] == array[n] || n - i == Math.abs(array[n] - array[i])) {
                return false;
            }
        }
        return true;
    }

    //打印皇后摆放位置
    private void print() {
        count++;
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + "\t");
        }
        System.out.println();
    }
}

---