精华内容
下载资源
问答
  • 数据结构课程设计迷宫算法的实现JAVA
    2021-03-07 23:10:14

    41528d3028836879cd698677c3999917.gif数据结构课程设计迷宫算法的实现JAVA

    数 据 结 构 课 程 设 计走 迷 宫学号:200908204136姓名:熊军日期:6 月 16 日一、题目说明.分别用以下算法实现。并设计图形用户界面提供迷宫大小、入口及出口位置和初始状态等,演示走迷宫的过程和结果。1.递归算法。2.使用栈作为辅助结构。3.使用队列作为辅助结构。二、总体设计方案以及细节设计为实现上述程序功能,主要使用的JAVA AWT 和 JAVA SWING包import java.awt.*;import javax.swing.*;import hartech.ui.*;3. 本程序包含四个模块:1) 主程序模块:package mg;import java.awt.*;import javax.swing.*;/*** Title: maze Global class** Description: ** Date: 2006-08-31 */public class Main {// _reset 变量用于 reset时用static int rows = 12, cols = 14;static int speed_reset = 50, speed = speed_reset;static JToggleButton[][] buttons;static Walking walking;static boolean[][] brick, brick_reset = {{ true, true, true, true, true, false, true, true, true, true,true, true, true, true, },{ true, false, false, false, true, false, true, true, true, true,false, false, false, true, },{ true, false, true, false, true, false, false, false, false, true,true, false, true, true, },{ true, false, true, false, true, false, true, true, true, false,true, false, true, false, },{ true, true, true, false, false, false, true, false, true, false,true, false, true, true, },{ true, false, true, true, true, true, true, false, true, false,true, false, false, true, },{ true, false, true, true, true, true, true, false, true, false,true, false, true, true, },{ true, false, false, false, false, false, true, true, true, false,true, false, true, false, },{ true, false, true, true, true, false, false, false, false, false,true, false, true, true, },{ true, false, true, false, true, false, true, true, true, true,true, false, false, true, },{ true, false, true, false, true, false, true, false, false, false,false, false, true, true, },{ true, true, true, false, true, true, true, true, true, true,true, false, true, true, }};static JFrame jFrame;static UI ui;public static void main(String[] args) {//启 动新线程,创 建一个窗口javax.swing.SwingUtilities.invokeLater(new Runnable() {public void run() {//J.setLookAndFeel(“Metal“);jFrame = new JFrame(“is there any way to go? Maze --- “);//建立一个 Swing 窗体jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//单击关闭图标后,程序退出并关闭// addMain.ui = new UI();jFrame.add(ui, BorderLayout.CENTER);jFrame.setSize(700, 400);//J.goCenter(jFrame);Main.drawButtons();Main.reset();jFrame.setVisible(true);}});}// 用于重置到 软件开始public static void reset() {if (walking != null) {walking.timer.stop();}clean();brick = copyBoolean(brick_reset);speed = speed_reset;UI.jSlider.setValue(speed);setBricks();}// 用于清楚已 标记上的数 字public static void clean() {if (walking != null) {walking.timer.stop();}for (int i = 0; i Title: maze Global class** Description: ** Date: 2006-08-31 */public class Main {// _reset 变量用于 reset 时用static int rows = 12, cols = 14;static int speed_reset = 50, speed = speed_reset;static JToggleButton[][] buttons;static Walking walking;static boolean[][] brick, brick_reset = {{ true, true, true, true, true, false, true, true, true, true,true, true, true, true, },{ true, false, false, false, true, false, true, true, true, true,false, false, false, true, },{ true

    更多相关内容
  • NULL 博文链接:https://stupid.iteye.com/blog/224414
  • 这三种算法分别适合不同的迷宫情况,深度优先适合于那种主线支线明显的游戏(如RPG),而递归分割则适合转角较少的游戏(也许是FPS和ACT),至于prim,似乎适合最标准的迷宫游戏(因为很难走)。 2.寻找路径 因为...
  • 主要介绍了java 实现迷宫回溯算法示例详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 今天小编就为大家分享一篇关于Java基于深度优先遍历的随机迷宫生成算法,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • 主要为大家详细介绍了Java实现走迷宫回溯算法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 最近在学习算法,又又看到了一个挺有趣的题目,就是走迷宫,就写了一篇简单实现走迷宫算法,就只是找到一条出路,你问为啥不写复杂一点,因为作者想留给你们写(就是懒得考虑那么多dog)。如果有小伙伴需要考虑复杂...

    最近在学习算法,又又看到了一个挺有趣的题目,就是走迷宫,就写了一篇简单实现走迷宫的算法,就只是找到一条出路,你问为啥不写复杂一点,因为作者想留给你们写(就是懒得考虑那么多dog)。如果有小伙伴需要考虑复杂一些的,比如输出多条路线,或者多条路线找到最简等要求,可以给我留言,我在出一个2.0迷宫(正大光明水文章)。

    说明

    走迷宫是递归求解的基本题型,我们在二维阵列中使用1表示迷宫墙壁,使用0表示行走的路径,找到从入口至出口的路线。
    从第一行的第一个元素为入口,走到最后一行的最后一个元素为出口

      0  1	1	1                                   
      0  0	0	1
      0  1	0	0
      0  1	1	0	
    
      *  1	1	1             这个就是路线                      
      *  *	*	1
      0  1	*	*
      0  1	1	*	
    

    提示:下一步进入我们最喜欢的解题思路环节。
    在这里插入图片描述

    解题思路

    上面我们已经画出了行走路线,但是要怎么才能实现那?

    1: 第一步

    我们理所应当要先考虑怎么实现行走,这个很简单,我们只需要在原先的二维坐标上面进行操作,比如(a,b),我们给 a+1 就实现了向下,a-1 向上 ,b+1 向右,b-1 向左,这样就解决了行走。

    2: 第二步

    我们需要考虑边界问题,如果你不考虑,那么恭喜你将喜提ArrayIndexOutOfBoundsException异常(数组索引越界异常)。因为是二维数组嘛,所以最小我们要考虑大于等于0,最大只能是小于数组的长度(数组的行和列)

    3: 第三步 (核心)

    这步也是核心,我用的是递归解法,不懂的小伙伴需要去了解一下递归的思想(有时间我也写一写递归)。除了第一步,后面的每一步我们都可以考虑最大有四种行走的可能,我们可以写四个方法,分别代表向上、下、左、右移动,行走后是否等于 0 ,也就是是否可以接着行走(可以接着行走,再次调用我们的方法),一直到最后每一个方法都不成立,达到递归返回的条件,这个时候无非两种情况,要么走到死胡同,要么成功了。成功,我们只需要判断这个下标是否为出口点就可以了,然后递返。如果是死胡同,就递返到有交叉出口的地方,也就是能调用两种及以上行走方法的地方,接着走下一条路线。(这里有点绕可以多看看,因为递归有点抽象,不好理解,也不好说)。

    所以我画了一个图方便理解。

    在这里插入图片描述
    我们可以看到从起点开始,代替移动的四个方法只有向下满足,所以这时候只能向下移动,到分叉路口,这个时候移动会根据我们写的移动方法的顺序,接着移动,这里假如是向下的方法优先,就会先向下移动。走蓝色的路线,走到最下面,然后进行判断,走到死胡同了,然后触发我们设置的递归条件,进行递返,一直到交叉口的位置,走红色路线,然后进行判断,在进行递返。
    在这里插入图片描述
    注意!
    我们需要留心的一个小细节,当我们走到一个点的时候,需要改变走过点的值,因为你到下一步,四种可能当中就一定会满足你刚刚走过的点,这样你就又走回去了。

    代码

    不要看代码多,很多都是每一步的注解,和一些数据的输出,关键代码不多

    public class Test {
    
        public static void main(String[] args) {
            //走迷宫
            String [][]source = {
               {"0", "0", "1", "1", "1"},
               {"1", "0", "1", "1", "0"},
               {"0", "0", "0", "0", "0"},
               {"1", "0", "1", "1", "0"},
               {"0", "0", "1", "1", "0"},
               {"0", "1", "0", "0", "0"},
               {"0", "0", "0", "1", "0"}
            };
            //输出原始数据
            for(int i = 0 ; i < source.length ; i++){
                for(int j = 0 ; j < source[i].length ; j++){
                    System.out.print(source[i][j] + " ");
                }
                System.out.println();
            }
            //调用移动的方法 (0,0)为我们设置的起点
            move(0, 0, source);
    
            System.out.println("--------------");
            for(int i = 0 ; i < source.length ; i++){
                for(int j = 0 ; j < source[i].length ; j++){
                    System.out.print(source[i][j] + " ");
                }
                System.out.println();
            }
        }
    
        public static int move(int a, int b, String [][]source){
            //移动的四个方向
            int ad = a + 1;         //下
            int ax = a - 1;         //上
            int bd = b + 1;         //右
            int bx = b - 1;         //左
    
            //判断是否满足边界条件
            if(ad < source.length){
                //下  如果能走下一步接着调用移动方法
                if(source[ad][b] == "0"){
                    //给走过的路线标记 * 号避免,刚走了下一步,到下一个点又执行向上
                    source[a][b] = "*";
                    //如果等于 1 表示找到出口 然后一直返回(触发递归的条件)
                    if(move(ad, b, source) == 1){
                        source[a][b] = "-";
                        System.out.println(a + "," + b);
                        return 1;
                    }
                }
            }
            if(ax >= 0){
                //上
                if(source[ax][b] == "0"){
                    source[a][b] = "*";
                    if(move(ax, b, source) == 1){
                        source[a][b] = "-";
                        System.out.println(a + "," + b);
                        return 1;
                    }
                }
            }
            if(bd < source[a].length){
                //右
                if(source[a][bd] == "0"){
                    source[a][b] = "*";
                    if(move(a, bd, source) == 1){
                        source[a][b] = "-";
                        System.out.println(a + "," + b);
                        return 1;
                    }
                }
            }
            if(bx >= 0){
                //左
                if(source[a][bx] == "0"){
                    source[a][b] = "*";
                    if( move(a, bx, source) == 1){
                        source[a][b] = "-";
                        System.out.println(a + "," + b);
                        return 1;
                    }
                }
            }
                source[a][b] = "*";
                //出口点
                if(a == 5 && b == 4){
                    System.out.println("有出口");
                    //输出成功的每一个点
                    System.out.println(a + "," + b);
                    source[a][b] = "-";
                    //返回 1 代表成功 0 失败
                    return 1;
                }
            return 0;
        }
    
    }
    

    结果

    最下面带 - 就是我们的成功的路线,带 * 就是我们走过的但是不通的路线

    0 0 1 1 1 
    1 0 1 1 0 
    0 0 0 0 0 
    1 0 1 1 0 
    0 0 1 1 0 
    0 1 0 0 0 
    0 0 0 1 0 
    有出口
    5,4
    5,3
    5,2
    6,2
    6,1
    6,0
    5,0
    4,0
    4,1
    3,1
    2,1
    1,1
    0,1
    0,0
    --------------
    - - 1 1 1 
    1 - 1 1 * 
    0 - * * * 
    1 - 1 1 * 
    - - 1 1 * 
    - 1 - - - 
    - - - 1 * 
    
    

    老规矩,这个算法只是作者自己的理解,可能有地方有问题或者bug(毕竟作者也就是一个老一点的菜鸟),如果有问题,可以留言和私信我,看到都会进行修改,让我们共同进步,一起成长 ^ - ^。

    在这里插入图片描述

    展开全文
  • 迷宫算法(JAVA实现)对于走迷宫,人们提出过很多计算机上的解法。深度优先搜索、广度优先搜索是使用最广的方法。生活中,人们更愿意使用“紧贴墙壁,靠右行走”的简单规则。下面的代码则采用了另一种不同的解法。...

    迷宫算法(JAVA实现)

    对于走迷宫,人们提出过很多计算机上的解法。深度优先搜索、广度优先搜索是使用最广的方法。生活中,人们更愿意使用“紧贴墙壁,靠右行走”的简单规则。

    下面的代码则采用了另一种不同的解法。它把走迷宫的过程比做“染色过程”。假设入口点被染为红色,它的颜色会“传染”给与它相邻的可走的单元。这个过程不断进行下去,如果最终出口点被染色,则迷宫有解。

    在以下程序中“#”代表不可通过,“.”代表可以通过。

    public class Maze

    {

    class

    Cell//内部类

    {

    private int row;

    private int col;

    private Cell from;//指向父节点

    public Cell(int row, int col, Cell from)

    {

    this.row = row;

    this.col = col;

    this.from = from;

    }

    }

    char[][]

    maze =

    {{'#','#','#','#','B','#','#','#','#','#','#','#'},

    {'#','#','#','#','.','.','.','.','#','#','#','#'},

    {'#','#','#','#','.','#','#','#','#','.','.','#'},

    {'#','.','.','.','.','#','#','#','#','#','.','#'},

    {'#','.','#','#','#','#','#','.','#','#','.','#'},

    {'#','.','#','#','#','#','#','.','#','#','.','#'},

    {'#','.','#','#','.','.','.','.','.','.','.','#'},

    {'#','.','#','#','.','#','#','#','.','#','.','#'},

    {'#','.','.','.','.','#','#','#','.','#','.','#'},

    {'#','#','.','#','.','#','#','#','.','#','.','A'},

    {'#','#','.','#','#','#','.','.','.','#','#','#'},

    {'#','#','#','#','#','#','#','#','#','#','#','#'}};

    public void

    show()

    {

    for(int i=0; i

    {

    for(int j=0; j

    System.out.print(" " + maze[i][j]);

    System.out.println();

    }

    }

    //把与from集合中相邻的可染色节点染色,被染色节点记入 dest

    //一旦发现出口将被染色,则返回当前的“传播源”节点

    public Cell

    colorCell(Set from,

    Set dest)

    {

    Iterator it =

    from.iterator();

    while(it.hasNext())

    {

    Cell a = it.next();

    Cell[] c = new Cell[4];

    c[0] = new Cell(a.row-1, a.col, a); //向上

    c[1] = new Cell(a.row, a.col-1, a); //向左

    c[2] = new Cell(a.row+1, a.col, a); //向下

    c[3] = newCell(a.row, a.col+1, a); //向右

    for(int i=0; i<4; i++)

    {

    if(c[i].row < 0 || c[i].row >=

    maze.length)continue;

    if(c[i].col < 0 || c[i].col >=

    maze[0].length)continue;

    char x = maze[c[i].row][c[i].col];

    if(x=='B') return a;

    if(x=='.')

    {

    maze[c[i].row][c[i].col] = '?';//对可通过路径进行标记

    dest.add(c[i]);

    }

    }

    }

    return null;

    }

    public void

    resolve()

    {

    Set set = new

    HashSet();

    set.add(new Cell(9,11,null));

    for(;;)

    {

    Set set1 = new

    HashSet();

    Cell a = colorCell(set, set1);

    if(a!=null)

    {

    System.out.println("找到解!");

    while(a!=null)

    {

    maze[a.row][a.col] = '+';//标出通路路径

    a =a.from;

    }

    break;

    }

    if(set1.isEmpty())

    {

    System.out.println("无解!");

    break;

    }

    set = set1;

    }

    }

    public

    static void main(String[] args)

    {

    Maze m = new Maze();

    m.show();

    m.resolve();

    m.show();

    }

    }

    程序的输出结果为:"+"代表通路

    a4c26d1e5885305701be709a3d33442f.png

    展开全文
  • 首先详细介绍了什么是遗传算法,然后通过遗传算法的思想用实例解析使用遗传算法解决迷宫问题,需要的朋友可以参考下
  • 用遗传算法求解迷宫问题的Java代码,代码有注释。
  • a*算法解决迷宫问题java.zip
  • Java 算法 走出迷宫

    2021-02-12 15:25:07
    前几天参加字节跳动招聘的笔试,遇到了一个走迷宫的题目(笔试题目,就不挂原图了),当时没有做出来,今天周末,上午总结了一下,来说一说这个迷宫到底怎么走这篇文章将会分为三个部分,分别是:深度优先算法:获得一...

    前几天参加字节跳动招聘的笔试,遇到了一个走迷宫的题目(笔试题目,就不挂原图了),当时没有做出来,今天周末,上午总结了一下,来说一说这个迷宫到底怎么走

    这篇文章将会分为三个部分,分别是:深度优先算法:获得一条路径

    广度优先算法:获得最短路径的长度

    广度优先算法:在有传送门的迷宫中寻找最短路径

    一、深度优先算法:获得一条路径

    在这个题目中,不涉及传送门,地图可以这样表示:

    其中,1 的位置表示了墙,即不可使用,0 的位置则为路,因为现在值要求获得一条路径,是不是最佳路径我们不管,所以我们可以使用“一条路走到黑”的思路,深度优先。

    (注:这里假设的启点为左上,重点为右下,在启点与重点非这种情形下,算法仍然适用)。

    具体的做法是这样的:

    首先我们先定义一个Position类来存储一下当前位置,也可以用数组,这里新建类是方便表示和理解:

    class Position{

    int row;

    int cow;

    public Position(int row,int cow){

    this.cow = cow;

    this.row = row;

    }

    public void show(){

    System.out.println(this.row + " " + this.cow);

    }

    }

    这里我还定义了一个show方法,是我在写的时候调试用的,大家可以不管或者直接删除。

    然后我们需要设立一个栈,当然也可使用队列来存储这条路径,其次,我们还维护一个访问状态的二维数组,避免在一条圈上反复寻找,造成死循环。

    public List solutionDFS(int[][] nums){

    int rows = nums.length;

    int cows = nums[0].length;

    int[][] visited = new int[rows][cows];

    Stack stack = new Stack<>();

    Position p = new Position(0,0); // 记录一下当前位置,在启点 stack.add(p);

    visited[0][0] = 1; // 访问状态设置为 1 ,代表已经访问过了 Position temp;

    // 只要找到了终点就退出循环 // 始终没有找到,也会导致栈弹空 while (!stack.isEmpty()&& !(p.row == rows-1 && p.cow == cows-1)){

    p = stack.peek(); // 获取上一个访问过的位置 // 按照方向 → ↓ ← ↑的顺序依次进行试探性的走一步 // 如果能走通(在迷宫范围内,不是墙,而且没有访问过,就可以认为是可以走) if (p.cow+1

    temp = new Position(p.row,p.cow+1);

    stack.add(temp);

    visited[temp.row][temp.cow] = 1;

    }else if (p.row+1

    temp = new Position(p.row+1,p.cow);

    stack.add(temp);

    visited[temp.row][temp.cow] = 1;

    }else if (p.cow-1>-1 && nums[p.row][p.cow-1] == 0 && visited[p.row][p.cow-1] != 1) {

    temp = new Position(p.row,p.cow-1);

    stack.add(temp);

    visited[temp.row][temp.cow] = 1;

    }else if (p.row-1 >-1 && nums[p.row-1][p.cow] == 0 && visited[p.row-1][p.cow] != 1){

    temp = new Position(p.row-1,p.cow);

    stack.add(temp);

    visited[temp.row][temp.cow] = 1;

    }else {

    // 如果没有尝试了四个方向都没有走通,说明上一个点的选取有问题,直接弹出 stack.pop();

    }

    }

    // 最后根据还在栈里的的元素,推导出一挑可用路径 if (stack.isEmpty()) return new LinkedList<>();

    Deque deque = new LinkedList<>();

    for (Position po:stack) {

    deque.addLast(new int[]{po.row,po.cow});

    }

    return (List)deque;

    }

    这是针对上面的迷宫的一个输出:

    路径比较长,我拆成了左右两个部分进行展示。

    二、广度优先算法,获得最短路径

    如果想要获得一条最短路径,那么我们可以使用广度优先的思路,“一层一层的剥开我的心”

    !啊,回来!

    广度优先的思路其实也很容易理解,拿到一个点后,根据这个点的步数,更新这个点周围四个方向上的最小步数,直到全局稳定(也就是没有更小值可以更新了)

    public int solutionBFS(int[][] nums){

    int rows = nums.length;

    int cows = nums[0].length;

    int[][] count = new int[rows][cows];

    // 首先对计数的数组进行初始化 for (int i = 0;i

    Arrays.fill(count[i],Integer.MAX_VALUE);

    }

    count[0][0] = 0;

    // 由于深度优先算法是和遍历的层数有关的,所以我们使用双向链表来操作 // 前面添加,后面取用(还可以使用两个栈来进行交替使用) Deque deque = new LinkedList<>();

    Position p = new Position(0,0);

    deque.add(p);

    int[] r = {0,1,0,-1};

    int[] c = {1,0,-1,0};

    while (!deque.isEmpty()){

    p = deque.pollLast();

    for (int i = 0; i<4;i++){

    int tempR = p.row+r[i];

    int tempC = p.cow+c[i];

    if (tempR>-1 && tempR-1 && tempC

    // 如果能够进行更新,那就将这个位置再次压入队列中,等待下一次更新 if (count[tempR][tempC] > count[p.row][p.cow]+1){

    count[tempR][tempC] = count[p.row][p.cow]+1;

    Position temp = new Position(tempR,tempC);

    deque.addFirst(temp);

    }

    }

    }

    }

    return count[rows-1][cows-1];

    }

    这是示例迷宫的输出:

    由于和上面是一个地图,所以数过之后你会发现,确实最少路径是17步。

    三、广度优先算法:在有传送门的迷宫中寻找最短路径

    这是我们这次主要要说的迷宫,有传送门的迷宫。

    一个示例的带有传送门的地图可能是这样的:

    其中:

    -2 表示启点,-3表示终点,0表示普通路径,-1表示墙,大于0的数字则表示传送门(能够保证传送门成对出现)。

    我的思考过程是这样的:

    由于传送门之间的穿送是不记录步数的,直觉的思路是:当遇到一个传送门时,直接传送,进而继续进行广度优先搜索(寻找最短路径)。

    我认为这个思路可行,但是实现起来可能比较麻烦,因为:一方面,你不知道传送门用的顺序

    另一方面,你不知道传送门使用的次数,可能是一次,也可能是0次。而广度优先,对一个点的访问极有可能更多次。

    下面来说一下我的思路:

    仍然是广度优先没有错,但是是两次,另外在两次之间,对传送门的步数取最小值:

    public int solutionTransfer(int[][] nums){

    int rows = nums.length;

    int cows = nums[0].length;

    HashMap> hashMap = new HashMap<>();

    int endRow=0,endCow=0,startRow=0,startCow = 0;

    // 先获得起始位置、终点位置,以及各个传送门的位置// 将传送门的代号和位置保存到hashmap中 for (int i = 0; i

    for (int j = 0;j

    if (nums[i][j] == -2){

    startRow = i;

    startCow = j;

    }else if (nums[i][j] == -3){

    endRow = i;

    endCow = j;

    }else {

    if (nums[i][j]>0){

    if ( !hashMap.containsKey(nums[i][j])){

    List list = new LinkedList<>();

    hashMap.put(nums[i][j],list);

    }

    hashMap.get(nums[i][j]).add(new int[]{i,j});

    }

    }

    }

    }

    // 第一步广度优先算法 int[][] count = new int[rows][cows];

    for (int i = 0;i

    Arrays.fill(count[i],Integer.MAX_VALUE);

    }

    count[startRow][startCow] = 0;

    Deque deque = new LinkedList<>();

    Position p = new Position(startRow,startCow);

    deque.add(p);

    int[] r = {0,1,0,-1};

    int[] c = {1,0,-1,0};

    while (!deque.isEmpty()){

    p = deque.pollLast();

    for (int i = 0; i<4;i++){

    int tempR = p.row+r[i];

    int tempC = p.cow+c[i];

    if (tempR>-1 && tempR-1 && tempC

    if (count[tempR][tempC] > count[p.row][p.cow]+1){

    count[tempR][tempC] = count[p.row][p.cow]+1;

    Position temp = new Position(tempR,tempC);

    deque.addFirst(temp);

    }

    }

    }

    }

    // 通过hash来获得每一对传送门,嗖嗖嗖~ for (int targ : hashMap.keySet()){

    List list = hashMap.get(targ);

    int[] in = list.get(0);

    int[] out = list.get(1);

    if (count[in[0]][in[1]] < count[out[0]][out[1]]){

    count[out[0]][out[1]] = count[in[0]][in[1]];

    }else {

    count[in[0]][in[1]] = count[out[0]][out[1]];

    }

    // 将更改过步数的路径继续压队列 // 这里的代码还可以优化,实际上只需要将原来大的那个点压入队列即可 // 也就是放到 if 和else 里面去,虽然看到了,但是,懒 deque.addFirst(new Position(in[0],in[1]));

    deque.addFirst(new Position(out[0],out[1]));

    }

    // 新一轮的广度优先搜索,更新最小步骤数 while (!deque.isEmpty()){

    p = deque.pollLast();

    for (int i = 0; i<4;i++){

    int tempR = p.row+r[i];

    int tempC = p.cow+c[i];

    if (tempR>-1 && tempR-1 && tempC

    if (count[tempR][tempC] > count[p.row][p.cow]+1){

    count[tempR][tempC] = count[p.row][p.cow]+1;

    Position temp = new Position(tempR,tempC);

    deque.addFirst(temp);

    }

    }

    }

    }

    // 返回最小步骤数 return count[endRow][endCow];

    }

    针对给出的示例迷宫(带有传送门),测试结果是这样的:

    感谢评论区 @华樱 指出的问题,对上面第三个问题做了一点点改动,改动代码如下:

    public int solutionTransferS(int[][] nums){

    int rows = nums.length;

    int cows = nums[0].length;

    HashMap> hashMap = new HashMap<>();

    int endRow=0,endCow=0,startRow=0,startCow = 0;

    // 先获得起始位置、终点位置,以及各个传送门的位置// 将传送门的代号和位置保存到hashmap中 for (int i = 0; i

    for (int j = 0;j

    if (nums[i][j] == -2){

    startRow = i;

    startCow = j;

    }else if (nums[i][j] == -3){

    endRow = i;

    endCow = j;

    }else {

    if (nums[i][j]>0){

    if ( !hashMap.containsKey(nums[i][j])){

    List list = new LinkedList<>();

    hashMap.put(nums[i][j],list);

    }

    hashMap.get(nums[i][j]).add(new int[]{i,j});

    }

    }

    }

    }

    int[][] count = new int[rows][cows];

    for (int i = 0;i

    Arrays.fill(count[i],Integer.MAX_VALUE);

    }

    count[startRow][startCow] = 0;

    Position p = new Position(startRow,startCow);

    Deque deque = new LinkedList<>();

    deque.addFirst(p);

    List list;

    int[] r = {0,1,0,-1};

    int[] c = {1,0,-1,0};

    while (!deque.isEmpty()){

    p = deque.pollLast();

    for (int i = 0; i<4;i++){

    int tempR = p.row+r[i];

    int tempC = p.cow+c[i];

    if (tempR>-1 && tempR-1 && tempC

    if (nums[p.row][p.cow] >0 && nums[tempR][tempC] == nums[p.row][p.cow]){

    continue;

    }

    if (count[tempR][tempC] > count[p.row][p.cow]+1){

    count[tempR][tempC] = count[p.row][p.cow]+1;

    Position temp = new Position(tempR,tempC);

    deque.addFirst(temp);

    }

    }

    }

    if (hashMap.containsKey(nums[p.row][p.cow])){

    list = hashMap.get(nums[p.row][p.cow]);

    for (int[] t:list) {

    if (p.row!=t[0] || p.cow!=t[1]){

    if (count[t[0]][t[1]] > count[p.row][p.cow]){

    count[t[0]][t[1]] = count[p.row][p.cow];

    p.row = t[0];

    p.cow = t[1];

    deque.addFirst(p);

    }

    break;

    }

    }

    }

    }

    return count[endRow][endCow];

    }

    至于仍然存在的代码冗余问题,确实是还没理解足够透彻,欢迎大家继续挑毛病。

    想要获得全部代码,欢迎到我的仓库:PluteW/InterviewCode​github.com8784c84499a111be01c5985bec8f6794.png

    展开全文
  • 迷宫课程设计,有图形化界面,可以单步演示、整体演示、自由设定迷宫大小,使用java语言,封装良好,易于修改。
  • Java迷宫算法;Java迷宫算法;Java迷宫算法;Java迷宫算法;Java迷宫算法;Java迷宫算法;Java迷宫算法
  • 主要为大家详细介绍了使用栈的迷宫算法java版代码,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 迷宫生成算法Java

    2022-03-17 16:27:04
    迷宫生成三大算法 1.深度优先生成 2.随机普里姆 3.递归分割
  • A*算法搜索实现迷宫

    2017-10-29 20:36:10
    A*算法是人工智能中的一种搜索算法,是一种启发式搜索算法,它不需遍历所有节点,只是利用包含问题启发式信息的评价函数对节点进行排序,使搜索方向朝着最有可能找到目标并产生最优解的方向。
  • java迷宫课程设计.zip

    2021-06-08 22:06:33
    通过java实现的迷宫课程设计。分成算法部分和界面部分,算法部分涉及到迷宫生成算法,深度优先,广度优先,运用了栈和队列等容器。界面部分采用javafx实现。有显示迷宫路线,更改迷宫大小,展示迷宫解谜动画过程。...
  • 游戏中需要随机生成迷宫地图,引入java.util.Random类,利用Random类提供的生成随机数方法,随机生成障碍物、通路或者奖励等状态。迷宫地图采用二维数组进行表示与存储。 2,A*算法求解迷宫路径 根据A*算法求解出...
  • 老鼠走迷宫java算法

    2021-02-13 00:43:24
    说明老鼠走迷宫是递回求解的基本题型,我们在二维阵列中使用2表示迷宫墙壁,使用1来表示老鼠的行走路径,试以程式求出由入口至出口的路径。解法老鼠的走法有上、左、下、右四个方向,在每前进一格之后就选一个方向...
  • 使用A*算法求解迷宫寻路问题,使用python编程,人工智能导论课后实验
  • 算法- java实现走迷宫

    2021-06-09 16:50:31
    迷宫问题: 小球从起点绕过障碍物到达终点。 实现思路 二维数组来表示迷宫 约定规则 用1表示迷宫四边和障碍物 用0表示未走过的路 用2表示走通过的路 用3表示走过但是走不通的路 代码实现 难点是移动的方法中的...
  • 文章目录迷宫问题的解决思路,加深对递归回溯的理解使用JAVA语言,但算法思路所有语言共用前言一、迷宫问题是什么?二、代码部分展示1.创建迷宫2.使用递归回溯来给小球找路总结 前言 对于迷宫问题的解决:采用递归...
  • 数据结构课程设计迷宫算法的实现_JAVA.doc
  • A星算法 迷宫寻路,源代码,注释详细,适合刚刚接触java算法的人学习
  • 该资源为迷宫随机生成程序,用Eclipse平台开发的,采用了深度优先遍历算法迷宫行数列数在界面输入;入口为定点(左上角);有两个出口,在右边界和下边界随机选择。
  • 遗传算法经典Java实现

    2018-04-12 16:05:41
    遗传算法是解决最优解的。其代码是java实现,且有main函数可以方便自行调试查看运行结果。
  • 数据结构课程设计迷宫算法的实现_java.doc还剩24页未读,继续阅读下载文档到电脑,马上远离加班熬夜!亲,喜欢就下载吧,价低环保!内容要点:路5. 点击“Reset”可复位,即显示出原先的迷宫。6. 进度条可控制搜寻...
  • 数据结构课程设计java求解迷宫,回溯法,A算法.docx
  • JAVA算法:走迷宫回溯算法设计JAVA版本) 迷宫数组 int[][] maze = { {0, 1, 0, 0, 0}, {0, 1, 0, 1, 0}, {0, 0, 0, 0, 0}, {0, 1, 1, 1, 0}, ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,995
精华内容 2,398
关键字:

算法设计迷宫java

java 订阅