Clone Graph

Leetcode Daily Challenge (8th April, 2023)

8 April, 2023

Contributors

Lakshit Chiranjiv Sagar

@lakshit-cs

Problem Statement:-

Given a reference of a node in a connected undirected graph.

Return a deep copy (clone) of the graph.

Each node in the graph contains a value (int) and a list (List[Node]) of its neighbors.

class Node {
    public int val;
    public List<Node> neighbors;
}

Test case format:

For simplicity, each node's value is the same as the node's index (1-indexed). For example, the first node with val == 1, the second node with val == 2, and so on. The graph is represented in the test case using an adjacency list.

An adjacency list is a collection of unordered lists used to represent a finite graph. Each list describes the set of neighbors of a node in the graph.

The given node will always be the first node with val = 1. You must return the copy of the given node as a reference to the cloned graph.

Link: https://leetcode.com/problems/clone-graph/description/

Problem Explanation with examples:-

Example 1

Input: adjList = [[2,4],[1,3],[2,4],[1,3]]
Output: [[2,4],[1,3],[2,4],[1,3]]
Explanation: There are 4 nodes in the graph.
1st node (val = 1)'s neighbors are 2nd node (val = 2) and 4th node (val = 4).
2nd node (val = 2)'s neighbors are 1st node (val = 1) and 3rd node (val = 3).
3rd node (val = 3)'s neighbors are 2nd node (val = 2) and 4th node (val = 4).
4th node (val = 4)'s neighbors are 1st node (val = 1) and 3rd node (val = 3).

Example 2

Input: adjList = [[]]
Output: [[]]
Explanation: Note that the input contains one empty list. The graph consists of only one node with val = 1 and it does not have any neighbors.

Example 3

Input: adjList = []
Output: []
Explanation: This an empty graph, it does not have any nodes.

Constraints

The number of nodes in the graph is in the range [0, 100].
1 <= Node.val <= 100
Node.val is unique for each node.
There are no repeated edges and no self-loops in the graph.
The Graph is connected and all nodes can be visited starting from the given node.

Intuition:-

We use a dfs to traverse the graph and create a copy of it.
Use a visited array to keep track of the nodes that have been visited.
If the node has not been visited, then we create a new node and add it to the neighbors of the current node.
We then call dfs on the new node and the original node.
If the node has been visited, then we add the visited node to the neighbors of the current node.

Solution:-

If the node is None, then we return None.
We create a copy of the node and a visited array of size 101.
We call dfs on the original node and the copy of the node.
In dfs, we mark the copy of the node as visited.
For each neighbor of the original node, if the neighbor has not been visited, then we create a new node and add it to the neighbors of the copy of the node.
We then call dfs on the new node and the original node.
If the neighbor has been visited, then we add the visited node to the neighbors of the copy of the node.
Return the copy of the node at the end.

Code:-

JAVA Solution

class Solution {
    public void dfs(Node node , Node copy , Node[] visited){
        visited[copy.val] = copy;
        

        for(Node n : node.neighbors){

            if(visited[n.val] == null){
                Node newNode = new Node(n.val);
                copy.neighbors.add(newNode);
                dfs(n , newNode , visited);
            }
            else{
                copy.neighbors.add(visited[n.val]);
            }
        }
        
    }
    public Node cloneGraph(Node node) {
        if(node == null) return null; 
        
        Node copy = new Node(node.val); 
        Node[] visited = new Node[101]; 
        dfs(node , copy , visited); 
        return copy;
    }
}

Python Solution

class Solution:
    def cloneGraph(self, node: 'Node') -> 'Node':
        def dfs(node,copy,vis):
            vis[copy.val] = copy

            for n in node.neighbors:
                if vis[n.val] == None:
                    newNode = Node(n.val)
                    copy.neighbors.append(newNode)
                    dfs(n, newNode, vis)
                else:
                    copy.neighbors.append(vis[n.val])

        if not node:
            return None
        
        copy = Node(node.val)
        vis = [None]*101
        dfs(node,copy,vis)

        return copy

Complexity Analysis:-

TIME:-

The time complexity is O(n) where n is the number of nodes in the graph. We visit each node once.

SPACE:-

The space complexity is O(n) where n is the number of nodes in the graph. We use a visited array of size n and a recursive stack of size n.

References:-

DFS

Connect with me:-

java

python

leetcode

dsa