# Minimize cost to color all the vertices of an Undirected Graph using given operation

• Difficulty Level : Expert
• Last Updated : 26 May, 2021

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.

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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

## Javascript

 ``

Output:

`15`

Time Complexity: O(V+E)
Auxiliary Space: O(V)

My Personal Notes arrow_drop_up