Leetcode - Clone Graph

Clone an undirected graph. Each node in the graph contains a label and a list of its neighbors.

OJ's undirected graph serialization:
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.
Visually, the graph looks like the following:

       1
      / \
     /   \
    0 --- 2
         / \
         \_/

[分析] 这道题目看似简单，如果对题意和Java引用概念把握不好得话是写不对的。我的实现版本遇到有节点指向自身的case就挂，虽然知道问题所在却不知道如何修改好，看到网友的实现后豁然开朗，让我对引用的理解又加深了。使用HashMap，保存原节点和复制节点的映射，遇到节点指向自身时将该节点自身的引用加入到neighbors中而不要新建一个对象，好像是废话但自己当时怎么也想不到，练习练习再练习！

public class Solution {
    public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
        if (node == null) return null;
        UndirectedGraphNode nodeClone = new UndirectedGraphNode(node.label);
        LinkedList<UndirectedGraphNode> queue = new LinkedList<UndirectedGraphNode>();
        HashMap<UndirectedGraphNode, UndirectedGraphNode> map = new HashMap<UndirectedGraphNode, UndirectedGraphNode>();
        queue.offer(node);
        map.put(node, nodeClone);
        while (!queue.isEmpty()) {
            UndirectedGraphNode curr = queue.poll();
            List<UndirectedGraphNode> neighbors = curr.neighbors;
            for (UndirectedGraphNode neigh : neighbors) {
                if (!map.containsKey(neigh)) {
                    UndirectedGraphNode neighClone = new UndirectedGraphNode(neigh.label);
                    map.get(curr).neighbors.add(neighClone);
                    queue.offer(neigh);
                    map.put(neigh, neighClone);
                } else {
                    map.get(curr).neighbors.add(map.get(neigh));
                }
            }
        }
        return nodeClone;
    }
}

错误版本及fail的case

public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
        if (node == null) return null;
        UndirectedGraphNode clone = new UndirectedGraphNode(node.label);
        LinkedList<UndirectedGraphNode> queue = new LinkedList<UndirectedGraphNode>();
        LinkedList<UndirectedGraphNode> queueClone = new LinkedList<UndirectedGraphNode>();
        queue.offer(node);
        queueClone.offer(clone);
        HashSet<UndirectedGraphNode> visited = new HashSet<UndirectedGraphNode>();
        visited.add(node);
        while (!queue.isEmpty()) {
            UndirectedGraphNode curr = queue.poll();
            UndirectedGraphNode currClone = queueClone.poll();
            for (UndirectedGraphNode neigh : curr.neighbors) {
                UndirectedGraphNode neighClone = new UndirectedGraphNode(neigh.label);
                currClone.neighbors.add(neighClone);
                if (visited.contains(neigh)) continue;
                queue.offer(neigh);
                queueClone.offer(neighClone);
                visited.add(neigh);
            }
        }
        return clone;
    }