Leetcode 133 克隆图

题目描述

给你无向 连通 图中一个节点的引用，请你返回该图的 深拷贝（克隆）。

图中的每个节点都包含它的值 val（int） 和其邻居的列表（list[Node]）。

class Node {
    public int val;
    public List<Node> neighbors;
}

测试用例格式：

简单起见，每个节点的值都和它的索引相同。例如，第一个节点值为 1（val = 1），第二个节点值为 2（val = 2），以此类推。该图在测试用例中使用邻接列表表示。

邻接列表 是用于表示有限图的无序列表的集合。每个列表都描述了图中节点的邻居集。

给定节点将始终是图中的第一个节点（值为 1）。你必须将 给定节点的拷贝 作为对克隆图的引用返回。

示例 1：

输入：adjList = [[2,4],[1,3],[2,4],[1,3]]
输出：[[2,4],[1,3],[2,4],[1,3]]
解释：
图中有 4 个节点。
节点 1 的值是 1，它有两个邻居：节点 2 和 4 。
节点 2 的值是 2，它有两个邻居：节点 1 和 3 。
节点 3 的值是 3，它有两个邻居：节点 2 和 4 。
节点 4 的值是 4，它有两个邻居：节点 1 和 3 。

示例 2：

输入：adjList = [[]]
输出：[[]]
解释：输入包含一个空列表。该图仅仅只有一个值为 1 的节点，它没有任何邻居。

示例 3：

输入：adjList = []
输出：[]
解释：这个图是空的，它不含任何节点。

示例 4:

输入：adjList = [[2],[1]]
输出：[[2],[1]]

提示：

节点数不超过 100 。
每个节点值 Node.val 都是唯一的，1 <= Node.val <= 100。
无向图是一个简单图，这意味着图中没有重复的边，也没有自环。
由于图是无向的，如果节点 p 是节点 q 的邻居，那么节点 q 也必须是节点 p 的邻居。
图是连通图，你可以从给定节点访问到所有节点。

解题思路

一开始不理解深拷贝是什么意思，看测试样例是以为只需要输出一个list，在list里顺序保存每个节点的邻居节点就可以。图的深拷贝是对图的重建，对于一张图而言，它的深拷贝即构建一张与原图结构，值均一样的图，但是其中的节点不再是原来图节点的引用。
一开始想用有序列表按照val来储存节点进行遍历（类似于Dijkstra算法），其实只需要用BFS或者DFS加上一个字典或者哈希表就可以解决，BFS、DFS用来遍历整个图的所有结点，使用哈希表或者字典来保存已经遍历过的结点，避免了陷入死循环中。

首先已有开始结点的引用，克隆该结点的val，并将该结点标记，之后通过克隆该结点的邻居结点，当对应的邻居结点已经被标记过时，则返回克隆结点。

详解：https://leetcode-cn.com/problems/clone-graph/solution/ke-long-tu-by-leetcode-solution/

BFS、DFS学习视频（视频中含python代码）：https://www.bilibili.com/video/BV1Ks411579J/?spm_id_from=333.788.videocard.1
https://www.bilibili.com/video/BV1Ks411575U/?spm_id_from=333.788.videocard.0

代码

错误代码

错误代码，一开始并不理解深拷贝的意思，以为需要输出一个list，按顺序在list中存储每个结点的邻居，正好刚刚学习了Dijkstra算法，就用这种思路写了一个可以输出list的代码，可以通过测试样例。

class Solution:
    def cloneGraph(self, node: 'Node') -> 'Node':
        pqueue = []
        heapq.heappush(pqueue, (node.val, node.neighbors))
        neiborhood = defaultdict(list)
        neibor = []
        for i in range(len(node.neighbors)):
            neibor = neibor+[node.neighbors[i].val]
        neiborhood[node.val] = neibor
        while pqueue:
            cur, neighbor = heapq.heappop(pqueue)
            length = len(neighbor)
            for i in range(length):
                print(neighbor[i].val)
                print(neiborhood)
                if neighbor[i].val not in neiborhood.keys():
                    heapq.heappush(pqueue,(neighbor[i].val, neighbor[i].neighbors))
                    neibor = []
                    for j in range(len(neighbor[i].neighbors)):
                        neibor = neibor+[neighbor[i].neighbors[j].val]
                    neiborhood[neighbor[i].val] = neibor
        data = dict(sorted(neiborhood.items(), key=lambda x: x[0]))
        value_list = list(data.values())
        return value_list

深度优先代码

摘自Leetcode：
作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/clone-graph/solution/ke-long-tu-by-leetcode-solution/
来源：力扣（LeetCode）

class Solution(object):

    def __init__(self):
        self.visited = {}

    def cloneGraph(self, node):
        """
        :type node: Node
        :rtype: Node
        """
        if not node:
            return node

        # 如果该节点已经被访问过了，则直接从哈希表中取出对应的克隆节点返回
        if node in self.visited:
            return self.visited[node]

        # 克隆节点，注意到为了深拷贝我们不会克隆它的邻居的列表
        clone_node = Node(node.val, [])

        # 哈希表存储
        self.visited[node] = clone_node

        # 遍历该节点的邻居并更新克隆节点的邻居列表
        if node.neighbors:
            clone_node.neighbors = [self.cloneGraph(n) for n in node.neighbors]

        return clone_node

广度优先代码

摘自Leetcode：
作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/clone-graph/solution/ke-long-tu-by-leetcode-solution/
来源：力扣（LeetCode）

class Solution(object):
    #广度优先
    def cloneGraph(self, node):
        """
        :type node: Node
        :rtype: Node
        """
        if not node:
            return node
        visited = {} #创建一个hash表来存储访问过的结点

        clone_node = Node(node.val, [])  # clone当前结点，存入队列中
        queue = deque([node])  #遍历的应该是初试图，在visited中存放创建的结点
        visited[node] =  clone_node

        while queue:
            n = queue.popleft()  #取出结点，查看该结点的邻居，如果该结点邻居C未被访问，则将C加入队列，并为C创造clone结点存入visited中
            for h in n.neighbors:
                if h not in visited:
                    clone_node = Node(h.val, [])
                    visited[h] = clone_node
                    queue.append(h)
                visited[n].neighbors.append(visited[h])
        return visited[node]