用java写了段走迷宫的代码，show一下吧，呵呵

[leonwu1981]

以前玩rpg游戏最烦的就是迷宫了，不过当时我就摸索出对付出口在迷宫边上的方法了，就是靠着墙走。最近看数据结构，就按照当年的思路写了解决方法。以后会常来这里学习，先混个脸熟吧

/*走迷宫。思路是紧贴着墙的某一边走。如果开始靠错了墙或者迷宫出口不在迷宫边上就不保证正确
*了。如果要完善点的话我想把走过的路和方向用数组记下来，如果有重复的话就找另外一堵墙靠。
*/
public class Maze {
int[][] maze;
int[] start = {//启始点坐标
0, 0};
int[] end = {//终点坐标
7, 7};
final static int UP = 0;//移动方向
final static int RIGHT = 1;
final static int DOWN = 2;
final static int LEFT = 3;
int[] road;//当前点

public Maze() {
this(new int[][] { {//默认迷宫
0, 0, 1, 0, 0, 0, 1, 0}
, {
0, 0, 1, 0, 0, 0, 1, 0}
, {
0, 0, 0, 0, 1, 1, 0, 0}
, {
0, 1, 1, 1, 0, 0, 0, 1}
, {
0, 0, 0, 1, 0, 0, 0, 1}
, {
0, 1, 0, 0, 0, 1, 0, 0}
, {
1, 1, 1, 1, 0, 1, 1, 0}
, {
0, 0, 0, 0, 0, 0, 0, 0}
}
);
}

public Maze(int[][] maze) {
this.maze = maze;
road = new int[]{start[0] , start[1] , UP};
System.out.println("Start:");
System.out.println(road[0] + "" + road[1]);
while (road[0] != end[0] || road[1] != end[1]) {//走到终点？
switch (road[2]) {
case UP:
if (canUp()) {
goUp();
}
else {
road[2] = (road[2] + 1) % 4;
}
break;
case RIGHT:
if (canRight()) {
goRight();
}
else {
road[2] = (road[2] + 1) % 4;
}
break;
case DOWN:
if (canDown()) {
goDown();
}
else {
road[2] = (road[2] + 1) % 4;
}
break;
case LEFT:
if (canLeft()) {
goLeft();
}
else {
road[2] = (road[2] + 1) % 4;
}
break;
}
}
System.out.println("OK!");
}

public boolean canUp() {
if (road[0] > 0 && maze[road[0] - 1][road[1]] != 1) {
return true;
}
return false;
}

public void goUp() {
road[0] = road[0] - 1;
road[2] = (UP + 3) % 4;//保持贴着墙壁的一边走
System.out.println(road[0] + "" + road[1]);

}

public boolean canRight() {
if (road[1] < 7 && maze[road[0]][road[1] + 1] != 1) {
return true;
}
return false;
}

public void goRight() {
road[1] = road[1] + 1;
road[2] = (RIGHT + 3) % 4;
System.out.println(road[0] + "" + road[1]);
}

public boolean canDown() {
if (road[0] < 7 && maze[road[0] + 1][road[1]] != 1) {
return true;
}
return false;
}

public void goDown() {
road[0] = road[0] + 1;
road[2] = (DOWN + 3) % 4;
System.out.println(road[0] + "" + road[1]);

}

public boolean canLeft() {
if (road[1] > 0 && maze[road[0]][road[1] - 1] != 1) {
return true;
}
return false;
}

public void goLeft() {
road[1] = road[1] - 1;
road[2] = (LEFT + 3) % 4;
System.out.println(road[0] + "" + road[1]);

}

public static void main(String[] args) {
Maze ma = new Maze();
}
}

[zzwu]

up!

(让大家来学习)

[xiaoyao008]

up 如果出口在中央那么怎么走哇！求教！！

[fanever]

广搜就OK了，只要O(N^2)，而且找到的是最短路径哦

[jp1984]

copy的

[instruction]

算法好象和高程教材上的差不多？

[firstsee]

A*搜索就可以了

[tograk_1]

能不能加一个功能？ 就是：你试过的路径和真正走的路径分出来，比如：
头部加这个：private final int TRIED=3;
private final int PATH=7;

结构为：这通路是1，不同路数0；
1110110001111
1011101111001
0000101010100
1110111010111
1010000111001
1011111101111
1000000000000
1111111111111

The maze was successfully traversed.

7770110001111
3077707771001
0000707070300
7770777070333
7070000773003
7077777703333
7000000000000
7777777777777


还有如果没有通路就输出“没有通路”
要加这个功能怎么弄?
请教一下，谢谢！

[tograk_1]

希望快点回答