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

         / \

         \_/
思路：这道题是克隆一个一模一样的图。使用map来保存每个节点的克隆节点，使用队列来遍历图中的每个节点——遍历的结点出队列，没有遍历的结点入队列。
然后对于每个节点的邻居结点，在map中查找，如果有，则将其push到该节点的克隆节点的邻居结点（也是克隆）；反之，则创建这个邻居结点，然后作为该克隆节点的邻居结点。

/**

 * 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;

        map<UndirectedGraphNode *,UndirectedGraphNode *> clone;

        queue<UndirectedGraphNode *> q;

        clone[node]=new UndirectedGraphNode(node->label);

        q.push(node);

        while(!q.empty())

        {

            UndirectedGraphNode *pCur=q.front();

            q.pop();

            for(int i=0;i<pCur->neighbors.size();i++)

            {

                UndirectedGraphNode *pNei=pCur->neighbors[i];

                if(clone.find(pNei)!=clone.end())

                {

                    clone[pCur]->neighbors.push_back(clone[pNei]);

                }

                else

                {

                    clone[pNei]=new UndirectedGraphNode(pNei->label);

                    clone[pCur]->neighbors.push_back(clone[pNei]);

                    q.push(pNei);

                }

            }

        }

        return clone[node];

    }

};