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

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