LeetCode: Clone Graph

Clone Graph

Clone an undirected graph. Each node in the graph contains a label and a list of its neighbors.

耗时：84ms。

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

/*主要思想：
    1）使用BFS遍历原来树，将所有的树的节点复制一遍；
    2）使用map，建立原有树和克隆树之间节点的对应关系；
    3）遍历所有节点的neighbors,存储对应关系。
*/

/**
 * Definition for undirected graph.
 * struct UndirectedGraphNode {
 *     int label;
 *     vector<UndirectedGraphNode *> neighbors;
 *     UndirectedGraphNode(int x) : label(x) {};
 * };
 */
/*主要思想：
    1）使用BFS遍历原来树，将所有的树的节点复制一遍；
    2）使用map，建立原有树和克隆树之间节点的对应关系；
    3）遍历所有节点的neighbors,存储对应关系。
*/

class Solution {
public:
    UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
        if(node == NULL)
            return NULL;
            
        
        
        UndirectedGraphNode* copynode = new UndirectedGraphNode(node->label);//copynode表示克隆树的根节点。
        
        map<UndirectedGraphNode*, UndirectedGraphNode*> mapNode;
        mapNode[node] = copynode;//建立原有树和克隆树之间节点的对应关系
        
        UndirectedGraphNode* copyt = copynode;
        UndirectedGraphNode* t = node;
        
        //使用BFS记录遍历的节点顺序，便于构造这棵树。
        queue<UndirectedGraphNode*> q;//用队列存储这个树的结构。
        q.push(node);
        
        while(q.size() > 0)
        {
            t = q.front();
            copyt = mapNode[t];
            q.pop();
            for(int i = 0;i<t->neighbors.size();i++)
            {
                
                //创建tmp节点
                if(mapNode.find(t->neighbors[i]) == mapNode.end())//没有找到相邻的节点，说明没有创建过，需要新创建，然后再建立关系
                {
                    q.push(t->neighbors[i]);//说明当前节点没有遍历过，则加入到队列中
                    
                    //复制节点，并存入对应的neighbors中。
                    UndirectedGraphNode* tmp = new UndirectedGraphNode(t->neighbors[i]->label);
                    copyt->neighbors.push_back(tmp);
                    
                    //创建节点之间的对应关系。
                    mapNode[t->neighbors[i]] = tmp;
                    
                    
                }
                else //如果存在该节点
                {
                    copyt->neighbors.push_back(mapNode[t->neighbors[i]]);
                }
            }
        }
        return copynode;
    }
};