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
         / \
         \_/
解题思路:看了好久才看明白题目的意思，全靠这位仁兄

This problem is an application of graph traversal, which has two systematic methods: Bread-First Search (BFS) and Depth-First Search (DFS). In the following, I am going to assume that you are familiar with them and just focus on what I think is the most tricky part of this problem, that is, what else is needed beyond graph traversal to clone a graph?

In order to clone a graph, you need to have a copy of each node in the original graph. Well, you may not have too many ideas about it. Let's do an example.

Suppose we are given a graph {0, 1 # 1, 0}. We know that the graph has two nodes 0 and 1 and they are connected to each other.

We now start from 0. We make a copy of 0. Then we check 0's neighbors and we see 1. We make a copy of 1 and we add the copy to the neighbors of the copy of 0. Now the cloned graph is {0 (copy), 1 (copy)}. Then we visit 1. We make a copy of 1... well, wait, why do we make another copy of it? We already have one! Note that if you make a new copy of the node, these copies are not the same and the graph structure will be wrong! This is just what I mean by "the most tricky part of this problem". In fact, we need to maintain a mapping from each node to its copy. If the node has an existed copy, we simply use it. So in the above example, the remaining process is that we visit the copy of 1 and add the copy of 0 to its neighbors and the cloned graph is eventually {0 (copy), 1 (copy) # 1 (copy), 0 (copy)}.

Note that the above process uses BFS. Of course, you can use DFS. The key is the node-copy mapping, anyway.

 其实说简单点就是复制一个无向图（测试数据证明是有向图）,注意点就是每次在构造新节点时先判断一下是否节点已经创建过。每个节点只有在新建的时候才需要把它的连接点加入到它的相邻节点vector。

/**
 * Definition for undirected graph.
 * struct UndirectedGraphNode {
 *     int label;
 *     vector<UndirectedGraphNode *> neighbors;
 *     UndirectedGraphNode(int x) : label(x) {};
 * };
 */
class Solution {
public:
    unordered_map<UndirectedGraphNode *,UndirectedGraphNode *>mp;
    UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
        if(!node)return NULL;
        if(mp.find(node)==mp.end()){
            mp[node]=new UndirectedGraphNode(node->label);
            for(UndirectedGraphNode* neigh:node->neighbors)
                mp[node]->neighbors.push_back(cloneGraph(neigh));
        }
        return mp[node];
    }
};