数据结构与算法(Java)之递归实例

迷宫问题

package com.weeks.recursion;

import java.util.List;

/**
 * @author 达少
 * @version 1.0
 * 迷宫游戏，通过递归方法找到出路
 */
public class Maze {
    public static void main(String[] args) {
        //获得地图
        int[][] map = initMap();
        //显示初始化的地图
        showMap(map);
        //寻找出路
        try {
            findWay2(map, 1, 1);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        //显示找出的路径地图
        System.out.println("===地图出路路径===");
        showMap(map);
    }

    //获得地图并初始化迷宫地图
    public static int[][] initMap() {
        //定义二维数组表示地图
        int rows = 8;
        int cols = 7;
        int[][] map = new int[rows][cols];
        //约定：0代表无障碍物，1代表障碍物
        //将地图的上下设置为障碍物
        for (int i = 0; i < cols; i++) {
            map[0][i] = 1;
            map[rows - 1][i] = 1;
        }
        //将地图的左右也设置为障碍物
        for (int i = 0; i < rows; i++) {
            map[i][0] = 1;
            map[i][cols - 1] = 1;
        }
        //设置地图的中间障碍物(3,1)(3,2)
        map[3][1] = 1;
        map[3][2] = 1;

        return map;
    }

    //显示地图
    public static void showMap(int[][] map) {
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[i].length; j++) {
                System.out.print(map[i][j] + " ");
            }
            System.out.println();
        }
    }

    /**
     * 不同的策略：
     * 上下左右排列组合共有24总策略分别是：
     * 第一组：
     * 1.上下左右
     * 2.上下右左
     * 3.上左下右
     * 4.上左右下
     * 5.上右左下
     * 6.上右下左
     * 第二组
     * 1.下上左右
     * 2.下上右左
     * 3.下左上右
     * 4.下左右上
     * 5.下右左上
     * 6.下右上左
     * 第三组
     * 1.左上下右
     * 2.左上右下
     * 3.左下上右
     * 4.左下右上
     * 5.左右下上
     * 6.左右上下
     * 第四组
     * 1.右上下左
     * 2.右上左下
     * 3.右下上左
     * 4.右下左上
     * 5.右左下上
     * 6.右左上下
     */
    //通过递归找到路，当给定出发点，找到map[rows-2][cols-2]点就算找到出路

    /**
     * 寻找出路策略：上下左右
     * @param map      代表地图
     * @param startRow 代表出发点的横坐标
     * @param startCol 代表出发点的中坐标
     * @return
     */
    public static boolean findWay1(int[][] map, int startRow, int startCol) {
        //判断地图是否为空
        if (map == null) {
            throw new RuntimeException("地图不能为空！！！");
        }
        //获得地图的大小
        int rows = map.length;
        int cols = map[0].length;
        /**
         * 约定：
         * 0 代表此点还没有走过
         * 1 代表障碍不能走
         * 2 代表此点能走通
         * 3 代表此点走过，但走不通
         *
         */
        //map[rows-2][cols-2] == 2就找到出路结束
        if (map[rows - 2][cols - 2] == 2) {
            return true;
        } else {
            if (map[startRow][startCol] == 0) {//表示当前的点没有走过
                //从当前点出发,假设当前点能走通
                map[startRow][startCol] = 2;
                //现在判断此点是否真能走通，寻找路的策略是从下开始顺时针选择方向
                if (findWay1(map, startRow - 1, startCol)) {
                    return true;
                } else if (findWay1(map, startRow + 1, startCol)) {
                    return true;
                } else if (findWay1(map, startRow, startCol - 1)) {
                    return true;
                } else if (findWay1(map, startRow, startCol + 1)) {
                    return true;
                } else {//表示此点走不通
                    map[startRow][startCol] = 3;
                    return false;
                }
            } else {//表示当前点是 1，2，3都不能走
                return false;
            }
        }
    }

    /**
     * 改变寻找策略，寻找路的策略是：上下右左
     *
     * @param map      代表地图
     * @param startRow 代表出发点的横坐标
     * @param startCol 代表出发点的中坐标
     * @return
     */
    public static boolean findWay2(int[][] map, int startRow, int startCol) {
        //判断地图是否为空
        if (map == null) {
            throw new RuntimeException("地图不能为空！！！");
        }
        //获得地图的大小
        int rows = map.length;
        int cols = map[0].length;
        /**
         * 约定：
         * 0 代表此点还没有走过
         * 1 代表障碍不能走
         * 2 代表此点能走通
         * 3 代表此点走过，但走不通
         *
         */
        //map[rows-2][cols-2] == 2就找到出路结束
        if (map[rows - 2][cols - 2] == 2) {
            return true;
        } else {
            if (map[startRow][startCol] == 0) {//表示当前的点没有走过
                //从当前点出发,假设当前点能走通
                map[startRow][startCol] = 2;
                //现在判断此点是否真能走通，寻找路的策略是从下开始顺时针选择方向
                if (findWay2(map, startRow -  1, startCol)) {
                    return true;
                } else if (findWay2(map, startRow + 1, startCol)) {
                    return true;
                } else if (findWay2(map, startRow, startCol + 1)) {
                    return true;
                } else if (findWay2(map, startRow, startCol - 1)) {
                    return true;
                } else {//表示此点走不通
                    map[startRow][startCol] = 3;
                    return false;
                }
            } else {//表示当前点是 1，2，3都不能走
                return false;
            }
        }
    }


    //求出走去迷宫的最短路径，在没有学图这种数据结构前，可以使用列举各种策列
    //比较不同策略走的路径长短来实现比较

}

//第一坐标类记录路径坐标
class Coordinate{
    private int row;
    private int col;

    public Coordinate(int row, int col) {
        this.row = row;
        this.col = col;
    }

    public int getRow() {
        return row;
    }

    public void setRow(int row) {
        this.row = row;
    }

    public int getCol() {
        return col;
    }

    public void setCol(int col) {
        this.col = col;
    }

    @Override
    public String toString() {
        return "(" + row + "," + col + ')';
    }
}

八皇后问题

package com.weeks.recursion;

/**
 * @author 达少
 * @version 1.0
 * 使用递归回溯解决八皇后问题：就是在一个8x8的棋盘上将8个皇后摆在不同的位置
 * 使8个皇后不能互相攻击，而不互相攻击的方法就是每一对皇后不能摆放在同一行或
 * 同一列或同一斜线上。问能有几种摆放方法？
 */
public class EightQueensProblem {
    //定义皇后的个数
    private int queensNum = 8;
    //使用一维数组就能代替棋盘，数组的下标可以表示棋盘的行，数组中的值表示皇后摆放在棋盘的列
    //比如:checkBoard[1]=4,表示这个皇后摆放在棋盘的第二行的第五列的位置
    private int[] checkerBoard = new int[queensNum];
    private static int count = 0;
    public static void main(String[] args) {
        EightQueensProblem eightQueensProblem = new EightQueensProblem();
        eightQueensProblem.queen(0);
        System.out.printf("有%d种方法解决八皇后问题。。。", count);
    }

    //使用递归摆放皇后
    public void queen(int number){
        if (number == 8){//说明第8个皇后已经摆好了，不用再往下摆了
            print();
            return;
        }else{//在摆放第n个皇后时要检查与前n-1个皇后是否冲突
            //i<queensNum,意思是要下雨棋盘的列数，但是queenNum和棋盘的列数一样，
            // 所以不再定义变量表示棋盘的列数
            for (int i = 0; i < queensNum; i++) {
                checkerBoard[number] = i;
                if(judgeHit(number)){//不产生攻击,继续摆放下一个皇后
                    queen(number+1);
                }
                //产生冲突就不用管，继续下一个i++的情况判断
            }
        }
    }

    //检查当前皇后摆放的位置是否与之前摆放的皇后位置是否会产生攻击
    private boolean judgeHit(int n){
        //循环判断
        for (int i = 0; i < n; i++) {
            //checkerBoard[i] == checkerBoard[n]:是否在同列
            //Math.abs(n - i) == Math.abs(checkerBoard[n] - checkerBoard[i]):是否在同一条斜线上
            //不用检查是否在同一行，因为 i<n 不可能会在同一行上
            if(checkerBoard[i] == checkerBoard[n] ||
                    Math.abs(n - i) == Math.abs(checkerBoard[n] - checkerBoard[i])){
                //产生攻击
                return false;
            }
        }
        //不产生攻击
        return true;
    }

    //打印寻找到的每一种情况
    private void print(){
        count++;
        for (int i = 0; i < checkerBoard.length; i++) {
            System.out.print(checkerBoard[i] + " ");
        }
        System.out.println();
    }
}