Clone Graph - LeetCode

原文
点击打开链接

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
/ \
\_/

http://blog.csdn.net/fightforyourdream/article/details/17497883
这道题就要注意的是，此题是深克隆，而不是浅克隆！！！

AC CODE 1:

public class Solution {
public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
if(node == null)
return null;

LinkedList<UndirectedGraphNode> queue = new LinkedList<UndirectedGraphNode>();
HashMap<UndirectedGraphNode, UndirectedGraphNode> map =
new HashMap<UndirectedGraphNode,UndirectedGraphNode>();

UndirectedGraphNode newHead = new UndirectedGraphNode(node.label);

queue.add(node);
map.put(node, newHead);

while(!queue.isEmpty()){
UndirectedGraphNode curr = queue.pop();
ArrayList<UndirectedGraphNode> currNeighbors = curr.neighbors;

for(UndirectedGraphNode aNeighbor: currNeighbors){
if(!map.containsKey(aNeighbor)){
UndirectedGraphNode copy = new UndirectedGraphNode(aNeighbor.label);
map.put(aNeighbor,copy);
map.get(curr).neighbors.add(copy);
queue.add(aNeighbor);
}else{
map.get(curr).neighbors.add(map.get(aNeighbor));
}
}

}
return newHead;
}
}

AC CODE 2:

/**
* Definition for undirected graph.
* class UndirectedGraphNode {
*     int label;
*     ArrayList<UndirectedGraphNode> neighbors;
*     UndirectedGraphNode(int x) { label = x; neighbors = new ArrayList<UndirectedGraphNode>(); }
* };
*/
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Stack;

public class Solution {
public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
if(node == null){
return null;
}

LinkedList<UndirectedGraphNode> queue = new LinkedList<UndirectedGraphNode>();

Hashtable<UndirectedGraphNode, UndirectedGraphNode> ht = new Hashtable<UndirectedGraphNode, UndirectedGraphNode>();
UndirectedGraphNode retClone = new UndirectedGraphNode(node.label);
ht.put(node, retClone);
queue.add(node);

while(!queue.isEmpty()){
UndirectedGraphNode cur = queue.remove();
UndirectedGraphNode curClone = ht.get(cur);

ArrayList<UndirectedGraphNode> neighbors = cur.neighbors;
for(int i=0; i<neighbors.size(); i++){
UndirectedGraphNode neighbor = neighbors.get(i);
if(ht.containsKey(neighbor)){
UndirectedGraphNode neighborClone = ht.get(neighbor);
curClone.neighbors.add(neighborClone);
}else{
UndirectedGraphNode neighborClone = new UndirectedGraphNode(neighbor.label);
curClone.neighbors.add(neighborClone);
ht.put(neighbor, neighborClone);
queue.add(neighbor);
}
}
}

return retClone;
}
}