力扣133克隆图

力扣133克隆图

标签：

dfs、bfs、哈希表

BFS解法

代码：未经过优化的AC代码

class Solution {
public:
    // 广度优先搜索
    Node* cloneGraph(Node* node) {
        if (node == nullptr) {
            return nullptr;
        }

		// 记录被访问状态的数组
        vector<bool> visited(101, false);
        // 原图节点队列
        queue<Node *> que;
        // 克隆图节点队列
        queue<Node *> res;

        que.push(node);
        visited[node->val] = true;


        vector<Node *> nodes(101, nullptr);
        Node *ret = new Node(node->val);
        res.push(ret);
        nodes[ret->val] = ret;

        
        while (que.size()) {
            Node *p = que.front(); que.pop();
            Node *q = res.front(); res.pop();
            for (int i = 0; i < p->neighbors.size(); i++) {
                if (!visited[p->neighbors[i]->val]) {
                    que.push(p->neighbors[i]);
                    visited[p->neighbors[i]->val] = true;
                    Node *new_node = new Node(p->neighbors[i]->val);
                    q->neighbors.push_back(new_node);
                    res.push(new_node);
                    nodes[new_node->val] = new_node;
                } else {
                    q->neighbors.push_back(nodes[p->neighbors[i]->val]);
                }
            }
        }
        return ret;
    }
};

使用哈希表优化之后的代码，省了一些空间：

class Solution {
public:
    // 广度优先搜索
    Node* cloneGraph(Node* node) {
        if (node == nullptr) {
            return nullptr;
        }

        unordered_map<int, Node*> visited;

        queue<Node *> que;
        que.push(node);

        // 克隆节点并存储在哈希表中
        visited[node->val] = new Node(node->val);
        
        while (que.size()) {
            Node *p = que.front(); que.pop();
            for (int i = 0; i < p->neighbors.size(); i++) {
                if (!visited.count(p->neighbors[i]->val)) {
                    que.push(p->neighbors[i]);
                    visited[p->neighbors[i]->val] = new Node(p->neighbors[i]->val);
                }
                visited[p->val]->neighbors.push_back(visited[p->neighbors[i]->val]);                
            }
        }
        return visited[node->val];
    }
};

BFS

代码：

class Solution {
private:
    unordered_map<Node*, Node*> visited;
public:
    // 深度优先搜索
    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;
    }
};