Minimum cost to reverse edges such that there is path between every pair of nodes - GeeksforGeeks

19 Jul, 2021
Given a connected, directional graph. Each node is connected to exactly two other nodes. There is weight associated with each edge denoting the cost to reverse its direction. The task is to find the minimum cost to reverse some edges of the graph such that it is possible to go from each node to every other node.Examples:  
Input: 
5
1 2 7
5 1 8
5 4 5
3 4 1
3 2 10
Output: 15
Input:
6
1 5 4
5 3 8
2 4 15
1 6 16
2 3 23
4 6 42
Output: 39
 
Approach: 
In order to reach from each node to every other node, the graph must form a ring i.e Direct all edges on it in one of 2 directions either clockwise or anti-clockwise. Let us denote the cost of redirecting all the clockwise edges to anticlockwise direction as cost1 and vice versa as cost2. The answer is clearly the minimum of these two costs.
Maintain two boolean arrays start and end. The start and end arrays denote whether there is an edge starting from or ending at a given node. Whenever we encounter an edge going from node a to node b, we first check the condition if there is an edge already starting from node a or ending at node b. If there is an edge that satisfying the condition, the edge is in the opposite direction to the edge already present. In this case, we update cost2 and store the edge in the opposite direction. Otherwise, we update the cost1. This way we are able to maintain the costs of both orientations. Finally, print the minimum cost.
Below is the implementation of above approach:  
C++
Java
Python3
C#
Javascript
// C++ code to find// the minimum cost to// reverse the edges#include <bits/stdc++.h>using namespace std; // Function to calculate// min cost for reversing// the edgesint minCost(vector<vector<int> >& graph, int n){     int cost1 = 0, cost2 = 0;    // bool array to mark    // start and end node    // of a graph    bool start[n + 1] = { false };    bool end[n + 1] = { false };     for (int i = 0; i < n; i++) {         int a = graph[i][0];        int b = graph[i][1];        int c = graph[i][2];         // This edge must        // start from b and end at a        if (start[a] || end[b]) {            cost2 += c;            start[b] = true;            end[a] = true;        }         // This edge must        // start from a and end at b        else {            cost1 += c;            start[a] = true;            end[b] = true;        }    }     // Return minimum of    // both possibilities    return min(cost1, cost2);} // Driver codeint main(){    int n = 5;    // Adjacency list representation    // of a graph    vector<vector<int> > graph = {        { 1, 2, 7 },        { 5, 1, 8 },        { 5, 4, 5 },        { 3, 4, 1 },        { 3, 2, 10 }    };     int ans = minCost(graph, n);    cout << ans << '\n';     return 0;}
// Java code to find the minimum cost to// reverse the edgesclass GFG{ // Function to calculate min cost for// reversing the edgesstatic int minCost(int[][] graph, int n){     int cost1 = 0, cost2 = 0;         // bool array to mark start and    // end node of a graph    boolean []start = new boolean[n + 1];    boolean []end = new boolean[n + 1];     for (int i = 0; i < n; i++)    {        int a = graph[i][0];        int b = graph[i][1];        int c = graph[i][2];         // This edge must start from b        // and end at a        if (start[a] || end[b])        {            cost2 += c;            start[b] = true;            end[a] = true;        }         // This edge must start from a        // and end at b        else        {            cost1 += c;            start[a] = true;            end[b] = true;        }    }     // Return minimum of both possibilities    return Math.min(cost1, cost2);} // Driver codepublic static void main(String[] args){    int n = 5;         // Adjacency list representation    // of a graph    int [][]graph = {{ 1, 2, 7 },                     { 5, 1, 8 },                     { 5, 4, 5 },                     { 3, 4, 1 },                     { 3, 2, 10 }};     int ans = minCost(graph, n);    System.out.println(ans);}} // This code is contributed by Rajput-Ji
# Python code to find the minimum cost to# reverse the edges # Function to calculate min cost for# reversing the edgesdef minCost(graph, n):     cost1, cost2 = 0, 0;         # bool array to mark start and    # end node of a graph    start = [False]*(n + 1);    end = [False]*(n + 1);     for i in range(n):        a = graph[i][0];        b = graph[i][1];        c = graph[i][2];         # This edge must start from b        # and end at a        if (start[a] or end[b]):            cost2 += c;            start[b] = True;            end[a] = True;         # This edge must start from a        # and end at b        else:            cost1 += c;            start[a] = True;            end[b] = True;     # Return minimum of both possibilities    return min(cost1, cost2); # Driver codeif __name__ == '__main__':    n = 5;         # Adjacency list representation    # of a graph    graph = [[ 1, 2, 7 ],                    [ 5, 1, 8 ],                    [ 5, 4, 5 ],                    [ 3, 4, 1 ],                    [ 3, 2, 10 ]];     ans = minCost(graph, n);    print(ans);     # This code is contributed by 29AjayKumar
// C# code to find the minimum cost to// reverse the edgesusing System;     class GFG{ // Function to calculate min cost for// reversing the edgesstatic int minCost(int[,] graph, int n){    int cost1 = 0, cost2 = 0;         // bool array to mark start and    // end node of a graph    Boolean []start = new Boolean[n + 1];    Boolean []end = new Boolean[n + 1];     for (int i = 0; i < n; i++)    {        int a = graph[i, 0];        int b = graph[i, 1];        int c = graph[i, 2];         // This edge must start from b        // and end at a        if (start[a] || end[b])        {            cost2 += c;            start[b] = true;            end[a] = true;        }         // This edge must start from a        // and end at b        else        {            cost1 += c;            start[a] = true;            end[b] = true;        }    }     // Return minimum of both possibilities    return Math.Min(cost1, cost2);} // Driver codepublic static void Main(String[] args){    int n = 5;         // Adjacency list representation    // of a graph    int [,]graph = {{ 1, 2, 7 },                    { 5, 1, 8 },                    { 5, 4, 5 },                    { 3, 4, 1 },                    { 3, 2, 10 }};     int ans = minCost(graph, n);    Console.WriteLine(ans);}} // This code is contributed by PrinciRaj1992
<script> // JavaScript code to find// the minimum cost to// reverse the edges  // Function to calculate// min cost for reversing// the edgesfunction minCost(graph, n) {     let cost1 = 0, cost2 = 0;    // bool array to mark    // start and end node    // of a graph    let start = new Array(n + 1).fill(false);    let end = new Array(n + 1).fill(false);     for (let i = 0; i < n; i++) {         let a = graph[i][0];        let b = graph[i][1];        let c = graph[i][2];         // This edge must        // start from b and end at a        if (start[a] || end[b]) {            cost2 += c;            start[b] = true;            end[a] = true;        }         // This edge must        // start from a and end at b        else {            cost1 += c;            start[a] = true;            end[b] = true;        }    }     // Return minimum of    // both possibilities    return Math.min(cost1, cost2);} // Driver code let n = 5;// Adjacency list representation// of a graphlet graph = [    [1, 2, 7],    [5, 1, 8],    [5, 4, 5],    [3, 4, 1],    [3, 2, 10]]; let ans = minCost(graph, n);document.write(ans + '<br>'); </script>
15
 
Time Complexity: O(N) where N is number of edges 
Rajput-Ji
princiraj1992
29AjayKumar
_saurabh_jaiswal
varshagumber28
direct
Algorithms
Arrays
Graph
Arrays
Graph
Algorithms
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
DSA Sheet by Love Babbar
K means Clustering - Introduction
SCAN (Elevator) Disk Scheduling Algorithms
Quadratic Probing in Hashing
Difference between Informed and Uninformed Search in AI
Arrays in Java
Arrays in C/C++
Program for array rotation
Stack Data Structure (Introduction and Program)
Largest Sum Contiguous Subarray