精华内容
下载资源
问答
  • 算法流程(基于宽度优先) 3.1 步骤流程: 一、 从初始节点 S 出发,将初始节点加入队列 Q,此时 Q={(0,0)},已搜索节 点表 C={ }; 二、 若队列 Q 为空,则搜索失败,退出; 三、 若队列 Q 不为空,则取出队列 Q 的头...

    正文之前

    国庆最后一天,也是准备爆肝五年这个历史性任务开启的前一天,今天很伤,但是么~

    514052973cd5?utm_source=oschina-app

    蝼蚁聚团求存,强者则与寂寞和星空为伴

    哈哈,这句话居然还是我超喜欢的小说之一的作者写的。。。果然,英雄所见略同:

    514052973cd5?utm_source=oschina-app

    所以,请计算机2018级《人工智能》课堂的兄弟,看到这里就自觉关闭网页吧。。。。我写了一下午。。。想留着纪念下。。不想明天直接就是一大片一样的。。

    正文

    作业需求如下,其实很简单啦!~

    514052973cd5?utm_source=oschina-app

    需求分析

    起点状态其实就对应初始状态,起点可走周围四个方向(过程中需对是否越界,是 否撞墙做出判断,不满足条件都为不可到达的状态,生成子节点时可直接不考虑), 一旦遍历的点为终点这时经历的路径必为最短,即经历的层数最少,当然,此路径并 不唯一,取最先达到终点的路径为优先。

    算法流程(基于宽度优先)

    3.1 步骤流程:

    一、 从初始节点 S 出发,将初始节点加入队列 Q,此时 Q={(0,0)},已搜索节 点表 C={ };

    二、 若队列 Q 为空,则搜索失败,退出;

    三、 若队列 Q 不为空,则取出队列 Q 的头结点,检查 C 中是否有该节点; 四、 若有该节点,则退出此线路;

    五、 若无该节点,则将该节点置入 C 中,再判断该节点是否为目标节点;

    六、 若为目标节点,则由该节点回溯到初始节点,即可得到路径,后退出搜索; 七、 若不是目标节点,那么将该节点扩展,得到其扩展子节点,先过滤掉已经在 C

    中存在的子节点,然后设置所有子节点的父节点为当前节点,并且将所有子节

    点入队; 八、 回到步骤二.

    3.2 关键点分析

    上述步骤中,初始化动作为步骤一,步骤二到步骤八是循环操作。其中有三处跳出 循环的点:

    队列 Q 为空时,代表着所有的节点能从初始点到达的节点都已经搜索完毕,可以 直接结束程序(break);

    如果当前节点是搜索过的节点,那么退出本次循环,进入下次循环(continue); 3. 找到了目标节点,回溯至初始节点后得到路径,完美退出(exit)。

    代码放一放:

    514052973cd5?utm_source=oschina-app

    输出结果如图:

    514052973cd5?utm_source=oschina-app

    正文之后

    我知道这个算法实现写的稀烂的。。。而且讲道理,我觉得很是有点广度优先的意思在里头了。。。这。。很可怕了~ 不过不管了。写了那么久,将就着用吧!溜了,吃饭去了

    展开全文
  • 算法流程(基于宽度优先) 3.1 步骤流程: 一、 从初始节点 S 出发,将初始节点加入队列 Q,此时 Q={(0,0)},已搜索节 点表 C={ }; 二、 若队列 Q 为空,则搜索失败,退出; 三、 若队列 Q 不为空,则取出队列 Q 的头...

    正文之前

    国庆最后一天,也是准备爆肝五年这个历史性任务开启的前一天,今天很伤,但是么~

    514052973cd5

    蝼蚁聚团求存,强者则与寂寞和星空为伴

    哈哈,这句话居然还是我超喜欢的小说之一的作者写的。。。果然,英雄所见略同:

    514052973cd5

    所以,请计算机2018级《人工智能》课堂的兄弟,看到这里就自觉关闭网页吧。。。。我写了一下午。。。想留着纪念下。。不想明天直接就是一大片一样的。。

    正文

    作业需求如下,其实很简单啦!~

    514052973cd5

    需求分析

    起点状态其实就对应初始状态,起点可走周围四个方向(过程中需对是否越界,是 否撞墙做出判断,不满足条件都为不可到达的状态,生成子节点时可直接不考虑), 一旦遍历的点为终点这时经历的路径必为最短,即经历的层数最少,当然,此路径并 不唯一,取最先达到终点的路径为优先。

    算法流程(基于宽度优先)

    3.1 步骤流程:

    一、 从初始节点 S 出发,将初始节点加入队列 Q,此时 Q={(0,0)},已搜索节 点表 C={ };

    二、 若队列 Q 为空,则搜索失败,退出;

    三、 若队列 Q 不为空,则取出队列 Q 的头结点,检查 C 中是否有该节点; 四、 若有该节点,则退出此线路;

    五、 若无该节点,则将该节点置入 C 中,再判断该节点是否为目标节点;

    六、 若为目标节点,则由该节点回溯到初始节点,即可得到路径,后退出搜索; 七、 若不是目标节点,那么将该节点扩展,得到其扩展子节点,先过滤掉已经在 C

    中存在的子节点,然后设置所有子节点的父节点为当前节点,并且将所有子节

    点入队; 八、 回到步骤二.

    3.2 关键点分析

    上述步骤中,初始化动作为步骤一,步骤二到步骤八是循环操作。其中有三处跳出 循环的点:

    队列 Q 为空时,代表着所有的节点能从初始点到达的节点都已经搜索完毕,可以 直接结束程序(break);

    如果当前节点是搜索过的节点,那么退出本次循环,进入下次循环(continue); 3. 找到了目标节点,回溯至初始节点后得到路径,完美退出(exit)。

    代码放一放:

    514052973cd5

    输出结果如图:

    514052973cd5

    正文之后

    我知道这个算法实现写的稀烂的。。。而且讲道理,我觉得很是有点广度优先的意思在里头了。。。这。。很可怕了~ 不过不管了。写了那么久,将就着用吧!溜了,吃饭去了

    展开全文
  • 迷宫入门问题 原题 题目描述 小明置身于一个迷宫,请你帮小明找出从起点到终点的最短路程。 小明只能向上下左右四个方向移动。 输入 输入包含多组测试数据。输入的第一行是一个整数T,表示有T组测试数据。 每组输入...

    迷宫入门问题

    原题

    题目描述

    小明置身于一个迷宫,请你帮小明找出从起点到终点的最短路程。
    小明只能向上下左右四个方向移动。

    输入

    输入包含多组测试数据。输入的第一行是一个整数T,表示有T组测试数据。
    每组输入的第一行是两个整数N和M(1<=N,M<=100)。
    接下来N行,每行输入M个字符,每个字符表示迷宫中的一个小方格。
    字符的含义如下:
    ‘S’:起点
    ‘E’:终点
    ‘-’:空地,可以通过
    ‘#’:障碍,无法通过
    输入数据保证有且仅有一个起点和终点。

    输出

    对于每组输入,输出从起点到终点的最短路程,如果不存在从起点到终点的路,则输出-1。

    样例输入

    5 5
    s-###
    -----
    ##---
    E#---
    ---##
    
    样例输出
    9
    
    #include<iostream>
    #include<cstring>
    #include<string>
    #include<queue>
    #include <algorithm>
    using namespace std;
    int de[100][100];    //计步数组  记录走到这个位置所需的步数 不能走到的位置标记为-1 
    char map[100][100];  //用于存放迷宫地图 
    typedef pair<int,int> P;  //坐标
    int to[2][4]={1,-1,0,0,0,0,1,-1};  //在当前坐标下能走的四个方向
    int sx,ex,sy,ey;  //(sx,sy)为起点坐标  (ex,ey)为终点坐标
    int x,y,nx,ny;     //(x,y)为函数中当前位置坐标   (nx,ny)为接下来能到达的坐标 
    int r,l;  //r为行数 l为列数 
    int bfs()
    {
    	memset(de,-1,sizeof(de));
    	queue<P> qu;
    	qu.push(P(sx,sy));   //将起点坐标放入队头 
    	de[sx][sy]=0;
    	while(!qu.empty()) 
    	{
    		P p=qu.front();   //取出队头坐标 
    		qu.pop() ;        //删除对头及走过的坐标 
    		x=p.first,y=p.second; 
    		if(x==ex&&y==ey) break; //到达终点 跳出循环		
    	     	for(int i=0;i<4;i++)
    	    	{
    	    		nx=x+to[0][i];    //开始向四个方向移动 
    	    		ny=y+to[1][i];	    		
    	    			if(nx>=0&&nx<r&&ny>=0&&ny<l&&map[nx][ny]!='#'&&de[nx][ny]==-1)
    	                 //判断是否越界 以及是否能走  排除走过的路 
    	                 {
    	                 	 qu.push(P(nx,ny));  //将能走的坐标放入队列 之后依次删除 
    						 de[nx][ny]=de[x][y]+1;  //步数加一 
    					  } 				  
    			}
    	}
    	if(de[ex][ey]==-1)  return -1;  //终点的记步数组为-1 及不能到达终点 
    	else return de[ex][ey]; 
    } 
    int main()
    {
    	int n,i,j;
    	while(cin>>n){
    		while(n--){
    			cin>>r>>l;
    			for(i=0;i<r;i++){
    				for(j=0;j<l;j++){ 
    				cin>>map[i][j];
    				if(map[i][j]=='S')     //记录起点坐标 
    				 {
    					sx=i,sy=j;
    				 } 
    				 else if(map[i][j]=='E')  //记录终点坐标 
    				 {
    				 	ex=i,ey=j;
    				 }
    				}
    			}
    			cout<<bfs()<<endl;
    		}
    	}
    	return 0;
    }
    
    展开全文
  • 宽度优先迷宫遍历

    2007-11-16 21:01:19
    利用宽度优先算法解决迷宫问题
  • 宽度搜索优先按照距开始状态由近及远的顺序进行搜索,因此可以很容易用来求最短路径、最少操作之类问题的答案。它是按照开始状态->只需1次转移就能到达的所有状态->只需2次就能到达的所有状态->...这样的顺序进行...

    BFS介绍:

    宽度搜索优先按照距开始状态由近及远的顺序进行搜索,因此可以很容易用来求最短路径、最少操作之类问题的答案。它是按照开始状态->只需1次转移就能到达的所有状态->只需2次就能到达的所有状态->...这样的顺序进行搜索。对于同一个状态,bfs只经过一次,时间复杂度为O(状态数*转移方式)。BFS搜索利用了队列,搜索时首先将初始状态添加对队列中,此后不断从队列中取出状态,并把从该状态可以转到的所有状态添加到队列中,如此往复,直到队列为空或者找到解。

    迷宫问题:

    给定一个大小为N*M的迷宫,迷宫由通道和墙壁组成('#','.','S','G'分别表示墙、通道、起点和终点),每一步可以向邻接的上下左右四个方向移动。请给出从起点到终点所需的最小步数。假定起点一定可以到达终点。

     源码如下:

    #include <iostream>
    #include <queue>
    using namespace std;
    //定义常量 无法到达
    const int INF=1000000000;
    //定义迷宫规模
    const int MAXN=100;
    const int MAXM=100;
    //自定义数据类型 存储所处位置
    typedef pair<int,int> Pair;
    char migong[MAXN][MAXM];
    int N,M;
    //定义迷宫入口和出口位置
    int sx,sy,gx,gy;
    //定义标记数组,记录每个位置所走过的距离
    int flag[MAXN][MAXM];
    //定义前进方向,分别为右、下、左、上,往不同方向前进时x y坐标同步变化
    int dx[4]={1,0,-1,0};
    int dy[4]={0,1,0,-1};
    
    int bfs(){
        queue<Pair> q;
        //初始化距离数组,全部为不可到达
        for(int i=0;i<N;i++)
            for(int j=0;j<M;j++) flag[i][j]=INF;
        //将起点入队
        q.push(Pair(sx,sy));
        //起始点距离为0
        flag[sx][sy]=0;
        while(q.size()){
            //取得当前所处位置坐标并将该点从队列中移除
            Pair p=q.front();q.pop();
            //如果到达终点 ,结束循环
            if(p.first==gx && p.second==gy)
                break;
            //尝试向四个方向前进
            for(int i=0;i<4;i++){
                int nx=p.first+dx[i];
                int ny=p.second+dy[i];
                //防止坐标溢出,同时判断是否碰到墙壁或者走回原路
                if(nx>=0 && nx<N && ny>=0 && ny<M && migong[nx][ny]!='#' && flag[nx][ny]==INF){
                    q.push(Pair(nx,ny));
                    flag[nx][ny]=flag[p.first][p.second]+1;
                }
            }
        }
        return flag[gx][gy];
    }
    int main ()
    {
        cin>>N>>M;
        for(int i=0;i<N;i++)
            for(int j=0;j<M;j++){
                cin>>migong[i][j];
                //记录入口位置
                if(migong[i][j]=='S'){
                    sx=i;sy=j;
                }
                //记录出口位置
                if(migong[i][j]=='G'){
                    gx=i;gy=j;
                }
            }
        cout<<bfs()<<endl;
    }
    

     运行结果如下:

    展开全文
  • 例8.4迷宫问题 如图所示,给出一个n*m的迷宫图和一个入口、一个出口 编写一个程序,打印从一条从迷宫入口到出口的路径。这里黑色方块的单元表示走不通(用-1表示),白色表示可以走(用0表示) 只能往上、下、左、右...
  • 点击上方“简说Python”,选择“置顶/星标...走迷宫显示迷宫迷宫生成等等再提,先看一下迷宫的读取和显示。第一行是行数和列数,代表有101行101列,这个迷宫后面可以使用最小生成树生成。读进一个迷宫:publicclas...
  • 宽度优先搜索算法

    2020-10-12 20:24:15
    宽度优先搜索算法算法简介实战练习 算法简介 宽度优先搜索又称广度优先搜索或横向优先搜索。该算法是一种图形搜索算法,该算法是从起点开始搜索然后一层一层的向下搜索,如果找到目标或者搜索完了全部的节点则算法...
  • 迷宫算法宽度优先搜索Java实现 import java.util.ArrayList; import java.util.List; import java.util.Scanner; /** 5 5 1 1 0 1 1 0 1 0 1 0 0 1 1 1 0 0 0 1 1 0 1 0 1 1 1 * */ public class BfsTest { ...
  • 题目: 给定一个n*m的二维整数数组,用来表示一个迷宫,数组中只包含0或1,其中0表示可以走的路,1表示不可通过的墙壁。 最初,有一个人位于左上角(1, 1)处,已知该人每次可以向上、下、左、右任意一个方向移动一个...
  • 广度优先算法(Breadth-First Search),同广度优先搜索,又称作宽度优先搜索,或横向优先搜索,简称BFS,是一种图形搜索演算法。简单的说,BFS是从根节点开始,沿着树的宽度遍历树的节点,如果发现目标,则演算终止...
  • 广度优先算法(Breadth-First Search),同广度优先搜索,又称作宽度优先搜索,或横向优先搜索,简称BFS,是一种图形搜索演算法。简单的说,BFS是从根节点开始,沿着树的宽度遍历树的节点,如果发现目标,则演算终止...
  • BFS属于一种盲目搜寻法...比如迷宫。   例子:在一个n*n的矩阵中,从原点(0,0)走到终点(n-1.n-1),只能上下左右走,求最短步数,n*n是01矩阵,0表示该格子没有障碍,1表示有障碍。   int mazeArr[maxn][maxn]...
  • BFS宽度优先搜索算法

    2015-07-12 14:59:24
    广度优先搜索(也称宽度优先搜索,缩写BFS,以下采用广度来描述)是连通图的一种遍历策略。因为它的思想是从一个顶点V0开始,辐射状地优先遍历其周围较广的区域,故得名。  一般可以用它做什么呢?一个最直观经典的...
  • 前言:最近在慕课网看了个视屏学习广度优先算法,通过这个算法来计算出走出迷宫的最短路径,因此在此记录来加深自己对广度优先算法的理解。 目录   一、什么是广度优先算法?广度优先算法能做什么? 二、代码...
  • 易语言最短路径走迷宫,BFS(宽度优先搜索) 易语言纯源码实现 简单搜索算法
  • Artifical-Intelligence-ShortestPathInMaze:这些代码是使用“深度优先搜索”和“宽度优先搜索”算法迷宫中找到最短路径的方法。 该代码还显示了单元界面上的所有步骤,计算了执行期间的花费时间
  • 问题引入 地图上有很多个城市,已知各城市之间距离(或者是所需时间,后面都用距离了),一般问题无外乎就是以下几个: 从某城市到其余所有城市的最短距离【单源...此算法仅供娱乐参考,实际不会用它的,因为算法复杂
  • 宽度优先搜索,即BFS,有时也叫做广度优先搜索。与深度优先搜索的一条路走到黑不同,它是先遍历离自己最近的一些点,然后逐步向更远的路径进行搜索。它利用的是队列来完成这一操作。在这道迷宫求解问题中它的时间...
  • 广度优先搜索算法(也称宽度优先搜索,缩写BFS)是图里面常用的一种遍历算法。这一算法也是很多重要的图的算法的原型。Dijkstra单源最短路径算法和Prim最小生成树算法都采用了和广度优先搜索类似的思想。广度优先...
  • 算法入门】广度/宽度优先搜索(BFS)

    万次阅读 多人点赞 2012-04-30 02:58:22
    广度/宽度优先搜索(BFS) 【算法入门】 郭志伟@SYSU:raphealguo(at)qq.com 2012/04/27 1.前言 广度优先搜索(也称宽度优先搜索,缩写BFS,以下采用广度来描述)是连通图的一种遍历策略。因为它的思想是从一个...
  • 迷宫生成器和运行器实现了深度优先搜索和宽度优先搜索。 目标 该项目的目标是学习JavaScript的一些基础知识,主要是绘制到canvas对象,以创建简单的图形。 该项目的另一个目标是以有趣的方式尝试使用不同的搜索算法...
  • 宽搜,即宽度优先搜索,是图的搜索算法之一。其别名又叫BFS,属于一种盲目搜寻法,目的是系统地展开并检查图中的所有节点,以找寻结果。 代码效果 输入一个宽高自定的迷宫,若走得通,输出最短路径步数; 若走不通,...
  • 宽度优先搜索-----解决迷宫最短路径问题 一、关于宽度优先搜索的知识 1.深度优先搜索利用栈进行计算,因此一般场景中采用递归的方式实现。 2.宽度优先搜索则利用队列进行计算,搜索时首先将初始状态添加到队列里,...
  • 宽度优先搜索:(最小路径/操作) 1.迷宫问题在这里插入代码片 ①普通迷宫(墙,路,出入口)初级 ②特殊迷宫(墙,路,钥匙,门,炸弹,怪兽…)高级 本质:从某个状态出发探索所有可以到达的情况, 总是优先...
  • 广度/宽度优先搜索(BFS) 【算法入门】 郭志伟@SYSU:raphealguo(at)qq.com 2012/04/27 1.前言 广度优先搜索(也称宽度优先搜索,缩写BFS,以下采用广度来描述)是连通图的一种遍历策略。因为它的思想是从一个...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 160
精华内容 64
关键字:

宽度优先算法迷宫