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

nodeis 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 of8, the vertices {1, 2, 5} gets colored at no additional cost.

On coloring the vertex 6 for a cost of7, 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 <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*

**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.