The Depth-First Search (DFS) approach is one of the most intuitive ways to solve the graph cloning problem. Here, we will recursively explore each node starting from the root (Node 1) and keep a map to store already cloned nodes, ensuring each node is cloned once.
For each node, we:
Time Complexity: O(V+E), where V is the number of vertices and E is the number of edges. This is because we visit each node and edge once.
Space Complexity: O(V), for the recursion stack and the clone map.
1#include <stdio.h>
2#include <stdlib.h>
3#include <string.h>
4
5#define MAX_NODES 101
6
7typedef struct Node {
8 int val;
9 struct Node** neighbors;
10 int numNeighbors;
11} Node;
12
13Node* cloneGraph(Node* node, Node** cloneMap);
14
15Node* cloneGraphUtil(Node* node, Node** cloneMap) {
16 if (node == NULL) return NULL;
17
18 if (cloneMap[node->val]) return cloneMap[node->val];
19
20 Node* cloneNode = (Node*)malloc(sizeof(Node));
21 cloneNode->val = node->val;
22 cloneNode->numNeighbors = node->numNeighbors;
23 cloneNode->neighbors = (Node**)malloc(sizeof(Node*) * node->numNeighbors);
24 cloneMap[node->val] = cloneNode;
25
26 for (int i = 0; i < node->numNeighbors; i++) {
27 cloneNode->neighbors[i] = cloneGraphUtil(node->neighbors[i], cloneMap);
28 }
29
30 return cloneNode;
31}
32
33Node* cloneGraph(Node* node) {
34 Node* cloneMap[MAX_NODES] = {NULL};
35 return cloneGraphUtil(node, cloneMap);
36}The above C program defines a structure Node for graph nodes and uses a recursive function cloneGraphUtil to perform a DFS for cloning. We use an array of pointers cloneMap indexed by node values to track cloned nodes.
An alternative approach is to use Breadth-First Search (BFS), which is iterative in nature. Here, we utilize a queue to help explore each node level by level, preventing deep recursion and managing each node's clone in a breadth-wise manner.
In this BFS approach:
Time Complexity: O(V+E).
Space Complexity: O(V).
1from collections import deque
2
3class Node:
4 def __init__(self, val = 0, neighbors = None):
5 self.val = val
6 self.neighbors = neighbors if neighbors is not None else []
7
8class Solution:
9 def cloneGraph(self, node: 'Node') -> 'Node':
10 if not node:
11 return None
12
13 visited = {}
14 queue = deque([node])
15 visited[node] = Node(node.val, [])
16
17 while queue:
18 n = queue.popleft()
19 for neighbor in n.neighbors:
20 if neighbor not in visited:
21 visited[neighbor] = Node(neighbor.val, [])
22 queue.append(neighbor)
23 visited[n].neighbors.append(visited[neighbor])
24
25 return visited[node]The Python BFS implementation uses a deque for iterative traversal and a dictionary visited to record cloned nodes. It features level-wise cloning and linking of the nodes, ensuring all nodes are cloned and linked efficiently.