精华内容
下载资源
问答
  • 单源最短路(Bellman - Ford算法)宽度优先搜索迷宫最短路径用宽度优先搜索(bfs)相比用深度优先搜索(dfs)的好处在于bfs每次计算都是最短路径不存在重复计算,而dfs每计算出一条可行的路径都要与先前的路径比较,然后...

    单源最短路(Bellman - Ford算法)

    宽度优先搜索

    迷宫最短路径用宽度优先搜索(bfs)相比用深度优先搜索(dfs)的好处在于bfs每次计算都是最短路径不存在重复计算,而dfs每计算出一条可行的路径都要与先前的路径比较,然后储存最短路径。

    而bfs的思想是先计算出围绕起点的所有点的距离并储存起来

    a7e35087982ace113de0068caa441357.png

    S是起点,数字为该点到S的距离

    根据该思想为下题写一段程序

    在N*M的迷宫中,计算出S到G的最短路径

    ‘#’,’.’, ‘S’, 'G’分别表示墙壁、通道、起点、终点

    b447a812c2568fe015a5cdb85f15795f.png

    代码如下:

    import java.util.LinkedList;

    import java.util.Queue;

    import java.util.Scanner;

    public class Main {

    public static void main(String[] args) {

    Scanner sc = new Scanner(System.in);

    int n = sc.nextInt();

    int m = sc.nextInt();

    String t = sc.nextLine();

    char [][] map = new char [n][m];

    int[] begin = new int [2];

    int[] end = new int [2];

    for(int i = 0; i < n; i++) {

    String s = sc.nextLine();

    map[i] = s.toCharArray();

    if(s.contains("S")) {

    begin[0] = i;

    begin[1] = s.indexOf("S");

    }

    if(s.contains("G")) {

    end[0] = i;

    end[1] = s.indexOf("G");

    }

    }

    System.out.println(bfs(map, begin, end));

    }

    public static int bfs(char [][] map, int [] begin, int [] end) {

    //移动的四个方向

    int[] dx = {1, 0, -1, 0};

    int[] dy = {0, 1, 0, -1};

    //用来储存距离到起始点最短路径的二维数组

    int[][] d = new int [map.length][map[0].length];

    //储存未进行处理的点

    Queue que = new LinkedList();

    //将所有的位置都初始化为最大

    for(int i = 0; i < d.length; i++) {

    for(int j = 0; j < d[0].length; j++) {

    d[i][j] = Integer.MAX_VALUE;

    }

    }

    //将起始点放入队列

    que.offer(begin);

    //将起始点最短路径设为0

    d[ begin[0] ][ begin[1] ] = 0;

    //一直循环直到队列为空

    while(!que.isEmpty()) {

    //取出队列中最前端的点

    int [] current = que.poll();

    //如果是终点则结束

    if(current[0] == end[0] && current[1] == end[1]) break;

    //四个方向循环

    for(int i = 0; i < 4; i++) {

    //试探

    int ny = current[0] + dy[i];

    int nx = current[1] + dx[i];

    //判断是否可以走

    if(ny >= 0 && ny < d.length && nx >= 0 && nx < d[0].length && map[ny][nx] != '#' && d[ny][nx] == Integer.MAX_VALUE) {

    //如果可以走,则将该点的距离加1

    d[ny][nx] = d[current[0]][current[1]] + 1;

    //并将该点放入队列等待下次处理

    int[] c = {ny, nx};

    que.offer(c);

    }

    }

    }

    return d[end[0]][end[1]];

    }

    }

    展开全文
  • Java实现迷宫最短路径的BFS算法

    千次阅读 2020-03-31 17:36:27
    利用广度优先遍历算法的特点,由于迷宫每次只能走一格,所以对于任意一个节点,bfs最先到达时一定时最短路径。 package recursion; import java.util.ArrayDeque; import java.util.Deque; import java.util.Stack;...

    点击进入尚硅谷数据结构和算法Java代码导航

    利用广度优先遍历算法的特点,由于迷宫每次只能走一格,所以对于任意一个节点,bfs第一次到达该点时一定是最短路径。

    package recursion;
    
    import java.util.ArrayDeque;
    import java.util.Deque;
    import java.util.Stack;
    
    public class Maze {
    	private class Node{
    		int x;
    		int y;
    		public Node(int x, int y) {
    			this.x = x;
    			this.y = y;
    		}
    	}
    	private int[][] map;
    	//起点
    	private int startX;
    	private int startY;
    	//终点
    	private int endX;
    	private int endY;
    	//代表上下左右四个可能走的方向
    	private int[] dx = {1,0,-1,0};
    	private int[] dy = {0,1,0,-1};
    	public Maze(int[][] map, int startX, int startY, int endX, int endY) {
    		this.map = map;
    		this.startX = startX;
    		this.startY = startY;
    		this.endX = endX;
    		this.endY = endY;
    	}
    	public void print(int[][] map) {
    		for(int i=0; i<map.length; i++) {
    			for(int j=0; j<map[0].length; j++) {
    				System.out.printf("%4d",map[i][j]);
    			}
    			System.out.println();
    		}
    	}
    	//广度优先遍历寻找迷宫所有点的最短路径, x,y是起始点
    	public void bfs() {
    		Deque<Node> quene = new ArrayDeque<Node>();
    		//存储每个点的前驱节点,方便打印最短路径的路线
    		int[][] pre = new  int[this.map.length][this.map[0].length];
    		//存储每个点的最短路径
    		int[][] dis = new  int[this.map.length][this.map[0].length];
    		for(int i=0; i<dis.length; i++) {
    			for(int j=0; j<dis[0].length; j++) {
    				dis[i][j] = 100;
    			}
    		}
    		//将起点入队,起点的距离设为0,并标记为已访问
    		quene.add(new Node(this.startX, this.startY));
    		dis[this.startX][this.startY] = 0;
    		map[this.startX][this.startY] = 2;
    		Node temp;
    		//广度优先遍历所有可访问的点,并记下每个点的最短路径和前驱节点
    		while(!quene.isEmpty()) {
    			temp = quene.poll();
    			//尝试每个点的四个方向
    			for(int i=0; i<4; i++) {
    				int tx = temp.x + dx[i];
    				int ty = temp.y + dy[i];
    				//如果该点没有访问过,将该点入队并标记为访问过
    				if(map[tx][ty] == 0) {
    					//迷宫中每次只能走一步,所以距离加一
    					dis[tx][ty] = dis[temp.x][temp.y] + 1;
    					pre[tx][ty] = i;
    					map[tx][ty] = 2;
    					quene.add(new Node(tx, ty));
    				}
    			}
    		}//到这里dis中存放的就是最短路径,下面时利用pre数组打印路径
    		
    		int a = this.endX;
    		int b = this.endY;
    		System.out.printf("从(%d,%d)到(%d,%d)的最短距离是:%d,路线为:\n",
    				this.startX, this.startY, a, b, dis[a][b]);
    		//倒序访问最短路径的路线并入栈
    		Stack<Node> stack = new Stack<Node>();
    		stack.add(new Node(a, b));
    		while(a != this.startX || b != this.startY) {
    			int da = dx[pre[a][b]];
    			int db = dy[pre[a][b]];
    			a = a - da;
    			b = b - db;
    			stack.add(new Node(a,b));
    		}
    		//出栈的顺序就是从起点到终点的路线
    		while(!stack.isEmpty()) {
    			Node p = stack.pop();
    			System.out.printf("(%d,%d)->",p.x,p.y);
    		}
    	}
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    
    		//创建一个迷宫并初始化
    		int[][] map = new int[8][8];
    		for(int i=0; i<map.length; i++) {
    			for(int j=0; j<map[0].length; j++) {
    				map[i][j] = 0;
    			}
    		}
    		for(int i=0; i<map.length; i++) {
    			map[i][0] = -1;
    			map[i][7] = -1;
    			map[0][i] = -1;
    			map[7][i] = -1;
    		}
    		map[4][1] = -1;
    		map[4][2] = -1;
    		map[5][3] = -1;
    		map[4][4] = -1;
    		map[3][4] = -1;
    		Maze maze = new Maze(map, 1, 1, 5, 5);
    		maze.bfs();
    	}
    }
    
    展开全文
  • /*** 描述: 定义迷宫节点类型*/private static classMazeNode {//节点的值intval;//节点的x和y坐标intx;inty;.../*** 迷宫路径初始化*@paramdata*@parami*@paramj*/public MazeNode(int data, i...

    /*** 描述: 定义迷宫节点类型*/

    private static classMazeNode {//节点的值

    intval;//节点的x和y坐标

    intx;inty;//节点四个方向的行走状态,true表示可以走,false表示不能走

    boolean[] state;/*** 迷宫路径初始化

    *@paramdata

    *@parami

    *@paramj*/

    public MazeNode(int data, int i, intj){this.state = new boolean[4];this.val =data;this.x =i;this.y =j;

    }

    }

    源代码/*** 描述: 迷宫的类型定义

    *

    * @Author shilei

    * @Date 2019/5/18*/

    public classMaze {//迷宫所有的路径存储在二维数组当中

    privateMazeNode[][] maze;//存储迷宫路径节点的队列结构,采用层层扩张的方式,寻找迷宫最优的路径信息

    private LinkQueuequeue;//记录迷宫路径节点的行走信息

    privateMazeNode[] pathrecord;//迷宫的行数

    private introw;//迷宫的列数

    private intcol;/*** 迷宫初始化

    *@paramrow

    *@paramcol*/

    public Maze(int row, intcol) {this.row =row;this.col =col;this.maze = newMazeNode[row][col];this.queue=new LinkQueue<>();this.pathrecord = new MazeNode[row*col];

    }/*** 初始化指定位置的迷宫节点

    *@paramdata

    *@parami

    *@paramj*/

    public void initMazeNode(int data, int i, intj) {this.maze[i][j] = newMazeNode(data, i, j);

    }/*** 修改迷宫所有节点四个方向的行走状态信息*/

    public voidinitMazeNodePathState() {for (int i=0;i

    maze[i][j].state[Constant.RIGHT]=true;

    }if(i+1

    maze[i][j].state[Constant.DOWN]=true;

    }if(j>0&&maze[i][j-1].val==0){

    maze[i][j].state[Constant.LEFT]=true;

    }if(i>0&&maze[i-1][j].val==0){

    maze[i][j].state[Constant.UP]=true;

    }

    }

    }

    }/*** 寻找迷宫路径*/

    public voidfindMazePath() {if (maze[0][0].val != 0) {return;

    }

    queue.offer(maze[0][0]);while(!queue.isEmpty()){

    MazeNode top=queue.peek();int x =top.x;int y =top.y;if(x == row-1 && y == col-1){return;

    }//往右方向走

    if(maze[x][y].state[Constant.RIGHT]){

    maze[x][y].state[Constant.RIGHT]= false;

    maze[x][y+1].state[Constant.LEFT] = false;

    queue.offer(maze[x][y+1]);

    pathrecord[x*col+y+1] =maze[x][y];

    }//往下方向走

    if(maze[x][y].state[Constant.DOWN]){

    maze[x][y].state[Constant.DOWN]= false;

    maze[x+1][y].state[Constant.UP] = false;

    queue.offer(maze[x+1][y]);

    pathrecord[(x+1)*col+y] =maze[x][y];

    }//往左方向走

    if(maze[x][y].state[Constant.LEFT]){

    maze[x][y].state[Constant.LEFT]= false;

    maze[x][y-1].state[Constant.RIGHT] = false;

    queue.offer(maze[x][y-1]);

    pathrecord[x*col+y-1] =maze[x][y];

    }//往上方向走

    if(maze[x][y].state[Constant.UP]){

    maze[x][y].state[Constant.UP]= false;

    maze[x-1][y].state[Constant.DOWN] = false;

    queue.offer(maze[x-1][y]);

    pathrecord[(x-1)*col+y] =maze[x][y];

    }

    queue.poll();

    }

    }/*** 打印迷宫路径搜索的结果*/

    public voidshowMazePath(){if(pathrecord[row*col-1] == null){

    System.out.println("迷宫不存在有效路径");

    }else{int x = row-1;int y = col-1;for(;;){

    maze[x][y].val= '*';

    MazeNode node= pathrecord[x*col+y];if(node == null){break;

    }

    x=node.x;

    y=node.y;

    }for (int i = 0; i < row; i++) {for (int j = 0; j < col; j++) {if(maze[i][j].val == '*'){

    System.out.print('*' + " ");

    }else{

    System.out.print(maze[i][j].val+ " ");

    }

    }

    System.out.println();

    }

    }

    }/*** 描述: 定义迷宫节点类型*/

    private static classMazeNode {//节点的值

    intval;//节点的x和y坐标

    intx;inty;//节点四个方向的行走状态,true表示可以走,false表示不能走

    boolean[] state;/*** 迷宫路径初始化

    *@paramdata

    *@parami

    *@paramj*/

    public MazeNode(int data, int i, intj){this.state = new boolean[4];this.val =data;this.x =i;this.y =j;

    }

    }

    }

    展开全文
  • 迷宫问题利用java的宽度优先搜索实现寻找最短路径 题目描述: int[][] map= { {0, 1, 0, 0, 0}, {0, 0, 0, 1, 0}, {1, 1, 0, 0, 0}, {0, 0, 0, 0, 1}, {0, 0, 0, 0, 0}}; 它表示一个迷宫,其中的1表示墙壁,0...

    迷宫问题利用java的宽度优先搜索实现寻找最短路径

    题目描述:

     int[][] map= { {0, 1, 0, 0, 0},
                    {0, 0, 0, 1, 0},
                    {1, 1, 0, 0, 0},
                    {0, 0, 0, 0, 1},
                    {0, 0, 0, 0, 0}};
    

    它表示一个迷宫,其中的1表示墙壁,0表示可以走的路,只能横着走或竖着走,不能斜着走,要求编程序找出从左上角到右下角的最短路线。

    求最短路径问题:
    不能直接用队列,需要用到数组模拟队列,去保存每个点的前一个点.

    下面是具体的代码实现.


    下面的代码可以实现从地图上任意起点开始,到指定终点的最短路径,代码的具体功能代码里面注释的很清楚了:

    import java.util.Scanner;
    
    public class Test {
    
        //地图的大小
        static int n = 5;
        static int m = 5;
        //用来保存地图
        static int[][] map;
        //用来保存是否被访问过
        static int[][] isVisited = new int[n][m];
        //遵循 左下右上 的顺序走
        static int[][] trval = {{0, -1}, {1, 0}, {0, 1}, {-1, 0}};
        //利用数组模拟队列
        static Node[] nodes = new Node[n * m];
        //判断是否已经到达终点
        static boolean flag = false;
    
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            map = new int[][]{
                    {0, 1, 0, 0, 0},
                    {0, 0, 0, 1, 0},
                    {1, 1, 0, 0, 0},
                    {0, 0, 0, 0, 1},
                    {0, 0, 0, 0, 0}};
            System.out.print("请输入起点坐标:");
            int start_x = sc.nextInt();
            int start_y = sc.nextInt();
            System.out.print("请输入终点坐标:");
            int end_x = sc.nextInt();
            int end_y = sc.nextInt();
    
            bfs(start_x, start_y, end_x, end_y);
    
    
        }
    
    
        //传进来起点的x,y的起点和终点坐标
        static void bfs(int x, int y, int end_x, int end_y) {
            //判断要查询的起点和终点坐标 是否在地图上
            if (!isStandard(x, y) || !isStandard(end_x, end_y)) {
                System.out.println("输入的坐标有误~~~");
                return;
            }
    
            //当前第几个元素
            int head = 0;
            int index = 0;
    
            isVisited[x][y] = 1;
            nodes[head] = new Node(x, y, -1);
            int next_x;
            int next_y;
            while (!flag) {
    
                for (int i = 0; i < trval.length; ++i) {
                    next_x = nodes[head].x + trval[i][0];
                    next_y = nodes[head].y + trval[i][1];
    
                    if (isStandard(next_x, next_y)) {
                        isVisited[next_x][next_y] = 1;
                        nodes[++index] = new Node(next_x, next_y, head);
                    }
                    if (next_x == end_x && next_y == end_y) {
                        flag = true;
                        break;
                    }
                }
                head++;
            }
    
            //打印走过的路径
            System.out.println("走过的路径坐标为:");
            printTrval(--head);
            System.out.println("终点");
    
        }
    
        //判断这个点是否超出地图范围
        static boolean isStandard(int x, int y) {
            if (x < n && x >= 0 && y >= 0 && y < m && map[x][y] == 0 && isVisited[x][y] == 0) {
                return true;
            }
            return false;
        }
    
        //打印走过的路径
        static void printTrval(int index) {
            if (nodes[index].pre == -1) {
                System.out.print("[" + nodes[index].x + "," + nodes[index].y + "]-->");
            } else {
                printTrval(nodes[index].pre);
                System.out.print("[" + nodes[index].x + "," + nodes[index].y + "]-->");
            }
        }
    
    
    }
    
    //用来保存每个结点以及前一个结点
    class Node {
        int x;
        int y;
        int pre;
    
        public Node(int x, int y, int pre) {
            this.x = x;
            this.y = y;
            this.pre = pre;
        }
    }
    
    展开全文
  • java实现的求迷宫最短路径算法

    热门讨论 2009-04-14 23:03:01
    java实现的求迷宫最短路径的算法源代码,代码中有大量注释,容易看懂
  • 这道题也可以用深度搜索,只要改变策略,找出每条路,再比较哪条路路径更短,不过这样感觉很麻烦。 所以我们可以改换成广度搜索法。 这里我们用#表示墙,O表示可走路径。具体看代码(注释得比较清楚) import java....
  • The goal is to draw a maze after resolving it (using BFS) with the shortest path from start to exit.OUTPUT must be like this***************************************************[20,19]******************...
  • 您将获得最终房间,并且必须找到从起始房间开始的最短路径(比较房间的名称).结果应该是“方式”,如: 开始:厨房 结束:厕所 路径:厨房,客厅,走廊,卧室,厕所 我想我必须对房间使用一些递归,我想我应该保存在已经存在...
  • DFS-迷宫最短路径求解

    千次阅读 2020-06-02 00:48:38
    例如如图:找到从入口到出口的最短路径,有障碍物的地方不能走。 解决这种问题首先是要建立出数据模型来存放数据。然后再进行逻辑分析。 我们可以定义一个二维数组来存放数据 //迷宫数据 0=空位,1=入口,2=出口,...
  • 上一篇文章演示了通过深度优先遍历搜索迷宫路径,无法得到最短迷宫路径,那么通过广度优先遍历,层层向外扩张的方式,可以找到迷宫最优的路径信息,借助一个队列实现广度优先遍历层层向外扩张的思想,再借助一个...
  • 迷宫 最短路径及所有路径的问题

    热门讨论 2009-12-06 22:46:28
    迷宫问题,完成的是一个现实中的迷宫游戏求最短路径及所有路径的问题,本程序相对于航班信息查询系统比较简单,主要包含使用系统迷宫(可以选择迷宫的入口和出口,并输出所有路径和最短路径),使用新建迷宫(可以...
  • java】走迷宫最短路径

    千次阅读 2017-04-22 16:06:32
    输入一个n*m的迷宫,1表示空地,0表示障碍物,输出从某个点到某个点的最短路径 样例输入: 6 5 1 1 0 1 1 1 0 1 1 1 1 0 1 0 0 1 0 1 1 1 1 1 1 0 1 1 1 1 1 1 0 0 0 3 样例输出: DDDDRRUUURU import java.util....
  • 测试用例: //5 5 矩阵m n //1 0 起点x y ...import java.util.Scanner; //5 5 矩阵m n //1 0 起点x y //3 3 终点x y //2 障碍物个数 //2 2 障碍物1坐标 //2 1 障碍物2坐标 public class HW...
  • java算法DFS—求迷宫出口最短路径 先设置全局的变量 import java.util.Scanner; public class DFS { static int p,q,min=9999; //出口坐标(p,q),最小部署min static int a[][] =new int [100][100];//1表示空地...
  • 文章目录迷宫的制作初始化二维数组中的数值利用递归实现路径搜索定义判断节点是否可以通过的方法比较最短路径测试代码结果 迷宫的制作 迷宫如下,可以看成一个二维数组,黑色的代表是墙,不能通过,黄色的代表迷宫的...
  • 问题:小明置身于一个迷宫,请你帮小明找出从起点到终点的最短路程。小明只能向上下左右四个方向移动。输入:输入包含多组测试数据。输入的第一行是一个整数T,表示有T组测试数据。每组输入的第一行是两个整数N和M(1...
  • [b1 - 1].circle.getFill() == Color.WHITE 这句话就是不能通过的意思 && squareData[a1][b1 - 1].pathMark == 0 这句是还未走过 , 走过后标记为1 path是记录路劲的栈 现在的路径不是最短的 , 求修改为最短路径的...
  • 它表示一个迷宫,其中的1表示墙壁,0表示可以走的路,只能横着走或竖着走,不能斜着走,要求编程序找出从左上角到右下角的最短路线。 输入描述: 一个5 × 5的二维数组,表示一个迷宫。数据保证有唯一解。 int...
  • JAVA|迷宫问题输出最短路径

    千次阅读 2019-12-16 11:03:06
    本学期Java课程设计选题为迷宫游戏。 课设的迷宫主要思路为:设置不同关卡,每个关卡的迷宫样式固定,每次游戏随机生成起点和终点。 核心问题即为: 1、随机生成的两点之间是否有路径可走? 2、最短路径是否小于等于...
  • 迷宫最短路径【队列+回溯】

    千次阅读 2018-10-09 00:10:58
    迷宫最短路径(0表示通路,1表示受阻) 问题:有一个迷宫,求从入口到出口的最短路径,其中0表示通路,1表示受阻,规定向下是X轴,向右是Y轴 输入:第一个数迷宫x轴的长度,第二个数迷宫y轴的长度,紧接着入口点的坐标...
  • 迷宫问题寻找最短路径(BFS)

    千次阅读 2021-02-18 16:35:57
    如下图,找到从(1,1)到(6,5)的最短路径。 BFS原理(BFS:广度优先搜索) 故事设定:走格子策略为下右上左,给我个面子,假装迷宫自带十万倍重力buff,他们飞不起来???? 某天太阳高照,天气炎热,唐僧四人走走...
  • 利用dfs算法计算迷宫问题的最小路径 设其最小的步数为min 其当前运行的步数为step */ static int endx,endy,min; static int a[][];//记录地图地形,1表示空地,2表示障碍物 static int v[][];//0表示未访问...
  • 迷宫算法总结(最短路径

    千次阅读 2020-11-20 09:51:25
    算法 迷宫算法总结(最短路径) @author:Jingdai @date:2020.11.20 迷宫问题是一个非常经典的算法问题,现总结一下。 题目描述 给你一个迷宫,并给你一个起点和终点,请你给出从起点到终点的最短路径,若不存在...
  • A*算法--迷宫最短路径JAVA实现)

    万次阅读 2015-09-29 14:07:22
    转载自:http://www.java3z.com/cwbwebhome/article/article1/1376.html?id=4920序:搜索区域 假设有人想从A点移动到一墙之隔的B点,如下图,绿色的是起点A,红色是终点B,蓝色方块是中间的墙。你首先注意到,搜索...
  • 挑战是通过矩阵迷宫m x n获得最短路径,其中2 我的解决方案是从一开始就找到完成所有可能的路径,计算沿途穿过的墙数 . 如果墙的数量为1或更少,则解决方案有效并记录其长度 .path_dict = {}min_solution = Nonedef ...
  • dfs和bfs是搜索算法的经典,解决迷宫最短路径问题,dfs解决起来很麻烦,但是bfs却很在行。 例题 黄色是障碍物,不可走 思路分析 bfs用到队列,Java中使用LinkedList,将开始的地点加入到队列,然后开始循环,以该...
  • 迷宫最短路径

    千次阅读 2018-03-16 17:46:21
    给定一个大小为N*M的迷宫,由通道('.')和墙壁('#')组成,其中通道S表示起点,通道G表示终点,每一步移动可以达到上下左右中不是墙壁的位置。试求出起点到终点的最小步数。(本题假定迷宫是有解的)(N,M&lt;=100)...
  • 自己实现的递归寻路的算法。用到了穷举效率不是很高。 不过递归和回溯算法超经典。以城市地图为例,根据权重,找到最佳路径。文档源码详解。大家可以看看。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,099
精华内容 839
关键字:

java迷宫最短路径

java 订阅