Given a connected graph with **N** vertices and **M** edges. The task is to print the lexicographically smallest BFS traversal of the graph starting from 1.

**Note**: The vertices are numbered from 1 to N.

**Examples:**

Input: N = 5, M = 5 Edges: 1 4 3 4 5 4 3 2 1 5Output: 1 4 3 2 5 Start from 1, go to 4, then to 3 and then to 2 and to 5.Input: N = 3, M = 2 Edges: 1 2 1 3Output: 1 2 3

**Approach:** Instead of doing a normal BFS traversal on the graph, we can use a priority queue(min heap) instead of a simple queue. When a node is visited add its adjacent nodes into the priority queue. Every time, we visit a new node, it will be the one with the smallest index in the priority queue. Print the nodes when every time we visit them starting from 1.

Below is the implementation of the above approach:

`// C++ program to print the lexcicographically ` `// smallest path starting from 1 ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to print the smallest lexicographically ` `// BFS path starting from 1 ` `void` `printLexoSmall(vector<` `int` `> adj[], ` `int` `n) ` `{ ` ` ` `// Visited array ` ` ` `bool` `vis[n + 1]; ` ` ` `memset` `(vis, 0, ` `sizeof` `vis); ` ` ` ` ` `// Minimum Heap ` ` ` `priority_queue<` `int` `, vector<` `int` `>, greater<` `int` `> > Q; ` ` ` ` ` `// First one visited ` ` ` `vis[1] = ` `true` `; ` ` ` `Q.push(1); ` ` ` ` ` `// Iterate till all nodes are visited ` ` ` `while` `(!Q.empty()) { ` ` ` ` ` `// Get the top element ` ` ` `int` `now = Q.top(); ` ` ` ` ` `// Pop the element ` ` ` `Q.pop(); ` ` ` ` ` `// Print the current node ` ` ` `cout << now << ` `" "` `; ` ` ` ` ` `// Find adjacent nodes ` ` ` `for` `(` `auto` `p : adj[now]) { ` ` ` ` ` `// If not visited ` ` ` `if` `(!vis[p]) { ` ` ` ` ` `// Push ` ` ` `Q.push(p); ` ` ` ` ` `// Mark as visited ` ` ` `vis[p] = ` `true` `; ` ` ` `} ` ` ` `} ` ` ` `} ` `} ` ` ` `// Function to insert edges in the graph ` `void` `insertEdges(` `int` `u, ` `int` `v, vector<` `int` `> adj[]) ` `{ ` ` ` `adj[u].push_back(v); ` ` ` `adj[v].push_back(u); ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `int` `n = 5, m = 5; ` ` ` `vector<` `int` `> adj[n + 1]; ` ` ` ` ` `// Insert edges ` ` ` `insertEdges(1, 4, adj); ` ` ` `insertEdges(3, 4, adj); ` ` ` `insertEdges(5, 4, adj); ` ` ` `insertEdges(3, 2, adj); ` ` ` `insertEdges(1, 5, adj); ` ` ` ` ` `// Function call ` ` ` `printLexoSmall(adj, n); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

1 4 3 2 5

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Print the lexicographically smallest DFS of the graph starting from 1
- Breadth First Search or BFS for a Graph
- Check if a given directed graph is strongly connected | Set 2 (Kosaraju using BFS)
- 0-1 BFS (Shortest Path in a Binary Weight Graph)
- BFS for Disconnected Graph
- Detect cycle in an undirected graph using BFS
- Detect Cycle in a Directed Graph using BFS
- Islands in a graph using BFS
- Print all paths from a given source to a destination using BFS
- Program to print all the non-reachable nodes | Using BFS
- Lexicographically Smallest Topological Ordering
- BFS vs DFS for Binary Tree
- Traversing directory in Java using BFS
- BFS using STL for competitive coding
- Water Jug problem using BFS
- Diameter of n-ary tree using BFS
- Level of Each node in a Tree from source node (using BFS)
- Count the number of nodes at given level in a tree using BFS.
- BFS using vectors & queue as per the algorithm of CLRS
- Finding the path from one vertex to rest using BFS

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.