133. 克隆图

链接：133. 克隆图

题解：

深度优先搜索
思路

对于本题而言，我们需要明确图的深拷贝是在做什么，对于一张图而言，它的深拷贝即构建一张与原图结构，值均一样的图，但是其中的节点不再是原来图节点的引用。因此，为了深拷贝出整张图，我们需要知道整张图的结构以及对应节点的值。

由于题目只给了我们一个节点的引用，因此为了知道整张图的结构以及对应节点的值，我们需要从给定的节点出发，进行「图的遍历」，并在遍历的过程中完成图的深拷贝。

为了避免在深拷贝时陷入死循环，我们需要理解图的结构。对于一张无向图，任何给定的无向边都可以表示为两个有向边，即如果节点 A 和节点 B 之间存在无向边，则表示该图具有从节点 A 到节点 B 的有向边和从节点 B 到节点 A 的有向边。

为了防止多次遍历同一个节点，陷入死循环，我们需要用一种数据结构记录已经被克隆过的节点。

算法

使用一个哈希表存储所有已被访问和克隆的节点。哈希表中的 key 是原始图中的节点，value 是克隆图中的对应节点。

从给定节点开始遍历图。如果某个节点已经被访问过，则返回其克隆图中的对应节点。

如下图，我们给定无向边边 A - B，表示 A 能连接到 B，且 B 能连接到 A。如果不对访问过的节点做标记，则会陷入死循环中。

如果当前访问的节点不在哈希表中，则创建它的克隆节点并存储在哈希表中。注意：在进入递归之前，必须先创建克隆节点并保存在哈希表中。如果不保证这种顺序，可能会在递归中再次遇到同一个节点，再次遍历该节点时，陷入死循环。

递归调用每个节点的邻接点。每个节点递归调用的次数等于邻接点的数量，每一次调用返回其对应邻接点的克隆节点，最终返回这些克隆邻接点的列表，将其放入对应克隆节点的邻接表中。这样就可以克隆给定的节点和其邻接点。

/*
// 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:
    unordered_map<Node*, Node*> visited;
    Node* cloneGraph(Node* node) {
        if (node == nullptr) {
            return node;
        }

        // 如果该节点已经被访问过了，则直接从哈希表中取出对应的克隆节点返回
        if (visited.find(node) != visited.end()) {
            return visited[node];
        }

        // 克隆节点，注意到为了深拷贝我们不会克隆它的邻居的列表
        Node* cloneNode = new Node(node->val);
        // 哈希表存储
        visited[node] = cloneNode;

        // 遍历该节点的邻居并更新克隆节点的邻居列表
        for (auto& neighbor: node->neighbors) {
            cloneNode->neighbors.emplace_back(cloneGraph(neighbor));
        }
        return cloneNode;
    }
};

/*
// 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) {
        // 找到所有节点
        std::vector<Node*> nodes = find_nodes(node);
        // 复制所有新节点
        std::unordered_map<Node*, Node*> mapping_nodes = clone_nodes(nodes);
        // 建立新的连接关系
        build_edges(nodes, mapping_nodes);
        // 返回新图节点
        return mapping_nodes[node];
    }
private:
    std::vector<Node*> find_nodes(Node* node) {
        if (!node) {
            return {};
        }
        std::queue<Node*> que;
        que.push(node);
        std::unordered_set<Node*> visited;
        visited.insert(node);
        std::vector<Node*> result;
        result.push_back(node);
        while (!que.empty()) {
            auto f = que.front();
            que.pop();
            for (auto neighbor : f->neighbors) {
                if (visited.find(neighbor) != visited.end()) {
                    continue;
                }
                result.push_back(neighbor);
                que.push(neighbor);
                visited.insert(neighbor);
            }
        }
        return result;
    }
    std::unordered_map<Node*, Node*> clone_nodes(const std::vector<Node*>& nodes) {
        std::unordered_map<Node*, Node*> clones;
        for_each(nodes.begin(), nodes.end(), [&clones](auto node) {
            clones[node] = new (std::nothrow) Node(node->val);
        });
        return clones;
    }
    void build_edges(std::vector<Node*>& nodes, std::unordered_map<Node*, Node*>& mapping_nodes) {
        for_each(nodes.begin(), nodes.end(), [&mapping_nodes](auto node) {
            auto mapping_node = mapping_nodes[node];
            for (auto neighbor : node->neighbors) {
                mapping_node->neighbors.push_back(mapping_nodes[neighbor]);
            }
        });
    }
};

/*
// 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) {
        if (!node) {
            return nullptr;
        }
        std::unordered_map<Node*, Node*> table;
        copy_node(node, table);
        connect_node(node, table);
        return table[node];
    }
private:
    void copy_node(Node* node, std::unordered_map<Node*, Node*>& table) {
        if (!node) {
            return;
        }
        std::queue<Node*> que;
        que.push(node);
        std::unordered_set<Node*> visited;
        visited.insert(node);
        while (!que.empty()) {
            auto f = que.front();
            table[f] = new (std::nothrow)Node(f->val);
            que.pop();
            for (auto neigh : f->neighbors) {
                if (visited.find(neigh) != visited.end()) {
                    continue;
                }
                que.push(neigh);
                visited.insert(neigh);
            }
        }
    }
    void connect_node(Node* node, std::unordered_map<Node*, Node*>& table) {
        if (!node) {
            return;
        }
        std::queue<Node*> que;
        que.push(node);
        std::unordered_set<Node*> visited;
        visited.insert(node);
        while (!que.empty()) {
            auto f = que.front();
            que.pop();
            for (auto neigh : f->neighbors) {
                table[f]->neighbors.push_back(table[neigh]);
                if (visited.find(neigh) != visited.end()) {
                    continue;
                }
                que.push(neigh);
                visited.insert(neigh);
            }
        }

    }
};