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:

Below is the implementation for the above approach:

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

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

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.




Recommended Posts:


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.



Improved By : 29AjayKumar, amit143katiyar

Article Tags :