图的遍历(bfs+dfs)模板

bfs

 1 #include<iostream>
 2 #include<queue>
 3 #include<cstdio>
 4 using namespace std;
 5 queue<int>q;
 6 int map[1001][1001];
 7 int vis[1001];
 8 int n,m;
 9 void bfs(int p)
10 {
11     q.push(p);
12     vis[p]=1;
13     printf("%c-->",char(q.front()+64));
14     while(q.size()!=0)
15     {
16         int k=q.front();
17         q.pop();
18         for(int i=1;i<=n;i++)
19         {
20
21             if(vis[i]==0&&map[k][i]==1)
22             {
23                 printf("%c-->",char(i+64));
24                 //q.pop();
25                 q.push(i);
26                 vis[i]=1;
27             }
28         }
29     }
30 }
31 int main()
32 {
33
34     scanf("%d%d",&n,&m);
35     for(int i=1;i<=m;i++)
36     {
37         char x,y;
38         //scanf("\n%d %d",&x,&y);
39         cin>>x>>y;
40         x=x-64;
41         y=y-64;
42         map[x][y]=map[y][x]=1;
43     }
44     bfs(1);
45     return 0;
46 }

dfs

 1 #include<iostream>
 2 #include<cstdio>
 3 using namespace std;
 4 int map[1001][1001];
 5 int vis[1001];
 6 int n,m;
 7 void dfs(int p)
 8 {
 9     vis[p]=1;
10     printf("%c --> ",char(p+64));
11     for(int i=1;i<=n;i++)
12     {
13         if(vis[i]==0&&map[p][i]==1)
14         {
15
16             dfs(i);
17         }
18         //else
19         //return ;
20     }
21 }
22 int main()
23 {
24
25     scanf("%d%d",&n,&m);
26     for(int i=1;i<=m;i++)
27     {
28         char x;
29         char y;
30         scanf("\n%c %c",&x,&y);
31         //cin>>x>>y;
32         x=x-64;
33         y=y-64;
34         map[x][y]=map[y][x]=1;
35     }
36     dfs(1);
37     return 0;
38 }
时间: 2024-11-10 07:36:33

图的遍历(bfs+dfs)模板的相关文章

模板 图的遍历 bfs+dfs 图的最短路径 Floyed+Dijkstra

广搜 bfs 1 //bfs 2 3 #include<iostream> 4 #include<cstdio> 5 using namespace std; 6 int queue[1001],top=0,end=1; 7 int map[1001][1001]; 8 int vis[1001]; 9 int n,m; 10 void bfs(int p) 11 { 12 queue[end]=p; 13 vis[p]=1; 14 printf("%c -->&q

图的遍历 (dfs与bfs)x

遍历是很多图论算法的基础,所谓图的遍历( graph traversal),也称为搜索( search),就是从图中某个顶点出发,沿着一些边访遍图中所有的顶点,且使每个顶点仅被访问一次.         遍历可以采取两种方法进行:         深度优先搜索( DFS: depth first search):         广度优先搜索( BFS: breadth first search). 对图进行存储与遍历: 输入: 第一行:顶点数n. 第二行:边数m. 以下m行,每行两个顶点编号u

算法导论--图的遍历(DFS与BFS)

转载请注明出处:勿在浮沙筑高台http://blog.csdn.net/luoshixian099/article/details/51897538 图的遍历就是从图中的某个顶点出发,按某种方法对图中的所有顶点访问且仅访问一次.为了保证图中的顶点在遍历过程中仅访问一次,要为每一个顶点设置一个访问标志.通常有两种方法:深度优先搜索(DFS)和广度优先搜索(BFS).这两种算法对有向图与无向图均适用. 以下面无向图为例: 1.深度优先搜索(DFS) 基本步骤: 1.从图中某个顶点v0出发,首先访问v

算法导论—无向图的遍历(BFS+DFS,MATLAB)

华电北风吹 天津大学认知计算与应用重点实验室 最后改动日期:2015/8/22 无向图的存储方式有邻接矩阵,邻接链表,稀疏矩阵等. 无向图主要包括双方面内容,图的遍历和寻找联通分量. 一.无向图的遍历 无向图的遍历有两种方式-广度优先搜索(BFS)和深度优先搜索(DFS).广度优先搜索在遍历一个顶点的全部节点时,先把当前节点全部相邻节点遍历了.然后遍历当前节点第一个相邻的节点的全部相邻节点,广度优先搜索使用队列来实现.深度优先搜索在遍历当前节点的全部相邻节点时,先对当前节点的第一个相邻节点进行訪

图的遍历——BFS

原创 裸一篇图的BFS遍历,直接来图: 简单介绍一下BFS遍历的过程: 以上图为例子,从0开始遍历,访问0,按大小顺序访问与0相邻的所有顶点,即先访问1,再访问2: 至此顶点0已经没有作用了,因为其本身和与其所有相邻的顶点都已被访问,将其出队列,我们用队列 存储已访问过的顶点:然后顺着队列,访问顶点1和所有与顶点1相邻的顶点,这里没有,所有访问顶点 2和所有与顶点2相邻的结点,即3和4,注意,是先访问3,再访问4,因为采用邻接矩阵来存储图. Java: import java.util.*; p

图的创建和遍历(BFS/DFS)

图的表示方法主要有邻接矩阵和邻接表.其中邻接表最为常用,因此这里便以邻接表为例介绍一下图的创建及遍历方法. 创建图用到的结构有两种:顶点及弧 struct ArcNode { int vertexIndex; //该弧指向的顶点位置 struct ArcNode* next; //指向下一个弧 InfoType info; //该弧的相关信息,如权重等 }; struct Vertex { VertexType data; //顶点信息 ArcNode* firstArc; //指向第一条依附该

BFS DFS 模板

/* 该 DFS 框架以 2D 坐标范围为例,来体现 DFS 算法的实现思想. */ #include<cstdio> #include<cstring> #include<cstdlib> using namespace std; const int maxn=100; bool vst[maxn][maxn]; //访问标记 int map[maxn][maxn]; //坐标范围 int dir[4][2]= {0,1,0,-1,1,0,-1,0}; // 方向向量

python实现图广度优先遍历、深度优先遍历

一.广度优先遍历-bfs 顾名思义,bfs总是先访问完同一层的结点,然后才继续访问下一层结点,它最有用的性质是可以遍历一次就生成中心结点到所遍历结点的最短路径,这一点在求无权图的最短路径时非常有用.广度优先遍历的核心思想非常简单,用python实现起来也就十来行代码.下面就是超精简的实现,用来理解核心思想足够了: 1 import queue 2 3 def bfs(adj, start): 4 visited = set() 5 q = queue.Queue() 6 q.put(start)

图的遍历——DFS和BFS模板(一般的图)

关于图的遍历,通常有深度优先搜索(DFS)和广度优先搜索(BFS),本文结合一般的图结构(邻接矩阵和邻接表),给出两种遍历算法的模板 1.深度优先搜索(DFS) #include<iostream> #include<unordered_map> #include<queue> #include<cstring> #include<cstdlib> #include<cmath> #include<algorithm> #

图的遍历(BFS、DFS的邻接矩阵和邻接表实现)

当年老师给我们讲这里的时候,讲的真是云里雾里的. .其实画个图就很容易理解的事情,为什么扯那么远 我觉得 DFS其实就是树的先序遍历的强化版本 BFS是层序遍历的强化 只不过 图的实现方式比较多元化 而且不像二叉树有明确的根 操作起来相对难一些 理论其实很好理解 就是具体操作起来 每次都很晕的样子 眼高手低了又. 图的遍历是指从图中的任一顶点出发,对图中的所有顶点访问一次且只访问一次.图的遍历操作和树的遍历操作功能相似.图的遍历是图的一种基本操作,图的许多其它操作都是建立在遍历操作的基础之上.