Clone Graph

Problem

https://leetcode.com/problems/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.

Pattern

Hash Table, Depth-First Search, Breadth-First Search, Graph Theory

Approaches

BFS

Explanation

The trick is to use a old2new = defaultdict(Node) to map the original node to its clone. The defaultdict creates the cloned node automatically if one doesn’t exist which greatly simplifies the code.

We use BFS to visit each node in the graph. For each node, we set the value of the cloned node to be the same as the original node and the neighbors to the cloned neighbors using old2new[neighbor]. We keep track of the starting_node so that we can return the clone old2new[starting_node] at the end.

Code

from __future__ import annotations

from collections import defaultdict, deque


class Node:
    """Node in a graph with adjacency list."""

    def __init__(self, val: int = 0, neighbors: list | None = None):
        self.val = val
        self.neighbors = neighbors if neighbors is not None else []


"""
class Node:
    def __init__(val = 0, neighbors = None):
        self.val = val
        self.neighbors = neighbors if neighbors is not None else []
"""


def cloneGraph(node: "Node" | None) -> "Node" | None:
    """Return a deep copy of the graph reachable from ``node``."""
    if node is None:
        return None

    stack = deque()
    stack.append(node)

    old2new = defaultdict(Node)
    visited = set()
    while stack:
        old_node = stack.pop()

        if old_node in visited:
            continue

        visited.add(old_node)

        new_node = old2new[old_node]
        new_node.val = old_node.val
        new_node.neighbors = [
            old2new[neighbor] for neighbor in old_node.neighbors
        ]

        stack.extend(old_node.neighbors)

    return old2new[node]

Test

>>> from clone_graph__bfs import cloneGraph, Node
>>> node1 = Node(1); node2 = Node(2); node3 = Node(3); node4 = Node(4)
>>> node1.neighbors = [node2, node4]; node2.neighbors = [node1, node3]
>>> node3.neighbors = [node2, node4]; node4.neighbors = [node1, node3]
>>> clone = cloneGraph(node1)
>>> clone is not node1 and clone.val == 1
True
>>> cloneGraph(None) is None
True

Complexity

\(n\) is the number of nodes in the graph

Measure	Complexity	Notes
Time	\(O(n)\)	visit each node once
Auxiliary Space	\(O(n)\)	old2new dictionary stores all the original nodes and cloned nodes

class clone_graph__bfs.Node(val: int = 0, neighbors: list | None = None)

Bases: object

Node in a graph with adjacency list.

clone_graph__bfs.cloneGraph(node: 'Node' | None) → 'Node' | None

Return a deep copy of the graph reachable from node.