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

思路：复制图，图的遍历BFS和DFS都可以，但是老图old与新图new的每一个结点是要一一对应的，

可以分两次遍历，第一次遍历生成所有的新结点以及新节点和老结点的对应关系，存储在unordered_map<UndirectedGraphNode *,UndirectedGraphNode *> map里面，

第二次遍历 利用map中对对应关系 将 新图的邻居neighbors赋值，参考：http://blog.csdn.net/lanxu_yy/article/details/17802415

但是可以利用map查看是否已经有了该节点的副本，所以可以不用两次遍历

BFS：当要设置某个结点map[tmpN]的邻居的时候，可以先在map中查看是否存在该邻居的副本nb，有了就这是设置map[tmpN]的邻居为nb的副本，否则就new以nb的副本，再设置，同时要把nb加入需要设置邻居的队列。

/**
 * Definition for undirected graph.
 * struct UndirectedGraphNode {
 *     int label;
 *     vector<UndirectedGraphNode *> neighbors;
 *     UndirectedGraphNode(int x) : label(x) {};
 * };
 */
class Solution {
public:
    UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
        if(node==NULL)    
            return NULL;

        unordered_map<UndirectedGraphNode *,UndirectedGraphNode *> old_new;
        queue<UndirectedGraphNode *> currQ;//存储老的结点，这些老结点已经生成对应新结点了，但是他们的邻居还没处理
        currQ.push(node);
        old_new[node]=new UndirectedGraphNode(node->label);
        while(currQ.size()>0)
        {
            UndirectedGraphNode *tmpN=currQ.front();
            currQ.pop();
            for(auto nb : tmpN->neighbors) //处理tmpN的邻居结点---- old_new[tmpN]->neighbors
            {
                if(old_new.count(nb)==0) // 它的邻居还没生
                {
                    old_new[nb]=new UndirectedGraphNode(nb->label);
                    old_new[tmpN]->neighbors.push_back(old_new[nb]);//添加邻居
                    // nb刚刚拷贝了，但是它的邻居还没处理，所以要加入队列，注意不是新生的结点old_new[nb]加入队列，而是nb加入队列！！
                    currQ.push(nb);
                }
                else
                    old_new[tmpN]->neighbors.push_back(old_new[nb]); //要添加old_new[nb]，不是nb，不是nb，不是nb
                
            }
        }
        return old_new[node];
    }
};

DFS:

/**
 * Definition for undirected graph.
 * struct UndirectedGraphNode {
 *     int label;
 *     vector<UndirectedGraphNode *> neighbors;
 *     UndirectedGraphNode(int x) : label(x) {};
 * };
 */
class Solution {
public:
    UndirectedGraphNode *dfsClone(  UndirectedGraphNode *node,
                                    unordered_map<UndirectedGraphNode *,UndirectedGraphNode *> &old_new)
    {
        if(old_new.count(node)==0)
        {
            old_new[node]=new UndirectedGraphNode(node->label);
            for(auto nb : node->neighbors )
                old_new[node]->neighbors.push_back(dfsClone(nb,old_new));
        }
        return old_new[node];
    }
    UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) 
    {
        if(node==NULL)    
            return NULL;

        unordered_map<UndirectedGraphNode *,UndirectedGraphNode *> old_new;
        dfsClone(node,old_new);
        return old_new[node];
    }
};