leetcode133.克隆图(java)：深度优先遍历和广度优先遍历

题目

示例

思路一：深度优先遍历

1. 从给定节点出发
2. 使用HashMap<Node,Node>保存访问过的节点，key为原始图的节点，value为克隆图的节点
3. 如果该节点已经被访问过，HashMap.containsKey(node)，则返回对应的value；否则，在hashMap中加入该节点。
4. 递归调用每个节点的邻居，每个节点递归调用的次数等于邻居数量，每次调用返回其对应邻居的克隆节点，最终返回这些克隆邻居节点的列表，将其放入对应克隆节点的邻接表中。

具体代码

/*
// 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)

思路二：广度优先遍历

1. 使用HashMap存储访问过的节点和克隆节点，key为原始图节点，value为克隆图对应节点。
2. 将第一个节点添加到队列
3. 从队列首部取出一个节点，遍历该节点的所有邻接点，如果该邻接点被访问过，则从hashmap中返回，否则创建一个新节点存储在hashmap中
4. 将克隆的邻接点添加到克隆图对应节点的邻接表中。

具体代码

/*
// 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/