[leetcode每日一题2020/8/12]133. 克隆图

题目来源于leetcode，解法和思路仅代表个人观点。传送门。
难度：中等
用时：01:00:00 (思路很快就有了，后面稍微修正了一下，也挺快的)

题目

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

图中的每个节点都包含它的值 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]]

提示：

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

思路

这里，简单想法就是遍历一遍节点，然后顺便生成他的复制品（duplicates）。然后我就想到了bfs。（其实dfs更简单，但是没想到）
BFS：

1. 对给定的节点进行广度遍历BFS。
2. 在BFS的过程中，加入克隆节点的生成和其邻接节点的构建。

---

需要注意的几点：
3. 把邻接节点加入队列的时候，只入队没有遍历过的节点。这时只生成克隆的邻接节点，不考虑其邻接列表。
4. 由于给定的节点1<=Node.val<=100，且唯一。我们可以用长度为101的数组，记录，该节点是否被遍历过。
5. 更重要的是。由于题目给出的结构是List<Node>。那么一个节点的邻接表里面存放的节点，也是要存在于图上的。也就是说，不能单纯的new一个节点放进去。那么，这里用到了一个Map<Integer,Node>，用来记录、存放克隆节点。保证每个克隆节点都是单例的。

代码

我这里的代码不小心写成层序遍历了，我好菜（不熟练

/*
// 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 {
    int[] flag = new int[101];
    Map<Integer,Node> map = new HashMap<>();
    public Node cloneGraph(Node node) {
        //特殊情况
        if(node==null){
            return null;
        }
        //队列
        Queue<Node> queue = new LinkedList<>();
        //进行广度遍历
        queue.offer(node);
        while(queue.size()!=0){
            int size = queue.size();
            //对于队列里的每一个节点
            for(int i=0;i<size;i++){
                //取出节点
                Node orignalNode = queue.poll();
                //如果该无向图成环
                if(flag[orignalNode.val] == 1){
                    continue;
                }
                //标记该节点（防止重复遍历）
                flag[orignalNode.val] = 1;
                //复制一个节点
                Node duplicateNode;
                if(map.get(orignalNode.val)==null){
                    duplicateNode = new Node();
                    map.put(orignalNode.val,duplicateNode);
                }else{
                    duplicateNode = map.get(orignalNode.val);
                }
                //复制其值
                duplicateNode.val = orignalNode.val;
                //复制其邻接表
                for(int j=0;j<orignalNode.neighbors.size();j++){
                    Node orignalNeighborNode = orignalNode.neighbors.get(j);
                    Node duplicateNeighborNode;
                    if(map.get(orignalNeighborNode.val) == null){
                        duplicateNeighborNode = new Node();
                        map.put(orignalNeighborNode.val,duplicateNeighborNode);
                    }else{
                        duplicateNeighborNode = map.get(orignalNeighborNode.val);
                    }
                    duplicateNeighborNode.val = orignalNeighborNode.val;

                    duplicateNode.neighbors.add(duplicateNeighborNode);
                    //把邻接节点加入队列(如果该节点未被标记【没遍历过】)
                    if(flag[orignalNeighborNode.val] == 0){
                        queue.offer(orignalNeighborNode);
                    }
                }
            }
        }
        return map.get(1);
    }
}

算法复杂度

时间复杂度： O(n)。每个节点只遍历一遍。
空间复杂度： O(n)。用flag记录所有节点是否被遍历过。用Map记录所有克隆节点。