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

由于是无向图，所以要注意的就是要随时记录已经复制过的节点，以便加到后面节点的邻接节点指针数组中。

本题采用广度优先边访问、边复制，具体代码如下：

class Solution {
public:
    UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
		UndirectedGraphNode *result = NULL;
		if(node == NULL)
			return result;
		unordered_set<int> S;
		unordered_map<int, UndirectedGraphNode *> M;
		queue<UndirectedGraphNode *> Q1, Q2;
		Q1.push(node);
		S.insert(node->label);
		result = new UndirectedGraphNode(node->label);
		Q2.push(result);
		M[result->label] = result;
		UndirectedGraphNode *innode, *tmpnode, *copenode;
		while(!Q1.empty() && !Q2.empty())
		{
			innode = Q1.front();
			copenode = Q2.front();
			Q1.pop();
			Q2.pop();
			for(int i=0; i<innode->neighbors.size(); ++i)
			{
				if(S.find(innode->neighbors[i]->label) == S.end())
				{
					Q1.push(innode->neighbors[i]);
					S.insert(innode->neighbors[i]->label);
					tmpnode = new UndirectedGraphNode(innode->neighbors[i]->label);
					M[tmpnode->label] = tmpnode;
					Q2.push(tmpnode);
					copenode->neighbors.push_back(tmpnode);
				}
				else
				{
					copenode->neighbors.push_back(M[innode->neighbors[i]->label]);
				}
			}
		}
		return result;
    }
};