Clone graph

Author: volodimyr

133.clone_graph/clone.py

@@ -0,0 +1,83 @@
+# 133. Clone graph
+# Topics: 'Hash Table', 'Depth-First Search', 'Breadth-First Search', 'Graph'
+# Level: 'Medium'
+
+# 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.
+
+
+
+from collections import deque
+from typing import Optional
+
+class Node:
+    def __init__(self, val = 0, neighbors = None):
+        self.val = val
+        self.neighbors = neighbors if neighbors is not None else []
+
+class Solution:
+    def cloneGraph(self, node: Optional['Node']) -> Optional['Node']:
+        if not node:
+            return node
+        clones = {node.val: Node(node.val)}
+        q = deque([node])
+        while q:
+            cur = q.popleft()
+            for n in cur.neighbors:
+                if n.val not in clones:
+                    clones[n.val] = Node(n.val)
+                    q.append(n)
+                clones[cur.val].neighbors.append(clones[n.val])
+
+        return clones[node.val]

133.clone_graph/test_clone.py

@@ -0,0 +1,117 @@
+import unittest
+from collections import deque
+from clone import Node, Solution
+
+# Assuming Node and Solution are already defined above
+
+class TestCloneGraph(unittest.TestCase):
+    def build_graph(self, adj):
+        if not adj:
+            return None
+        nodes = {i+1: Node(i+1) for i in range(len(adj))}
+        for i, neighbors in enumerate(adj, start=1):
+            nodes[i].neighbors = [nodes[n] for n in neighbors]
+        return nodes[1]
+
+    def graph_to_adj(self, node):
+        if not node:
+            return []
+        adj = {}
+        q = deque([node])
+        seen = set()
+        while q:
+            cur = q.popleft()
+            if cur.val in seen:
+                continue
+            seen.add(cur.val)
+            adj[cur.val] = [n.val for n in cur.neighbors]
+            for n in cur.neighbors:
+                q.append(n)
+        return [adj[i] for i in sorted(adj.keys())]
+
+    def test_empty_graph(self):
+        sol = Solution()
+        self.assertIsNone(sol.cloneGraph(None))
+
+    def test_single_node(self):
+        start = self.build_graph([[]])
+        sol = Solution()
+        cloned = sol.cloneGraph(start)
+        self.assertEqual(self.graph_to_adj(cloned), [[]])
+        self.assertIsNot(cloned, start)
+
+    def test_two_nodes_connected(self):
+        start = self.build_graph([[2], [1]])
+        sol = Solution()
+        cloned = sol.cloneGraph(start)
+        self.assertEqual(self.graph_to_adj(cloned), [[2], [1]])
+        self.assertIsNot(cloned, start)
+
+    def test_four_cycle(self):
+        start = self.build_graph([[2,4],[1,3],[2,4],[1,3]])
+        sol = Solution()
+        cloned = sol.cloneGraph(start)
+        self.assertEqual(
+            self.graph_to_adj(cloned),
+            [[2,4],[1,3],[2,4],[1,3]]
+        )
+        self.assertIsNot(cloned, start)
+
+    def test_branch_graph(self):
+        start = self.build_graph([[2,3], [4], [4], []])
+        sol = Solution()
+        cloned = sol.cloneGraph(start)
+        self.assertEqual(
+            self.graph_to_adj(cloned),
+            [[2,3], [4], [4], []]
+        )
+        self.assertIsNot(cloned, start)
+
+class TestCloneGraph1(unittest.TestCase):
+    def build_diamond_graph(self):
+        # 1-2-3
+        #  \ | /
+        #    4
+        
+        n1 = Node(1)
+        n2 = Node(2)
+        n3 = Node(3)
+        n4 = Node(4)
+
+        n1.neighbors = [n2, n3]
+        n2.neighbors = [n1, n4, n3]
+        n3.neighbors = [n1, n2, n4]
+        n4.neighbors = [n2, n3]
+
+        return n1
+
+    def collect_edges(self, node):
+        # helper to serialize the graph for comparison
+        visited = set()
+        q = deque([node])
+        edges = {}
+
+        while q:
+            cur = q.popleft()
+            if cur.val in visited:
+                continue
+            visited.add(cur.val)
+            edges[cur.val] = sorted([n.val for n in cur.neighbors])
+            for n in cur.neighbors:
+                q.append(n)
+
+        return edges
+
+    def test_diamond_graph(self):
+        sol = Solution()
+        original = self.build_diamond_graph()
+        cloned = sol.cloneGraph(original)
+
+        original_edges = self.collect_edges(original)
+        cloned_edges = self.collect_edges(cloned)
+
+        self.assertEqual(original_edges, cloned_edges)
+
+
+if __name__ == "__main__":
+    unittest.main()