A. 急求大佬帮忙写一下java程序
递归的话就是深度优先搜索（可以理解成不撞南墙不回头，撞了墙就原路返回）可以加上剪枝（就是做标记，如果之前某一次走过但不通的路下次再走到就不用走了）
用栈的话应该是广度优先搜索（大概就是分裂无数个你，每次向所有方向走一步），不过广搜要用队列实现，用栈本质还是深搜了
具体算法可以搜网络
B. 用java语言控制小机器人走迷宫的算法
我昨天刚写了个走迷宫的界面(一个初始小球，一个目标小球，随机在界面种生成障碍(迷宫图)，然后初始小球移动到目标小球那)，不知道是否跟你的想法一样。用的是回溯法(目前我只知道这个算法走迷宫)，你可以查下。PS:我电脑没联网不能把代码给你…QQ254774042。
C. Java迷宫算法问题（用栈实现）有算法简述
importjava.io.File;
importjava.io.FileNotFoundException;
importjava.util.HashSet;
importjava.util.LinkedList;
importjava.util.List;
importjava.util.Scanner;
publicclassTest{
publicstaticvoidmain(String[]args)throwsFileNotFoundException{
Scannerinput=newScanner(newFile("Maze2tong.txt"));
introw=0;
char[][]Mazemap=newchar[12][58];
while(input.hasNext()){
Stringline=input.nextLine();
for(intcolumn=0;column<=line.length()-1;column++){
charc=line.charAt(column);
Mazemap[row][column]=c;
}
row++;
}
for(inti=0;i<12;i++){
for(intj=0;j<58;j++){
System.out.print(Mazemap[i][j]);
}
System.out.print(" ");
}
LinkedList<TwoTuple<Integer,Integer>>trace=newLinkedList<TwoTuple<Integer,Integer>>();
System.out.println(maze(Mazemap,trace));
System.out.println(trace);
}
publicstaticbooleanmaze(char[][]maze,
List<TwoTuple<Integer,Integer>>trace){
LinkedList<TwoTuple<Integer,Integer>>path=newLinkedList<TwoTuple<Integer,Integer>>();
HashSet<TwoTuple<Integer,Integer>>traverse=newHashSet<TwoTuple<Integer,Integer>>();
for(inti=0;i<maze.length;i++){
for(intj=0;j<maze[i].length;j++){
if(maze[i][j]=='S'){
path.add(newTwoTuple<Integer,Integer>(i,j));
}
}
}
while(!path.isEmpty()){
TwoTuple<Integer,Integer>temp=path.pop();
if(traverse.contains(temp)){
continue;
}elseif(maze[temp.first][temp.second]=='F'){
trace.add(temp);
returntrue;
}elseif(!traverse.contains(temp)){
if(temp.second+1<maze[temp.first].length
&&maze[temp.first][temp.second+1]!='W')
path.add(newTwoTuple<Integer,Integer>(temp.first,
temp.second+1));
if(temp.second-1>0
&&maze[temp.first][temp.second-1]!='W')
path.add(newTwoTuple<Integer,Integer>(temp.first,
temp.second-1));
if(temp.first+1<maze.length
&&maze[temp.first+1][temp.second]!='W')
path.add(newTwoTuple<Integer,Integer>(temp.first+1,
temp.second));
if(temp.first-1>0
&&maze[temp.first-1][temp.second]!='W')
path.add(newTwoTuple<Integer,Integer>(temp.first-1,
temp.second));
traverse.add(temp);
trace.add(temp);
}
}
trace.clear();
returnfalse;
}
}
classTwoTuple<A,B>{
publicfinalAfirst;
publicfinalBsecond;
publicTwoTuple(Aa,Bb){
first=a;
second=b;
}
@Override
publicinthashCode(){
returnfirst.hashCode()+second.hashCode();
}
@Override
publicbooleanequals(Objectobj){
if(!(objinstanceofTwoTuple)){
}
returnobjinstanceofTwoTuple&&first.equals(((TwoTuple)obj).first)
&&second.equals(((TwoTuple)obj).second);
}
publicStringtoString(){
return"("+first+","+second+")";
}
}///:-
importjava.io.File;
importjava.io.FileNotFoundException;
importjava.util.LinkedList;
importjava.util.Scanner;
classMyPoint
{
publicbooleanvisited=false;
publicintparentRow=-1;
publicintparentColumn=-1;
publicfinalcharcontent;
publicintx;
publicinty;
publicMyPoint(charc,intx,inty)
{
this.content=c;
this.x=x;
this.y=y;
}
}
publicclassMaze
{
publicstaticMyPoint[][]getMazeArray(){
Scannerinput=null;
MyPoint[][]mazemap=newMyPoint[12][58];
try{
input=newScanner(newFile("Maze2tong.txt"));
introw=0;
while(input.hasNext()){
Stringline=input.nextLine();
for(intcolumn=0;column<=line.length()-1;column++){
charc=line.charAt(column);
MyPointpoint=newMyPoint(c,row,column);
mazemap[row][column]=point;
}
row++;
}
input.close();
}catch(FileNotFoundExceptione){
e.printStackTrace();
}
returnmazemap;
}
publicstaticbooleantomRun(MyPoint[][]maze,MyPointend)
{
intx=maze.length;
inty=maze[0].length;
LinkedList<MyPoint>stack=newLinkedList<MyPoint>();
for(inti=0;i<maze.length;i++){
for(intj=0;j<maze[i].length;j++){
if(maze[i][j].content=='S'){
stack.push(maze[i][j]);
maze[i][j].visited=true;
}
}
}
booleanresult=false;
while(!stack.isEmpty())
{
MyPointt=stack.pop();
//System.out.println("poppoint:"+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;
}
}
returnresult;
}
publicstaticvoidshow(intx,inty,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+"]");
}
publicstaticvoidmain(String[]args)
{
MyPoint[][]maze=getMazeArray();
MyPointpoint=newMyPoint('c',1,1);
if(tomRun(maze,point))
{
System.out.println("逃生路径如下：");
show(point.x,point.y,maze);
}
else
System.out.println("无法走出迷宫！");
}
}
D. 求用java语言寻找走出迷宫路线的算法
首先给定一个初始坐标，然后构建一个容器保存坐标值，之后进行迭代，横坐标+1，或者纵坐标+1，这个顺寻自己定义（四个方向），经过的“路径”保存在那个容器中，如果遇到死角，以此往回迭代，在容器中将遇到死角的那个坐标删除。最后找到自己定义的那个迷宫出口坐标。
E. java迷宫程序代码
qq你了
F. 请帮忙用数据结构（java版）的知识解决这道迷宫问题的程序代码。
我这是用c写的。你可以看看，希望能帮助到你。
#include"stdlib.h"
#include"stdio.h"
#define N 50
#define M 50
int X;
int maze[N+2][M+2];
struct point{
int row,col,predecessor;
}queue[512];
int head=0,tail=0;
void shoudong_maze(int m,int n){
int i,j;
printf("\n\n");
printf("请按行输入迷宫，0表示通路，1表示障碍:\n\n");
for(i=0;i<m;i++)
for(j=0;j<n;j++)
scanf("%d",&maze[i][j]);
}
void zidong_maze(int m,int n){
int i,j;
printf("\n迷宫生成中……\n\n");
system("pause");
for(i=0;i<m;i++)
for(j=0;j<n;j++)
maze[i][j]=rand()%2;
//由于rand()产生的随机数是从0到RAND_MAX
//RAND_MAX是定义在stdlib.h中的,其值至少为32767)
//要产生从X到Y的数,只需要这样写：k=rand()%(Y-X+1)+X;
}
void print_maze(int m,int n){
int i,j;
printf("\n迷宫生成结果如下:\n\n");
printf("迷宫入口\n");
printf("↓");
for(i=0;i<m;i++)
{printf("\n");
for(j=0;j<n;j++)
{if(maze[i][j]==0) printf("□");
if(maze[i][j]==1) printf("■");}
}
printf("→迷宫出口\n");
}
void result_maze(int m,int n)
{ int i,j;
printf("迷宫通路(用☆表示)如下所示：\n\t");
for(i=0;i<m;i++)
{ printf("\n");
for(j=0;j<n;j++)
{if(maze[i][j]==0||maze[i][j]==2) printf("□");
if(maze[i][j]==1) printf("■");
if(maze[i][j]==3) printf("☆");
}
}
}
void enqueue(struct point p)
{ queue[tail]=p;
tail++;
}
struct point dequeue()
{ head++;
return queue[head-1];
}
int is_empty()
{ return head==tail;
}
void visit(int row,int col,int maze[52][52])
{ struct point visit_point={row,col,head-1};
maze[row][col]=2;
enqueue(visit_point);
}
int mgpath(int maze[52][52],int m,int n)
{ X=1;
struct point p={0,0,-1};
if(maze[p.row][p.col]==1)
{ printf("\n===============================================\n");
printf("此迷宫无解\n\n");X=0;return 0;}
maze[p.row][p.col]=2;
enqueue(p);
while(!is_empty())
{p=dequeue();
if((p.row==m-1)&&(p.col==n-1)) break;
if((p.col+1<n)&&(maze[p.row][p.col+1]==0)) visit(p.row,p.col+1,maze);
if((p.row+1<m)&&(maze[p.row+1][p.col]==0)) visit(p.row+1,p.col,maze);
if((p.col-1>=0)&&(maze[p.row][p.col-1]==0)) visit(p.row,p.col-1,maze);
if((p.row-1>=0)&&(maze[p.row-1][p.col]==0)) visit(p.row-1,p.col,maze);
}
if(p.row==m-1&&p.col==n-1)
{printf("\n==================================================================\n");
printf("迷宫路径为：\n");
printf("(%d,%d)\n",p.row,p.col);
maze[p.row][p.col]=3;
while(p.predecessor!=-1)
{p=queue[p.predecessor];
printf("(%d,%d)\n",p.row,p.col);
maze[p.row][p.col]=3;
}
}
else {printf("\n=============================================================\n");
printf("此迷宫无解！\n\n");X=0;}
return 0;
}
int main()
{int i,m,n,cycle=0;
while(cycle!=(-1))
{
printf("********************************************************************************\n");
printf(" ☆欢迎进入迷宫求解系统☆\n");
printf(" 设计者:尹旭 林静波（信息2班）\n");
printf("********************************************************************************\n");
printf(" 手动生成迷宫 请按：1\n");
printf(" 自动生成迷宫 请按：2\n");
printf(" 退出 请按：3\n\n");
printf("********************************************************************************\n");
printf("\n");
printf("请选择你的操作：\n");
scanf("%d",&i);
switch(i)
{case 1:printf("\n请输入行数：");
scanf("%d",&m);
printf("\n");
printf("请输入列数：");
scanf("%d",&n);
while((m<=0||m>50)||(n<=0||n>50))
{ printf("\n抱歉，你输入的行列数超出预设范围(0-50,0-50),请重新输入：\n\n");
printf("请输入行数：");
scanf("%d",&m);
printf("\n");
printf("请输入列数：");
scanf("%d",&n);
}
shoudong_maze(m,n);
print_maze(m,n);
mgpath(maze,m,n);
if(X!=0)
result_maze(m,n);
printf("\n\nPress Enter Contiue!\n");
getchar();
while(getchar()!='\n');
break;
case 2:printf("\n请输入行数：");
scanf("%d",&m);
printf("\n");
printf("请输入列数：");
scanf("%d",&n);
while((m<=0||m>50)||(n<=0||n>50))
{printf("\n抱歉，你输入的行列数超出预设范围(0-50,0-50),请重新输入：\n\n");
printf("请输入行数：");
scanf("%d",&m);
printf("\n");
printf("请输入列数：");
scanf("%d",&n);
}
zidong_maze(m,n);
print_maze(m,n);
mgpath(maze,m,n);
if(X!=0)
result_maze(m,n);
printf("\n\nPress Enter Contiue!\n");getchar();while(getchar()!='\n');break;
case 3:cycle=(-1);
break;
default:printf("\n");
printf("你的输入有误!\n");
printf("\nPress Enter Contiue!\n");
getchar();
while(getchar()!='\n');break;
}
}
}
G. 求助，关于用java实现A*算法的迷宫寻路
首先，你要知道走迷宫的思路：就是遇到岔路都往一个方向，比如往右，遇到死路就回头，回头遇到岔路继续往右。
H. 求走迷宫问题的算法，要求用Java写的
public class Maze { private int[][] maze = null;
private int[] xx = { 1, 0, -1, 0 };
private int[] yy = { 0, 1, 0, -1 };
private Queue queue = null; public Maze(int[][] maze) {
this.maze = maze;
queue = new Queue(maze.length * maze.length);
} public void go() {
Point outPt = new Point(maze.length - 1, maze[0].length - 1);
Point curPt = new Point(0, 0);
Node curNode = new Node(curPt, null);
maze[curPt.x][curPt.y] = 2;
queue.entryQ(curNode); while (!queue.isEmpty()) {
curNode = queue.outQ();
for (int i = 0; i < xx.length; ++i) {
Point nextPt = new Point();
nextPt.x = (curNode.point).x + xx[i];
nextPt.y = (curNode.point).y + yy[i];
if (check(nextPt)) {
Node nextNode = new Node(nextPt, curNode);
queue.entryQ(nextNode);
maze[nextPt.x][nextPt.y] = 2;
if (nextPt.equals(outPt)) {
java.util.Stack<Node> stack = new java.util.Stack<Node>();
stack.push(nextNode);
while ((curNode = nextNode.previous) != null) {
nextNode = curNode;
stack.push(curNode);
}
System.out.println("A Path is:");
while (!stack.isEmpty()) {
curNode = stack.pop();
System.out.println(curNode.point);
}
return;
}
}
}
}
System.out.println("Non solution!");
} private boolean check(Point p) {
if (p.x < 0 || p.x >= maze.length || p.y < 0 || p.y >= maze[0].length) {
return false;
}
if (maze[p.x][p.y] != 0) {
return false;
}
return true;
} public static void main(String[] args) {
int[][] maze = {
{ 0, 0, 1, 0, 1, 0, 1, 0, 1, 0 },
{ 0, 0, 1, 1, 1, 0, 0, 0, 1, 0 },
{ 0, 1, 0, 0, 1, 0, 0, 0, 0, 1 },
{ 0, 0, 0, 0, 1, 0, 0, 0, 1, 1 },
{ 0, 0, 1, 0, 0, 0, 0, 0, 0, 1 },
{ 1, 0, 1, 0, 1, 0, 0, 1, 0, 0 },
{ 0, 1, 0, 0, 1, 0, 0, 1, 0, 1 },
{ 1, 0, 1, 0, 1, 1, 0, 1, 0, 0 }
};
new Maze(maze).go();
} private class Queue { Node[] array = null;
int size = 0;
int len = 0;
int head = 0;
int tail = 0; public Queue(int n) {
array = new Node[n + 1];
size = n + 1;
} public boolean entryQ(Node node) {
if (isFull()) {
return false;
}
tail = (tail + 1) % size;
array[tail] = node;
len++;
return true;
} public Node outQ() {
if (isEmpty()) {
return null;
}
head = (head + 1) % size;
len--;
return array[head];
} public boolean isEmpty() {
return (len == 0 || head == tail) ? true : false;
} public boolean isFull() {
return ((tail + 1) % size == head) ? true : false;
}
} private class Node { Point point = null;
Node previous = null; public Node() {
this(null,null);
} public Node(Point point, Node node) {
this.point = point;
this.previous = node;
}
} private class Point { int x = 0;
int y = 0; public Point() {
this(0, 0);
} public Point(int x, int y) {
this.x = x;
this.y = y;
} public boolean equals(Point p) {
return (x == p.x) && (y == p.y);
} @Override
public String toString() {
return "(" + x + "," + y + ")";
}
}
}
I. 求Java关于迷宫的算法（用栈实现）
packagecom.Albert.LabyringhStack;
publicclassPoint{
intx;
inty;
intdirection;//direction指向此点附近的一个点应该有四个编号为1234
publicintgetX(){
returnx;
}
publicvoidsetX(intx){
this.x=x;
}
publicintgetY(){
returny;
}
publicvoidsetY(inty){
this.y=y;
}
publicintgetDirection(){
returndirection;
}
publicvoidsetDirection(intdirection){
this.direction=direction;
}
publicvoidaddDirection(){
this.direction++;
}
publicPoint(){
}
publicPoint(intx,inty){
super();
this.x=x;
this.y=y;
this.direction=1;
}
publicPoint(intx,inty,intdirection){
super();
this.x=x;
this.y=y;
this.direction=direction;
}
}
packagecom.Albert.LabyringhStack;
importjava.util.*;
publicclassLabyringhStack{
publicPointS;
publicPointF;
char[][]mazemap;
Stack<Point>path;
publicLabyringhStack(){
}
publicLabyringhStack(char[][]ma){//初始化存入数组
this.mazemap=newchar[ma.length][ma[0].length];
for(inti=0;i<ma.length;i++){
for(intj=0;j<ma[0].length;j++){//mazemap[0]必须有元素不可为空
this.mazemap[i][j]=ma[i][j];
}
}
S=returnPlace('S');
F=returnPlace('F');
}
publicPointreturnPlace(chars){//返回数组中字符的位置
Pointpoint=newPoint();
for(inti=0;i<this.mazemap.length;i++){
for(intj=0;j<this.mazemap[0].length;j++){//mazemap[0]必须有元素不可为空
if(this.mazemap[i][j]==s)
{point.setX(i);
point.setY(j);
point.setDirection(1);
}
}
}
returnpoint;
}
publiccharreturnChar(Pointpoint){
if(point.getX()>=0&&point.getY()>=0)
returnthis.mazemap[point.getX()][point.getY()];
else
return'#';
}
publicvoidreplacePlace(Pointpoint,chars){//更改特定位置处的字符
mazemap[point.getX()][point.getY()]=s;
}
publicvoidprintPath(){
Stack<Point>tempPath=newStack<Point>();
while(!path.empty()){//对栈进行反序
tempPath.push(path.pop());
}
while(!tempPath.empty()){
System.out.print("("+tempPath.peek().getX()+","+tempPath.pop().getY()+")");
}
}
publicbooleangetPath(){//取得路径的算法如果有路径就返回真
path=newStack<Point>();
S.setDirection(1);
path.push(S);
replacePlace(S,'X');
while(!path.empty()){
PointnowPoint=path.peek();//取得当前位置
if(nowPoint.getX()==F.getX()&&nowPoint.getY()==F.getY()){
//printPath();
returntrue;
}
Pointtemp=newPoint();//存放下一个可走的位置
intfind=0;//标志是否可向下走
while(nowPoint.getDirection()<5&&find==0){
switch(nowPoint.getDirection()){
case1:temp=newPoint(nowPoint.getX(),nowPoint.getY()-1,1);break;//取得当前位置左边的位置
case2:temp=newPoint(nowPoint.getX()+1,nowPoint.getY(),1);break;//取得当前位置下边的位置
case3:temp=newPoint(nowPoint.getX(),nowPoint.getY()+1,1);break;//取得当前位置右边的位置
case4:temp=newPoint(nowPoint.getX()-1,nowPoint.getY(),1);break;//取得当前位置上边的位置
}
nowPoint.addDirection();//指向下一个需要验证的点
if(returnChar(temp)=='O'||returnChar(temp)=='F')find=1;//如果能向下走则置为1
}
if(find==1){//如果可走就进栈
replacePlace(temp,'X');//设置成X防止回走
// printArr();
path.push(temp);
}else{//如果不可走就退栈
replacePlace(nowPoint,'O');
path.pop();
}
}
returnfalse;
}
publicvoidprintArr(){
for(inti=0;i<mazemap.length;i++){
for(intj=0;j<mazemap[0].length;j++){//mazemap[0]必须有元素不可为空
System.out.print(mazemap[i][j]);
}
System.out.println();
}
System.out.println();
}
}
packagecom.Albert.LabyringhStack;
publicclassMain{
/**
*@paramargs
*/
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
char[][]mazemap={
{'M','M','M','M','M','M','M','M'},
{'M','S','O','O','M','M','M','M'},
{'M','M','M','O','M','M','M','M'},
{'M','M','O','O','O','O','M','M'},
{'M','M','M','M','M','F','M','M'},
{'M','M','M','M','M','M','M','M'},
{'M','M','M','M','M','M','M','M'}
};
LabyringhStacksolution=newLabyringhStack(mazemap);
if(solution.getPath()){
System.out.print("迷宫路径如下：");
solution.printPath();
}
else{
System.out.println("没有可走的路");
}
}
}
J. JAVA机器人走迷宫的编程——急求！
深度优先的迷宫图算法。
N年前的老问题了。
10分不值得做。