Leetcode NO.133 Clone Graph

题目要求如下：

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

本题看着唬人，其实挺简单的。。就是用DFS来解，只不过需要注意的是，需要加一个hashmap用来存储已经访问过的node。。

举个例子：

就拿上面给定的例子。首先访问0并copy0，0与1，2相邻，所以下一步要访问1，2

访问1，并copy 1，1与2相连

访问2，并copy 2，2与2相连。。但是此时不能下一步再copy一个2，所以需要一个hashmap存储已经处理过的元素。

代码如下：

class Solution {
public:
    UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
    	if (node == nullptr)
    		return nullptr;
    	else {
        	UndirectedGraphNode* ret = new UndirectedGraphNode(node->label);
        	hash[node->label] = ret;
        	for (int i = 0; i < node->neighbors.size(); ++i) {
        		if (hash.find(node->neighbors[i]->label) == hash.end())
        			ret->neighbors.push_back(cloneGraph(node->neighbors[i]));
        		else 
        			ret->neighbors.push_back(hash[node->neighbors[i]->label]);
        	}
        	return ret;
    	}
    }
private:
    unordered_map<int, UndirectedGraphNode*> hash;
};