133. Clone Graph (need BFS)

Description

Given the head of a graph, return a deep copy (clone) of the graph. Each node in the graph contains a label (int) and a list (List[UndirectedGraphNode]) of its neighbors. There is an edge between the given node and each of the nodes in its neighbors.

OJ’s undirected graph serialization (so you can understand error output):
Nodes are labeled uniquely.

We use # as a separator for each node, and , as a separator for node label and each neighbor of the node.

As an example, consider the serialized graph {0,1,2#1,2#2,2}.

The graph has a total of three nodes, and therefore contains three parts as separated by #.

First node is labeled as 0. Connect node 0 to both nodes 1 and 2.
Second node is labeled as 1. Connect node 1 to node 2.
Third node is labeled as 2. Connect node 2 to node 2 (itself), thus forming a self-cycle.

Problem URL

---

Solution

给一个无向图中的节点，返回这个图的一个复制。无向图节点结构有：label，list<node> neighbors。

First, we maintain a hashmap which stores cloned node, when we want to connect a node in map, we just check map having this node first, and if it is in the map, we could simply return it.

We use a clone helper function to perform DFS clone process. For a node, judge it is valid or not, and if it is in the map, just return it. If it is not in the map, put it in the map, and then clone all of its neighbors.

Code

/**
 * Definition for undirected graph.
 * class UndirectedGraphNode {
 *     int label;
 *     List<UndirectedGraphNode> neighbors;
 *     UndirectedGraphNode(int x) { label = x; neighbors = new ArrayList<UndirectedGraphNode>(); }
 * };
 */
public class Solution {
    private HashMap<Integer, UndirectedGraphNode> map = new HashMap<Integer, UndirectedGraphNode>();
    public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
        return clone(node);
    }
    
    private UndirectedGraphNode clone(UndirectedGraphNode node){
        if (node == null)
            return null;
        if (map.containsKey(node.label)){
            return map.get(node.label);
        }
        UndirectedGraphNode cloneNode = new UndirectedGraphNode(node.label);
        map.put(cloneNode.label, cloneNode);
        for (UndirectedGraphNode neighbor : node.neighbors){
            cloneNode.neighbors.add(clone(neighbor));
        }
        return cloneNode;
    }
}

Time Complexity: O(n * m)
Space Complexity: O(n)

---

Review

For iteration of graph, DFS and BFS are good choices. Recursion is also supported.