133. Clone Graph

问题描述：

Given a reference of a node in a connected undirected graph, return a deep copy (clone) of the graph. Each node in the graph contains a val (int) and a list (List[Node]) of its neighbors.

Example:

Input:
{"$id":"1","neighbors":[{"$id":"2","neighbors":[{"$ref":"1"},{"$id":"3","neighbors":[{"$ref":"2"},{"$id":"4","neighbors":[{"$ref":"3"},{"$ref":"1"}],"val":4}],"val":3}],"val":2},{"$ref":"4"}],"val":1}

Explanation:
Node 1's value is 1, and it has two neighbors: Node 2 and 4.
Node 2's value is 2, and it has two neighbors: Node 1 and 3.
Node 3's value is 3, and it has two neighbors: Node 2 and 4.
Node 4's value is 4, and it has two neighbors: Node 1 and 3.

Note:

1. The number of nodes will be between 1 and 100.
2. The undirected graph is a simple graph, which means no repeated edges and no self-loops in the graph.
3. Since the graph is undirected, if node p has node q as neighbor, then node q must have node p as neighbor too.
4. You must return the copy of the given node as a reference to the cloned graph.

解题思路：

要深度拷贝一个图，每一个节点的值以及与周围点的关系都需要拷贝。

可以用一个map来存储旧节点和新节点的对应关系。

<旧节点，新节点>

对这个图进行遍历，我喜欢使用BFS，用一个queue进行把没有拷贝过的节点放进去。

然后使用一个set存储访问过的节点，防止重复访问。

注意只有在对该节点进行完拷贝后才可以加入到visited set里面去。

代码：

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> neighbors;

    Node() {}

    Node(int _val, vector<Node*> _neighbors) {
        val = _val;
        neighbors = _neighbors;
    }
};
*/
class Solution {
public:
    Node* cloneGraph(Node* node) {
        if(node == NULL) return NULL;
        map<Node*, Node*> record;
        queue<Node*> nodeQ;
        set<Node*> visited;
        nodeQ.push(node);
        while(!nodeQ.empty()){
            Node* cur = nodeQ.front();
            if(visited.count(cur) != 0){
                nodeQ.pop();
                continue;
            }
            nodeQ.pop();
            if(record.count(cur) == 0){
                vector<Node*> neighbors;
                Node* newNode = new Node(cur->val, neighbors);
                record[cur] = newNode;
            }
            for(auto n : cur->neighbors){
                if(visited.count(n) == 0)
                    nodeQ.push(n);
                if(record.count(n) == 0){
                    vector<Node*> neighbors;
                    Node* newNode = new Node(n->val, neighbors);
                    record[n] = newNode;
                }
                record[cur]->neighbors.push_back(record[n]);
            }
            visited.insert(cur);
        }
        return record[node];
    }
};