精华内容
下载资源
问答
  • 没啥事写的一个C++解最小步数二阶... 用的是广搜(BFS),效率算是比较高,平均结算7ms(笔记本八代i7),平均7~8步能复原,源码有比较细致的注释,配套一个简单的QT界面,具体的细节以及原理稍后更新,可见我博客。
  • 第4章 广搜的优化技巧.pdf
  • C++的广搜深搜算法及入门级别动态规划.pdf
  • 没啥事写的一个C++解最小步数二阶魔方的程序,cpp 200多行,尽力写的比较精简,大多是格式化设计... 用的是广搜(BFS),效率算是比较高,平均结算7ms(笔记本八代i7),平均7~8步能复原,源码有比较细致的注释,配套
  • 北大ACM、NOIP课程广搜

    2017-11-28 12:49:32
    北大ACM、NOIP课程广搜 北大ACM、NOIP课程广搜 北大ACM、NOIP课程广搜
  • # pyqt5 八数码拼图游戏 广度优先搜索(bfs)、双向广搜(dbfs)、A*搜索求解 1. pyqt5制作可视化窗口,qss美观ui; 2. 自定义导入图片,生成3、4、5阶八数码拼图; 3. 可以点击移动小方块进行游戏; 4. 可以选择使用...
  • NULL 博文链接:https://128kj.iteye.com/blog/1703983
  • NULL 博文链接:https://128kj.iteye.com/blog/1745423
  • C++实现图的深搜/广搜。有向图,有向网,无向图,无向网,结构创建与搜索遍历均实现。
  • 图的先广搜索

    千次阅读 2021-04-03 23:03:59
    输出无向图的给定起点的先广序列。 输入格式: 输入第一行给出三个正整数,分别表示无向图的节点数N(1<N≤10)、边数M(≤50)和探索起始节点编号S(节点从1到N编号)。 随后的M行对应M条边,每行给出一对正整数...

    题目:

    输出无向图的给定起点的先广序列。

    输入格式:

    输入第一行给出三个正整数,分别表示无向图的节点数N(1<N≤10)、边数M(≤50)和探索起始节点编号S(节点从1到N编号)。

    随后的M行对应M条边,每行给出一对正整数,分别是该条边直接连通的两个节点的编号。

    输出格式:

    输出从S开始的无向图的先广搜索序列,用一个空格隔开,最后也有一个空格;如果为非连通图,再在结尾处另起一行输出一个0,表示此图非连通。

    由于广度优先遍历的节点序列是不唯一的,为了使得输出具有唯一的结果,我们约定以表头插入法构造邻接表。

    输入样例:

    6 8 2
    1 2
    2 3
    3 4
    4 5
    5 6
    6 4
    3 6
    1 5
    

    输出样例:

    2 3 1 6 4 5

    代码:

    #include <bits/stdc++.h>
    using namespace std;
    
    int N;
    int M;
    int S;
    deque<int> grp[20];
    bool vis[20] ;
    vector<int> ans;
    
    void bfs(int s)
    {
         queue<int> que;
         que.push(s);
    
         while(que.empty()==0){
              int po = que.front();
              que.pop();
              if(vis[po]==false){
                   vis[po]=true;
                   ans.push_back(po);
                   for(int i=0;i<grp[po].size();i++){
                        que.push(grp[po][i]);
                   }
              }
         }
    
    }
    
    
    int main()
    {
         cin>>N>>M>>S;
         int n1,n2;
         for(int i=0;i<M;i++){
              cin>>n1>>n2;
              grp[n1].push_front(n2);
              grp[n2].push_front(n1);
         }
         bfs(S);
         for(int i=0;i<ans.size();i++){
              cout<<ans[i]<<" ";
         }
         if(ans.size()!=N){
              cout<<"\n0";
         }
    }
    
    
    
    
    展开全文
  •  广搜:广度优先搜索遍历类似于树的按层次遍历的过程。其过程为:假设从图中的某顶点v出发,在访问了v之后依次访问v的各个未曾被访问过的邻接点,然后分别从这些邻接点出发依次访问它们的邻接点,并使“先被访问的...

    深度优先搜索遍历类似于树的先根遍历,是树的先根遍历的推广。其过程为:假设初始状态是图中所有顶点未曾被访问,则深度优先搜索可以从图中的某个顶点v出发,访问此顶点,然后依次从v的未被访问的邻接点出发深度优先遍历图,直至图中所有和v有路径相通的顶点都被访问到;若此时图中尚有顶点未被访问,则另选图中一个未曾被访问的顶点作为起始点,重复上述过程,直至图中所有顶点都被访问到为止。

    算法描述

    不说了直接上题

     输入:

    输入的第一行包含一个正整数n,表示图中共有n个顶点。其中n不超过50。

    以后的n行中每行有n个用空格隔开的整数0或1,对于第i行的第j个0或1,1表示第i个顶点和第j个顶点有直接连接,0表示没有直接连接。当i和j相等的时候,保证对应的整数为0。

    输入保证邻接矩阵为对称矩阵,即输入的图一定是无向图。

    输出:

    只有一行,包含n个整数,表示按照题目描述中的深度优先遍历算法遍历整个图的访问顶点顺序。每个整数后输出一个空格,并请注意行尾输出换行

    样例输入

    4

    0 1 0 1

    1 0 0 0

    0 0 0 1

    1 0 1 0

    样例输出

    0 1 3 2

    代码展示:

    
    #include<iostream>
    #include<string.h>
    using namespace std;
    int visit[100],arc[100][100];
    void dfs(int v){
      cout<<v<<" ";
      visit[v]=1;
      for(int i=0;i<4;i++){
        if(arc[v][i]==1&&visit[i]==0){
          visit[i]=1;
          dfs(i);
        }
      }
    }
    int main(int argc, char const *argv[]) {
      int n;
      cin>>n;
      for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
          cin>>arc[i][j];
        }
      }
      dfs(0);
      cout<<endl;
      return 0;
    }
    

     广搜:广度优先搜索遍历类似于树的按层次遍历的过程。其过程为:假设从图中的某顶点v出发,在访问了v之后依次访问v的各个未曾被访问过的邻接点,然后分别从这些邻接点出发依次访问它们的邻接点,并使“先被访问的顶点的邻接点”先于“后被访问的顶点的邻接点”被访问,直至图中所有已被访问的顶点的邻接点都被访问到。若此时图中尚有顶点未被访问,则另选图中一个未曾被访问的顶点作为起始点。重复上述过程,直至图中所有顶点都被访问到为止。

    算法展示:

    输入:

    输入的第一行包含一个正整数n,表示图中共有n个顶点。其中n不超过50。

    以后的n行中每行有n个用空格隔开的整数0或1,对于第i行的第j个0或1,1表示第i个顶点和第j个顶点有直接连接,0表示没有直接连接。当i和j相等的时候,保证对应的整数为0。

    输入保证邻接矩阵为对称矩阵,即输入的图一定是无向图。

    输出:

    只有一行,包含n个整数,表示按照题目描述中的广度优先遍历算法遍历整个图的访问顶点顺序。每个整数后输出一个空格,并请注意行尾输出换行。

    样例输入:

    4
    0 0 0 1
    0 0 1 1
    0 1 0 1
    1 1 1 0
    

    样例输出:

    0 3 1 2 
    

    代码展示:

    #include<iostream>
    #include<queue>
    using namespace std;
    int visit[51],arc[51][51];
    void bfs(int v,int n){
      queue<int>q;
      q.push(v);
      visit[v]=1;
      while(!q.empty()){
        v=q.front();
        cout<<v<<" ";
        q.pop();
        for(int i=0;i<n;i++){
          if(arc[v][i]==1&&visit[i]==0){
            visit[i]=1;
            q.push(i);
          }
        }
      }
    }
    int main(int argc, char const *argv[]) {
      int n;
      cin>>n;
      for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
          cin>>arc[i][j];
        }
      }
      bfs(0,n);
      return 0;
    }
    

     

    展开全文
  • 【搜索-广搜】 迷宫的最短路径

    千次阅读 2017-02-14 15:13:18
    3.广搜运用了队列,搜索的时候首先将初始状态加入队列里,此后从队列的最前端取出状态,把从该状态可以转移到的且尚未访问过的部分加入队列,如此往复,直至队列被取空或找到了问题的解; 4.适用于找最短路径,...

    题目:

    给定一个大小为N*M的迷宫,由通道('.')和墙壁('#')组成,其中通道S表示起点,通道G表示终点,每一步移动可以达到上下左右中不是墙壁的位置。试求出起点到终点的最小步数。(本题假定迷宫是有解的)(N,M<=100)

    样例输入:

    10 10

    样例输出:

    22

    这道题目以及解法均来自《挑战程序设计竞赛(第2版)》第34页-36页;

    个人觉得这个例题很好地表现了广度优先搜索是如何与队列先进先出(FIFO)的思想联系起来的,通过不断取得某个状态后能够达到的所有状态并将其加入队列, 并且由于队列本身的特性先加入队列的状态总是先得到处理,这样就达到了一个目的:总是先将需要转移次数更少的状态进行分析处理,换句话说就是总是取得了这个状态的树中更接近根部的节点,又或者是总是让搜索树的广度得到尽可能增加。

    /*********代码的建立过程**********/

    在这个问题中,找到从起点到终点的最短路径其实就是一个建立队列的过程:

    1.从起点开始,先将其加入队列,设置距离为0;

    2.从队列首端取出位置,将从这个位置能够到达的位置加入队列,并且让这些位置的距离为上一个位置的距离加上1;

    3.循环2直到将终点添加到队列中,这说明我们已经找到了路径;

    注意到在这个过程中,每次处理的位置所对应的距离是严格递增的,因此一旦找到终点,当时的距离就是最短距离;

    同样基于这个原因,搜索可移动到的位置所使用的判断条件中不仅仅是不碰墙壁、不超过边界,还有一个就是没有到达过,因为如果已经到达了这个位置,这说明已经有更短的路径到达这个位置,这次到达这个位置的路径是更差的,不可能得到更好的最终解。

    代码:

    #include<cstdio>
    #include<cstring>
    #include<queue>
    #include<algorithm>
    using namespace std;
    
    
    typedef pair<int ,int> P;
    const int inf=100000000;
    
    
    int n,m;
    char maze[110][110];
    int sx,sy,gx,gy;
    int dx[4]= {0,1,0,-1},dy[4]= {1,0,-1,0};
    int d[110][110];
    
    
    int bfs()
    {
        for(int i=0; i<n; i++)
            for(int j=0; j<m; j++)
                d[i][j]=inf;
        queue<P> que;
        que.push(P(sx,sy));
        d[sx][sy]=0;
        while(que.size())
        {
            P p=que.front();
            que.pop();
            if(p.first==gx&&p.second==gy) break;
            for(int i=0; i<4; i++)
            {
                int nx=p.first+dx[i],ny=p.second+dy[i];
                if(nx>=0&&nx<n&&ny>=0&&ny<m&&d[nx][ny]==inf&&maze[nx][ny]!='#')
                    d[nx][ny]=d[p.first][p.second]+1,que.push(P(nx,ny));
            }
        }
        return d[gx][gy];
    }
    
    
    int main()
    {
        scanf("%d%d",&n,&m);
        for(int i=0; i<n; i++)
            scanf("%s",maze[i]);
        for(int i=0; i<n; i++)
            for(int j=0; j<m; j++)
            {
                if(maze[i][j]=='S')
                    sx=i,sy=j;
                if(maze[i][j]=='G')
                    gx=i,gy=j;
            }
        int ans=bfs();
        printf("%d\n",ans);
        return 0;
    }
    

    关于书本的摘录:

    (详细见ppt上面的广搜搜索过程)

    1.先搜索距离初始状态近的状态;

    2.复杂度为O(状态数×转移方式)

    3.广搜运用了队列,搜索的时候首先将初始状态加入队列里,此后从队列的最前端取出状态,把从该状态可以转移到的且尚未访问过的部分加入队列,如此往复,直至队列被取空或找到了问题的解;

    4.适用于找最短路径,最少操作数;

    展开全文
  • 【C++广搜,队列】奇怪的电梯

    千次阅读 2018-08-30 11:45:33
    然后广搜是一去不复返的搜索,如果我们经过一系列操作又到过之前走过的楼层不是白费力气吗╮(╯﹏╰)╭,所以还要给到过的楼层打标记 #include #include using namespace std; typedef struct { int step; ...

    前言

    题目洛谷P1135。我有参考洛谷上的题解

    在此膜拜一下洛谷上的各位大神!

    如果有疏漏、不足之处,欢迎指正。

    题目

    问题 A: 奇怪的电梯
    时间限制: 1 Sec  内存限制: 128 MB
    题目描述

        大楼的每一层楼都可以停电梯,而且第i层楼(1<=i<=N)上有一个数字Ki(0<=Ki<=N)。电梯只有四个按钮:开,关,上,下。上下的层数等于当前楼层上的那个数字。当然,如果不能满足要求,相应的按钮就会失灵。例如:3 3 1 2 5代表了Ki(K1=3,K2=3,……),从一楼开始。在一楼,按“上”可以到4楼,按“下”是不起作用的,因为没有-2楼。那么,从A楼到B楼至少要按几次按钮呢?

    输入

    第一行为三个用空格隔开的正整数,表示N,A,B(1≤N≤200, 1≤A,B≤N),第二行为N个用空格隔开的正整数,表示Ki


    输出

    仅一行,即最少按键次数,若无法到达,则输出-1


    样例输入
    5 1 5
    3 3 1 2 5


    样例输出
    3

    分析


    这道题用广搜的思路如下:

    • 在起点广搜
    • 找到一层可以去的楼层,前往
    • 把这一层作为起点,返回第一步

    不同于深搜是“不撞南墙不回头”地递归寻找所有可能性,边找还要边比较是否是最优解;广搜用先进先出的队列找到一个能去的再去,只要找到答案了也必定是最优解(最少次数),如果队列空了还没符合条件就无解。

    到达一层楼以后,我们要记下的信息可以用结构体表示:

    typedef struct
    {
        int step;//当前一共走了多少步
        int floor;//现在在哪层楼
    } dt;

    (PS:以前我还从来没用过typedef定义一个新的数据结构呢。。。平时都直接用的是纯纯的结构体( ̄▽ ̄)/。但是纯结构体后面要赋一个数组来存所有的结构体,不太方便,Get了typedef以后感觉这个真不错(o゚▽゚)o  )

    (摘自洛谷题解,有修改)(typedef struct)定义队列元素的类型,dt为结构类型,使用typedef可以定义一个新的类型名称,在程序中dt就像int、float一样,作为一个数据类型的名称使用

    然后广搜是一去不复返的搜索,如果我们经过一系列操作又到过之前走过的楼层不是白费力气吗╮(╯﹏╰)╭,所以还要给到过的楼层打标记

    #include<iostream>
    #include<queue>
    using namespace std;
    typedef struct
    {
    	int step;
    	int floor;
    } dt;
    queue<dt>lift;//定义队列 
    bool flag[2000],f;
    int main()
    {
    	int n,a,b,k[2000];//k【i】表示第i层可以上升/下降多少楼 
    	dt s,e;//定义了dt类型的s,e两个数,表示起点层,终点层 
    	cin>>n>>a>>b;
    	for(int i=1;i<=n;i++)
    	{
    		cin>>k[i];
    	}
    	//初始化,来到第a楼 
    	s.step =0;s.floor =a;
    	lift.push(s);//这楼入队 
    	//当可行的方案没实行完,也就是队列不为空时,广搜 
    	while(!lift.empty())
    	{
    		s=lift.front();//每次来到新楼层了把起点更新 
    		lift.pop() ;//走过的楼层(处理过的可能性)可以出队了 
    		if(s.floor ==b)//走到了规定楼层 
    		{
    			cout<<s.step<<endl;
    			f=1;
    			break;
    		}
    		//上升的情况 
    		if(s.floor +k[s.floor]<=n&&!flag[s.floor+k[s.floor]])//如果楼层在范围内且没被走过 
    		{
    			e.floor =s.floor+k[s.floor];
    			e.step =s.step +1;
    			flag[e.floor]=1;
    			lift.push(e); 
    		}
    		//下降的情况 
    		if(s.floor -k[s.floor]>=1&&!flag[s.floor-k[s.floor]])
    		{
    			e.floor =s.floor-k[s.floor];
    			e.step =s.step +1;
    			flag[e.floor]=1;
    			lift.push(e); 
    		}
    	}
    	if(f==0)	cout<<"-1"<<endl; 
    	return 0;
    } 

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 双向广搜总结

    2011-11-15 18:07:31
    双向广搜在竞赛中是很有战斗力的,比单向的广搜快很多
  • 算法-搜索- 广搜的优化技巧.rar
  • 二叉树的深搜与广搜

    千次阅读 2016-03-23 20:07:12
    广搜:10 8 9 5 6 7 1 2 3 4 大家对照着图结合开头的几句话来具体感受到底什么是深搜,什么是广搜。 个人认为必须要对广搜和深搜之间的区别和这两种算法的遍历顺序有一个概念,这样看起代码来应该会很容易,大家可以...
  • QT C++ 算法 广搜BFS 最下步数复原二阶魔方 本人不是计算机专业,学过半年数据算法,当时有个大作业求解二阶魔方,有一个例子就是通不过测试,心存遗憾,工作时摸鱼想到问题所在,利用休假时间写个博客分享一下,...
  • 广搜模板

    2019-09-17 10:33:12
    广搜(宽度优先遍历) 主要思路就是由近及远的搜索,主要用于寻找最短路。最好注意剪枝,减少复杂度。 武士风度的牛 稍微改变一下搜索的方向就可以了。 代码 #include <bits/stdc++.h> using namespace std; ...
  • C.就来谈谈深搜与广搜

    千次阅读 2017-05-04 15:16:58
    深搜与广搜的基础代码实现 下面以一道简单的搜索算法题为例: 在一个,迷宫中寻找出口,并且要求路径最短。且迷宫中有障碍物不能穿过,并由规定起点出发。输入包括三部分,第一行:迷宫的尺寸大小。 第二行:...
  • 抓住那头牛(广搜)--算法学习

    千次阅读 2020-03-31 15:06:54
    队列就是先进先出 若要遍历所有节点: 深搜 1-2-4-8-5-6-3-7  广搜 1-2-3-4-5-6-7-8 广搜算法: 1:首先,把初始节点So放入到open表中 2:如果问题误解,那么就失败退出 3:把open表的第一个节点取出放入closed...
  • 走迷宫(广搜做法)

    2018-04-14 08:12:27
    //走迷宫广搜做法,跟深搜大同小异只不过广搜比深搜快一点搜索题有时候深搜过不去超时就换广搜 d是方向数组下标改变方向了d就不同于i所以sum++,总之是到很水很基础的搜索题 # include # include # include using ...
  • ppt用形象的图解演示了深搜广搜及智能式搜索的基本原理,适合初学搜索的人使用,由于所述为本人所概括,错误之处万望谅解!
  • python 广搜

    2018-07-19 17:34:25
    前端时间学了数据结构中的深搜与广搜。是用C语言实现的。那就像想能不能用python实现图的广搜。为什么不考虑深搜,因为我知道的深搜都是用递归的形式去实现的,对内存空间浪费极大。而且python中似乎没有指针的概念...
  • 深搜(dfs)-广搜(bfs)python实现

    千次阅读 2018-12-14 19:57:35
    基于邻接表的深搜和广 图:(忽略边权,这里只看边) import sys from queue import Queue sys.setrecursionlimit(1000000) # 深搜 def dfs(start, graph, vis): print(start, end=' ') vis[start] = True ...
  • 广搜与深搜实现

    2017-06-11 16:28:20
    以下是基于图的链表表示...http://sjjg.js.zwu.edu.cn/SFXX/sf1/sdyxbl.html  (广搜) bfs通过检测边发现点,被发现点(但未探索)入队。(被探索是指是否检测过与该点相关联的临近顶点)一个顶点被完全探索当且仅当
  • 【搜索】【广搜模板】

    千次阅读 2017-08-01 06:50:37
    ACM模板C++queue的应用 struct note{ int x; //横坐标 int step; //步数 int y; //纵坐标 }; void BFS(note front_head)//BFS { queue<note>Q;//建立空队列 Q.push(front_head);//将起始点加入队列 n
  • 算法——广搜(BFS)/深搜(DFS)

    千次阅读 2019-08-09 12:41:46
    首先我会生成一颗二叉树,然后根据广搜,一层一层的便利: class Node(object): """初始化一个节点,需要为节点设置值""" def __init__(self, val): self.val = val self.left = None self.right = ...
  • c++广搜练习--营救

    千次阅读 2018-08-05 10:14:46
    题目描述  铁塔尼号遇险了!...广搜练习题,这道题花了我不少时间,在学校oj网站上一直错误百分之27,修改了很多次,又参考了网上代码之后终于ac,题目本身难度不算大,多注意细节即可,代码仅供参考。
  • 广搜

    2015-01-22 15:38:49
    poj3278,poj3984很基础的广搜
  • BFS广搜题目【经典训练题】

    千次阅读 2016-11-03 21:27:57
    BFS广搜题目【经典训练题】【有时间一个个做下来】 作者: 东方侠者 pku 1175 Starry Night 题目地址: http://acm.pku.edu.cn/JudgeOnline/problem?id=1175 解法:BFS,要注意的是如何判断图形是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 91,303
精华内容 36,521
关键字:

广搜

友情链接: tools.zip