### 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 val (`int`

) and a list (`List[Node]`

) of its neighbors.**Example:**

Input:{"$id":"1","neighbors":[{"$id":"2","neighbors":[{"$ref":"1"},{"$id":"3","neighbors":[{"$ref":"2"},{"$id":"4","neighbors":[{"$ref":"3"},{"$ref":"1"}],"val":4}],"val":3}],"val":2},{"$ref":"4"}],"val":1}Explanation:Node 1's value is 1, and it has two neighbors: Node 2 and 4. Node 2's value is 2, and it has two neighbors: Node 1 and 3. Node 3's value is 3, and it has two neighbors: Node 2 and 4. Node 4's value is 4, and it has two neighbors: Node 1 and 3.

**Note:**

- The number of nodes will be between 1 and 100.
- The undirected graph is a simple graph, which means no repeated edges and no self-loops in the graph.
- Since the graph is undirected, if node
*p*has node*q*as neighbor, then node*q*must have node*p*as neighbor too. - You must return the
**copy of the given node**as a reference to the cloned graph.

### Video Tutorial

You can find the detailed video tutorial here### Thought Process

It's a basic graph problem that can be solved in 3 different ways: BFS using queue, DFS using recursion, DFS using stack(very similar to BFT using queue). The trick is using a map to keep a one-to-one mapping between the old nodes and the copied nodes, meanwhile, we can also use the map to avoid a cycle when performing BFS or DFS.### Solutions

#### BFS using queue

Time Complexity: O(N)Space Complexity: O(N) the extra queue and map

####

DFS using recursion

Time Complexity: O(N) Space Complexity: O(N) the extra map

####

DFS using stack

Time Complexity: O(N) Space Complexity: O(N) the extra queue and stack

The main test method

### References

- Leetcode official solution (download pdf)
- Code Ganker CSDN