Java与算法之(5) - 老鼠走迷宫(深度优先算法)
2016-09-06 13:47
651 查看
小老鼠走进了格子迷宫,如何能绕过猫并以最短的路线吃到奶酪呢?
注意只能上下左右移动,不能斜着移动。
在解决迷宫问题上,深度优先算法的思路是沿着一条路一直走,遇到障碍或走出边界再返回尝试别的路径。
首先用一个二维数组来把迷宫“数字化”。
初始化迷宫,标记猫的位置:
下面这个二维数组用来遍历尝试四个方向的格子:
运行后输出:
注意只能上下左右移动,不能斜着移动。
在解决迷宫问题上,深度优先算法的思路是沿着一条路一直走,遇到障碍或走出边界再返回尝试别的路径。
首先用一个二维数组来把迷宫“数字化”。
int[][] maze = new int[5][4];迷宫中每个格子的横纵坐标对应数组的一维和二维索引,例如最左上角的格子是maze[0][0],数组的值表示该格子是否可以通过,0表示可以通过,1表示该格子有猫。
初始化迷宫,标记猫的位置:
this.maze[2][0] = 1; this.maze[1][2] = 1; this.maze[2][2] = 1; this.maze[3][2] = 1;起点位置坐标是x=0,y=0,如果向右移动就是x=x+1,y=y,向下移动是x=x,y=y+1。我们预先规定每到一个格子都按照右、下、左、上的顺序尝试下一个格子是否能走,如果右边的格子没有猫且未出边界,就移动到下一个格子,继续按照右、下、左、上的顺序尝试;如果右边的格子不能走则尝试下面的格子。
下面这个二维数组用来遍历尝试四个方向的格子:
int[][] next = new int[][] { {1, 0}, {0, 1}, {-1, 0}, {0, -1} };为了不走回头路,我们还需要另外一个二维数组标记哪些格子是已走过的,如果已走过则不能回头。
int[][] mark = new int[5][4];用一个栈记录路径
LinkedList<Integer> map = new LinkedList<>();走格子的思路是:
for(遍历四个方向的格子) { if(格子超出边界 或 格子有猫 或 格子已经走过) { continue; } else { 移动到格子 记录当前格子已走过 记录当前路径 for(以新格子为中心遍历四个方向的格子) { ...... } } }但是我们并不知道要走多少步才能到达目标,也就不知道循环要嵌套多少层,但是可以看出每次新的遍历循环开启后,执行的代码和上一层循环是一样的,所以这里用递归解决。来看完整的代码:
import java.util.LinkedList;
public class DfsRatMaze {
int min = Integer.MAX_VALUE;
int endX = 3; //目标点横坐标
int endY = 3; //目标点纵坐标
int width = 5; //迷宫宽度
int height = 4; //迷宫高度
int[][] maze = new int[5][4];
int[][] mark = new int[5][4];
LinkedList<Integer> map = new LinkedList<>();
public void dfs(int startX, int startY, int step) {
int[][] next = new int[][] { //按右->下->左->上的顺序尝试
{1, 0},
{0, 1},
{-1, 0},
{0, -1}
};
int nextX, nextY;
int posible;
if(startX == endX && startY == endY) {
if(step < min)
min = step;
for(int i = map.size() - 1; i >= 0; i -= 2){
nextX = map.get(i);
nextY = map.get(i - 1);
System.out.print("[" + nextX + "," + nextY + "]");
if(i != 1)
System.out.print("->");
}
System.out.println();
return;
}
for(posible = 0; posible < next.length; posible++) { //按右->下->左->上的顺序尝试
nextX = startX + next[posible][0];
nextY = startY + next[posible][1];
if(nextX < 0 || nextX >= width || nextY < 0 || nextY >= height) { //超出边界
continue;
}
if(maze[nextX][nextY] == 0 && mark[nextX][nextY] == 0) { //非障碍且未标记走过
map.push(nextX);
map.push(nextY);
mark[nextX][nextY] = 1;
dfs(nextX, nextY, step + 1); //递归调用, 移动到下一格
mark[nextX][nextY] = 0;
map.pop();
map.pop();
}
}
}
/*
* 初始化迷宫
*/
public void initMaze() {
this.maze = new int[width][height];
this.mark = new int[width][height];
this.maze[2][0] = 1; this.maze[1][2] = 1; this.maze[2][2] = 1; this.maze[3][2] = 1;
this.mark[0][0] = 1;
//打印迷宫 _表示可通行 *表示障碍 !表示目标
for(int y = 0; y < height; y++) {
for(int x = 0; x < width; x++) {
if(x == endX && y == endY) {
System.out.print("! ");
} else if(this.maze[x][y] == 1) {
System.out.print("* ");
} else {
System.out.print("_ ");
}
}
System.out.println();
}
System.out.println();
}
public static void main(String[] args) {
int startX = 0;
int startY = 0;
DfsRatMaze d = new DfsRatMaze();
d.initMaze();
d.dfs(startX, startY, 0);
if(d.min < Integer.MAX_VALUE)
System.out.println("最少需要" + d.min + "步");
else
System.out.println("目标地点无法到达");
}
}
运行后输出:
[1,0]->[1,1]->[2,1]->[3,1]->[4,1]->[4,2]->[4,3]->[3,3] [1,0]->[1,1]->[2,1]->[3,1]->[3,0]->[4,0]->[4,1]->[4,2]->[4,3]->[3,3] [1,0]->[1,1]->[0,1]->[0,2]->[0,3]->[1,3]->[2,3]->[3,3] [0,1]->[1,1]->[2,1]->[3,1]->[4,1]->[4,2]->[4,3]->[3,3] [0,1]->[1,1]->[2,1]->[3,1]->[3,0]->[4,0]->[4,1]->[4,2]->[4,3]->[3,3] [0,1]->[0,2]->[0,3]->[1,3]->[2,3]->[3,3] 最少需要6步可以看到,程序计算出了所有路线,并找到了最短的路线。而整个代码还不到100行,真是神奇的算法。
相关文章推荐
- 每天一道算法题(六)深度优先算法(DFS)学习及Java实现
- 24点算法的java代码
- 利用高级Java、算法、三角学、分布计算设计自己的智能机器人
- 18位身份证号码校验码的算法(JAVA)
- java数据结构及算法二
- 图象细化算法实现的java applet源代码
- java数据结构及算法三
- 中国农历算法java实现(转自Herong Yang)
- 利用高级Java、算法、三角学、分布计算设计自己的智能机器人--(重锤痛击续2)
- java实现的18位身份证格式验证算法
- 一道微软算法题的java解法
- Java和C#摘要算法实现
- 在java中实现图形学中的直线算法
- 上楼梯算法的java实现(转)
- 图像边缘检测(Canny 算法)的Java实现
- 用Java编写扫雷游戏--算法思考
- FIFO与LRU 算法实现(java)
- Java 算法
- 用java写二叉树的算法
- 用Java实现归并排序(Merge-Sort)算法