Java迷宫寻路

public class MiGong {
    public static void main(String[] args) {
        //初始化迷宫地图
        int[][] map = new int[8][7];
        //遍历第一行和最后一行的墙壁
        for (int i = 0;i < 7;i++){
            map[0][i] = 1;
            map[7][i] = 1;
        }
        //遍历第一列和最后一列
        for (int i = 0; i < 8; i++) {
            map[i][0] = 1;
            map[i][6] = 1;
        }
        //增加两面墙
        map[3][1] = 1;
        map[3][2] = 1;
        map[2][2] = 1;
        //遍历地图
        System.out.println("初始地图:");
        for (int i = 0; i < 8;i++){
            for (int j = 0; j < 7; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }
        setWay(map,1,1);
        System.out.println("寻路后地图:");
        for (int i = 0; i < 8;i++){
            for (int j = 0; j < 7; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }
    }

    //使用递归回溯算法来找路
    //说明
    //1.map表示地图
    //2.i,j表示从地图的哪个地方开始出发
    //3.如果小球能到map[6][5]说明,找到出路
    //4.约定:当map[i][j]为0时表示该点没有走过,当为1时表示围墙,2表示可以走,3表示已经走过但走不通
    //5.在走迷宫时,需要确定一个策略 下->右->上->左,如果该点走不通,再回溯

    public static boolean setWay(int[][] map,int i,int j){
        if (map[6][5] == 2){
            return true;
        }else {
            if (map[i][j] == 0){//表示这个点还没有走过
                //按照策略走
                map[i][j] = 2;//假设能走通
                if (setWay(map,i+1,j)){
                    return true;
                }else if (setWay(map,i,j+1)){
                    return true;
                }else if (setWay(map,i-1,j)){
                    return true;
                }else if (setWay(map,i,j-1)){
                    return true;
                }else {
                    //说明该点走不通是死路
                    map[i][j] = 3;
                    return false;
                }
            }else {
                //说明该点为1,2,3 走不通
                return false;
            }
        }
    }

}
  • 3
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java中,迷宫单步通常涉及到图形算法中的径搜索,比如广度优先搜索(Breadth-First Search, BFS)或深度优先搜索(Depth-First Search, DFS)。单步算法会在给定的迷宫矩阵中找从起点到终点的最短径,每次只移动一步。这里我将简要讲解BFS方法,因为BFS通常是解决此类问题的理想选择,因为它保证了找到的是最短径。 **BFS算法步骤**: 1. **初始化**:创建一个队列,将起点加入队列,并设置起点为已访问状态。 2. **循环**:从队列中取出第一个位置,检查是否是终点。如果是,则返回径;如果不是,将当前位置的所有相邻未访问的格子加入队列,并标记为已访问。 3. **递归**:对每个新加入队列的位置,重复步骤2。 4. **终止条件**:如果队列为空且没有找到终点,说明没有径。 **Java代码示例**(简化版): ```java import java.util.LinkedList; import java.util.Queue; public class MazeSolver { private boolean[][] maze; // 迷宫矩阵 private int startX, startY, endX, endY; // 起点和终点坐标 private boolean[][] visited; // 记录已访问的节点 public boolean solveMaze(int startX, int startY, int endX, int endY) { this.startX = startX; this.startY = startY; this.endX = endX; this.endY = endY; visited = new boolean[maze.length][maze.length]; Queue<int[]> queue = new LinkedList<>(); queue.offer(new int[]{startX, startY}); visited[startX][startY] = true; while (!queue.isEmpty()) { int[] current = queue.poll(); if (current == endX && current == endY) { return printPath(current); } for (int[] neighbor : getNeighbors(current)) { if (!visited[neighbor][neighbor]) { visited[neighbor][neighbor] = true; queue.offer(neighbor); } } } return false; // 没有找到径 } private boolean printPath(int[] current) { System.out.println("找到了径: "); // 假设从左上角开始打印,逆序输出径 // 在实际应用中,你需要根据你的需求调整这部分逻辑 // 例如,按照DFS反向跟踪记录径 return true; } private int[][] getNeighbors(int[] position) { // 返回给定位置的上下左右邻居 // 根据迷宫的边界条件进行判断 } } ```

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值