133. Clone Graph

问题：

给定一个图，对该图进行深拷贝，返回拷贝出来的图。

adj[i]：代表节点 i 所相邻的节点。

Example 1:
Input: adjList = [[2,4],[1,3],[2,4],[1,3]]
Output: [[2,4],[1,3],[2,4],[1,3]]
Explanation: There are 4 nodes in the graph.
1st node (val = 1)'s neighbors are 2nd node (val = 2) and 4th node (val = 4).
2nd node (val = 2)'s neighbors are 1st node (val = 1) and 3rd node (val = 3).
3rd node (val = 3)'s neighbors are 2nd node (val = 2) and 4th node (val = 4).
4th node (val = 4)'s neighbors are 1st node (val = 1) and 3rd node (val = 3).

Example 2:
Input: adjList = [[]]
Output: [[]]
Explanation: Note that the input contains one empty list. The graph consists of only one node with val = 1 and it does not have any neighbors.

Example 3:
Input: adjList = []
Output: []
Explanation: This an empty graph, it does not have any nodes.

Example 4:
Input: adjList = [[2],[1]]
Output: [[2],[1]]
 

Constraints:
1 <= Node.val <= 100
Node.val is unique for each node.
Number of Nodes will not exceed 100.
There is no repeated edges and no self-loops in the graph.
The Graph is connected and all nodes can be visited starting from the given node.

　　example1:

 

example2：

 

解法：BFS

queue：<拷贝先res，拷贝元node>

visited：处理过的节点map: key: node->val  value: Node*地址

每次对处理对象节点->neighbors节点进行new

(只有这些节点不存在在visited中的时候，若已存在，直接将visited里的地址赋值给neighbors)

new完之后的neighbor节点，加入visited中。标记为已访问。

 

代码参考：

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> neighbors;
    Node() {
        val = 0;
        neighbors = vector<Node*>();
    }
    Node(int _val) {
        val = _val;
        neighbors = vector<Node*>();
    }
    Node(int _val, vector<Node*> _neighbors) {
        val = _val;
        neighbors = _neighbors;
    }
};
*/

class Solution {
public:
    Node* cloneGraph(Node* node) {
        Node* res;
        queue<vector<Node*>> q;
        if(node==nullptr) return nullptr;
        unordered_map<int, Node*> visited;
        if(node) {
            res = new Node(node->val);
            q.push({res,node});
            visited[node->val] = res;
        }
        while(!q.empty()) {
            int sz = q.size();
            for(int i=0; i<sz; i++) {
                vector<Node*> cur = q.front();
                q.pop();
                for(Node* n:cur[1]->neighbors) {
                    if(visited.count(n->val)==0) {
                        Node* newnode = new Node(n->val);
                        visited[n->val] = newnode;
                        q.push({visited[n->val],n});
                    }
                    cur[0]->neighbors.push_back(visited[n->val]);
                }
            }
        }
        return res;
    }
};