04递归 recursion

递归

递归就是方法自己调用自己，每次调用传入的参数不同。

• 递归方法必须向退出递归的条件逼近，否则就死循环了。

1、迷宫回溯问题

思路：

1. 二维数组map表示迷宫8 * 7
2. 开始位置(1, 1)，目标位置(6, 5)
3. 当map[i][j]为：
   1. 0 表示没走过
   2. 1 表示墙，走不了
   3. 2 表示可以走通
   4. 3 表示已经走过，但是走不通
4. 在走迷宫时，确定一个策略： 下 -> 右 -> 上 -> 左
5. 若当前位置走不通，回溯

package msp.cai.recursion;

/*
 * 迷宫回溯问题
 */
public class RecursionTest01 {
    public static void main(String[] args) {
        // 定义地图并初始化
        int[][] map = new int[8][7];
        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][4] = 1;
        map[4][2] = 1;
        map[4][3] = 1;
        // 打印迷宫
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.print(map[i][j] + "  ");
            }
            System.out.println();
        }
        findPath(map, 1, 1);
        System.out.println("标记后的地图：");
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 7; j++) {
                System.out.print(map[i][j] + "  ");
            }
            System.out.println();
        }
    }

    /**
     * @param map 地图
     * @param i   开始的行
     * @param j   开始的列
     * @return null
     */
    public static boolean findPath(int[][] map, int i, int j) {
        // 已经找到目的地
        if (map[6][5] == 2) {
            return true;
        }
        // 还没找到
        else {
            // 若还没走过，0
            if (map[i][j] == 0) {
                map[i][j] = 2;  // 假定该位置可以走通
                if (findPath(map, i+1, j)) return true; // 向下
                else if (findPath(map, i, j+1)) return true; // 向右
                else if (findPath(map, i-1, j)) return true; // 向上
                else if (findPath(map, i, j-1)) return true; // 向左
                else {
                    map[i][j] = 3;
                    return false;
                }
            }
            // 已经走过了， 可能是 1，2，3
            else return false;
        }
    }
}

2、八皇后问题

该问题由国际西洋棋手马克思 贝瑟尔于1848年提出：

在8*8格的棋盘上放8个皇后，要求任意两个皇后不能处于同一行、同一列和同一斜线。

求共有多少种摆法。

思路：

1. 第一个皇后放到第一行，第一列；
2. 第二个皇后放到第二行，第一列，判断是否满足，若不则放到第2、3…列，找到一个合适的；
3. 继续放第3、4…个皇后，直到第8个也能放到一个不冲突的位置，即找到了一种正确摆法；
4. 当得到一个正确解时，开始回溯，得到第一个皇后放第一列的所有解；
5. 然后将第一个皇后放到第一行的第2、3…8列，继续执行步骤2,3,4。

package msp.cai.recursion;

/*
 * 8皇后问题
 */
public class RecursionTest02 {
    final int max = 8;    // 8个皇后
    int[] arr = new int[max];      // 保存皇后的摆放位置,具体的值为每个皇后在该行中列的位置
    static int count = 0;

    // 打印摆放位置
    private void print() {
        // 只有 成功找到一种摆法后 才打印
        count++;
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    // 检测 当前位置的皇后n 与 之前的n-1个 是否冲突
    private boolean check(int n) {
        for (int i = 0; i < n; i++) {
            // 若在同一行 或 在同一斜线，表示冲突了
            // 不需要判断是否在同一行了
            if (arr[i] == arr[n] || Math.abs(n - i) == Math.abs(arr[n] - arr[i]))
                return false;
        }
        return true;
    }

    // 摆放皇后
    private void put(int n) {
        if (n == max) {   // 8个都放完了
            print();
            return;
        }
        for (int i = 0; i < 8; i++) {
            arr[n] = i; // 先将该皇后放到第i列
            if (check(n)) {
                put(n + 1); // 若不冲突，放下一个皇后
            }
            // 若冲突了，将i++，重新判断
        }
    }

    public static void main(String[] args) {
        RecursionTest02 queen8 = new RecursionTest02();

        queen8.put(0);
        System.out.printf("8个皇后总共%d种摆法", count);
    }
}