「回忆迷宫java」回忆迷宫的孩子谁演的

admin 2023-01-03 01:12:09 755

本篇文章给大家谈谈回忆迷宫java，以及回忆迷宫的孩子谁演的对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

1、求用java语言寻找走出迷宫路线的算法
2、关于Java走迷宫的问题。我已经有相关代码了，但是我看不懂。麻烦高手帮忙注释一下，然后再修改点儿。
3、Java迷宫算法问题（用栈实现）有算法简述
4、JAVA数据结构迷宫求解！
5、用java语言控制小机器人走迷宫的算法?
6、java迷宫图形界面

求用java语言寻找走出迷宫路线的算法

首先给定一个初始坐标，然后构建一个容器保存坐标值，之后进行迭代，横坐标+1，或者纵坐标+1，这个顺寻自己定义（四个方向），经过的“路径”保存在那个容器中，如果遇到死角，以此往回迭代，在容器中将遇到死角的那个坐标删除。最后找到自己定义的那个迷宫出口坐标。

关于Java走迷宫的问题。我已经有相关代码了，但是我看不懂。麻烦高手帮忙注释一下，然后再修改点儿。

package 走迷宫;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.GridLayout;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.ArrayList;

import java.util.LinkedList;

import java.util.List;

import java.util.TimerTask;

import javax.swing.JButton;

import javax.swing.JFrame;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

// 迷宫

public class Maze extends JFrame implements ActionListener {

private JPanel panel;

private JPanel northPanel;

private JPanel centerPanel;

private MazeGrid grid[][];

private JButton restart;

private JButton dostart;

private int rows;// rows 和cols目前暂定只能是奇数

private int cols;

private ListString willVisit;

private ListString visited;

private LinkedListString comed;

private long startTime;

private long endTime;

public Maze() {

rows = 25;

cols = 25;

willVisit = new ArrayListString();

visited = new ArrayListString();

comed = new LinkedListString();

init();

this.setTitle("回溯法--走迷宫");

this.add(panel);

this.pack();

this.setVisible(true);

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

public void init() {

panel = new JPanel();

northPanel = new JPanel();

centerPanel = new JPanel();

panel.setLayout(new BorderLayout());

restart = new JButton("重新生成迷宫");

dostart = new JButton("开始走迷宫");

grid = new MazeGrid[rows][cols];

centerPanel.setLayout(new GridLayout(rows, cols, 1, 1));

centerPanel.setBackground(new Color(0, 0, 0));

northPanel.add(restart);

northPanel.add(dostart);

dostart.addActionListener(this);

restart.addActionListener(this);

for (int i = 0; i grid.length; i++)

for (int j = 0; j grid[i].length; j++) {

if (j % 2 == 0 i % 2 == 0)

grid[i][j] = new MazeGrid(true, 20, 20);

else

grid[i][j] = new MazeGrid(false, 20, 20);

}

grid[0][0].setVisited(true);

grid[0][0].setPersonCome(true);

grid[0][0].setStart(true);

visited.add("0#0");

grid[rows - 1][cols - 1].setEnd(true);

grid = createMap(grid, 0, 0);

for (int i = 0; i grid.length; i++)

for (int j = 0; j grid[i].length; j++) {

grid[i][j].repaint();

centerPanel.add(grid[i][j]);

}

panel.add(northPanel, BorderLayout.NORTH);

panel.add(centerPanel, BorderLayout.CENTER);

}

/**

* 生成迷宫

* @param mazeGrid

* @param x

* @param y

* @return

public MazeGrid[][] createMap(MazeGrid mazeGrid[][], int x, int y) {

int visitX = 0;

int visitY = 0;

if (x - 2 = 0) {

if (!mazeGrid[x - 2][y].isVisited()) {

willVisit.add((x - 2) + "#" + y);

}

if (x + 2 cols) {

if (!mazeGrid[x + 2][y].isVisited()) {

willVisit.add((x + 2) + "#" + y);

}

if (y - 2 = 0) {

if (!mazeGrid[x][y - 2].isVisited()) {

willVisit.add(x + "#" + (y - 2));

}

if (y + 2 rows) {

if (!mazeGrid[x][y + 2].isVisited()) {

willVisit.add(x + "#" + (y + 2));

}

if (!willVisit.isEmpty()) {

int visit = (int) (Math.random() * willVisit.size());

String id = willVisit.get(visit);

visitX = Integer.parseInt(id.split("#")[0]);

visitY = Integer.parseInt(id.split("#")[1]);

mazeGrid[(visitX + x) / 2][(visitY + y) / 2].setMark(true);

mazeGrid[visitX][visitY].setVisited(true);

if (!visited.contains(id)) {// 将这个点加到已访问中去

visited.add(id);

}

willVisit.clear();

createMap(mazeGrid, visitX, visitY);

} else {

if (!visited.isEmpty()) {

String id = visited.remove(visited.size() - 1);// 取出最后一个元素

visitX = Integer.parseInt(id.split("#")[0]);

visitY = Integer.parseInt(id.split("#")[1]);

mazeGrid[visitX][visitY].setVisited(true);

createMap(mazeGrid, visitX, visitY);

}

return mazeGrid;

}

/**

* 走迷宫

* @param mazeGrid

* @param x

* @param y

public String goMaze(MazeGrid mazeGrid[][], int x, int y) {

int comeX = 0;

int comeY = 0;

// left

if (x - 1 = 0) {

if (mazeGrid[x - 1][y].isMark()) {

if (!comed.contains((x - 1) + "#" + y))

willVisit.add((x - 1) + "#" + y);

}

// right

if (x + 1 cols) {

if (mazeGrid[x + 1][y].isMark()) {

if (!comed.contains((x + 1) + "#" + y))

willVisit.add((x + 1) + "#" + y);

}

// up

if (y - 1 = 0) {

if (mazeGrid[x][y - 1].isMark()) {

if (!comed.contains(x + "#" + (y - 1)))

willVisit.add(x + "#" + (y - 1));

}

// down

if (y + 1 rows) {

if (mazeGrid[x][y + 1].isMark()) {

if (!comed.contains(x + "#" + (y + 1)))

willVisit.add(x + "#" + (y + 1));

}

if (!willVisit.isEmpty()) {

int visit = (int) (Math.random() * willVisit.size());

String id = willVisit.get(visit);

comeX = Integer.parseInt(id.split("#")[0]);

comeY = Integer.parseInt(id.split("#")[1]);

mazeGrid[x][y].setPersonCome(false);

mazeGrid[comeX][comeY].setPersonCome(true);

mazeGrid[x][y].repaint();

mazeGrid[comeX][comeY].repaint();

willVisit.clear();

comed.add(x + "#" + y);

} else {

if (!comed.isEmpty()) {

String id = comed.removeLast();

comeX = Integer.parseInt(id.split("#")[0]);

comeY = Integer.parseInt(id.split("#")[1]);

mazeGrid[x][y].setPersonCome(false);

mazeGrid[comeX][comeY].setPersonCome(true);

mazeGrid[x][y].repaint();

mazeGrid[comeX][comeY].repaint();

comed.addFirst(x + "#" + y);

}

return comeX + "#" + comeY;

}

int comeX = 0;

int comeY = 0;

public void actionPerformed(ActionEvent e) {

if (e.getActionCommand().equals("重新生成迷宫")) {

refreshMap(grid);

} else if (e.getActionCommand().equals("开始走迷宫")) {

startTime = System.currentTimeMillis();

dostart.setVisible(false);

restart.setText("禁止刷新");

int delay = 1000;

int period = 500;// 循环间隔

java.util.Timer timer = new java.util.Timer();

timer.scheduleAtFixedRate(new TimerTask() {

public void run() {

if (grid[rows - 1][cols - 1].isPersonCome()) {

endTime = System.currentTimeMillis();

JOptionPane.showMessageDialog(null, "已经走出迷宫，耗时"

+ (endTime - startTime) / 1000 + "秒", "消息提示",

JOptionPane.ERROR_MESSAGE);

this.cancel();

restart.setText("重新生成迷宫");

} else {

String id = goMaze(grid, comeX, comeY);

comeX = Integer.parseInt(id.split("#")[0]);

comeY = Integer.parseInt(id.split("#")[1]);

}

}, delay, period);

}

/**

* 刷新地图

public void refreshMap(MazeGrid mazeGrid[][]) {

comeX = 0;

comeY = 0;

willVisit.clear();

visited.clear();

comed.clear();

this.remove(panel);

init();

this.add(panel);

this.pack();

this.setVisible(true);

}

public static void main(String args[]) {

long start = System.currentTimeMillis();

new Maze();

long end = System.currentTimeMillis();

System.out.println("使用ArrayList生成迷宫耗时：" + (end - start) + "毫秒");

}

Java迷宫算法问题（用栈实现）有算法简述

import java.io.File;

import java.io.FileNotFoundException;

import java.util.HashSet;

import java.util.LinkedList;

import java.util.List;

import java.util.Scanner;

public class Test {

public static void main(String[] args) throws FileNotFoundException {

Scanner input = new Scanner(new File("Maze2tong.txt"));

int row = 0;

char[][] Mazemap = new char[12][58];

while (input.hasNext()) {

String line = input.nextLine();

for (int column = 0; column = line.length() - 1; column++) {

char c = line.charAt(column);

Mazemap[row][column] = c;

}

row++;

}

for (int i = 0; i 12; i++) {

for (int j = 0; j 58; j++) {

System.out.print(Mazemap[i][j]);

}

System.out.print("\n");

}

LinkedListTwoTupleInteger, Integer trace = new LinkedListTwoTupleInteger, Integer();

System.out.println(maze(Mazemap, trace));

System.out.println(trace);

}

public static boolean maze(char[][] maze,

ListTwoTupleInteger, Integer trace) {

LinkedListTwoTupleInteger, Integer path = new LinkedListTwoTupleInteger, Integer();

HashSetTwoTupleInteger, Integer traverse = new HashSetTwoTupleInteger, Integer();

for (int i = 0; i maze.length; i++) {

for (int j = 0; j maze[i].length; j++) {

if (maze[i][j] == 'S') {

path.add(new TwoTupleInteger, Integer(i, j));

}

while (!path.isEmpty()) {

TwoTupleInteger, Integer temp = path.pop();

if (traverse.contains(temp)) {

continue;

} else if (maze[temp.first][temp.second] == 'F') {

trace.add(temp);

return true;

} else if (!traverse.contains(temp)) {

if (temp.second + 1 maze[temp.first].length

maze[temp.first][temp.second + 1] != 'W')

path.add(new TwoTupleInteger, Integer(temp.first,

temp.second + 1));

if (temp.second - 1 0

maze[temp.first][temp.second - 1] != 'W')

path.add(new TwoTupleInteger, Integer(temp.first,

temp.second - 1));

if (temp.first + 1 maze.length

maze[temp.first + 1][temp.second] != 'W')

path.add(new TwoTupleInteger, Integer(temp.first + 1,

temp.second));

if (temp.first - 1 0

maze[temp.first - 1][temp.second] != 'W')

path.add(new TwoTupleInteger, Integer(temp.first - 1,

temp.second));

traverse.add(temp);

trace.add(temp);

}

trace.clear();

return false;

}

class TwoTupleA, B {

public final A first;

public final B second;

public TwoTuple(A a, B b) {

first = a;

second = b;

}

@Override

public int hashCode() {

return first.hashCode() + second.hashCode();

}

@Override

public boolean equals(Object obj) {

if (!(obj instanceof TwoTuple)) {

}

return obj instanceof TwoTuple first.equals(((TwoTuple) obj).first)

second.equals(((TwoTuple) obj).second);

}

public String toString() {

return "(" + first + ", " + second + ")";

}

} // /:-

import java.io.File;

import java.io.FileNotFoundException;

import java.util.LinkedList;

import java.util.Scanner;

class MyPoint

{

public boolean visited=false;

public int parentRow=-1;

public int parentColumn=-1;

public final char content;

public int x;

public int y;

public MyPoint(char c,int x,int y)

{

this.content = c;

this.x = x;

this.y = y;

}

public class Maze

{

public static MyPoint[][] getMazeArray(){

Scanner input = null;

MyPoint[][] mazemap = new MyPoint[12][58];

try {

input = new Scanner(new File("Maze2tong.txt"));

int row = 0;

while (input.hasNext()) {

String line = input.nextLine();

for (int column = 0; column = line.length() - 1; column++) {

char c = line.charAt(column);

MyPoint point = new MyPoint(c,row,column);

mazemap[row][column] = point;

}

row++;

}

input.close();

} catch (FileNotFoundException e) {

e.printStackTrace();

}

return mazemap;

}

public static boolean tomRun(MyPoint[][] maze,MyPoint end)

{

int x = maze.length;

int y = maze[0].length;

LinkedListMyPoint stack=new LinkedListMyPoint();

for (int i = 0; i maze.length; i++) {

for (int j = 0; j maze[i].length; j++) {

if (maze[i][j].content == 'S') {

stack.push(maze[i][j]);

maze[i][j].visited=true;

}

boolean result=false;

while(!stack.isEmpty())

{

MyPoint t=stack.pop();

//System.out.println("pop point:"+t.x+" "+t.y+" value:"+maze[t.x][t.y]);

if(t.content == 'F')

{

result=true;

end.x = t.x;

end.y = t.y;

break;

}

if(t.x-1 0 maze[t.x-1][t.y].visited==false maze[t.x-1][t.y].content != 'W')

{

stack.push(maze[t.x-1][t.y]);

maze[t.x-1][t.y].parentRow=t.x;

maze[t.x-1][t.y].parentColumn=t.y;

maze[t.x-1][t.y].visited=true;

}

if(t.x + 1 x maze[t.x+1][t.y].visited==false maze[t.x+1][t.y].content != 'W')

{

stack.push(maze[t.x+1][t.y]);

maze[t.x+1][t.y].parentRow=t.x;

maze[t.x+1][t.y].parentColumn=t.y;

maze[t.x+1][t.y].visited=true;

}

if(t.y - 1 0 maze[t.x][t.y - 1].visited==false maze[t.x][t.y-1].content != 'W')

{

stack.push(maze[t.x][t.y-1]);

maze[t.x][t.y-1].parentRow=t.x;

maze[t.x][t.y-1].parentColumn=t.y;

maze[t.x][t.y-1].visited=true;

}

if( t.y + 1 y maze[t.x][t.y + 1].visited==false maze[t.x][t.y+1].content != 'W')

{

stack.push(maze[t.x][t.y+1]);

maze[t.x][t.y+1].parentRow=t.x;

maze[t.x][t.y+1].parentColumn=t.y;

maze[t.x][t.y+1].visited=true;

}

return result;

}

public static void show(int x,int y,MyPoint[][] visited)

{

if(visited[x][y].parentRow==-1)

{

System.out.println("["+x+","+y+"]");

return;

}

show(visited[x][y].parentRow,visited[x][y].parentColumn,visited);

System.out.println("-"+"["+x+","+y+"]");

}

public static void main(String[] args)

{

MyPoint[][] maze = getMazeArray();

MyPoint point = new MyPoint('c',1,1);

if(tomRun(maze,point))

{

System.out.println("逃生路径如下：");

show(point.x,point.y,maze);

}

else

System.out.println("无法走出迷宫！");

}

WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW

WSOOOOOOOOOOOOOOWOOOOOOOOOOOOOOOOOWOOOOOOOOOOOOOOOWOOOOOOW

WWOOOOOOOOOOOOOWWWWWWWWWWWWWOOOOOOOOOOWWWWWWWWWWWWWOOOOOOW

WWWWWWOOOOOOOOOOOOWWWWWWWOOOOOOOOOOOOWWWWWWWWWWWWWWWWOOOOW

WOOOOOOWWWWWWWWWWWWWWOOOOOOOOOOOWWWWWWWWWWWWWWWWWWWWWWWWWW

WOOOOWWWWWWWOOOOOOWWWWOOOOOOWWWWWWWWWWWOOOOWWWWWWWWWOWWWWW

WOOOWWWWWWWWWWWWOOWWWWWWWWWWWWOOOOOOOOOOOOWWWWWWWWWOOOOOWW

WOOWWWWWWWWWWWWWOOWWWWWWWWWWWWWWWWWOOOOOOOWWWWWWWWWWWWOOOW

WOWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWOOOOOOOWWWWWWWWWWWOOW

WOWWWWWWWWWWWWWOOOOOOOOOOOOOOOOOOOOOOOOOOOOWWWWWWWWWWWWOOW

WOOOOOOOOOOOOOOOOWWWWOOOOOOOOWWWWWWWOOOOOOWWWWWWWWWWWWWWFW

WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW

WSOOOOOOOOOOOOOOWOOOOOOOOOOOOOOOOOWOOOOOOOOOOOOOOOWOOOOOOW

WWOOOOOOOOOOOOOWWWWWWWWWWWWWOOOOOOOOOOWWWWWWWWWWWWWOOOOOOW

WWWWWWOOOOOOOOOOOOWWWWWWWOOOOOOOOOOOOWWWWWWWWWWWWWWWWOOOOW

WOOOOOOWWWWWWWWWWWWWWOOOOOOOOOOOWWWWWWWWWWWWWWWWWWWWWWWWWW

WOOOOWWWWWWWOOOOOOWWWWOOOOOOWWWWWWWWWWWOOOOOOOOOOOOOOOOOWW

WOOOWWWWWWWWWWWWOOWWWWWWWWWWWWOOOOOOOOOOOOWWWWWWWWWOOOOOWW

WOOWWWWWWWWWWWWWOOWWWWWWWWWWWWWWWWWOOOOOOOWWWWWWWWWWWWOOOW

WOWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWOOOOOOOWWWWWWWWWWWOOW

WOWWWWWWWWWWWWWOOOOOOOOOOOOOOOOOOOOOOOOOOOOWWWWWWWWWWWWOOW

WOOOOOOOOOOOOOOOOWWWWOOOOOOOOWWWWWWWOOOOOOWWWWWWWWWWWWWWFW

WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW

JAVA数据结构迷宫求解！

#includestdio.h

#includegraphics.h

#includeconio.h

typedef struct{

int x,y;

int dir;

}pos,elem;

typedef struct{

elem* b,* t;

int size;

}stack;

void initstack(stack* s)

{

s-b=(elem*)malloc(50*sizeof(elem));

if(s-b){

s-t=s-b;

s-size=50;

return;

}

exit(0);

}

void push(stack* s,elem* e)

{

*s-t=*e;

s-t++;

}

void pop(stack* s,elem* e)

{

*e=*--s-t;

}

void gettop(stack* s,elem* e)

{

*e=*(s-t-1);

}

void clearstack(stack* s)

{

s-t=s-b;

}

int stackempty(stack* s)

{

return !(s-t-s-b);

}

int destroystack(stack* s)

{

free(s-b);

free(s);

return 1;

}

int mg[10][10]={

{-1,-0,-1,-1,-1,-1,-1,-1,-1,-1},

{-1,-0,-0,-0,-1,-0,-0,-0,-0,-1},

{-1,-0,-1,-0,-1,-0,-1,-1,-0,-1},

{-1,-0,-1,-1,-0,-0,-0,-0,-0,-1},

{-1,-0,-0,-1,-0,-1,-1,-0,-0,-1},

{-1,-0,-0,-0,-0,-0,-1,-0,-0,-1},

{-1,-0,-1,-0,-0,-0,-0,-1,-0,-1},

{-1,-0,-1,-1,-0,-0,-0,-1,-0,-1},

{-1,-0,-0,-0,-1,-0,-0,-1,-0,-0},

{-1,-1,-1,-1,-1,-1,-1,-1,-1,-1}

};

void step(stack* s,pos* cur,stack* result);

void savepath(stack* s,pos* cur,stack* result);

void draw(int y,int x);

void step(stack* s,pos* cur,stack* result)

{

if(stackempty(result)||s-t-s-bresult-t-result-b){

for(cur-dir++;cur-dir5;cur-dir++){

setfillstyle(SOLID_FILL,15);

switch(cur-dir){

case 1:

if(!mg[cur-y-1][cur-x]){

mg[cur-y][cur-x]=1;

push(s,cur);

cur-y--;

cur-dir=0;

draw(cur-y,cur-x);

return;

}

break;

case 2:

if(!mg[cur-y][cur-x+1]){

mg[cur-y][cur-x]=1;

push(s,cur);

cur-x++;

cur-dir=0;

draw(cur-y,cur-x);

return;

}

break;

case 3:

if(!mg[cur-y+1][cur-x]){

mg[cur-y][cur-x]=1;

push(s,cur);

cur-y++;

cur-dir=0;

draw(cur-y,cur-x);

return;

}

break;

case 4:

if(!mg[cur-y][cur-x-1]){

mg[cur-y][cur-x]=1;

push(s,cur);

cur-x--;

cur-dir=0;

draw(cur-y,cur-x);

return;

}

break;

default:

exit(0);

}

mg[cur-y][cur-x]=0;

setfillstyle(SOLID_FILL,0);

draw(cur-y,cur-x);

pop(s,cur);

}

void savepath(stack* s,pos* cur,stack* result)

{

pos* top=s-t;

if(stackempty(result)){

push(result,cur);

while(tops-b)

push(result,--top);

}

else if(result-t-result-bs-t-s-b){

clearstack(result);

push(result,cur);

while(tops-b)

push(result,--top);

}

void draw(int y,int x)

{

bar(100+15*x,100+15*y,115+15*x,115+15*y);

}

void main(void)

{

int i;

int x,y;

int gd=DETECT,gm;

stack* s=NULL;

stack* result=NULL;

pos* cur=NULL;

initgraph(gd,gm,"");

for(x=0;x10;x++)

for(y=0;y10;y++){

if(mg[y][x]){

setfillstyle(SOLID_FILL,3);

draw(y,x);

}

result=(stack*)malloc(sizeof(stack));

initstack(result);

s=(stack*)malloc(sizeof(stack));

cur=(pos*)malloc(sizeof(pos));

initstack(s);

cur-x=1;

cur-y=0;

cur-dir=0;

push(s,cur);

cur-x=1;

cur-y=1;

cur-dir=1;

do{

if(cur-x==9cur-y==8)

savepath(s,cur,result);

step(s,cur,result);

}while(!stackempty(s));

if(stackempty(result))

printf("no way available");

else{

int ch=0;

printf("following is the shortest path:\n");

while(!stackempty(result)){

pop(result,cur);

setfillstyle(SOLID_FILL,15);

draw(cur-y,cur-x);

if(ch5){

putchar('\n');

ch=0;

}

printf("(%d,%d,%d) ",cur-x,cur-y,cur-dir);

ch++;

}

printf("\n");

destroystack(s);

destroystack(result);

free(cur);

printf("Press any key to end");

while(!kbhit());

closegraph();

}

用java语言控制小机器人走迷宫的算法?

我昨天刚写了个走迷宫的界面(一个初始小球，一个目标小球，随机在界面种生成障碍(迷宫图)，然后初始小球移动到目标小球那)，不知道是否跟你的想法一样。用的是回溯法(目前我只知道这个算法走迷宫)，你可以查下。PS:我电脑没联网不能把代码给你…QQ254774042。

java迷宫图形界面

这是我之前课程设计做的一个迷宫，Swing做的，发在javaeye的博客上了，有打包成jar的，安装了jdk可以直接双击运行，有源码，还有我写的一个说明文档，网址如下：

自己下载下吧，我就不给你发到邮箱了。

关于回忆迷宫java和回忆迷宫的孩子谁演的的介绍到此就结束了，不知道你从中找到你需要的信息了吗？如果你还想了解更多这方面的信息，记得收藏关注本站。

标签：回忆迷宫java