Those people who develop the ability to continuously acquire new and better forms of knowledge that they can apply to their work and to their lives will be the movers and shakers in our society for the indefinite future.

Breadth-First Search is another fundamental algorithm in graph theory, it's a must to know!.

For this algorithm we need a queue.

` ````
#include <iostream>
#include <vector>
#include <queue>
#include <cstdlib>
using namespace std;
// Maximum number of nodes.
const int N = 10;
void bfs(vector<int> graph[], int root) {
vector<bool> visited(N, false);
queue<int> Q;
queue<int> L; // To mark levels.
Q.push(root);
L.push(0); // The root is at level 0.
visited[root] = true;
int prev = 0;
while (!Q.empty()) {
int u = Q.front();
int l = L.front();
Q.pop();
L.pop();
// Each level in it's own line.
if (prev != l) {
cout << endl;
}
prev = l;
cout << u << " ";
for (int v : graph[u]) {
if (!visited[v]) {
visited[v] = true;
Q.push(v);
L.push(l + 1); // Childs of u are part of the next level.
}
}
}
}
int main(int argc, char **argv) {
vector<int> graph[N];
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
graph[u].push_back(v);
graph[v].push_back(u);
}
// Start Breadth-First Search at node 0
bfs(graph, 0);
return EXIT_SUCCESS;
}
```

Example input(figure ? ):

` ````
5 4
0 1
0 2
2 4
2 3
```

Example output:

` ````
0
1 2
4 3
```

And that's it. Remember, Breadth-First Search must be part of your toolbox!