[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的博客