Mutating counts without cleanup
Wrong move: Zero-count keys stay in map and break distinct/count constraints.
Usually fails on: Window/map size checks are consistently off by one.
Fix: Delete keys when count reaches zero.
Move from brute-force thinking to an efficient approach using hash map strategy.
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:
[0, 100].1 <= Node.val <= 100Node.val is unique for each node.Problem summary: 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.
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Hash Map
[[2,4],[1,3],[2,4],[1,3]]
[[]]
[]
copy-list-with-random-pointer)clone-binary-tree-with-random-pointer)clone-n-ary-tree)Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #133: Clone Graph
/*
// Definition for a Node.
class Node {
public int val;
public List<Node> neighbors;
public Node() {
val = 0;
neighbors = new ArrayList<Node>();
}
public Node(int _val) {
val = _val;
neighbors = new ArrayList<Node>();
}
public Node(int _val, ArrayList<Node> _neighbors) {
val = _val;
neighbors = _neighbors;
}
}
*/
class Solution {
private Map<Node, Node> g = new HashMap<>();
public Node cloneGraph(Node node) {
return dfs(node);
}
private Node dfs(Node node) {
if (node == null) {
return null;
}
Node cloned = g.get(node);
if (cloned == null) {
cloned = new Node(node.val);
g.put(node, cloned);
for (Node nxt : node.neighbors) {
cloned.neighbors.add(dfs(nxt));
}
}
return cloned;
}
}
// Accepted solution for LeetCode #133: Clone Graph
/**
* Definition for a Node.
* type Node struct {
* Val int
* Neighbors []*Node
* }
*/
func cloneGraph(node *Node) *Node {
g := map[*Node]*Node{}
var dfs func(node *Node) *Node
dfs = func(node *Node) *Node {
if node == nil {
return nil
}
if n, ok := g[node]; ok {
return n
}
cloned := &Node{node.Val, []*Node{}}
g[node] = cloned
for _, nxt := range node.Neighbors {
cloned.Neighbors = append(cloned.Neighbors, dfs(nxt))
}
return cloned
}
return dfs(node)
}
# Accepted solution for LeetCode #133: Clone Graph
"""
# Definition for a Node.
class Node:
def __init__(self, val = 0, neighbors = None):
self.val = val
self.neighbors = neighbors if neighbors is not None else []
"""
from typing import Optional
class Solution:
def cloneGraph(self, node: Optional["Node"]) -> Optional["Node"]:
def dfs(node):
if node is None:
return None
if node in g:
return g[node]
cloned = Node(node.val)
g[node] = cloned
for nxt in node.neighbors:
cloned.neighbors.append(dfs(nxt))
return cloned
g = defaultdict()
return dfs(node)
// Accepted solution for LeetCode #133: Clone Graph
// Rust example auto-generated from java reference.
// Replace the signature and local types with the exact LeetCode harness for this problem.
impl Solution {
pub fn rust_example() {
// Port the logic from the reference block below.
}
}
// Reference (java):
// // Accepted solution for LeetCode #133: Clone Graph
// /*
// // Definition for a Node.
// class Node {
// public int val;
// public List<Node> neighbors;
// public Node() {
// val = 0;
// neighbors = new ArrayList<Node>();
// }
// public Node(int _val) {
// val = _val;
// neighbors = new ArrayList<Node>();
// }
// public Node(int _val, ArrayList<Node> _neighbors) {
// val = _val;
// neighbors = _neighbors;
// }
// }
// */
//
// class Solution {
// private Map<Node, Node> g = new HashMap<>();
//
// public Node cloneGraph(Node node) {
// return dfs(node);
// }
//
// private Node dfs(Node node) {
// if (node == null) {
// return null;
// }
// Node cloned = g.get(node);
// if (cloned == null) {
// cloned = new Node(node.val);
// g.put(node, cloned);
// for (Node nxt : node.neighbors) {
// cloned.neighbors.add(dfs(nxt));
// }
// }
// return cloned;
// }
// }
// Accepted solution for LeetCode #133: Clone Graph
/**
* Definition for _Node.
* class _Node {
* val: number
* neighbors: _Node[]
*
* constructor(val?: number, neighbors?: _Node[]) {
* this.val = (val===undefined ? 0 : val)
* this.neighbors = (neighbors===undefined ? [] : neighbors)
* }
* }
*
*/
function cloneGraph(node: _Node | null): _Node | null {
const g: Map<_Node, _Node> = new Map();
const dfs = (node: _Node | null): _Node | null => {
if (!node) {
return null;
}
if (g.has(node)) {
return g.get(node);
}
const cloned = new _Node(node.val);
g.set(node, cloned);
for (const nxt of node.neighbors) {
cloned.neighbors.push(dfs(nxt));
}
return cloned;
};
return dfs(node);
}
Use this to step through a reusable interview workflow for this problem.
For each element, scan the rest of the array looking for a match. Two nested loops give n × (n−1)/2 comparisons = O(n²). No extra space since we only use loop indices.
One pass through the input, performing O(1) hash map lookups and insertions at each step. The hash map may store up to n entries in the worst case. This is the classic space-for-time tradeoff: O(n) extra memory eliminates an inner loop.
Review these before coding to avoid predictable interview regressions.
Wrong move: Zero-count keys stay in map and break distinct/count constraints.
Usually fails on: Window/map size checks are consistently off by one.
Fix: Delete keys when count reaches zero.