[学习记录]BFS思路详解

[学习记录]BFS思路详解

广度优先搜索在进一步遍历图中顶点之前，先访问当前顶点的所有邻接结点,按照如下步骤遍历：

a .首先选择一个顶点作为起始结点，并将其染成灰色，其余结点为白色。

b. 将起始结点放入队列中。

c. 从队列首部选出一个顶点，并找出所有与之邻接的结点，将找到的邻接结点放入队列尾部，将已访问过结点涂成黑色，没访问过的结点是白色。如果顶点的颜色是灰色，表示已经发现并且放入了队列，如果顶点的颜色是白色，表示还没有发现

d. 按照同样的方法处理队列中的下一个结点。

基本就是出队的顶点变成黑色，在队列里的是灰色，还没入队的是白色。

图解

1.初始状态，从顶点1开始，队列={1}

2.访问1的邻接顶点，1出队变黑，2,3入队，队列={2,3,}

3.访问2的邻接结点，2出队，4入队，队列={3,4}

4.访问3的邻接结点，3出队，队列={4}

5.访问4的邻接结点，4出队，队列={ 空}

上面的图可以通过如下邻接矩阵表示：

1  int maze[5][5] = {
2     { 0, 1, 1, 0, 0 },
3     { 0, 0, 1, 1, 0 },
4     { 0, 1, 1, 1, 0 },
5     { 1, 0, 0, 0, 0 },
6     { 0, 0, 1, 1, 0 }
7 };

BFS实现：

 1 #include <bits/stdc++.h>
 2 #define N 5
 3 using namespace std;
 4 int maze[N][N] = {
 5     { 0, 1, 1, 0, 0 },
 6     { 0, 0, 1, 1, 0 },
 7     { 0, 1, 1, 1, 0 },
 8     { 1, 0, 0, 0, 0 },
 9     { 0, 0, 1, 1, 0 }
10 };
11 int visited[N + 1] = { 0, };
12 void BFS(int start)
13 {
14     queue<int> Q;
15     Q.push(start);
16     visited[start] = 1;
17     while (!Q.empty())
18     {
19         int front = Q.front();
20         cout << front << " ";
21         Q.pop();
22         for (int i = 1; i <= N; i++)
23         {
24             if (!visited[i] && maze[front - 1][i - 1] == 1)
25             {
26                 visited[i] = 1;
27                 Q.push(i);
28             }
29         }
30     }
31 }
32 int main()
33 {
34     for (int i = 1; i <= N; i++)
35     {
36         if (visited[i] == 1)
37             continue;
38         BFS(i);
39     }
40     return 0;
41 }

总的来说，如果DFS是单个推进，那么BFS就是单层推进，其遍历时空效率常高于DFS，其原因就是在使用后pop出队列的“抛弃策略”。