Clone Graph: Deep Copying in Connected Systems

Imagine you're building a social network, and you need to create a test environment that perfectly mirrors your production network - every user, every connection, every relationship.

Or picture yourself developing a game where you need to save the entire game state, including all the interconnected objects and their relationships. These are real-world scenarios where understanding graph cloning becomes crucial.

The Clone Graph problem asks us to create a perfect copy of a connected structure - not just the surface-level data, but all the deep relationships between elements.

It's like creating a perfect replica of a spider's web, where each intersection point (node) and every connecting thread (edge) must be duplicated exactly.

What makes this problem fascinating is its deceptive simplicity. At first glance, it might seem as easy as copying nodes one by one.

But what happens when Node A points to Node B, which points back to Node A?

1. How do we handle these cycles without getting stuck in an infinite loop?
2. How do we ensure that if multiple nodes point to the same neighbour in the original graph, they point to the same copy in our cloned graph?

This problem tests our understanding of:

• Deep vs shallow copying
• Graph traversal strategies (DFS/BFS)
• Handling cyclic references
• Memory management and optimisation
• Reference vs value semantics

A leetcode problem of graph copy:

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).

Let's understand how we can solve it?

Original Graph:

  1 ---- 2
  |      |
  4 ---- 3

   node1 connects to [2,4]
   node2 connects to [1,3]
   node3 connects to [2,4]
   node4 connects to [1,3]

Let's see how the map fills up during DFS:

Start at node 1:

map = {
  node1 -> newNode1  // Maps original node1 to its clone
}

Process node 1's neighbors (2,4):

map = {
  node1 -> newNode1
  node2 -> newNode2   // Added when processing node 1's first neighbor
}

When processing node 2's neighbour's (1,3):

• It sees node1 in map, so reuses newNode1
• Creates new node3

map = {
  node1 -> newNode1
  node2 -> newNode2
  node3 -> newNode3
}

This continues until all nodes are processed

map = {
  node1 -> newNode1
  node2 -> newNode2
  node3 -> newNode3
  node4 -> newNode4
}

Processing node 1

Current map: []

Creating new node 1

Processing neighbor 2 of node 1

Processing node 2

Current map: [ '1->1' ]

Creating new node 2

Processing neighbor 1 of node 2

Processing node 1

Current map: [ '1->1', '2->2' ]

Node 1 already cloned, reusing

Processing neighbor 3 of node 2

Processing node 3

Current map: [ '1->1', '2->2' ]

Creating new node 3

Processing neighbor 2 of node 3

Processing node 2

Current map: [ '1->1', '2->2', '3->3' ]

Node 2 already cloned, reusing

Processing neighbor 4 of node 3

Processing node 4

Current map: [ '1->1', '2->2', '3->3' ]

Creating new node 4

Processing neighbor 1 of node 4

Processing node 1

Current map: [ '1->1', '2->2', '3->3', '4->4' ]

Node 1 already cloned, reusing

Processing neighbor 3 of node 4

Processing node 3

Current map: [ '1->1', '2->2', '3->3', '4->4' ]

Node 3 already cloned, reusing

Processing neighbor 4 of node 1

Processing node 4

Current map: [ '1->1', '2->2', '3->3', '4->4' ]

Node 4 already cloned, reusing

/**
 * // Definition for a Node.
 * class Node {
 *     constructor(val = 0, neighbors = []) {
 *       this.val = val;
 *       this.neighbors = neighbors;
 *     }
 * }
 */

class Solution {
    /**
     * @param {Node} node
     * @return {Node}
     */
    constructor(){
        this.map = new Map()
    }

    cloneGraph(node) {  
        if(!node){
            return null
        }
        if(this.map.has(node)){
            return this.map.get(node)
        }
        let cloneNode = new Node(node.val)
        this.map.set(node, cloneNode)

        for(let neighbor of node.neighbors){
            cloneNode.neighbors.push(this.cloneGraph(neighbor))
        }
        return cloneNode
    }
}

#graphs #datastructures #cloningGraphs #leetcode