Java笔记——07.递归调用例题(迷宫问题，汉诺塔问题，八皇后问题）

07.递归调用例题

三种递归调用例题的简单解法

迷宫问题：

import java.util.Scanner;

public class MiGong {

    public static void main(String[] args) {
        
        //迷宫的行数和列数
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入迷宫的行数：");
        int row = myScanner.nextInt();
        System.out.println("请输入迷宫的列数：");
        int column = myScanner.nextInt();

        //创建数组，表示迷宫
        int[][] maze = new int[row][column];

        //设置迷宫的墙壁和障碍物
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < column; j++) {
                if (i == 0 || i == row - 1 || j == 0 || j == column - 1) {
                    maze[i][j] = 1;
                }
            }
        }
        maze[3][1] = 1;
        maze[3][2] = 1;
        maze[2][2] = 1;

        //遍历数组，输出当前迷宫的状态
        System.out.println("=============迷宫初始地图============");
        for (int a = 0; a < row; a++) {
            for (int b = 0; b < column; b++) {
                System.out.print(maze[a][b] + " ");
            }
            System.out.println();
        }

        Test way = new Test();
        System.out.println("请输入迷宫起点坐标i：");
        int i = myScanner.nextInt();
        System.out.println("请输入迷宫起点坐标j：");
        int j = myScanner.nextInt();
        System.out.println("请输入迷宫终点坐标x：");
        int x = myScanner.nextInt();
        System.out.println("请输入迷宫终点坐标y：");
        int y = myScanner.nextInt();
        if (way.findWay(maze, i, j, x, y)) {
            System.out.println("=============结果============");
            System.out.println("迷宫走通了");
        } else {
            System.out.println("=============结果============");
            System.out.println("迷宫走不通");
        }

        //遍历数组，输出当前迷宫的状态
        System.out.println("=============迷宫路线地图============");
        for (int a = 0; a < row; a++) {
            for (int b = 0; b < column; b++) {
                System.out.print(maze[a][b] + " ");
            }
            System.out.println();
        }
    }
}

class Test {

    //map为组成迷宫的二维数组，i和j为当前位置的坐标
    //0表示还没走，1表示障碍物，2表示走过了，3表示走过但走不通
    public boolean findWay(int[][] maze, int i, int j, int x, int y) {
        if (maze[x][y] == 2) {
            return true;
        } else {
            if (maze[i][j] == 0) {
                //假定可以走通
                maze[i][j] = 2;
                //制定策略，先向下走，然后向右走，再向上走，最后向左走
                if (findWay(maze, i + 1, j, x, y)) {
                    return true;
                } else if (findWay(maze, i, j + 1, x, y)) {
                    return true;
                } else if (findWay(maze, i - 1, j, x, y)) {
                    return true;
                } else if (findWay(maze, i, j - 1, x, y)) {
                    return true;
                } else {
                    //假定不成立
                    maze[i][j] = 3;
                    return false;
                }
            } else {
                return false;
            }
        }
    }
}

汉诺塔问题：

import java.util.Scanner;

public class Hanoi {

    public static void main(String[] args){
        char a = 'A';
        char b = 'B';
        char c = 'C';
        Tower tower = new Tower();
        Scanner myScanner = new Scanner(System.in);
        System.out.println("请输入汉诺塔的层数：");
        int num = myScanner.nextInt();
        tower.hanoi(num, a, b, c);
    }
}

class Tower{

    //num表示移动的个数，即汉诺塔的层数
    //a，b，c表示三个塔
    public void hanoi(int num, char a, char b, char c){

        //汉诺塔层数为一层
        if(num == 1){
            System.out.println(a + "->" + c);
        }else {
            //将汉诺塔视为两部分：最下面一层和上面的整个整体
            //所以目标就变成了将汉诺塔的最底层移动到c塔，上面的整体移动到b塔
            //然后以此类推，直到全部都移动到c塔

            //第一步，将上面的整体经由c塔移动到b塔
            hanoi(num - 1, a, c, b);
            //第二步，将最下面一层移动到c塔
            System.out.println(a + "->" + c);
            //第三步，将b塔视为初始塔，a塔视为中间塔，重复上面的操作
            hanoi(num - 1, b, a, c);
        }
    }
}

八皇后问题：

public class EightQueens {

    //定义一个max表示共有多少个皇后
    int max = 8;

    //定义数组array, 保存皇后放置位置的结果, 比如arr = {0, 4, 7, 5, 2, 6, 1, 3}
    //对应array下标表示第几行，即第几个皇后，array[i]=value , value表示第i+1个皇后，放在第i+1行的第value+1列
    int[] array = new int[max];

    //定义一个全局变量，保存八皇后问题的排法总数
    private static int count = 0;

    public static void main(String[] args) {

        EightQueens eightQueens = new EightQueens();
        eightQueens.placeChess(0);
        System.out.println("==========八皇后问题解法总数===========");
        System.out.println("共有" + count + "种解法");

    }

    //放置第n个皇后
    //placeChess是每一次递归时，进入到check中都有for(int i = 0; i < max; i++)，因此会有回溯
    private void placeChess(int n) {

        //当n=8, 表示8个皇后就已经放好了
        if (n == max) {
            //每次放好后，打印当前的放法
            print();
            return;
        }

        //依次放入皇后，并判断是否冲突
        for (int i = 0; i < max; i++) {
            //先把当前皇后放到当前行的第i列
            array[n] = i;
            //判断当前皇后放到i列时是否冲突
            if (judge(n)) {
                //接着放下一个皇后
                placeChess(n + 1);
            }
            //如果冲突，就继续执行array[n] = i，即将当前皇后，在本行后移一个位置
        }
    }

    //判断当前皇后是否和之前的n-1个皇后冲突
    public boolean judge(int n) {
        for (int i = 0; i < n; i++) {
            //array[i] == array[n] 表示判断第n个皇后是否和前面的n-1个皇后在同一列
            //Math.abs(n-i) == Math.abs(array[n] - array[i] 表示判断第n个皇后是否和第i皇后是否在同一斜线
            if (array[i] == array[n] || Math.abs(n - i) == Math.abs(array[n] - array[i])) {
                return false;
            }
        }
        return true;
    }

    //输出皇后的摆放位置
    private void print() {
        //count记录八皇后放法的总数
        count++;
        System.out.println("第" + count + "种解法：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }
}