133:
/**
* 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 node;
}
vector<UndirectedGraphNode *> nodes = find_all_nodes(node);
unordered_map<UndirectedGraphNode *, UndirectedGraphNode *> map =
copy_node(nodes);
connect(map, nodes);
return map[node];
}
private:
vector<UndirectedGraphNode *> find_all_nodes(UndirectedGraphNode *node) {
vector<UndirectedGraphNode *> nodes;
queue<UndirectedGraphNode *> q;
set<UndirectedGraphNode *> s;
q.push(node);
s.insert(node);
nodes.push_back(node);
while (!q.empty()) {
UndirectedGraphNode *node = q.front();
q.pop();
vector<UndirectedGraphNode *> neighbor_nodes = node->neighbors;
for (int i = 0; i < neighbor_nodes.size(); i++) {
UndirectedGraphNode * neighbor_node = neighbor_nodes[i];
if (s.find(neighbor_node) != s.end()) {
continue;
}
q.push(neighbor_node);
s.insert(neighbor_node);
nodes.push_back(neighbor_node);
}
}
return nodes;
}
unordered_map<UndirectedGraphNode *, UndirectedGraphNode *> copy_node(
vector<UndirectedGraphNode *> nodes) {
unordered_map<UndirectedGraphNode *, UndirectedGraphNode *> map;
for (int i = 0; i < nodes.size(); i++) {
map[nodes[i]] = new UndirectedGraphNode(nodes[i]->label);
}
return map;
}
void connect(unordered_map<UndirectedGraphNode *, UndirectedGraphNode *> map,
vector<UndirectedGraphNode *> nodes) {
for (int i = 0; i < nodes.size(); i++) {
UndirectedGraphNode *node = nodes[i];
vector<UndirectedGraphNode *> neighbor_nodes = node->neighbors;
vector<UndirectedGraphNode *> neighbor_nodes1 = map[node]->neighbors;
for (int j = 0; j < neighbor_nodes.size(); j++) {
UndirectedGraphNode *neighbor_node = neighbor_nodes[j];
neighbor_nodes1.push_back(map[neighbor_node]);
}
map[node]->neighbors = neighbor_nodes1;
}
}
};
138:
/**
* Definition for singly-linked list with a random pointer.
* struct RandomListNode {
* int label;
* RandomListNode *next, *random;
* RandomListNode(int x) : label(x), next(NULL), random(NULL) {}
* };
*/
class Solution {
public:
RandomListNode *copyRandomList(RandomListNode *head) {
if (head == NULL) {
return head;
}
unordered_map<RandomListNode *, RandomListNode *> map = copy_node(head);
connect(head, map);
return map[head];
}
private:
unordered_map<RandomListNode *, RandomListNode *> copy_node(RandomListNode* node) {
unordered_map<RandomListNode *, RandomListNode *> map;
while (node != NULL) {
map[node] = new RandomListNode(node->label);
node = node->next;
}
return map;
}
void connect(RandomListNode *node,
unordered_map<RandomListNode *, RandomListNode *> map) {
while (node != NULL) {
map[node]->next = map[node->next];
map[node]->random = map[node->random];
node = node->next;
}
}
};