题目描述
给你无向 连通 图中一个节点的引用,请你返回该图的 深拷贝(克隆)。
图中的每个节点都包含它的值 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]