Related Articles
Minimize cost to color all the vertices of an Undirected Graph using given operation
• Difficulty Level : Expert
• Last Updated : 24 Nov, 2020

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++

 `// C++ Program to find the minimum``// cost to color all vertices of an``// Undirected Graph``#include ``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;``}`

## Java

 `// 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 []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();``        ` `    ``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`

## Python3

 `# Python3 program to find the minimum``# cost to color all vertices of an``# Undirected Graph``import` `sys` `MAX` `=` `10` `adj ``=` `[[] ``for` `i ``in` `range``(``MAX``)]` `# Function to add edge in the``# given graph``def` `addEdge(u, v):``    ` `    ``adj[u].append(v)``    ``adj[v].append(u)` `# Function to perform DFS traversal and``# find the node with minimum cost``def` `dfs(v, cost, vis, min_cost_node):` `    ``vis[v] ``=` `True` `    ``# Update the minimum cost``    ``min_cost_node ``=` `min``(min_cost_node,``                        ``cost[v ``-` `1``])` `    ``for` `i ``in` `range``(``len``(adj[v])):` `        ``# Recur for all connected nodes``        ``if` `(vis[adj[v][i]] ``=``=` `False``):``            ``min_cost_node ``=` `dfs(adj[v][i],``                                ``cost, vis,``                                ``min_cost_node)``    ` `    ``return` `min_cost_node``        ` `# Function to calculate and return``# the minimum cost of coloring all``# vertices of the Undirected Graph``def` `minimumCost(V, cost):` `    ``# Marks if a vertex is``    ``# visited or not``    ``vis ``=` `[``False` `for` `i ``in` `range``(V ``+` `1``)]` `    ``min_cost ``=` `0` `    ``# Perform DFS traversal``    ``for` `i ``in` `range``(``1``, V ``+` `1``):` `        ``# If vertex is not visited``        ``if` `(``not` `vis[i]):``            ``min_cost_node ``=` `sys.maxsize``            ``min_cost_node ``=` `dfs(i, cost, vis,``                                ``min_cost_node)` `            ``# Update minimum cost``            ``min_cost ``+``=` `min_cost_node` `    ``# Return the final cost``    ``return` `min_cost` `# Driver Code``if` `__name__``=``=``"__main__"``:` `    ``V ``=` `6``    ``E ``=` `5``    ``cost ``=` `[ ``12``, ``25``, ``8``, ``11``, ``10``, ``7` `]``    ` `    ``addEdge(``1``, ``2``)``    ``addEdge(``1``, ``3``)``    ``addEdge(``3``, ``2``)``    ``addEdge(``2``, ``5``)``    ``addEdge(``4``, ``6``)` `    ``min_cost ``=` `minimumCost(V, cost)``    ` `    ``print``(min_cost)``    ` `# This code is contributed by rutvik_56`

## C#

 `// 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`

Output:

```15

```

Time Complexity: O(V+E)
Auxiliary 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