 Open in App
Not now

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

• Difficulty Level : Hard
• 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.

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
Related Articles