Task description: Given a reference of a node in a undirected graph. connected Return a (clone) of the graph. deep copy Each node in the graph contains a value ( ) and a list ( ) of its neighbors. int List[Node] 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 , the second node with , and so on. The graph is represented in the test case using an adjacency list. val == 1 val == 2 is a collection of unordered used to represent a finite graph. Each list describes the set of neighbors of a node in the graph. An adjacency list lists The given node will always be the first node with . You must return the as a reference to the cloned graph. val = 1 copy of the given node 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 is unique for each node. Node.val 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. Reasoning: As always we look at the problems and it might seem pretty challenging. As I always suggest, if you feel stuck or don’t know how to approach the problem start with talking with yourself. So we have a graph and we need to clone it, one thought must immediately pop up in your head. There’s no way to make a full copy of something without full traverse/exploration of it. Good. What approaches do we know to traverse a graph/tree? Correct BFS(Bread First Search) or DFS(Depth First Search). Does it matter which one we pick? I don’t think so. We just made the first step on our way to the solution. Let’s look at simple DFS. class Node
    {
        public int val;
        public List<Node> neighbors;

        public Node()
        {
            val = 0;
            neighbors = new ArrayList<Node>();
        }

        public Node(int _val)
        {
            val = _val;
            neighbors = new ArrayList<Node>();
        }

        public Node(int _val, ArrayList<Node> _neighbors)
        {
            val = _val;
            neighbors = _neighbors;
        }
    }

    public void traverseGraph(Node node)
    {
        LinkedList<Node> queue = new LinkedList<>();
        Set<Node> visitedNodes = new HashSet<>();

        queue.addLast(node);

        while (!queue.isEmpty())
        {
            Node current = queue.removeFirst();

            // we already visited this node, we should ship exploring this path
            if (!visitedNodes.add(current))
            {
                continue;
            }

            // just because every node contains a list of it's neighbors we can add all of them to our queue
            queue.addAll(current.neighbors);
        }
    } So now we have the code to exploring given graph, but we need not only to visit them but also create a copy for each node in a graph. I intentionally not telling you anything about creating links between nodes we’re going to copy, I’ll touch it later on, for now let’s focus on our effort for creating copies. We need some data structure for storing relationship between original node and it’s copy. At the same time it should support 2 features, one for adding link and the second one for getting the copy. It should work as fast as possible. Some of you might have already guessed — HashMap in Java or HashTable in other programming languages. We need to add just few lines of code in our function. public void traverseGraphAndCreateCopyOfNodes(Node node, Map<Node, Node> originalToCopyMap)
    {
        LinkedList<Node> queue = new LinkedList<>();
        Set<Node> visitedNodes = new HashSet<>();

        queue.addLast(node);

        while (!queue.isEmpty())
        {
            Node current = queue.removeFirst();

            // we already visited this node, we should ship exploring this path
            if (!visitedNodes.add(current))
            {
                continue;
            }

            Node copy = new Node(current.val);
            originalToCopyMap.put(current, copy);

            // just because every node contains a list of it's neighbors we can add all of them to our queue
            queue.addAll(current.neighbors);
        }
    } Let’s have a look at what we have done so far. Let’s imagine we are given this graph Then in our originalToCopyMap we have something like this The only thing is left. We need somehow connect cloned nodes so they have exactly the same connections between them as the original graph has. How do we do that, can we utilize originalToCopyMap? The answer we must use it. We’re going to make the second traverse after we do the first one, using data from that map we can copy/establish connections between cloned nodes so they repeat the original. public void traverseGraphAndCreateLinksBetweenNodes(Node node, Map<Node, Node> originalToCopyMap)
    {
        LinkedList<Node> queue = new LinkedList<>();
        Set<Node> visitedNodes = new HashSet<>();

        queue.addLast(node);

        while (!queue.isEmpty())
        {
            Node current = queue.removeFirst();

            // we already visited this node, we should ship exploring this path
            if (!visitedNodes.add(current))
            {
                continue;
            }

            Node clonedCurrent = originalToCopyMap.get(current);
            for (Node neighborOfCurrentNode: current.neighbors)
            {
                clonedCurrent.neighbors.add(originalToCopyMap.get(neighborOfCurrentNode));
            }

            // just because every node contains a list of it's neighbors we can add all of them to our queue
            queue.addAll(current.neighbors);
        }
    } After executing of the traverseGraphAndCreateLinksBetweenNodes method we should get this copied graph Solution: Using 3 simple steps we solved the given problem. Here’s the full source code Solution class Node
    {
        public int val;
        public List<Node> neighbors;

        public Node()
        {
            val = 0;
            neighbors = new ArrayList<Node>();
        }

        public Node(int _val)
        {
            val = _val;
            neighbors = new ArrayList<Node>();
        }

        public Node(int _val, ArrayList<Node> _neighbors)
        {
            val = _val;
            neighbors = _neighbors;
        }
    }

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

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

        traverseGraphAndCreateCopyOfNodes(node, originalToCopyMap);
        traverseGraphAndCreateLinksBetweenNodes(node, originalToCopyMap);

        return originalToCopyMap.get(node);
    }

    public void traverseGraphAndCreateCopyOfNodes(Node node, Map<Node, Node> originalToCopyMap)
    {
        LinkedList<Node> queue = new LinkedList<>();
        Set<Node> visitedNodes = new HashSet<>();

        queue.addLast(node);

        while (!queue.isEmpty())
        {
            Node current = queue.removeFirst();

            // we already visited this node, we should ship exploring this path
            if (!visitedNodes.add(current))
            {
                continue;
            }

            Node copy = new Node(current.val);
            originalToCopyMap.put(current, copy);

            // just because every node contains a list of it's neighbors we can add all of them to our queue
            queue.addAll(current.neighbors);
        }
    }

    public void traverseGraphAndCreateLinksBetweenNodes(Node node, Map<Node, Node> originalToCopyMap)
    {
        LinkedList<Node> queue = new LinkedList<>();
        Set<Node> visitedNodes = new HashSet<>();

        queue.addLast(node);

        while (!queue.isEmpty())
        {
            Node current = queue.removeFirst();

            // we already visited this node, we should ship exploring this path
            if (!visitedNodes.add(current))
            {
                continue;
            }

            Node clonedCurrent = originalToCopyMap.get(current);
            for (Node neighborOfCurrentNode: current.neighbors)
            {
                clonedCurrent.neighbors.add(originalToCopyMap.get(neighborOfCurrentNode));
            }

            // just because every node contains a list of it's neighbors we can add all of them to our queue
            queue.addAll(current.neighbors);
        }
    } We can stop right here and be happy about another solved problem. BUT some of you might have noticed we have some duplicates in our code which we can remove and let’s use recursion to make our code cleaner and shorter. public Node cloneGraph(Node node)
		{
			Map<Node, Node> map = new HashMap<>();
			return cloneGraph(node, map);
		}

		private Node cloneGraph(Node node, Map<Node, Node> map)
		{
			if (node == null)
			{
				return null;
			}

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

			Node copy = new Node(node.val);
			map.put(node, copy);
			for (Node neighbor : node.neighbors)
			{
				copy.neighbors.add(cloneGraph(neighbor, map));
			}

			return copy;
		} Recursive approach I hope this article will help you to understand the logic behind this problem and use it to solve other tasks. See you soon! Also Published Here Photo by Thomas Couillard on Unsplash

The code in this story is for educational purposes. The readers are solely responsible for whatever they build with it.

The Graph

Merge Intervals in Java Algorithms (LeetCode)

Java Algorithms: Copying List with Random Pointer (LeetCode)

Nominated for 2022 - HackerNoon Contributor of the Year - Algorithms

Nominated for 2022 - HackerNoon Contributor of the Year - Java

Nominated for 2022 - HackerNoon Contributor of the Year - Coding

Too Long; Didn't Read

Make resilience your competitive advantage

Clone Graph Blind75 LeetCode Problem

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

Validate Binary Search Tree Blind 75 LeetCode Question

10 Things Everyone Should Know About Machine Learning

10 Repositories that Will Transform the Way You Approach Technical Interviews

10 (Free) Data Structure and Algorithm Courses Junior Developers Should Explore

10 Data Structure & Algorithms Books Every Programmer Should Read

Validate Binary Search Tree Blind 75 LeetCode Question

10 Things Everyone Should Know About Machine Learning

10 Repositories that Will Transform the Way You Approach Technical Interviews

10 (Free) Data Structure and Algorithm Courses Junior Developers Should Explore

10 Data Structure & Algorithms Books Every Programmer Should Read

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps