精华内容
下载资源
问答
  • 迷宫最短路径算法

    2011-11-14 18:53:10
    关于迷宫最短路径的新算法,在文档中详细的指出了有关于迷宫中求解最短路径的算法
  • 迷宫最短路径算法 使用队列
                   

        (上接迷宫递归算法)

        顺便也把图里求迷宫最短路径算法贴出来,主要思想是利用队列,采用广度优先搜索法,当第一次出现目的点时,中断搜索,并输出路径。程序还是主要使用的C语言,对于队列操作我又重写了下基本操作代码比如入队、出队等,没办法对C++不熟啊!!

       个人认为需要说明的是:

       1. 为了记录路径,借鉴了树的双亲表示法,所以队列中的数组元素定义如下

       

    typedef struct  ...{
        
    int location;     //(x-1)*3+y 
        int parent;       //记录上一个节点即路径中前驱节点,方便最后输出
    }
    QueueNode;

     

       2.仍然采用了上面的映射思想,公式也是 location=(x-1)*3+y

      

    void Maze_Shortest(int maze[][5],point &start,point &des)
    ...{
        queue Queue;
        InitializeQueue(Queue);
        EnterQueue(Queue,(start.x
    -1)*5+start.y,Queue.head);
        
        
    int direction;
        
    bool FindFlag=false;  
        
    int dir[4][2]=...{...{1,0},...{0,1},...{-1,0},...{0,-1}};

        
    while (!EmptyQueue(Queue)&&!FindFlag)
        
    ...{
            
    int curX=Queue.array[Queue.head].location/3+1;
            
    int curY=Queue.array[Queue.head].location%3;

            
    for (direction=0;direction<4;direction++)          //遍历该点四周四个邻接点
            
    ...{
                
    int nextX=curX+dir[direction][0];
                
    int nextY=curY+dir[direction][1];
                
    if (!maze[nextX][nextY])                                     //如果为0 排除了墙和已经踩过的路
                
    ...{
                    EnterQueue(Queue,(nextX
    -1)*3+nextY,Queue.head);     //入队,入队元素是映射后节点!
                    
    if (nextX==des.x&&nextY==des.y)
                    
    ...{
                        FindFlag
    =true;
                        
    break;
                    }

                }

            }

            Queue.head
    ++;
        }

        
    if (EmptyQueue(Queue))
        
    ...{
            printf(
    "找不到路径 ");
        }

        
    if(FindFlag)
        
    ...{
            
    int pre=Queue.array[--Queue.rear].parent;
            Queue.array[
    1].parent=0;
            printf(
    "%d<- ",Queue.array[Queue.rear].location);
            
    while (pre)                                                   //迭代输出路径,可惜是逆向输出,不过可以用栈解决
            ...{
                printf(
    "%d<- ",Queue.array[pre].location);
                pre
    =Queue.array[pre].parent;
            }

        
        }

        
                
    展开全文
  • 随机地图c++生成求迷宫最短路径算法 最短路径解释参考 添加链接描述 代码 #include<iostream> using namespace std; #include<ctime> int mg[12][12] = { {1,1,1,1,1,1,1,1,1,1,1,1}, {1,1,1,0,0,1,0...

    随机地图c++生成求迷宫最短路径算法

    最短路径解释参考
    添加链接描述
    代码

    #include<iostream>
    using namespace std;
    #include<ctime>
    
    int mg[12][12] =
    {
     {1,1,1,1,1,1,1,1,1,1,1,1},
     {1,1,1,0,0,1,0,0,0,0,0,1},
     {1,1,1,0,1,1,0,0,0,0,0,1}, 
     {1,0,1,0,0,0,0,0,0,0,0,1},
     {1,0,0,1,0,0,1,0,0,1,0,1},
     {1,0,0,1,1,0,0,1,0,0,0,1},
     {1,0,1,0,0,0,0,1,1,1,1,1},
     {1,1,0,1,0,1,0,0,0,0,1,1},
     {1,0,1,1,0,1,0,0,1,0,0,1},
     {1,0,1,0,0,0,0,0,0,1,0,1},
     {1,1,0,0,1,0,0,1,1,0,0,1},
     {1,1,1,1,1,1,1,1,1,1,1,1}
    };//数组存贮地图,四周加一道围墙
    
    
    
    
    typedef struct
    {
    	int i, j;
    	int pre;
    }Box;//方块类型
    
    typedef struct
    {
    	Box data[100];
    	int front, rear;
    }QuTape;
    
    void print(QuTape qu, int front);
    void randompath(int m[12][12]) {
    	srand((unsigned)time(0));
    	
    	
    		for (int j = 0; j < 12; j++)
    		{
    			m[0][j] = 1;
    			m[11][j] = 1;
    		}
    
    		for (int j = 1; j < 11; j++)
    		{
    			m[j][0] = 1;
    			m[j][11] = 1;
    		}
    	for (int i = 1;i < 11; i++)
    	{
    		for (int j = 1; j < 11; j++)
    		{
    			m[i][j] =( rand() % 11) >= 4 ? 0: 1;
    		}
    	}
    
    
    
    }
    void showmg(int m[12][12])
    {
    	for (int i = 0; i < 12; i++)
    	{
    		for (int j = 0; j < 12; j++)
    		{
    			cout << m[i][j];
    		}
    		cout << endl;
    	}
    }
    bool mgpath(int xi, int yi, int xe, int ye)
    {
    	int i, j, find = 0, di;
    	QuTape qu;
    	qu.front = qu.rear = -1;
    	qu.rear++;
    	qu.data[qu.rear].i = xi;
    	qu.data[qu.rear].j = yi;
    	qu.data[qu.rear].pre = -1;
    	mg[xi][yi] = -1;
    	while (qu.front != qu.rear && !find)
    	{
    		qu.front++;
    		i = qu.data[qu.front].i;
    		j = qu.data[qu.front].j;
    		if (i == xe && j == ye)
    		{
    			find = 1;
    			print(qu, qu.front);
    			return true;
    		}
    		for (di = 0; di < 4; di++)
    		{
    			switch (di)
    			{
    			case 0:i = qu.data[qu.front].i - 1; j = qu.data[qu.front].j; break;
    			case 1:i = qu.data[qu.front].i; j = qu.data[qu.front].j + 1; break;
    			case 2:i = qu.data[qu.front].i + 1; j = qu.data[qu.front].j; break;
    			case 3:i = qu.data[qu.front].i; j = qu.data[qu.front].j - 1; break;
    			default:
    				break;
    			}
    			if (mg[i][j] == 0)
    			{
    				qu.rear++;
    				qu.data[qu.rear].i = i; qu.data[qu.rear].j = j;
    				qu.data[qu.rear].pre = qu.front;
    				mg[i][j] = -1;
    			}
    		}
    	}
    	return false;
    
    }
    
    void print(QuTape qu, int front)
    {
    	int k = front, j, ns = 0;
    	cout << endl;
    	do
    	{
    		j = k;
    		k = qu.data[k].pre;
    		qu.data[j].pre = -1;
    	} while (k != 0);
    	cout << "迷宫路径如下我的可爱鬼:\n";
    	k = 0;
    	while (k < 100)
    	{
    		if (qu.data[k].pre == -1)
    		{
    			ns++;
    			cout << "(" << qu.data[k].i << "," << qu.data[k].j << ")";
    			if (ns % 5 == 0)
    				cout << endl;
    		}
    		k++;
    	}
    	cout << endl;
    
    
    
    }
    int main()
    {
    	int q, w, e, r;
    	randompath(mg);
    	showmg(mg);
    	cout << "输入起点坐标,终点坐标的数字(输入一个数字后enter再输入第二个):";
    		cin >> q >> w >> e >> r;
    	
    			if (!mgpath(q,w,e,r))
    				cout << "无解";
    		
    	system("pause");
    }
    
    展开全文
  • 用Java实现迷宫最短路径算法

    千次阅读 2019-01-26 11:24:51
    迷宫最短路径用宽度优先搜索(bfs)相比用深度优先搜索(dfs)的好处在于bfs每次计算都是最短路径不存在重复计算,而dfs每计算出一条可行的路径都要与先前的路径比较,然后储存最短路径。 而bfs的思想是先计算出围绕...

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

    宽度优先搜索

    迷宫最短路径用宽度优先搜索(bfs)相比用深度优先搜索(dfs)的好处在于bfs每次计算都是最短路径不存在重复计算,而dfs每计算出一条可行的路径都要与先前的路径比较,然后储存最短路径。
    而bfs的思想是先计算出围绕起点的所有点的距离并储存起来
    在这里插入图片描述
    S是起点,数字为该点到S的距离

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

    在N*M的迷宫中,计算出S到G的最短路径
    ‘#’,’.’, ‘S’, 'G’分别表示墙壁、通道、起点、终点
    在这里插入图片描述

    代码如下:

    import java.util.LinkedList;
    import java.util.Queue;
    import java.util.Scanner;
    
    public class Main {
    	/**
    	代码输入格式
    	第一行两个整数n,m如
    	2 2
    	下面n行,每行m个字符如
    	S#
    	#G
    	*/
    	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<int []> que = new LinkedList<int []>();
    		//将所有的位置都初始化为最大
    		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]];
    	}
    
    }
    
    展开全文
  • 这是一个求迷宫最短路径算法,用的是dfs的思想~~~~~~~~~~~~~
  • 给出一个迷宫 2维数组 求解迷宫最短路径问题 例如 int mg[10][10]= { {1,1,1,1,1,1,1,1,1,1}, {1,0,0,1,0,0,0,1,0,1}, {1,0,0,1,0,0,0,1,0,1}, {1,0,0,0,0,1,1,0,0,1}, {1,0,1,1,1,0,0,0,0,1}, {1,0,0,0,...
  • java实现的求迷宫最短路径算法

    热门讨论 2009-04-14 23:03:01
    用java实现的求迷宫最短路径的算法源代码,代码中有大量注释,容易看懂
  • 方法之一:让一个小机器人在迷宫里随机走直到找到终点,这样做足够多次,记录最短路径。 缺点:几率低。可能走回头路。无法证明是真正的最短路径。 换种说法:x到【x到y最短路径上】的某一点的最短路径还是在这条...



    方法之一:让一个小机器人在迷宫里随机走直到找到终点,这样做足够多次,记录最短路径。
    缺点:几率低。可能走回头路。无法证明是真正的最短路径。

    换种说法:x到【x到y最短路径上】的某一点的最短路径还是在这条最短路径上

    如何判断无解?
    1、可用一个计数器,每当访问新格子,计数器加一。计数器最大值显然是各自总数。我们可以设置一个值,当计数器超过这个值的时候,结束程序。
    2、可以如下操作。记录等于n-1的点和n的点,从这些可以推断出等于n+1的点。如果推断出没有等于n+1的点了(同时没有到达终点),说明已经没有可以访问的点了,迷宫误解。

    下面这幅图中有一处符号错误,答案在图片后

    请问老师can_be_reached下面一行那个"<“是不是应该是”>"。。。
    老师:没错,打错了
    L_Table:距离表。承载着核心信息:到起点的距离
    冗余运算: 全部可达区域都计算过后才判断是否能达到重点
    每次都要遍历全部迷宫寻找“前线”(当前L最大的位置)。
    算法复杂度:约为N^2
    如何体现“无穷大”:用limit.h头文件。其中定义的部分常量如下。
    limit.h举例

    说明: 任何一个点最多入队一次
    复杂度:N






    开心一刻:广度搜索==摊大饼

    下节预告:最小生成树

    展开全文
  • 迷宫最短路径算法(使用队列)

    万次阅读 2007-08-25 13:17:00
    (上接迷宫递归算法) 顺便也把图里求迷宫最短路径算法贴出来,主要思想是利用队列,采用广度优先搜索法,当第一次出现目的点时,中断搜索,并输出路径。程序还是主要使用的C语言,对于队列操作我又重写了下基本操作...
  • 迷宫最短路径 问题描述 给定一个大小为N×M的迷宫迷宫由通道和墙壁组成,每一步可以向邻接的上下左右四个的通道移动。请求出从起点到终点所需的最小步数。请注意,本题假定从起点一定可以移动到终点。(N,M≤100...
  • 围住神经猫,迷宫最短路径算法分析

    千次阅读 2014-09-24 13:19:47
    //*******************************最短路径的简单应用*********************************************** 源码: //************************************************************************ ...
  • 迷宫最短路径 问题描述 给定一个大小为N×M的迷宫迷宫由通道和墙壁组成,每一步可以向邻接的上下左右四个的通道移动。请求出从起点到终点所需的最小步数。请注意,本题假定从起点一定可以移动到终点。(N,M≤100...
  • 一个迷宫最短路径寻径算法,可显示迷宫,路径。可修改迷宫。
  • python求迷宫最短路径

    2021-05-16 19:04:14
    python求迷宫最短路径算法-bfs # -*- coding: utf-8 -*- """ Created on Tue Apr 27 13:48:14 2021 @author: Administrator """ ###无递归、类求迷宫最短路径算法 #import random pre_route=list() #宽度搜索得到...
  • 查找迷宫最短路径

    2019-10-04 15:13:19
    迷宫最短路径算法 算法的基本思想 从迷宫入口点(1,1)出发,向四周搜索,记下所有能一步到达的点坐标,然后依次再从这些点出发,然后再记下所有能一步到达的坐标点…依次类推直到能找到迷宫的出口点(m,n)为止,...
  • 迷宫最短路径A*算法

    2009-02-05 14:15:30
    迷宫最短路径A*算法的C++代码实现 在VC++ 2005下编译及测试
  • 这是对于邓俊辉老师的《数据结构》一书的4.4.3节的迷宫最短路径算法的自我拓展。在上一篇博客中,我提到本人用DFS算法尝试不出最短路径的解决方法,所以在此篇博客中,本人采用了BFS算法,并结合建图的方式求出了...
  • 标题:机器人走迷宫(适用于走迷宫最短路径算法) 问题描述: 一块矩形方格,含有障碍和可通行格子,求从某一点到另外一点的最短距离?N*M的矩阵; 其中,1代表障碍,0代表可通行;示例:给定二维矩阵 0 0 1 0 0 ...
  • 迷宫最短路径思路

    千次阅读 多人点赞 2019-06-18 17:01:32
    迷宫最短路径 迷宫的算法很多,但是解释原理的却很少,在这里我利用自己的亲身经历来讲解一下求解迷宫的原理,迷宫求解可以利用栈结构,即深度优先,探索一个位置就标记,通则走,不同则后退寻找下一个位置,可以求...
  • Java实现迷宫最短路径的BFS算法

    千次阅读 2020-03-31 17:36:27
    利用广度优先遍历算法的特点,由于迷宫每次只能走一格,所以对于任意一个节点,bfs最先到达时一定时最短路径。 package recursion; import java.util.ArrayDeque; import java.util.Deque; import java.util.Stack;...
  • 标题:机器人走迷宫破壁解法(适用于走迷宫最短路径算法)-20200412 问题描述: 一块矩形方格,含有障碍和可通行格子,求从某一点到另外一点的最短距离?N*M的矩阵; 其中,1代表障碍,0代表可通行;示例:给定二...
  • Archer-Dungeon:用于最短路径算法练习的Archer Dungeon迷宫游戏
  • 基于bfs搜索算法迷宫最短路径游戏 废话不多说:因为在我的上一篇博客里已经提到了bfs算法.花了一天的时间写的一个小游戏,虽然界面不怎么样,但是算法确实很难写。
  • BFS解决迷宫最短路径

    2020-05-17 23:17:01
    BFS解决迷宫最短路径(Python)1、概述2、算法的逻辑3、代码解析4、代码编写过程遇到错误 1、概述 第一次写文章,题材选了最近刚上手的BFS算法,博客上介绍这类算法文章很多,有很多简洁快速的算法,我采用知识普通...
  • 迷宫最短路径 题目描述 设计一个算法找一条从迷宫入口到出口的最短路径。 输入 迷宫的行和列m n 迷宫的布局 输出 最短路径 样例输入 6 8 0 1 1 1 0 1 1 1 1 0 1 0 1 0 1 0 0 1 0 0 1 1 1 1 0 1 1 1 0 0 1 1 1 0 0 1 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 667
精华内容 266
关键字:

迷宫最短路径算法