Minimize cost to color all the vertices of an Undirected Graph using given operation

Given two integers V and E representing the number of vertices and edges of an undirected graph G(V, E), a list of edges EdgeList, and an array A[] representing the cost to color each node, the task is to find the minimum cost to color the graph using the following operation:

When a node is colored, all the nodes that can be reached from it are colored without any additional cost.

Examples:

Input: V = 6, E = 5, A[] = {12, 25, 8, 11, 10, 7}, EdgeList = {{1, 2}, {1, 3}, {3, 2}, {2, 5}, {4, 6}} 
Output: 15 
Explanation: 
On coloring the vertex 3 for a cost of 8, the vertices {1, 2, 5} gets colored at no additional cost. 
On coloring the vertex 6 for a cost of 7, the only remaining vertex {4} also gets colored. 
Therefore, the minimum cost = 8 + 7 = 15.

Input: V =7, E = 6, A[] = {3, 5, 8, 6, 9, 11, 10}, EdgeList = {{1, 4}, {2, 1}, {2, 7}, {3, 4}, {3, 5}, {5, 6}} 
Output: 5



Approach: 
Follow the steps below to solve the problem:

  • All the nodes reachable from a given node form a Connected Component.
  • So for each connected component, using Depth First Search, find the minimum cost node in a connected component of a graph.

Below is the implementation for the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ Program to find the minimum
// cost to color all vertices of an
// Undirected Graph
#include <bits/stdc++.h>
using namespace std;
  
#define MAX 10
  
vector<int> adj[MAX];
  
// Function to add edge in the
// given graph
void addEdge(int u, int v)
{
    adj[u].push_back(v);
    adj[v].push_back(u);
}
  
// Function to perform DFS traversal and
// find the node with minimum cost
void dfs(int v, int cost[], bool vis[],
         int& min_cost_node)
{
    vis[v] = true;
  
    // Update the minimum cost
    min_cost_node
        = min(min_cost_node, cost[v - 1]);
  
    for (int i = 0; i < adj[v].size(); i++) {
  
        // Recur for all connected nodes
        if (vis[adj[v][i]] == false) {
            dfs(adj[v][i], cost, vis,
                min_cost_node);
        }
    }
}
  
// Function to calculate and return
// the minimum cost of coloring all
// vertices of the Undirected Graph
int minimumCost(int V, int cost[])
{
  
    // Marks if a vertex is
    // visited or not
    bool vis[V + 1];
  
    // Initialize all vertices as unvisited
    memset(vis, false, sizeof(vis));
    int min_cost = 0;
  
    // Perform DFS traversal
    for (int i = 1; i <= V; i++) {
  
        // If vertex is not visited
        if (!vis[i]) {
            int min_cost_node = INT_MAX;
            dfs(i, cost, vis, min_cost_node);
  
            // Update minimum cost
            min_cost += min_cost_node;
        }
    }
  
    // Return the final cost
    return min_cost;
}
// Driver Code
int main()
{
    int V = 6, E = 5;
    int cost[] = { 12, 25, 8, 11, 10, 7 };
    addEdge(1, 2);
    addEdge(1, 3);
    addEdge(3, 2);
    addEdge(2, 5);
    addEdge(4, 6);
  
    int min_cost = minimumCost(V, cost);
  
    cout << min_cost << endl;
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find the minimum
// cost to color all vertices of an
// Undirected Graph
import java.util.*;
  
class GFG{
  
static final int MAX = 10;
  
@SuppressWarnings("unchecked")
static Vector<Integer> []adj = new Vector[MAX];
  
static int min_cost_node;
  
// Function to add edge in the
// given graph
static void addEdge(int u, int v)
{
    adj[u].add(v);
    adj[v].add(u);
}
  
// Function to perform DFS traversal and
// find the node with minimum cost
static void dfs(int v, int cost[], boolean vis[])
{
    vis[v] = true;
  
    // Update the minimum cost
    min_cost_node = Math.min(min_cost_node,
                             cost[v - 1]);
  
    for(int i = 0; i < adj[v].size(); i++)
    {
          
        // Recur for all connected nodes
        if (vis[adj[v].get(i)] == false)
        {
            dfs(adj[v].get(i), cost, vis);
        }
    }
}
  
// Function to calculate and return
// the minimum cost of coloring all
// vertices of the Undirected Graph
static int minimumCost(int V, int cost[])
{
  
    // Marks if a vertex is
    // visited or not
    boolean []vis = new boolean[V + 1];
  
    // Initialize all vertices as unvisited
    Arrays.fill(vis, false);
    int min_cost = 0;
  
    // Perform DFS traversal
    for(int i = 1; i <= V; i++)
    {
          
        // If vertex is not visited
        if (!vis[i]) 
        {
            min_cost_node = Integer.MAX_VALUE;
            dfs(i, cost, vis);
  
            // Update minimum cost
            min_cost += min_cost_node;
        }
    }
  
    // Return the final cost
    return min_cost;
}
  
// Driver Code
public static void main(String[] args)
{
    int V = 6, E = 5;
    int cost[] = { 12, 25, 8, 11, 10, 7 };
      
    for(int i = 0; i < adj.length; i++)
        adj[i] = new Vector<Integer>();
          
    addEdge(1, 2);
    addEdge(1, 3);
    addEdge(3, 2);
    addEdge(2, 5);
    addEdge(4, 6);
  
    int min_cost = minimumCost(V, cost);
  
    System.out.print(min_cost + "\n");
}
}
  
// This code is contributed by 29AjayKumar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find the minimum
// cost to color all vertices of an
// Undirected Graph
using System;
using System.Collections.Generic;
  
class GFG{
  
static readonly int MAX = 10;
static List<int> []adj = new List<int>[MAX];
static int min_cost_node;
  
// Function to add edge in the
// given graph
static void addEdge(int u, int v)
{
    adj[u].Add(v);
    adj[v].Add(u);
}
  
// Function to perform DFS traversal and
// find the node with minimum cost
static void dfs(int v, int []cost, bool []vis)
{
    vis[v] = true;
  
    // Update the minimum cost
    min_cost_node = Math.Min(min_cost_node,
                             cost[v - 1]);
  
    for(int i = 0; i < adj[v].Count; i++)
    {
          
        // Recur for all connected nodes
        if (vis[adj[v][i]] == false)
        {
            dfs(adj[v][i], cost, vis);
        }
    }
}
  
// Function to calculate and return
// the minimum cost of coloring all
// vertices of the Undirected Graph
static int minimumCost(int V, int []cost)
{
  
    // Marks if a vertex is
    // visited or not
    bool []vis = new bool[V + 1];
  
    int min_cost = 0;
  
    // Perform DFS traversal
    for(int i = 1; i <= V; i++)
    {
          
        // If vertex is not visited
        if (!vis[i]) 
        {
            min_cost_node = int.MaxValue;
            dfs(i, cost, vis);
  
            // Update minimum cost
            min_cost += min_cost_node;
        }
    }
  
    // Return the readonly cost
    return min_cost;
}
  
// Driver Code
public static void Main(String[] args)
{
    int V = 6;
    int []cost = { 12, 25, 8, 11, 10, 7 };
      
    for(int i = 0; i < adj.Length; i++)
        adj[i] = new List<int>();
          
    addEdge(1, 2);
    addEdge(1, 3);
    addEdge(3, 2);
    addEdge(2, 5);
    addEdge(4, 6);
  
    int min_cost = minimumCost(V, cost);
  
    Console.Write(min_cost + "\n");
}
}
  
// This code is contributed by Amit Katiyar 

chevron_right


Output:

15

Time Complexity: O(V+E) 
Auxilairy Space: O(V)
 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.