Given an **undirected non-weighted graph G**. For a given node **start** return the shortest path that is the number of edges from start to all the nodes in the complement graph of G.

Complement Graphis a graph such that it contains only those edges which are not present in the original graph.

**Examples:**

Input:Undirected Edges = (1, 2), (1, 3), (3, 4), (3, 5), Start = 1

Output:0 2 3 1 1

Explanation:

Original Graph:

Complement Graph:

The distance from 1 to every node in the complement graph are:

1 to 1 = 0,

1 to 2 = 2,

1 to 3 = 3,

1 to 4 = 1,

1 to 5 = 1

**Naive Approach:** A Simple solution will be to create the complement graph and use Breadth-First Search on this graph to find the distance to all the nodes.

**Time complexity:** O(n^{2}) for creating the complement graph and O(n + m) for breadth first search.

**Efficient Approach:** The idea is to use **Modified Breadth-First Search** to calculate the answer and then there is no need to construct the complement graph.

- For each vertex or node, reduce the distance of a vertex which is a complement to the current vertex and has not been discovered yet.
- For the problem, we have to observe that if the Graph is Sparse then the undiscovered nodes will be visited very fast.

Below is the implementation of the above approach:

`// CPP implementation to find the ` `// shortest path in a complement graph ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `const` `int` `inf = 100000; ` ` ` `void` `bfs(` `int` `start, ` `int` `n, ` `int` `m, ` ` ` `map<pair<` `int` `, ` `int` `>, ` `int` `> edges) ` `{ ` ` ` `int` `i; ` ` ` ` ` `// List of undiscovered vertices ` ` ` `// initially it will contain all ` ` ` `// the vertices of the graph ` ` ` `set<` `int` `> undiscovered; ` ` ` ` ` `// Distance will store the distance ` ` ` `// of all vertices from start in the ` ` ` `// complement graph ` ` ` `vector<` `int` `> distance_node(10000); ` ` ` ` ` `for` `(i = 1; i <= n; i++) { ` ` ` ` ` `// All vertices are undiscovered ` ` ` `undiscovered.insert(i); ` ` ` ` ` `// Let initial distance be infinity ` ` ` `distance_node[i] = inf; ` ` ` `} ` ` ` ` ` `undiscovered.erase(start); ` ` ` `distance_node[start] = 0; ` ` ` `queue<` `int` `> q; ` ` ` ` ` `q.push(start); ` ` ` ` ` `// Check if queue is not empty and the ` ` ` `// size of undiscovered vertices ` ` ` `// is greater than 0 ` ` ` `while` `(undiscovered.size() && !q.empty()) { ` ` ` `int` `cur = q.front(); ` ` ` `q.pop(); ` ` ` ` ` `// Vector to store all the complement ` ` ` `// vertex to the current vertex ` ` ` `// which has not been ` ` ` `// discovered or visited yet. ` ` ` `vector<` `int` `> complement_vertex; ` ` ` ` ` `for` `(` `int` `x : undiscovered) { ` ` ` `if` `(edges.count({ cur, x }) == 0) ` ` ` `complement_vertex.push_back(x); ` ` ` `} ` ` ` `for` `(` `int` `x : complement_vertex) { ` ` ` ` ` `// Check if optimal change ` ` ` `// the distance of this ` ` ` `// complement vertex ` ` ` `if` `(distance_node[x] ` ` ` `> distance_node[cur] + 1) { ` ` ` `distance_node[x] ` ` ` `= distance_node[cur] + 1; ` ` ` `q.push(x); ` ` ` `} ` ` ` ` ` `// Finally this vertex has been ` ` ` `// discovered so erase it from ` ` ` `// undiscovered vertices list ` ` ` `undiscovered.erase(x); ` ` ` `} ` ` ` `} ` ` ` `// Print the result ` ` ` `for` `(` `int` `i = 1; i <= n; i++) ` ` ` `cout << distance_node[i] << ` `" "` `; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `// n is the number of vertex ` ` ` `// m is the number of edges ` ` ` `// start - starting vertex is 1 ` ` ` `int` `n = 5, m = 4; ` ` ` ` ` `// Using edge hashing makes the ` ` ` `// algorithm faster and we can ` ` ` `// avoid the use of adjacency ` ` ` `// list representation ` ` ` `map<pair<` `int` `, ` `int` `>, ` `int` `> edges; ` ` ` ` ` `// Initial edges for ` ` ` `// the original graph ` ` ` `edges[{ 1, 3 }] = 1, ` ` ` `edges[{ 3, 1 }] = 1; ` ` ` `edges[{ 1, 2 }] = 1, ` ` ` `edges[{ 2, 1 }] = 1; ` ` ` `edges[{ 3, 4 }] = 1, ` ` ` `edges[{ 4, 3 }] = 1; ` ` ` `edges[{ 3, 5 }] = 1, ` ` ` `edges[{ 5, 3 }] = 1; ` ` ` ` ` `bfs(1, n, m, edges); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

0 2 3 1 1

**Time complexity:** O(V+E)

**Auxiliary Space:** O(V)

## Recommended Posts:

- Shortest path in an unweighted graph
- Multistage Graph (Shortest Path)
- Shortest Path in Directed Acyclic Graph
- 0-1 BFS (Shortest Path in a Binary Weight Graph)
- Multi Source Shortest Path in Unweighted Graph
- Shortest Path in a weighted Graph where weight of an edge is 1 or 2
- Shortest path with exactly k edges in a directed and weighted graph | Set 2
- Shortest path in a directed graph by Dijkstra’s algorithm
- Shortest path with exactly k edges in a directed and weighted graph
- Check if given path between two nodes of a graph represents a shortest paths
- Building an undirected graph and finding shortest path using Dictionaries in Python
- Shortest path in a graph from a source S to destination D with exactly K edges for multiple Queries
- Shortest path from source to destination such that edge weights along path are alternatively increasing and decreasing
- Convert the undirected graph into directed graph such that there is no path of length greater than 1
- Shortest path on a Square
- Shortest Path Faster Algorithm
- Some interesting shortest path questions | Set 1
- Shortest Path using Meet In The Middle
- Shortest path in a Binary Maze
- Dijkstra’s shortest path algorithm using set in STL

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.