LeetCode - 解题笔记 - 133 - Clone Graph

Solution 1

一开始我没弄明白这个题想干啥，后来看了一下发现：需要通过搜索明确图结构，然后用Node结构重建。

实际上DFS和BFS都可以用，需要注意的是，visited判定的结果不是跳过，而是找到对应的新节点加入到邻接表中。因此这里使用了哈希表，直接用是否存在key判断是否遍历过，并取出对应的新节点。

• 时间复杂度：$O(N)$，其中$N$为图中节点个数，全部遍历一次。
• 空间复杂度：$O(N)$，其中$N$为图中节点个数，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:
    Node* cloneGraph(Node* node) {
        unordered_map<Node*, Node*> visited;
        return dfs(node, visited);
    }
    
private:
    Node* dfs(Node* node, unordered_map<Node*, Node*> & visited) {
        if (node == nullptr) {
            return node;
        }
        
        if (visited.find(node) != visited.end()) {
            return visited[node];
        }
        
        Node* newNode = new Node(node->val);
        visited[node] = newNode;
        for (auto & neighbor: node->neighbors) {
            newNode->neighbors.push_back(dfs(neighbor, visited));
        }
        
        return newNode;
    }
};

Solution 2

BFS实现，时空占用基本一致

/*
// 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) {
        unordered_map<Node*, Node*> visited;
        return bfs(node, visited);
    }
    
private:    
    Node* bfs(Node* node, unordered_map<Node*, Node*> & visited) {
        if (node == nullptr) {
            return node;
        }
        
        queue<Node*> q;
        q.push(node);
        
        Node* newNode = new Node(node->val);
        visited[node] = newNode;

        while (!q.empty()) {
            auto tempNode = q.front();
            q.pop();
            for (auto& neighbor: tempNode->neighbors) {
                if (visited.find(neighbor) == visited.end()) {
                    visited[neighbor] = new Node(neighbor->val);
                    q.push(neighbor);
                }
                
                visited[tempNode]->neighbors.push_back(visited[neighbor]);
            }
        }

        return newNode;
    }
};

Solution 2

Solution 1的Python实现

"""
# Definition for a Node.
class Node:
    def __init__(self, val = 0, neighbors = None):
        self.val = val
        self.neighbors = neighbors if neighbors is not None else []
"""

class Solution:
    def cloneGraph(self, node: 'Node') -> 'Node':
        def dfs(node: 'Node') -> 'Node':
            nonlocal visited
            
            if node is None: return node
            
            if node in visited: return visited[node]
            
            newNode = Node(node.val)
            visited[node] = newNode
            for neighbor in node.neighbors:
                newNode.neighbors.append(dfs(neighbor))
                
            return newNode
            
            
        visited = dict()
        
        return dfs(node)

Solution 4

Solution 2的Python实现

"""
# Definition for a Node.
class Node:
    def __init__(self, val = 0, neighbors = None):
        self.val = val
        self.neighbors = neighbors if neighbors is not None else []
"""

class Solution:
    def cloneGraph(self, node: 'Node') -> 'Node':
        def bfs(node: 'Node') -> 'Node':
            nonlocal visited
            
            if node is None: return node
            
            q = collections.deque()
            q.append(node)
            newNode = Node(node.val)
            visited[node] = newNode

            while q:
                tempNode = q.popleft()
                for neighbor in tempNode.neighbors:
                    if neighbor not in visited:
                        visited[neighbor] = Node(neighbor.val)
                        q.append(neighbor)
                    visited[tempNode].neighbors.append(visited[neighbor])

            return newNode

        visited = dict()
        
        return bfs(node)