Baozi Leetcode solution 133: Clone Graph

Problem Statement 

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 val (int) and a list (List[Node]) of its neighbors.

 

Example:

Input:
{"$id":"1","neighbors":[{"$id":"2","neighbors":[{"$ref":"1"},{"$id":"3","neighbors":[{"$ref":"2"},{"$id":"4","neighbors":[{"$ref":"3"},{"$ref":"1"}],"val":4}],"val":3}],"val":2},{"$ref":"4"}],"val":1}

Explanation:
Node 1's value is 1, and it has two neighbors: Node 2 and 4.
Node 2's value is 2, and it has two neighbors: Node 1 and 3.
Node 3's value is 3, and it has two neighbors: Node 2 and 4.
Node 4's value is 4, and it has two neighbors: Node 1 and 3.

 

Note:

1. The number of nodes will be between 1 and 100.
2. The undirected graph is a simple graph, which means no repeated edges and no self-loops in the graph.
3. Since the graph is undirected, if node p has node q as neighbor, then node q must have node p as neighbor too.
4. You must return the copy of the given node as a reference to the cloned graph.

Problem link

 

Video Tutorial

You can find the detailed video tutorial here

• Youtube
• B站

 

Thought Process

It's a basic graph problem that can be solved in 3 different ways: BFS using queue, DFS using recursion, DFS using stack(very similar to BFT using queue). The trick is using a map to keep a one-to-one mapping between the old nodes and the copied nodes, meanwhile, we can also use the map to avoid a cycle when performing BFS or DFS.

Solutions

 

BFS using queue

 

public Node cloneGraphBFS(Node node) {
    if (node == null) {
        return node;
    }

    Map<Node, Node> lookup = new HashMap<>();

    Queue<Node> q = new LinkedList<>();
    q.add(node);
    lookup.put(node, new Node(node.val, new ArrayList<>()));

    while (!q.isEmpty()) {
        Node cur = q.poll();

        for (Node n : cur.neighbors) {
            Node copiedNeighbor = null;

            if (!lookup.containsKey(n)) {
                // the neighbors would be populated later when it's popped out from the queue
                copiedNeighbor = new Node(n.val, new ArrayList<>());
                lookup.put(n, copiedNeighbor);
                q.add(n);
            } else {
                copiedNeighbor = lookup.get(n);
            }
            lookup.get(cur).neighbors.add(copiedNeighbor);
        }
    }
    return lookup.get(node);
}

 

 

Time Complexity: O(N)
Space Complexity: O(N) the extra queue and map

DFS using recursion

public Node cloneGraphDFSWithRecursion(Node node) {
    if (node == null) {
        return node;
    }
    Map<Node, Node> lookup = new HashMap<>();
    return this.cloneGraphHelper(node, lookup);
}

/**
 * A dfs helper using recursion to make a copy of each node recursively via neighbors
 * @param node
 * @param lookup
 * @return the copied node of Node
 */
private Node cloneGraphHelper(Node node, Map<Node, Node> lookup) {
    if (node == null) {
        return node;
    }

    if (lookup.containsKey(node)) {
        return lookup.get(node);
    }

    Node copiedNode = new Node(node.val, new ArrayList<>());
    lookup.put(node, copiedNode);
    for (Node n : node.neighbors) {
        Node copiedN = this.cloneGraphHelper(n, lookup);
        copiedNode.neighbors.add(copiedN);
    }
    return copiedNode;
}

 

Time Complexity: O(N)
Space Complexity: O(N) the extra map

DFS using stack

// exactly the same as BFS except used a stack to mimic the recursion, technically any BFS can be written
// in DFS by using a stack
public Node cloneGraphDFSUsingStack(Node node) {
    if (node == null) {
        return node;
    }
    Map<Node, Node> lookup = new HashMap<>();
    Node t = new Node(node.val, new ArrayList<>());
    lookup.put(node, t);

    Stack<Node> stack = new Stack<>();
    stack.push(node);

    while (!stack.isEmpty()) {
        Node cur = stack.pop();

        for (Node n : cur.neighbors) {
            Node copiedNeighbor = null;
            if (!lookup.containsKey(n)) {
                copiedNeighbor = new Node(n.val, new ArrayList<>());
                stack.push(n);
                lookup.put(n, copiedNeighbor);
            } else {
                copiedNeighbor = lookup.get(n);
            }
            lookup.get(cur).neighbors.add(copiedNeighbor);
        }
    }

    return lookup.get(node);
}

 

 

Time Complexity: O(N)
Space Complexity: O(N) the extra queue and stack

The main test method

public static void main(String[] args) {
    CloneGraph cg = new CloneGraph();

    // construct the example graph
    Node n1 = new Node(1, new ArrayList<>());
    Node n2 = new Node(2, new ArrayList<>());
    Node n3 = new Node(3, new ArrayList<>());
    Node n4 = new Node(4, new ArrayList<>());
    n1.neighbors.addAll(Arrays.asList(new Node[]{n2, n4}));
    n2.neighbors.addAll(Arrays.asList(new Node[]{n3, n3}));
    n3.neighbors.addAll(Arrays.asList(new Node[]{n2, n4}));
    n4.neighbors.addAll(Arrays.asList(new Node[]{n1, n3}));
    // add a self cycle
    n1.neighbors.addAll(Arrays.asList(new Node[]{n1}));

    // expect the same BFS order print out
    Utilities.printGraphBFS(n1);
    Node copiedN1 = cg.cloneGraphBFS(n1);
    Utilities.printGraphBFS(copiedN1);
}

/**
 * print out a graph in BFS node, note it could be a cycle, so it's not really the topological order
 *
 *      1   -----     2
 *      |             |
 *      4   -----     3
 * @param node
 */
public static void printGraphBFS(CloneGraph.Node node) {
    if (node == null) {
        return;
    }

    Set<CloneGraph.Node> visited = new HashSet<>();
    Queue<CloneGraph.Node> queue = new LinkedList<>();
    queue.add(node);
    System.out.println(node.val);
    visited.add(node);

    while (!queue.isEmpty()) {
        CloneGraph.Node cur = queue.poll();
        for (CloneGraph.Node n : cur.neighbors) {
            if (!visited.contains(n)) {
                queue.add(n);
                System.out.println(n.val);
                visited.add(n);
            }
        }
    }
}

 

References

• Leetcode official solution (download pdf)
• Code Ganker CSDN