[Leetcode] 133. Clone Graph

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.

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.

How to understand?

There is a connected graph, clone the graph from the given adjacent list.

How to approach?

DFS

class Solution:

    def cloneGraph(self, node: Optional["Node"]) -> Optional["Node"]:
        if not node:
          return None
          
        oldToNew = {}

        def dfs(node):
            if node in oldToNew:
                return oldToNew[node]
            
            copy = Node(node.val)
            oldToNew[node] = copy
            
            for nei in node.neighbors:
                copy.neighbors.append(dfs(nei))
                
            return copy

        return dfs(node)

create Old to New dictionary. key will be node and value will be cloned node
create dfs function takes node as input
when the node is in the dictionary, return the value of the key.
create copy using Node class and node.val.
and put node as key and copy as value.
create for loop to use the neighbor in node.neighbors
append the result of the dfs(neighbor) to the copy's neighbors.
and return the copy in dfs function.
lastly return the dfs(node) result if node does exist.

BFS

class Solution:

    def cloneGraph(self, node: Optional["Node"]) -> Optional["Node"]:
        if not node:
            return None

        cloned = {}
        cloned[node] = Node(node.val, [])
        queue = collections.deque([node])

        while queue:
            curr = queue.popleft()

            for neig in curr.neighbors:
                if neig not in cloned:
                    cloned[neig] = Node(neig.val, [])
                    queue.append(neig)

                cloned[curr].neighbors.append(cloned[neig])


        return cloned[node]

create cloned dictionary
and put node key with the value using Node class and node.val
create queue to put the first value as [node] since deque expects iterable list.
while condition to check the queue has items to check.
pop left the item in the deque and set it as curr
for loop to check the current items' neighbor
when cloned doesn't have the neighbor in it, it will create the Node using neig.val and put it as value of the key neig in cloned.
and append the neig in queue
in for loop, append the cloned[neig] in cloned's current item's neighbors list⇒"Append the cloned version of the neighbor (cloned[neig]) to the cloned version of the current node (cloned[curr])'s neighbor list."
return the cloned[node] lastly.