4.java数据结构与算法 ---- 第六章递归(回溯) --师承尚硅谷韩顺平

第六章递归

小球迷宫

上代码:

package com.DataStructure._06Recursion;

/**
 * 迷宫问题:递归实现 -- 最短路径
 */
public class MiGong {
    public static void main(String[] args) {
        //定义迷宫的墙和障碍物,1表示
        int[][] map = new int[8][7];//8行7列
        //四周都是1
        for (int i = 0; i < 8; i++) {
            map[i][0] = 1;
            map[i][6] = 1;
        }
        for (int j = 0; j < 7; j++) {
            map[0][j] = 1;
            map[7][j] = 1;
        }
        //设置障碍物
        map[3][1] = 1;
        map[3][2] = 1;

        //map[6][5] = 9;
        //map[2][2] = 1;//测试死路 和 只留一个出口的路
        //map[1][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("---------跑迷宫测试--->");
        setWay(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();
        }

    }

    /**
     * 几个默认的说明
     *
     * @param map:就是地图
     * @param i,j:表示棋子的位置 默认起点是(1,1), 终点是(6,5)
     * @return 走得通;
     * @1表示围墙,2表示走过的路径(成功到达终点);3表示不通,走过的路径;
     * @2走路的规定 下--右--上--左(可以通过4*3*2个走路方式,存入数组,求出最短的路径!)
     */
    public static boolean setWay(int[][] map, int i, int j) {//策略:下--右--上--左
        if (map[6][5] == 2) {
            return true;
        } else {
            if (map[i][j] == 0) {
                map[i][j] = 2;
                if (setWay(map, i + 1, j)) {//下
                    return true;
                }
                if (setWay(map, i, j + 1)) {//右
                    return true;
                }
                if (setWay(map, i - 1, j)) {//上
                    return true;
                }
                if (setWay(map, i, j - 1)) {//左
                    return true;
                } else {
                    map[i][j] = 3;
                    return false;
                }
            } else {//不等于0就表示走不通了,返回false
                return false;
            }
        }
    }
}

效果展示:(策略:下–右–上–左)
i: 正常的情况

ii:一个缺口

iii:围城

八皇后–回溯算法

上代码:

package com.DataStructure._06Recursion;
/*
 * 八皇后问题:回溯算法典型案例
 * 8×8国际象棋棋盘放八个皇后棋子,(使其不能处于同一行,列,斜线),问有多少种摆法 (92种)
 *
 * 思路分析:
 * 1)第一个皇后先放第一行第一列
 * 2)第二个皇后放在第二行第一列、然后判断是否OK，
 *      如果不OK，继续放在第二列、第三列、依次把所有放完，找到一个合适
 * 3)继续第三个皇后，还是第一列、第二列……直到第8个皇后也能放在一个不冲突的位置，算是找到了一个解
 * 4)当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，
 *      即将第一个皇后，放到第一列的所有正确全部得到.
 * 5)然后回头继续第一个皇后放第二列，后面继续循环执行1,2,3,4的步骤
 */

public class EightQueue {
    //规定棋盘 max
    int max = 8;
    //定义解--数组表示 --存放八个皇后的摆放位置,下标是第几行,值是第几列
    int[] array = new int[max];//eg: arr = {0,4,7,5,2,6,1,3}

    static int countarray = 0;

    //主函数 测试用
    public static void main(String[] args) {
        EightQueue eightQueue = new EightQueue();
        eightQueue.check(0);
        System.out.println("--->总数:"+countarray);
    }


    /**
     * 放置第n个棋子
     *
     * @param n:从0开始
     */
    private void check(int n) {
        if (n == max) {//n=8 放置第9个的时候,就可以结束 输出结果了
            print();
            return;
        }

        //对n+1行的 所有列的循环
        for (int i = 0; i < max; i++) {
            //先把这个皇后放在这一行的第一列
            array[n] = i;
            //判断是否冲突
            if (judge(n)) {//不冲突,可以放n+1,开始递归
                check(n+1);
            }
            //冲突,就挪动到下一列(i++)
        }

    }


    /*
     * 判断是否ok --是否是同一直线
     * @param n:表示放置的第n个皇后 n从0开始
     * @return true:表示不冲突
     */
    private boolean judge(int n) {
        //首先默认 不在同一行的
        for (int i = 0; i < n; i++) {
            if (array[i] == array[n] || Math.abs(i - n) == Math.abs(array[i] - array[n])) {//前者判断是否一列,后者判断是否一斜线(按照y=x的函数理解)
                return false;
            }
        }
        return true;
    }

    /**
     * 输出结果
     */
    private void print() {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
        countarray++;
    }
}

效果:

(循环了很多很多次啊)