【Java数据结构与算法】 应用篇(3)：递归解决迷宫问题，回溯解决八皇后问题

大家好，我是皮皮猫吖！

每文一言：你一定会站在自己所热爱的世界里，闪闪发亮！

本篇文章：

主要是关于java数据结构与算法的一些应用：递归解决迷宫问题，回溯解决八皇后问题。

正文如下：

一、递归：迷宫问题

1）迷宫问题描述：

已知一个迷宫，红色的为墙体，不可通过，小球从(1,1)位置出发，需要到达箭头所指的位置，小球该如何到达目的地？

2）迷宫问题代码实现：

① 小球依照先向下走 -->再向右走 --> 再向上走 --> 再向左走的策略到达目的地

package com.data.structure.study5.recursion;

import com.sun.org.apache.regexp.internal.RE;

/**
 *
 * 递归：迷宫问题
 * @author imppm
 * @create 2021-03-13-14:42
 */
public class Recursion1Demo {
    public static void main(String[] args) {
        //创建一个迷宫
        // 8 * 7的迷宫
        //1：无法到达的地方
        //2：成功到达目的地所走的路线
        int[][] maze = {
                {1,1,1,1,1,1,1},
                {1,0,0,0,0,0,1},
                {1,0,0,0,0,0,1},
                {1,1,1,0,0,0,1},
                {1,0,0,0,0,0,1},
                {1,0,0,0,0,0,1},
                {1,0,0,0,0,0,1},
                {1,1,1,1,1,1,1}
        };

        //解决迷宫问题
        mazeProblem(maze, 1,1);

        //遍历迷宫最后的效果
        for (int i = 0; i < maze.length; i++){
            for (int j = 0; j < maze[i].length; j++){
                System.out.print(maze[i][j]+" ");
            }
            System.out.println();
        }
    }

    private static int count = 0;

    //迷宫问题：
    //迷宫问题分析：
    //  1.maze表示地图
    //  2.x，y表示从地图的哪里开始出发
    //  3.如果小球能走到maze[6][5]的位置，说明通路找到
    //  4.约定：当maze[x][y]为0的时候，表示没有走过，可以走；如果该位置为2，可以通过；如果该位置为3：表示此路不通
    //  5.走迷宫设置的策略：下 --> 右 --> 上 --> 左，如果该点走不通，进行回溯
    public static boolean mazeProblem(int[][] maze, int x, int y){
        //当到达终点的时候，设置为走的第几步
        if(x == 6 && y == 5){
            maze[x][y] = ++count;
            //返回true
            return true;
        }else{

            //如果当前位置可以走通
            if(maze[x][y] == 0) {

                //设置为第几步：假设该点是可以走通的
                maze[x][y] = ++count;

                //向下走：
                //判断当前位置的下面有没有地方可以走
                if (mazeProblem(maze, x+1, y)) {
                    //有，可以走
                    return true;
                }


                //向右走：
                //判断当前位置的右面有没有地方可以走
                else if (mazeProblem(maze, x, y+1)) {
                    //有，可以走
                    return true;
                }



                //向上走：
                //判断当前位置的上面可以走
                else if (mazeProblem(maze, x-1, y)) {
                    //有地方可以走
                    return true;
                }


                //向左走：
                // 判断当前位置的左面有没有地方可以走
                else if (mazeProblem(maze, x, y-1)) {
                    //有返回true
                    return true;
                }

                //该点的四边是不可以走的：
                else {
                    //这个点就是不需要到达的点，设置为-1
                    maze[x][y] = -1;
                    //走的步数-1
                    count--;
                    return false;
                }
            }
            //如果这个点不为0，这个点就是第几步，墙1、不必到达点-1
            //说明该点不可以走，直接返回
            else{
                return false;
            }
        }
    }

}

3）迷宫问题相关探索？

(1) 小球得到的路径，和程序员设置的找路策略有关：找路的 上下左右【策略】 的顺序相关

(2) 在得到小球路径时，可以先使用(下右上左)，再改成(上右下左)，看看路径是不是有变化

(3) 测试回溯现象

(4) 思考: 如何求出最短路径？

• 可以使用一个变量当作步数，如果当前策略走过的步数是最少的，即该策略下为小球到达目的地就是探索的最短路径！

二、递归：八皇后问题（回溯算法）

1）八皇后问题介绍：

八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。

2）八皇后问题算法思路分析

(1) 第一个皇后先放第一行第一列

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

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

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

(5) 然后回头继续第一个皇后放第二列，后面继续循环执行 1,2,3,4的步骤

说明：理用一个一维数组即可解决问题. arr[8] = {0 , 4, 7, 5, 2, 6, 1, 3} //对应arr 下标 表示第几行，即第几个皇后，arr[i] = val , val 表示第i+1个皇后，放在第i+1行的第val+1列

3）八皇后问题，代码分析

package com.data.structure.study5.recursion;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 八皇后问题
 * @author imppm
 * @create 2021-03-13-17:15
 */
public class Recursion2EightQueens {

    //定义最大皇后数量
    private int max = 8;

    //定义数组，保存八皇后位置的存储结果
    int[] array = new int[max];

    //记录皇后可以摆放成功位置的方式和
    static int count = 0;

    //记录判断冲突的次数
    static int judgeCount = 0;

    public static void main(String[] args) {
        Recursion2EightQueens queens = new Recursion2EightQueens();

        queens.check(0);

        System.out.println("八皇后问题总共有"+count+"种解法！");
        System.out.println("八皇后问题判断"+judgeCount+"次冲突！");
    }

    /**
     *  查找皇后可以放置的所有位置：从第一行的第一列开始探索
     *      探索方式简述：
     *      1.从第一行第一列开始探索皇后，
     *          递归进入第二行，开始探索第二行的第一列：
     *              如果两个皇后位置冲突，继续探索第二行的第二列位置:
     *                  如果两个皇后位置冲突，继续探索第二行的第三列位置：
     *                      ......
     *                  如果两个皇后位置没有冲突，开始探索第三行的第一列位置
     *              如果两个皇后位置没有冲突，递归进入第三行，从第三行的第一列开始探索，一直按照这个方式进行探索
     *      直到探索完第一行的第八列元素位置
     *
     *  1.n == max：当前探索成功，找到了合适的八皇后位置，
     *      返回到上一层，继续探索八皇后可以放置的其他位置
     *  2.for (int i = 0; i < max; i++){：遍历当前行的所有列
     *  3.array[n] = i：假设在该行的i+1列位置放置皇后
     *  4.if(judge(i))：判断当前行的皇后位置是否与其他行的皇后位置有冲突
     *       check(n+1);：如果当前行的皇后位置合理，继续探索下一行皇后位置
     *
     * @param n:皇后当前所在行数
     */
    public void check(int n){
        //如果n等于最大值,找到皇后当前解
        if(n == max){
//            打印出当前的皇后数组
            print();
            count++;
            return;
        }

//      每一次都是从当前行的第一列开始找皇后可以放置的位置
        for (int i = 0; i < max; i++){
            //假设当前行中皇后可以放置在该位置
            array[n] = i;

//           当前行设置的皇后位置，是否与之前行皇后位置有冲突
            if(judge(n)){
                //如果没有冲突，继续探索下一行
                check(n+1);
            }
            //如果有冲突，把该皇后放到当前行的下一列，进行探索
        }
    }

    /**
     *  判断当前行皇后的位置是否与之前行的皇后位置有冲突：
     *  1.array[i] == array[n]：
     *      当前行皇后放置的列位置与之前皇后的列位置有冲突，两个皇后放到了同一列
     *  2.Math.abs(n - i) == Math.abs(array[n]-array[i])：
     *      当前行皇后放置的列位置与之前的皇后列位置有冲突，两个皇后的在一条斜线上
     * @param n :表示第n个皇后
     * @return true:皇后可以放到该位置；false：皇后不可以放到该位置
     */
    private boolean judge(int n){
        //判断冲突次数+1
        judgeCount++;
        for (int i = 0; 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(){
        for (int i : array){
            System.out.print(i+" ");
        }
        System.out.println();
    }


}

---

希望本篇文章对大家有所帮助，后续会继续分享java数据结构与算法相关学习知识…

如果文章内容有错误的地方，请在留言处留下你的见解，方便大家共同学习。谢谢！

如有侵权或其他任何问题请联系：QQ1370922071，本文主要用于学习交流，转载请声明！

作者：皮皮猫吖

---