leetcode/clone_graph.py at main · atib92/leetcode · GitHub

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
"""
Clone Graph
Solved
Medium
Topics
premium lock icon
Companies
Given a reference of a node in a connected undirected graph.

Return a deep copy (clone) of the graph.

Each node in the graph contains a value (int) and a list (List[Node]) of its neighbors.

class Node {
    public int val;
    public List<Node> neighbors;
}


Test case format:

For simplicity, each node's value is the same as the node's index (1-indexed). For example, the first node with val == 1, the second node with val == 2, and so on. The graph is represented in the test case using an adjacency list.

An adjacency list is a collection of unordered lists used to represent a finite graph. Each list describes the set of neighbors of a node in the graph.

The given node will always be the first node with val = 1. You must return the copy of the given node as a reference to the cloned graph.


Example 1:


Input: adjList = [[2,4],[1,3],[2,4],[1,3]]
Output: [[2,4],[1,3],[2,4],[1,3]]
Explanation: There are 4 nodes in the graph.
1st node (val = 1)'s neighbors are 2nd node (val = 2) and 4th node (val = 4).
2nd node (val = 2)'s neighbors are 1st node (val = 1) and 3rd node (val = 3).
3rd node (val = 3)'s neighbors are 2nd node (val = 2) and 4th node (val = 4).
4th node (val = 4)'s neighbors are 1st node (val = 1) and 3rd node (val = 3).
Example 2:


Input: adjList = [[]]
Output: [[]]
Explanation: Note that the input contains one empty list. The graph consists of only one node with val = 1 and it does not have any neighbors.
Example 3:

Input: adjList = []
Output: []
Explanation: This an empty graph, it does not have any nodes.


Constraints:

The number of nodes in the graph is in the range [0, 100].
1 <= Node.val <= 100
Node.val is unique for each node.
There are no repeated edges and no self-loops in the graph.
The Graph is connected and all nodes can be visited starting from the given node.
"""
"""
# Definition for a Node.
class Node:
    def __init__(self, val = 0, neighbors = None):
        self.val = val
        self.neighbors = neighbors if neighbors is not None else []
"""

from typing import Optional
from collections import deque
class Solution:
    def cloneGraph_V1(self, node: Optional['Node']) -> Optional['Node']:
        """
        The idea is to a BFS of the graph and store {val:(node, node_copy)} in a nodeDB.
        In the second pass, we simply go through the nodedB and replicate the connections.
        """
        if node is None:
            return None
        node_dB = {}
        q = deque()
        q.append(node)
        while(len(q) != 0):
            node = q.popleft()
            if node.val not in node_dB:
                node_copy = Node(node.val)
                node_dB[node.val] = (node, node_copy)
                if node.neighbors is not None:
                    for neighbor in node.neighbors:
                        q.append(neighbor)
        # Nodes has been copied and saved in dB. Need to link up the nodes now.
        for key in node_dB:
            node, node_copy = node_dB.get(key)
            if node.neighbors is not None:
                node_copy.neighbors = []
                for neighbor in node.neighbors:
                    node_copy.neighbors.append(node_dB.get(neighbor.val)[1])
        return node_dB.get(1)[1]

    # Single Pass Code:
    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
        '''
        Single Pass
        '''
        if not node:
            return None
        q = deque()
        clones = {node:Node(node.val)}
        ret = clones[node]
        q.append(node)
        while q:
            node = q.popleft()
            # This line expect that any node pushed to queue would have its clone created
            clone = clones[node]
            if node.neighbors:
                for neighbor in node.neighbors:
                    if neighbor not in clones:
                        # Discovering a neighbor node for the first time
                        clones[neighbor] = Node(neighbor.val)
                        q.append(neighbor)
                    clone.neighbors.append(clones[neighbor])
        return ret