java实现迷宫算法

最新推荐文章于 2024-07-10 21:37:49 发布
最新推荐文章于 2024-07-10 21:37:49 发布
阅读量1k 收藏 1
点赞数
分类专栏： 算法 文章标签： java arrays string output class 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zuoyetian/article/details/6082118
版权

 

package com;

 

import java.util.LinkedList;

 

public class labyrinth{

      public static void main(String[] args) { 

            String[][] sArrays={

                        {"K","S","T","Q","D","S","T","B"},

                        {"G","3","H","W","H","J","Z","L"},

                        {"D","K","S","T","Q","W","O","G"},

                        {"F","S","T","L","L","K","S","H"},

                        {"I","S","B","Q","W","S","H","A"},

                        {"J","D","V","R","I","D","L","D"},

                        {"K","E","U","I","T","N","Q","A"},

                        {"J","6","O","C","N","Y","O","V"}

            };

            getLabyrinth(sArrays, "K,3,S,L,W,D,Q,V");

            System.out.println("***************************************************");

            getLabyrinth(sArrays, "K,4,S,L,W,D,Q,V");

      }

     

      public static void getLabyrinth(String[][] arrays,String target)

      {

            String[] targetArr=target.split(",");

            //final result

            LinkedList list=new LinkedList();

            //cycle the column

            for(int i=0;i<arrays.length;i++)

            {

                  for(int j=0;j<arrays[i].length;j++)

                  {

                        if(targetArr[0].equals(arrays[i][j]))

                        {

                              //the total linkedlist

                              LinkedList allLink=new LinkedList();

                              //the list which order to find news

                              LinkedList currLink=new LinkedList();

                              //record the next cycle

                              LinkedList tmpLink=new LinkedList();

                              currLink.add(i+","+j);

                              allLink.add(currLink);

                              tmpLink.add(currLink);

                              String[] tmp=new String[targetArr.length];

                              tmp[0]=arrays[i][j];

                              //cycle the special String

                              for(int n=1;n<targetArr.length;n++)

                              {

                                   

                                    int tmpNum=tmpLink.size();

                                    if(tmpNum!=0)

                                    {

                                          tmpLink=new LinkedList();

                                    }

                                    //cycle the matching String

                                    for(int m=0;m<tmpNum;m++)

                                    {

                                          if(allLink.size()==0)

                                          {

                                                break;

                                          }

                                          currLink=(LinkedList)allLink.get(allLink.size()-1);

                                          String currValue=(String)currLink.get(currLink.size()-1);

                                          int currI=Integer.parseInt(currValue.substring(0,currValue.indexOf(",")));

                                          int currY=Integer.parseInt(currValue.substring(currValue.indexOf(",")+1,currValue.length()));

                                          //above

                                          if(currI-1>0)

                                          {

                                                if(arrays[currI-1][currY].equals(targetArr[n]))

                                                {

                                                      LinkedList tempLinkList=(LinkedList)currLink.clone();

                                                      tmpLink.add((currI-1)+","+currY);

                                                      tempLinkList.add((currI-1)+","+currY);

                                                      allLink.add(0,tempLinkList);

                                                }

                                          }

                                          //left

                                          if(currY-1>0)

                                          {

                                                if(arrays[currI][currY-1].equals(targetArr[n]))

                                                {

                                                      LinkedList tempLinkList=(LinkedList)currLink.clone();

                                                      tmpLink.add((currI)+","+(currY-1));

                                                      tempLinkList.add((currI)+","+(currY-1));

                                                      allLink.add(0,tempLinkList);

                                                }

                                          }

                                          //blow

                                          if(currI+1<arrays.length)

                                          {

                                                if(arrays[currI+1][currY].equals(targetArr[n]))

                                                {

                                                      LinkedList tempLinkList=(LinkedList)currLink.clone();

                                                      tmpLink.add((currI+1)+","+currY);

                                                      tempLinkList.add((currI+1)+","+currY);

                                                      allLink.add(0,tempLinkList);

                                                }

                                          }

                                          //right

                                          if(currY+1<arrays[i].length)

                                          {

                                                if(arrays[currI][currY+1].equals(targetArr[n]))

                                                {

                                                      LinkedList tempLinkList=(LinkedList)currLink.clone();

                                                      tmpLink.add((currI)+","+(currY+1));

                                                      tempLinkList.add((currI)+","+(currY+1));

                                                      allLink.add(0,tempLinkList);

                                                }

                                          }

                                          //top left corner

                                         

                                          if(currI-1>0&&currY-1>0)

                                          {

                                                if(arrays[currI-1][currY-1].equals(targetArr[n]))

                                                {

                                                      LinkedList tempLinkList=(LinkedList)currLink.clone();

                                                      tmpLink.add((currI-1)+","+(currY-1));

                                                      tempLinkList.add((currI-1)+","+(currY-1));

                                                      allLink.add(0,tempLinkList);

                                                }

                                               

                                          }

                                          //lower right corner

                                          if(currI+1<arrays.length&&currY+1<arrays[i].length)

                                          {

                                                if(arrays[currI+1][currY+1].equals(targetArr[n]))

                                                {

                                                      LinkedList tempLinkList=(LinkedList)currLink.clone();

                                                      tmpLink.add((currI+1)+","+(currY+1));

                                                      tempLinkList.add((currI+1)+","+(currY+1));

                                                      allLink.add(0,tempLinkList);

                                                }

                                               

                                          }

                                          //lower left corner

                                          if(currI+1<arrays.length&&currY-1>0)

                                          {

                                                if(arrays[currI+1][currY-1].equals(targetArr[n]))

                                                {

                                                      LinkedList tempLinkList=(LinkedList)currLink.clone();

                                                      tmpLink.add((currI+1)+","+(currY-1));

                                                      tempLinkList.add((currI+1)+","+(currY-1));

                                                      allLink.add(0,tempLinkList);

                                                }

                                          }

                                          //top right corner

                                          if(currI-1>0&&currY+1<arrays[i].length)

                                          {

                                                if(arrays[currI-1][currY+1].equals(targetArr[n]))

                                                {

                                                      LinkedList tempLinkList=(LinkedList)currLink.clone();

                                                      tmpLink.add((currI-1)+","+(currY+1));

                                                      tempLinkList.add((currI-1)+","+(currY+1));

                                                      allLink.add(0,tempLinkList);

                                                }

                                          }

                                          //move of the current line

                                          allLink.removeLast();

                                    }

                                   

 

                              }

                              for(int s=0;s<allLink.size();s++)

                              {

                                    list.add(allLink.get(s));

                              }

                        }

                  }

            }

           

            if(list.size()==0)

            {

                  System.out.println("There is no match String!");

            }

            else

            {

                  for(int i=0;i<list.size();i++)

                  {

                        System.out.println("The "+(i+1)+" array is:");

                        LinkedList aimList=(LinkedList)list.get(i);

                        for(int j=0;j<aimList.size();j++)

                        {

                              System.out.println(aimList.get(j)+"    "+targetArr[j]+"/n");

                        }

                  }

            }

      }

}

 

Output：

 

 

The 1 array is:

0,0    K

1,1    3

2,2    S

3,3    L

4,4    W

5,5    D

6,6    Q

7,7    V

The 2 array is:

2,1    K

1,1    3

2,2    S

3,3    L

4,4    W

5,5    D

6,6    Q

7,7    V

***************************************************

There is no match String!

zuoyetian
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java实现创建迷宫，并求解最短路径(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-14 266
java实现创建迷宫，并求解最短路径(附完整源码)
java课程设计项目-Java语言编写的一个迷宫小游戏，涉及迷宫生成算法、深度、广度巡径等算法（源码+详细说明文档）
06-23
java课程设计项目——Java语言编写的一个迷宫小游戏（源码+详细说明文档） 说明文档部分内容： 软件总体框架 该软件主要分为如下三个模块： 参数设置模块 按钮功能模块按钮功能模块 迷宫主界面模块迷宫主界面模块 软件各模块介绍 参数设置模块 迷宫大小相关参数： ROWS（即迷宫行数，默认设置为奇数，最小值为11，最大值为99，默认值为11）； COLS（即迷宫列数，默认设置为奇数，最小值为11，最大值为99，默认值为11）； Lattice’s width（即组成迷宫的格子的宽度，迷宫格子默认设置为正方形，指定了迷宫格子的宽度相当于指定了迷宫格子的大小，默认设置为自然数，最小值为5，最大值为30，默认值为15）。 java课程设计项目——Java语言编写的一个迷宫小游戏（源码+详细说明文档）java课程设计项目——Java语言编写的一个迷宫小游戏（源码+详细说明文档）java课程设计项目——Java语言编写的一个迷宫小游戏（源码+详细说明文档）java课程设计项目——Java语言编写的一个迷宫小游戏（源码+详细说明文档）java课程设计项目——Java语言编写的一个迷宫小游戏（
JAVA实现随机迷宫(自动搜索路径）
weixin_49944622的博客
12-14 2235
一、生成迷宫算法简介 1.1 Depth First Search Algorithm（深度优先遍历算法） 算法思路 1、从第一个单元开始，检查当前单元是否堵塞（即周围四个单元都 是已被访问或不可访问） 2、若不堵塞，则随机选择一个相邻单元作为下一单元，检查是否可访问 3、若可访问，则打破当前单元与下一单元之间的墙壁，将当前单元入栈，将下一单元作为当前单元；若不不可访问，则回到步骤2 4、若当前单元堵塞，则回退至上一单元 5、如此遍历，直到所有的单元都被访问 特点 该算法产生的迷宫图片具有一条明显的主.
java-迷宫问题
weixin_65584018的博客
10-15 360
本章讲解一个迷宫问题，用来了解方法递归，迷宫和问题如下问题：求小球从开始到结束的路径，小球从坐标(1,1)开始找，到坐标(5,6)时结束。
Java 算法之迷宫(简单实现)
cjxiaobaic的博客
09-10 2003
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码
java实现走迷宫算法
Active7的博客
11-27 6348
代码实现了 读取文件中迷宫地图，打印迷宫地图并找到一条出口。第一次写java代码，留着纪念。 package com.maze.path; import java.util.Stack; import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.Input
算法- java实现走迷宫
qq_57481686的博客
06-09 507
迷宫问题： 小球从起点绕过障碍物到达终点。 实现思路 二维数组来表示迷宫 约定规则 用1表示迷宫四边和障碍物 用0表示未走过的路 用2表示走通过的路 用3表示走过但是走不通的路 代码实现 难点是移动的方法中的写法，没看过通常不会想到这样写。 /** * 走迷宫：从最左上角，走到最右下角 * 移动策略：下 ->右 -> 上 -> 左 * @Author: KingWang * @Date: 2021/6/7 * @Desc: **/ public class Migon
java 实现迷宫回溯算法示例详解
08-18
Java 实现迷宫回溯算法示例详解 本文主要介绍了 Java 实现迷宫回溯算法的示例详解，通过示例代码介绍了迷宫回溯算法的实现，文中对大家的学习或者工作具有一定的参考学习价值。 一、迷宫回溯算法的原理 迷宫回溯...
Java实现走迷宫回溯算法
08-28
算法实现 下面是使用 Java 实现走迷宫回溯算法的代码： 首先，定义一个 Position 类，用于表示迷宫中的坐标位置： ```java class Position { public Position() {} public Position(int row, int col) { this....
使用栈的迷宫算法java版代码
08-28
使用栈的迷宫算法java版代码是一种高效的迷宫算法实现方式，能够快速解决迷宫问题。 知识点： 1.迷宫算法的基本概念 迷宫算法是一种解决迷宫问题的算法，主要用于寻找迷宫中的路径。 2.使用栈的迷宫算法的基本...
基于C语言实现的迷宫算法示例
08-29
迷宫算法的实现可以通过各种编程语言，如C语言、Java、Python等。 二、基于C语言实现的迷宫算法 在本文中，我们将使用C语言来实现迷宫算法。首先，我们需要定义迷宫的结构体，包括迷宫的尺寸、入口和出口的坐标等...
迷宫算法Java
03-02
本教程将深入探讨如何使用Java实现两种主要的迷宫算法：广度优先搜索（BFS）和深度优先搜索（DFS）。这两种算法都属于图遍历算法，用于找到从起点到终点的最短路径或任何有效路径。 **广度优先搜索（BFS）** BFS是...
解密迷宫问题：三种高效算法Java实现，让你轻松穿越未知迷宫
xxxzzzqqq_的博客
04-26 4650
我们总结一下，在迷宫问题中，深度优先搜索（DFS）、广度优先搜索（BFS）和 A* 都可以用来寻找最短路径或最优解。空间要求低，不需要保存整个搜索树，只需要保存当前路径；所有解的路径长度差别不大，或者只需要找到其中一个解；迷宫比较大，而且有很多死路，采用 DFS 可以快速探索大面积空间。需要找到最短路径或最优解；迷宫中大部分路径长度差别不大；可以承受较大的空间复杂度，需要保存整个搜索树。需要找到最短路径或最优解；需要考虑迷宫中的障碍物，即寻找一条避开障碍物的路径；
java迷宫算法_迷宫求解算法（java版）
weixin_35621342的博客
02-12 908
迷宫求解算法一直是算法学习的经典，实现自然也是多种多样，包括动态规划，递归等实现，这里我们使用穷举求解，加深对栈的理解和应用。迷宫求解算法可以抽象为图的遍历问题。在图的遍历过程中通常由深度优先遍历(DFS)和广度优先遍历(BFS)两种。此例我们采用深度优先遍历，当然，在不同的情景之下，不同的优先遍历算法执行效率会有很大的差异，需要根据不同的使用环境选用合适的遍历算法。深度优先遍历深度优先遍历从某个...
Java迷宫小游戏，老程序员花一天时间完成，你可以吗？
热门推荐
编程界明世隐的博客
08-09 2万+
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 系列目录 1. Java俄罗斯方块 2. Java五子棋小游戏 3. 老Java程序员花一天时间写了个飞机大战 4. Java植物大战僵尸 5. 老Java程序员花2天写了个连连看 6. Java消消乐（天天爱消除） 7. Java贪吃蛇小游戏 8. Java扫雷小
【Java基础】迷宫问题的Java代码实现
yubao0723的专栏
04-16 1865
本文使用递归算法来解决迷宫问题，并用java实现
基于Java的迷宫小游戏
m0_73565130的博客
01-09 1760
基于Java的迷宫小游戏算法与分析
算法设计与分析 | 迷宫搜索（蓝桥杯Java）
鷾
03-12 1028
下图给出了一个迷宫的平面图，其中标记为 11 的为障碍，标记为 00 的为可以通行的地方。 迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。对于上面的迷宫，从入口开始，可以按 DRRURRDDDR 的顺序通过迷宫， 一共 1010 步。其中D、U、L、R 分别表示向下、向上、向左、向右走。 对于下面这个更复杂的迷宫（3030 行 5050 列），请找出一种通过迷宫的方式。
配置Java开发环境
最新发布
Broken_x的博客
07-10 1259
Java开发环境配置
数据结构课程设计迷宫算法的实现_JAVA.doc
03-07
"数据结构课程设计迷宫算法的实现，主要涵盖了三种不同的迷宫求解算法，包括递归算法、栈辅助结构算法和队列辅助结构算法，并利用Java的AWT和SWING库来设计图形用户界面。" 在这个数据结构课程设计中，学生熊军被...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值