LeetCode //C - 133. Clone Graph

133. Clone Graph

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: LeetCode
Link: 133. Clone Graph

---

Solution:

Ideas：

1. Initialization: The process begins by initializing a mapping array to keep track of the correspondence between the nodes in the original graph and their clones in the new graph.

2. DFS Traversal: It employs Depth-First Search (DFS) traversal to visit each node in the graph and make a clone of it. DFS is used recursively to navigate through the graph’s nodes and their neighbors.

3. Node Cloning: When a node is visited, it is cloned, and its corresponding mapping is stored in the mapping array. If a node is already in the mapping array, it has been cloned, and the cloned node is returned directly.

4. Neighbor Cloning: The neighbors of each node are also cloned recursively during the DFS traversal. The cloned neighbors are then linked to the cloned nodes appropriately, maintaining the graph’s structure.

5. Return Cloned Graph: Finally, a reference to the cloned graph is returned.

Code:

/**
 * Definition for a Node.
 * struct Node {
 *     int val;
 *     int numNeighbors;
 *     struct Node** neighbors;
 * };
 */

struct Node* dfs(struct Node* node, struct Node** map);  // Forward declaration

struct Node* cloneGraph(struct Node* node) {
    if(!node) return NULL; // If the graph is empty
    
    // Hash map to store mapping between original node and cloned node
    struct Node* map[101] = {NULL};
    
    return dfs(node, map);
}

struct Node* dfs(struct Node* node, struct Node** map) {
    if(map[node->val]) return map[node->val]; // If the node is already cloned, return the clone
    
    // Clone the current node
    struct Node* cloneNode = (struct Node*)malloc(sizeof(struct Node));
    cloneNode->val = node->val;
    cloneNode->numNeighbors = node->numNeighbors;
    cloneNode->neighbors = (struct Node**)malloc(cloneNode->numNeighbors * sizeof(struct Node*));
    
    map[node->val] = cloneNode; // Store the mapping between original node and cloned node
    
    // Recursively clone the neighbors
    for(int i = 0; i < node->numNeighbors; i++)
        cloneNode->neighbors[i] = dfs(node->neighbors[i], map);
    
    return cloneNode;
}