Shortest path in a complement graph

// Java implementation to find the 
// shortest path in a complement graph 
import java.io.*;
import java.util.*;

public 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