题目
示例
思路一:深度优先遍历
- 从给定节点出发
- 使用HashMap<Node,Node>保存访问过的节点,key为原始图的节点,value为克隆图的节点
- 如果该节点已经被访问过,HashMap.containsKey(node),则返回对应的value;否则,在hashMap中加入该节点。
- 递归调用每个节点的邻居,每个节点递归调用的次数等于邻居数量,每次调用返回其对应邻居的克隆节点,最终返回这些克隆邻居节点的列表,将其放入对应克隆节点的邻接表中。
具体代码
/*
// Definition for a Node.
class Node {
public int val;
public List<Node> neighbors;
public Node() {
val = 0;
neighbors = new ArrayList<Node>();
}
public Node(int _val) {
val = _val;
neighbors = new ArrayList<Node>();
}
public Node(int _val, ArrayList<Node> _neighbors) {
val = _val;
neighbors = _neighbors;
}
}
*/
class Solution {
public Node cloneGraph(Node node) {
Map<Node,Node> map = new HashMap<>();
return dfs(node,map);
}
public Node dfs(Node node, Map<Node,Node> map){
if(node == null){
return null;
}
if(map.containsKey(node)){
return map.get(node);
}
Node clone = new Node(node.val,new ArrayList<>());
map.put(node,clone);
for(Node n : node.neighbors){
clone.neighbors.add(dfs(n,map));
}
return clone;
}
}
时间复杂度:O(N)
空间复杂度:O(N),存储克隆节点和原节点的 HashMap 需要 O(N) 的空间,递归调用栈需要 O(H)的空间,其中 H 是图的深度。总体空间复杂度为 O(N)
思路二:广度优先遍历
- 使用HashMap存储访问过的节点和克隆节点,key为原始图节点,value为克隆图对应节点。
- 将第一个节点添加到队列
- 从队列首部取出一个节点,遍历该节点的所有邻接点,如果该邻接点被访问过,则从hashmap中返回,否则创建一个新节点存储在hashmap中
- 将克隆的邻接点添加到克隆图对应节点的邻接表中。
具体代码
/*
// Definition for a Node.
class Node {
public int val;
public List<Node> neighbors;
public Node() {
val = 0;
neighbors = new ArrayList<Node>();
}
public Node(int _val) {
val = _val;
neighbors = new ArrayList<Node>();
}
public Node(int _val, ArrayList<Node> _neighbors) {
val = _val;
neighbors = _neighbors;
}
}
*/
class Solution {
public Node cloneGraph(Node node) {
if(node == null){
return null;
}
Map<Node,Node> map = new HashMap<>();
Node clone = new Node(node.val,new ArrayList<>());
map.put(node,clone);
Deque<Node> queue = new LinkedList<>();
queue.offer(node);
while(!queue.isEmpty()){
Node no = queue.poll();
for(Node n:no.neighbors){
if(!map.containsKey(n)){
map.put(n,new Node(n.val,new ArrayList<>()));
queue.offer(n);
}
map.get(no).neighbors.add(map.get(n));
}
}
return clone;
}
}
时间复杂度:O(N)
空间复杂度:O(N) hashmap 使用 O(N) 的空间。BFS 中的队列使用 O(W) 的空间,其中 W 是图的宽度。总体空间复杂度为 O(N)。
参考资料
https://leetcode-cn.com/problems/clone-graph/solution/ke-long-tu-by-leetcode/