133. 克隆图

1. 题目

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

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

1
2
3
4
class Node {
    public int val;
    public List<Node> neighbors;
}

测试用例格式：

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

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

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

示例 1：

img 
1
2
3
4
5
6
7
8
输入：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：

img

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

示例 3：

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

示例 4：

img

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

提示：

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

2. 思路

  • 已知题目要求克隆完整的图，克隆指的是不能重复利用现有节点对象，需要重新构造每一个新的节点对象

  • 同时已知节点数量不超过100，同时每个节点值都是唯一的，分布在1 ~ 100，对应的图为无向图

  • 整体思路采用DFS进行图节点的克隆，对当前节点以及邻接点进行克隆，在完成节点克隆的同时进行节点缓存，避免重复克隆

  • 缓存采用的是Node数组进行，数组大小初始化为101，以使得通过节点值能够使得数组索引完整覆盖在1 ~ 100这个区间

  • 在克隆邻接节点的过程中，如果缓存的Node 数组中已经存在该节点，则直接使用，否则则调用cloneGraph方法进行节点的克隆

  • 完成克隆后即可返回新的图节点newNode

3. 代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
/*
// 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 {
    private Node[] map = new Node[101];

    public Node cloneGraph(Node node) {
        if (node == null) {
            return node;
        }

        var newNode = new Node(node.val);
        map[node.val] = newNode;

        for (var neighborNode : node.neighbors) {
            var newNeighborNode = map[neighborNode.val] != null ? map[neighborNode.val] : cloneGraph(neighborNode);
            newNode.neighbors.add(newNeighborNode);
        }

        return newNode;
    }
}

4. 复杂度

  • 时间复杂度: 对于每个节点，都需要进行一次克隆操作，因此克隆的时间复杂度是O(N)，对于每条边，都会进行一次邻居节点的克隆和查找，在最坏的情况下，每个节点都有N - 1个邻居相连，因此在整个图上，总的邻居节点的克隆和查找操作是O(E)，总的时间复杂度是O(N + E)，但在图的概念当中，通常E是大于等于N的，因此整体的时间复杂度为O(E)
  • 空间复杂度: O(N)

image-20231120122401282