My code:
/**
* Definition for undirected graph.
* class UndirectedGraphNode {
* int label;
* List<UndirectedGraphNode> neighbors;
* UndirectedGraphNode(int x) { label = x; neighbors = new ArrayList<UndirectedGraphNode>(); }
* };
*/
public class Solution {
public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
if (node == null)
return null;
/** tracker the origin node and the copied node (map) */
HashMap<UndirectedGraphNode, UndirectedGraphNode> tracker = new HashMap<UndirectedGraphNode, UndirectedGraphNode>();
/** for bfs */
Queue<UndirectedGraphNode> queue = new LinkedList<UndirectedGraphNode>();
queue.offer(node);
while (!queue.isEmpty()) {
UndirectedGraphNode temp = queue.poll();
UndirectedGraphNode copy;
/** copy this node if necessary*/
if (!tracker.containsKey(temp)) {
copy = new UndirectedGraphNode(temp.label);
tracker.put(temp, copy);
}
else {
copy = tracker.get(temp);
}
/** copy the whole neighbors list */
ArrayList<UndirectedGraphNode> copyList = new ArrayList<UndirectedGraphNode>();
/**
* if already exists in tracker, this node has already been copied or is waiting to be copied in the queue
* if not exists in tracker, this node has not been copied and is not in the queue
*/
for (UndirectedGraphNode elem : temp.neighbors) {
if (!tracker.containsKey(elem)) {
UndirectedGraphNode copyElem = new UndirectedGraphNode(elem.label);
copyList.add(copyElem);
tracker.put(elem, copyElem);
queue.offer(elem);
}
else {
copyList.add(tracker.get(elem));
}
}
copy.neighbors = copyList;
}
return tracker.get(node);
}
}
這道題目也是好幾天前做的了，基本忘了思路。
是用bfs來復制整個graph的。然后把已經復制好的放入HashMap中。
沒有復制好的，要么在隊列中，要么不在隊列中，并且不在HashMap中。
每次就是把每個結點對應的相鄰結點組成的ArrayList做出來。那么有兩種情況。
如果相鄰結點，不在HashMap中，那么就徹底的復制下該結點，塞入ArrayList中，同時放入HashMap中。并且插入隊列中。
如果在，那么就取出來，塞入ArrayList中。
訪問每個結點時也是這么操作。看看在不在HashMap中，如果是，就沒必要再深拷貝一下了。
然后隊列中的每個結點都必須訪問，復制。
隊列保證隊列中的元素，必須是未被拷貝并訪問過的。
這道題目我做出來的時候還多用了一個HashSet,所以時間慢了很多。然后后來看了答案，精簡之后，發現可以用HashMap完成兩者的工作，于是，速度大大得講了下來！
Anyway, Good luck, Richardo!
思路還是比較明顯的，dfs或者bfs
BFS:
My code:
/**
* Definition for undirected graph.
* class UndirectedGraphNode {
* int label;
* List<UndirectedGraphNode> neighbors;
* UndirectedGraphNode(int x) { label = x; neighbors = new ArrayList<UndirectedGraphNode>(); }
* };
*/
public class Solution {
HashMap<UndirectedGraphNode, UndirectedGraphNode> map = new HashMap<>();
public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
if (node == null) {
return null;
}
Queue<UndirectedGraphNode> q = new LinkedList<UndirectedGraphNode>();
Queue<UndirectedGraphNode> qm = new LinkedList<UndirectedGraphNode>();
UndirectedGraphNode root = node;
UndirectedGraphNode rootm = clone(root);
map.put(root, rootm);
q.offer(root);
qm.offer(rootm);
while (!q.isEmpty()) {
UndirectedGraphNode curr = q.poll();
UndirectedGraphNode currm = qm.poll();
for (UndirectedGraphNode nei : curr.neighbors) {
if (map.containsKey(nei)) {
currm.neighbors.add(map.get(nei));
}
else {
UndirectedGraphNode neim = clone(nei);
currm.neighbors.add(neim);
map.put(nei, neim);
q.offer(nei);
qm.offer(neim);
}
}
}
return rootm;
}
private UndirectedGraphNode clone(UndirectedGraphNode node) {
return new UndirectedGraphNode(node.label);
}
}
搞兩個隊列追蹤原結點和鏡像結點。搞一個hashmap存儲已經copy過的結點。
然后每次從隊列拿出第一個元素，遍歷他的鄰居。
如果已經存在過map中，說明已經copy過了，就直接拿來用，不用再塞進隊列了。
如果沒有存在，那就copy下，然后塞進隊列。
從隊列里面出來的每個元素，都是之前沒copy過的，這次操作結束后，就會全部copy好。
差不多就這么個思路。
DFS:
My code:
/**
* Definition for undirected graph.
* class UndirectedGraphNode {
* int label;
* List<UndirectedGraphNode> neighbors;
* UndirectedGraphNode(int x) { label = x; neighbors = new ArrayList<UndirectedGraphNode>(); }
* };
*/
public class Solution {
HashMap<UndirectedGraphNode, UndirectedGraphNode> map = new HashMap<>();
public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
if (node == null) {
return null;
}
return helper(node);
}
private UndirectedGraphNode helper(UndirectedGraphNode node) {
UndirectedGraphNode nodem = clone(node);
map.put(node, nodem);
for (UndirectedGraphNode nei : node.neighbors) {
if (!map.containsKey(nei)) {
UndirectedGraphNode neim = helper(nei);
nodem.neighbors.add(neim);
}
else {
nodem.neighbors.add(map.get(nei));
}
}
return nodem;
}
private UndirectedGraphNode clone(UndirectedGraphNode node) {
return new UndirectedGraphNode(node.label);
}
}
這個思路就比較直觀了。
Anyway, Good luck, Richardo! -- 09/09/2016
