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

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

## 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)
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.