Shortest path in a complement graph
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 Graph is 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(n2) 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:
C++
// C++ 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 && edges.count({ x, cur })==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; } |
Java
// Java implementation to find the // shortest path in a complement graph import java.io.*; import java.util.*; class GFG{ // Pair class is made so as to // store the edges between nodes static class Pair { int left; int right; public Pair( int left, int right) { this .left = left; this .right = right; } // We need to override hashCode so that // we can use Set's properties like contains() @Override public int hashCode() { final int prime = 31 ; int result = 1 ; result = prime * result + left; result = prime * result + right; return result; } @Override public boolean equals( Object other ) { if ( this == other){ return true ;} if (other instanceof Pair) { Pair m = (Pair)other; return this .left == m.left && this .right == m.right; } return false ; } } public static void bfs( int start, int n, int m, Set<Pair> edges) { int i; // List of undiscovered vertices // initially it will contain all // the vertices of the graph Set<Integer> undiscovered = new HashSet<>(); // Distance will store the distance // of all vertices from start in the // complement graph int [] distance_node = new int [ 1000 ]; for (i = 1 ; i <= n; i++) { // All vertices are undiscovered initially undiscovered.add(i); // Let initial distance be maximum value distance_node[i] = Integer.MAX_VALUE; } // Start is discovered undiscovered.remove(start); // Distance of the node to itself is 0 distance_node[start] = 0 ; // Queue used for BFS Queue<Integer> q = new LinkedList<>(); q.add(start); // Check if queue is not empty and the // size of undiscovered vertices // is greater than 0 while (undiscovered.size() > 0 && !q.isEmpty()) { // Current node int cur = q.peek(); q.remove(); // Vector to store all the complement // vertex to the current vertex // which has not been // discovered or visited yet. List<Integer>complement_vertex = new ArrayList<>(); for ( int x : undiscovered) { Pair temp1 = new Pair(cur, x); Pair temp2 = new Pair(x, cur); // Add the edge if not already present if (!edges.contains(temp1) && !edges.contains(temp2)) { complement_vertex.add(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.add(x); } // Finally this vertex has been // discovered so erase it from // undiscovered vertices list undiscovered.remove(x); } } // Print the result for (i = 1 ; i <= n; i++) System.out.print(distance_node[i] + " " ); } // Driver code public static void main(String[] args) { // 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 Set<Pair> edges = new HashSet<>(); // Initial edges for // the original graph edges.add( new Pair( 1 , 3 )); edges.add( new Pair( 3 , 1 )); edges.add( new Pair( 1 , 2 )); edges.add( new Pair( 2 , 1 )); edges.add( new Pair( 3 , 4 )); edges.add( new Pair( 4 , 3 )); edges.add( new Pair( 3 , 5 )) ; edges.add( new Pair( 5 , 3 )); Pair t = new Pair( 1 , 3 ); bfs( 1 , n, m, edges); } } // This code is contributed by kunalsg18elec |
0 2 3 1 1
Time complexity: O(V+E)
Auxiliary Space: O(V)