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


Tags:

Depth-first Search Breadth-first Search Graph

 

分析：
首先，这道题目不能直接返回node，因为需要克隆，也就意味着要为所有的节点心分配空间。
其次，分析节点的元素，包括label和neighbors两项，这意味着完成一个节点需要克隆一个int和一个vector<UndirectedGraphNode *>。
我们根据参数中的node提取出其label值，然后用构造方法生成一个节点，这样就完成了一个节点的生成。然后，根据参数中的node提取
其neighbors中的元素，我们只需要把这些元素加入刚生成的节点中，便完成了第一个节点的克隆。
再次，neighbor元素怎么生成呢？同样需要克隆。这样我们就可以总结出递归的思路。
最后，由于克隆要求每个节点只能有一个备份（其实也只能做到一个备份），所以，对于已经有开辟空间的节点，我们只需要返回已经
存在的节点即可。那怎么做到不重复呢？HashMap！只要我们为每个节点开辟一个空间的时候把这个空间指针保存在HashMap中，便可以
通过查找HashMap来确定当前要克隆的节点是否已经存在，不存在再新开辟空间。

 

c++代码：

/**
 * Definition for undirected graph.
 * struct UndirectedGraphNode {
 *     int label;
 *     vector<UndirectedGraphNode *> neighbors;
 *     UndirectedGraphNode(int x) : label(x) {};
 * };
 */

 
class Solution {
public:
    UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
        //labeled uniquely so label can be used as the key of map
        map<int, UndirectedGraphNode *> hashTable;
        return clone(node, hashTable);
    }
    UndirectedGraphNode * clone(UndirectedGraphNode *node, map<int, UndirectedGraphNode *> & hashTable){
        if(node == NULL){
            return NULL;
        }
        //表明这个节点已经创建了，所以没有必要重复创建，只要把已经创建的节点返回即可
        if(hashTable.find(node->label) != hashTable.end()){
            return hashTable[node->label];
        }
        //如果没有创建参数中节点，则创建，并添加到hashtable中
        UndirectedGraphNode * result = new UndirectedGraphNode(node->label);
        hashTable[node->label] = result;
        //clone所有的邻节点，并添加到刚clone好的节点的第二个元素vector中
        for(int i=0; i<node->neighbors.size();i++){
            UndirectedGraphNode * newnode = clone(node->neighbors[i], hashTable);
            result->neighbors.push_back(newnode);
        }
        return result;
    }
};