[LeetCode] 131: Clone Graph

[Problem]

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 #.

1. First node is labeled as 0. Connect node 0 to both nodes 1 and 2.
2. Second node is labeled as 1. Connect node 1 to node 2.
3. 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         / \         \_/

[Analysis]
需要进行深度拷贝，因此需要两个队列，一个用于BFS读原图，另一个用于BFS创建新图，此外需要一个map<int, Node*> visited记录某一个结点是否已经创建，如果已经创建，则直接从visited中取出，否则新建。

[Solution]

/**
 * Definition for undirected graph.
 * struct UndirectedGraphNode {
 *     int label;
 *     vector<UndirectedGraphNode *> neighbors;
 *     UndirectedGraphNode(int x) : label(x) {};
 * };
 */
class Solution {
public:
UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
// Note: The Solution object is instantiated only once and is reused by each test case.
if(NULL == node) return node;

// initial
UndirectedGraphNode *res = new UndirectedGraphNode(node->label);
map<int, UndirectedGraphNode*> visited;
queue<UndirectedGraphNode *> resQueue;
queue<UndirectedGraphNode *> preQueue;
resQueue.push(res);
preQueue.push(node);
visited[node->label] = res;

// BFS
while(!resQueue.empty()){
UndirectedGraphNode *n1 = resQueue.front();
resQueue.pop();
UndirectedGraphNode *n2 = preQueue.front();
preQueue.pop();

// clone children
for(int i = 0; i < n2->neighbors.size(); ++i){
// not visited
if(visited.find(n2->neighbors[i]->label) == visited.end()){
// create a new node
UndirectedGraphNode *n = new UndirectedGraphNode(n2->neighbors[i]->label);

// visit
visited[n->label] = n;

// insert into n1's neighbors
n1->neighbors.push_back(n);

// insert into queue
resQueue.push(n);
preQueue.push(n2->neighbors[i]);
}
// has already visited
else{
// insert into n1's neighbors
UndirectedGraphNode *n = visited[n2->neighbors[i]->label];
n1->neighbors.push_back(n);
}
}
}
return res;
}
};

说明：版权所有，转载请注明出处。Coder007的博客