Given A Graph, Build A New One With Reversed Edges

Given a strongly connected directed graph, build a new graph with the same number of nodes but every edge reversed. This is also called transposing a graph.

Example

Input: Any node of this graph:

Output: Any node of the new:

Notes

Input Parameters: Function has one argument pointing to a node of the given graph.

Output: Return any node of the new graph.

Constraints:

● 1

● Value in any node will be a unique integer between 1 and number of nodes, inclusive.

● No multiple edges (connecting any pair of nodes in one direction) or self loops (edges connecting a node with itself) in the input graph.

● You are not allowed to modify the given graph. Return a newly built graph.

‍

Solution

To solve this problem simple DFS will work. We provided one sample solution.

Time Complexity:

Our DFS-like algorithm takes O(n + m) time where n is the number of nodes and m is the number of edges.

Without multiple edges or self loops (which problem statement guarantees) the number of edges m can be as big as n*(n-1) in the worst case. So O(n^2) is the time complexity in terms of n.

Auxiliary Space Used:

O(n) for the call stack used by the recursive function dfs() in the worst case.

Space complexity:

Same O(n + m) or O(n^2) as in Time Complexity. Both input and output graphs take that much space.

// -------- START --------

    /*
    In constraints we are given that each node contains distinct values, so we can keep track of 
    node address using that value. {value : node} 
    */
	static HashMap reversed_graph = new HashMap();

    static void dfs(Node node)
	{        
        // First create new node.
		reversed_graph.put(node.val, new Node(node.val));        
		int n = node.neighbours.size();
        // Visit all the neighbours.
		for (int i = 0; i < n; i++)
		{
            // If node is not visited then first visit it.
			if (reversed_graph.containsKey(node.neighbours.get(i).val) == false )
			{
				dfs(node.neighbours.get(i));
			}
            // Add the reverse edge. 
			reversed_graph.get(node.neighbours.get(i).val).neighbours.add(
                reversed_graph.get(node.val));
		}
	}

	static Node build_other_graph(Node node)
	{
        // Build the graph.
		dfs(node);
        // Return any node of the new graph. 
		return reversed_graph.get(1);
	}

	// -------- END --------