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 from 0 to N - 1, where N is the total nodes in the graph.
We use # as a separator for each node, and , as a separator for each neighbor of the node.
As an example, consider the serialized graph {1,2#2#2}.
The graph has a total of three nodes, and therefore contains three parts as separated by #.
Connect node 0 to both nodes 1 and 2.
Connect node 1 to node 2.
Connect node 2 to node 2 (itself), thus forming a self-cycle.
Visually, the graph looks like the following:

　　 1
　　/ \
　 /    \
   0 --- 2
  / \
  \_/

Solution: 1. DFS. 2. BFS.

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

    // BFS
    UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
        if(!node) {
            return NULL;
        }
        unordered_map<UndirectedGraphNode*, UndirectedGraphNode*> map; 
        queue<UndirectedGraphNode*> q;
        q.push(node);
        map[node] = new UndirectedGraphNode(node->label);
        
        while(!q.empty()) {
            UndirectedGraphNode* orgnode = q.front();
            q.pop();
            UndirectedGraphNode* newnode = map[orgnode]; 
            for(int i = 0; i < orgnode->neighbors.size(); i++) {
                UndirectedGraphNode* orgneighbor = orgnode->neighbors[i];
                if(map.find(orgneighbor) == map.end()) {
                    UndirectedGraphNode* newneighbor = new UndirectedGraphNode(orgneighbor->label);
                    map[orgneighbor] = newneighbor;
                    q.push(orgneighbor);
                }
                newnode->neighbors.push_back(map[orgneighbor]);
            }
        }
        return map[node];
    }
};