📌  相关文章
📜  使用给定操作最小化为无向图的所有顶点着色的成本

📅  最后修改于: 2021-10-27 06:18:19             🧑  作者: Mango

给定两个整数VE表示无向图G(V, E)的顶点和边数、边列表EdgeList和数组A[]表示为每个节点着色的成本,任务是找到使用以下操作为图形着色的最低成本:

例子:

方法:
请按照以下步骤解决问题:

  • 所有节点都可以从一个给定的节点到达,形成一个连接组件。
  • 因此,对于每个连通分量,使用深度优先搜索,在图中的连通分量中找到成本最低的节点。

下面是上述方法的实现:

C++
// C++ Program to find the minimum
// cost to color all vertices of an
// Undirected Graph
#include 
using namespace std;
 
#define MAX 10
 
vector 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 []adj = new List[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();
         
    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


输出:

15

时间复杂度: O(V+E)
辅助空间: O(V)

如果您希望与专家一起参加现场课程,请参阅DSA 现场工作专业课程学生竞争性编程现场课程