Clone Graph
LeetCode 133 | Difficulty: Medium
MediumProblem Description
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 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.
Topics: Hash Table, Depth-First Search, Breadth-First Search, Graph Theory
Approach
BFS (Graph/Matrix)
Use a queue to explore nodes level by level. Start from source node(s), visit all neighbors before moving to the next level. BFS naturally finds shortest paths in unweighted graphs.
Shortest path in unweighted graph, level-order processing, spreading/flood fill.
Graph Traversal
Model the problem as a graph (nodes + edges). Choose BFS for shortest path or DFS for exploring all paths. For dependency ordering, use topological sort (Kahn's BFS or DFS with finish times).
Connectivity, shortest path, cycle detection, dependency ordering.
Hash Map
Use a hash map for O(1) average lookups. Store seen values, frequencies, or indices. The key question: what should I store as key, and what as value?
Need fast lookups, counting frequencies, finding complements/pairs.
Solutions
Solution 1: C# (Best: 152 ms)
| Metric | Value |
|---|---|
| Runtime | 152 ms |
| Memory | 26.3 MB |
| Date | 2019-12-31 |
/*
// Definition for a Node.
public class Node {
public int val;
public IList<Node> neighbors;
public Node(){}
public Node(int _val,IList<Node> _neighbors) {
val = _val;
neighbors = _neighbors;
}
*/
public class Solution {
public Node CloneGraph(Node node) {
if(node == null) return null;
Dictionary<Node, Node> map = new Dictionary<Node, Node>();
Node newNode = new Node(node.val, new List<Node>());
map.Add(node,newNode);
Queue<Node> queue = new Queue<Node>();
queue.Enqueue(node);
while(queue.Count != 0) {
Node n = queue.Dequeue();
foreach (var neighbor in n.neighbors)
{
if(!map.ContainsKey(neighbor))
{
map.Add(neighbor, new Node(neighbor.val, new List<Node>()));
queue.Enqueue(neighbor);
}
map[n].neighbors.Add(map[neighbor]);
}
}
return newNode;
}
}
📜 2 more C# submission(s)
Submission (2019-12-31) — 160 ms, 26 MB
/*
// Definition for a Node.
public class Node {
public int val;
public IList<Node> neighbors;
public Node(){}
public Node(int _val,IList<Node> _neighbors) {
val = _val;
neighbors = _neighbors;
}
*/
public class Solution {
public Node CloneGraph(Node node) {
if(node == null) return null;
Dictionary<Node, Node> map = new Dictionary<Node, Node>();
Node newNode = new Node(node.val, new List<Node>());
map.Add(node,newNode);
Queue<Node> queue = new Queue<Node>();
queue.Enqueue(node);
while(queue.Count != 0) {
Node n = queue.Dequeue();
foreach (var neighbor in n.neighbors)
{
if(!map.ContainsKey(neighbor))
{
map.Add(neighbor, new Node(neighbor.val, new List<Node>()));
queue.Enqueue(neighbor);
}
map[n].neighbors.Add(map[neighbor]);
}
}
return newNode;
}
}
Submission (2022-02-23) — 208 ms, 42.2 MB
/*
// Definition for a Node.
public class Node {
public int val;
public IList<Node> neighbors;
public Node(){}
public Node(int _val,IList<Node> _neighbors) {
val = _val;
neighbors = _neighbors;
}
*/
public class Solution {
public Node CloneGraph(Node node) {
if(node == null) return null;
Dictionary<Node, Node> map = new Dictionary<Node, Node>();
Node newNode = new Node(node.val, new List<Node>());
map.Add(node,newNode);
Queue<Node> queue = new Queue<Node>();
queue.Enqueue(node);
while(queue.Count != 0) {
Node n = queue.Dequeue();
foreach (var neighbor in n.neighbors)
{
if(!map.ContainsKey(neighbor))
{
map.Add(neighbor, new Node(neighbor.val, new List<Node>()));
queue.Enqueue(neighbor);
}
map[n].neighbors.Add(map[neighbor]);
}
}
return newNode;
}
}
Complexity Analysis
| Approach | Time | Space |
|---|---|---|
| Graph BFS/DFS | $O(V + E)$ | $O(V)$ |
| Hash Map | $O(n)$ | $O(n)$ |
Interview Tips
- Discuss the brute force approach first, then optimize. Explain your thought process.
- Ask about graph properties: directed/undirected, weighted/unweighted, cycles, connectivity.
- Hash map gives O(1) lookup — think about what to use as key vs value.