LeetCode-133

克隆图

LeetCode链接

啥意思呢，就是把图遍历一遍，然后每个节点new一遍，顺序不变。主要是就是BFS和DFS.

深度优先

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

        // 节点有没有访问过，insert判断返回值也一样的
        if (mapVisited.find(node) != mapVisited.end()) 
        {
            return mapVisited[node];
        }

        // 深拷贝就是new
        Node* cloneNode = new Node(node->val);
        // 存储
        mapVisited[node] = cloneNode;

        // 遍历该节点的邻居并更新克隆节点的邻居列表
        for (auto it : node->neighbors) 
        {
            cloneNode->neighbors.emplace_back(cloneGraph(it));
        }
        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) 
    {
        if (node == nullptr) 
        {
            return node;
        }

        unordered_map<Node*, Node*> mapVisited;

        // 将给定的节点添加到队列
        queue<Node*> queue;
        queue.push(node);
        // 克隆节点并存储到哈希表中
        mapVisited[node] = new Node(node->val);
        // 广度优先搜索
        while (!queue.empty()) 
        {
            Node* pNode = queue.front();
            queue.pop();
            for (auto it: pNode->neighbors) 
            {
                if (mapVisited.find(it) == mapVisited.end()) 
                {
                    // 先存
                    mapVisited[it] = new Node(it->val);
                    queue.push(it);
                }
                // 再访问
                mapVisited[pNode]->neighbors.emplace_back(mapVisited[it]);
            }
        }
        return mapVisited[node];
    }
};