一直低头写业务代码,对算法也有一些忘记,最近在网上也看了一些资料,通过广度优先算法实现走迷宫。
java:
一步:模拟一些数据
private static int[][] getDate() {
int[][] maze = new int[6][8];
String s1 = "0 1 0 0 0 1 0 0";
String s2 = "0 0 0 0 0 1 0 0";
String s3 = "0 1 0 0 0 1 0 0";
String s4 = "0 1 0 0 0 0 0 0";
String s5 = "0 1 0 0 0 1 0 0";
String s6 = "0 1 0 0 0 1 0 0";
for (int i = 0; i < 6; i++) {
switch (i) {
case 0:
maze[i] = getStrtoNum(s1);
break;
case 1:
maze[i] = getStrtoNum(s2);
break;
case 2:
maze[i] = getStrtoNum(s3);
break;
case 3:
maze[i] = getStrtoNum(s4);
break;
case 4:
maze[i] = getStrtoNum(s5);
break;
case 5:
maze[i] = getStrtoNum(s6);
break;
}
}
return maze;
}
private static int[] getStrtoNum(String str) {
String[] strArr = str.split(" ");
int[] t = new int[strArr.length];
for (int i = 0; i < t.length; i++) {
t[i] = Integer.parseInt(strArr[i]);
}
return t;
}
定义点位的内部类:
static class point {
private int i;
private int j;
public point(int i, int j) {
this.i = i;
this.j = j;
}
public int getI() {
return i;
}
public void setI(int i) {
this.i = i;
}
public int getJ() {
return j;
}
public void setJ(int j) {
this.j = j;
}
public boolean compare(point p) {
if (this.i == p.i && this.j == p.j) return true;
return false;
}
}
//区域,这里特别重要,代码着当前点的上、左、下、右四个点,在跑代码时是以此四个点位进行上、左、下右逐步向外扩散的,四个基础点位
private static LinkedList<point> dirs;
static {
dirs = new LinkedList<>();
dirs.add(new point(-1, 0));
dirs.add(new point(0, -1));
dirs.add(new point(1, 0));
dirs.add(new point(0, 1));
}
// 这个是获取当前点位时,加上基础点位后的偏移点位,返回的点位是要探索的点位
private static point add(point cur, point dir) {
return new point(cur.getI() + dir.getI(), cur.getJ() + dir.getJ());
}
// 这里是返回探索的点位,是否已经走,是否在迷宫之外,以及当前点位的值是多少
private static Map<String, Object> at(int[][] maze, point next) {
Map<String, Object> map = new HashMap<>();
if (next.i < 0 || next.i >= maze.length) {
map.put("val", 0);
map.put("flag", false);
} else if (next.j < 0 || next.j >= maze[next.i].length) {
map.put("val", 0);
map.put("flag", false);
} else {
try {
map.put("val", maze[next.i][next.j]);
map.put("flag", true);
} catch (ArrayIndexOutOfBoundsException e) {
e.printStackTrace();
}
}
return map;
}
// 走迷宫的业务代码,
private static int[][] walk(int[][] maze, point start, point end) {
int[][] steps = new int[maze.length][maze[0].length];
LinkedList<point> Q = new LinkedList<>();
Q.offer(start);
point next;
while (Q.size() > 0) {
point cur = Q.pollFirst();
// 判断当前点位是为是结束点位
if (cur.compare(end)) break;
for (point dir : dirs) {
next = add(cur, dir);
Map<String, Object> result = at(maze, next);
// 当前点位,是否允许走
if (Integer.parseInt(result.get("val").toString()) == 1 || !Boolean.parseBoolean(result.get("flag").toString())) {
continue;
}
//判断当前点位,是否已经被走无
result = at(steps, next);
if (Integer.parseInt(result.get("val").toString()) != 0 || !Boolean.parseBoolean(result.get("flag").toString())) {
continue;
}
//判断当前点位是否是开始点位
if (start.compare(next)) {
continue;
}
// 当前位置的数据值
result = at(steps, cur);
steps[next.i][next.j] = Integer.parseInt(result.get("val").toString()) + 1;
Q.offer(next);
}
}
return steps;
}
// 入口函数
public static void main(String[] args) {
// write your code here
int[][] maze = getDate();
// 迷宫入口是从那个点开始
point start = new point(0, 0);
// 迷宫结束点
point end = new point(maze.length - 1, maze[0].length);
int[][] steps = walk(maze, start, end);
for (int i = 0; i < steps.length; i++) {
for (int j = 0; j < steps[i].length; j++) {
System.out.printf("%3d", steps[i][j]);
}
System.out.println();
}
}
输入结果:
0 0 4 5 6 0 12 13
1 2 3 4 5 0 11 12
2 0 4 5 6 0 10 11
3 0 5 6 7 8 9 10
4 0 6 7 8 0 10 11
5 0 7 8 9 0 11 12