Clone Graph

Moderate
0/80
Average time to solve is 25m
profile
Contributed by
48 upvotes
Asked in companies
UberAppleGoogle

Problem statement

You are given a reference/address of a node in a connected undirected graph containing N nodes and M edges. You are supposed to return a clone of the given graph which is nothing but a deep copy. Each node in the graph contains an integer “data” and an array/list of its neighbours.

The structure of the graphNode class is as follows:

class graphNode 
{  
    public:
        int data;
        vector<graphNode*> neighbours;
}
Note :
1. Nodes are numbered from 1 to N.

2. Your solution will run on multiple test cases. If you are using global variables make sure to clear them.
Detailed explanation ( Input/output format, Notes, Images )
Input Format :
The first line of input contains an integer 'T' representing the number of the test case. Then the test cases are as follows.

The first line of each test case contains a single integer ‘N’ representing the number of nodes in the graph.

The second line of each test case contains a single integer ‘M’ representing the number of edges. 

The next ‘M’ lines in each test case contain two integers ‘U’ and ‘V’ separated by a single space denoting an undirected edge between nodes U and V. 
Output Format :
For each test case, print a single line containing "true" if the graph is cloned correctly otherwise it will print "false".

The output of each test case will be printed in a separate line.
Note :
You do not need to print anything; It has already been taken care of. Just implement the given function.
Constraints :
1 <= T <= 5
2 <= N <= 100000
1 <= M <= min(N(N-1)/2,100000)
1 <= E[i][0], E[i][1] <= N

Where  ‘N’ is the number of nodes in the given graph, ‘M’ denotes the number of edges and ‘E’ denotes the edge matrix.

Time Limit: 1 sec.
Sample Input 1 :
2
5
6
1 2
4 1
2 4
3 4
5 2
1 3
3
2
1 2
1 3
Sample Output 1 :
true
true
Explanation of Input 1 :
In the first test case, the returned graph contains 5 nodes and 6 edges which are:
1 2
4 1
2 4
3 4
5 2
1 3
Since it is similar to the given graph with different address nodes then the solution is correct.

In the second test case, the returned graph contains 3 nodes and 2 edges which are:
1 2
1 3
Since it is similar to the given graph with different address nodes then the solution is correct.
Sample Input 2 :
2
5
4
1 2
2 3
3 4
4 5
2
1
1 2
Sample Output 2 :
true
true
Explanation of Input 2 :
In the first test case, the returned graph contains 5 nodes and 4 edges which are:
1 2
2 3
3 4
4 5
Since it is similar to the given graph with different address nodes then the solution is correct.

In the second test case, the returned graph contains 2 nodes and 1 edge which is:
1 2

Since it is similar to the given graph with different address nodes then the solution is correct.
Hint

Think of BFS graph traversal algorithm.

Approaches (2)
BFS Graph Traversal

To clone a graph, we will need to traverse it. The approach here is to use BFS graph traversal. To clone a graph, you need to have a copy of each node and you need to avoid copying the same node multiple times. So we need a mapping from an original node to its copy.

 

The steps are as follows :
 

  1. We need to keep track of the visited/cloned nodes to avoid making multiple copies of the same node. Hence, a HashMap is required in order to maintain all the nodes which have already been created. Where in the HashMap the key stores the address of the original node and the value stores the address of the cloned node.
  2. Now in order to reach each node and its neighbours, we are creating a queue for BFS traversal and a HashMap which keeps a track of all the nodes which are already created.
  3. Create a new node corresponding to the given reference node and insert that node in the HashMap which marks it as visited.
  4. Push the given reference node into a queue and now keep repeating the below steps until the queue isn’t empty.
  5. Get the front node and pop it from the queue and visit all its neighbours, now check if a new cloned node has already been created for each neighbouring node (check it in the HashMap).
  6. If it wasn’t created, then create a new clone node corresponding to the neighbour node and insert it into the HashMap and also push this node into the queue.
  7. Now add the cloned neighbours to “neighbours” list of the cloned node.
  8. Ultimately when the queue is empty, return the source node of the cloned graph.

 

Time Complexity

O(N + M), where ‘N’ is the number of nodes and ‘M’ is the number of edges.

 

In order to clone a graph, we visit each node and traverse each edge exactly once. The Breadth-First Search traversal takes O(N+M) time. Push and pop operations in a queue take constant time. Thus, the overall time complexity will be O(N+M).

Space Complexity

O(N), where ‘N’ is the number of nodes.

 

The queue in the BFS approach takes the space equivalent to the width of the graph and in the worst-case scenario, it can go up to O(N). Thus the overall space complexity will be O(N).

Video Solution
Unlock at level 3
(75% EXP penalty)
Code Solution
(100% EXP penalty)
Clone Graph
Full screen
Console