Algoritmo de Boruvka | Codicioso Algo-9

Hemos discutido los siguientes temas sobre el árbol de expansión mínimo.
Aplicaciones del problema del árbol de expansión mínimo Algoritmo del  
árbol de expansión mínimo de Kruskal Algoritmo  
del árbol de expansión mínimo de Prim
En esta publicación, se analiza el algoritmo de Boruvka. Al igual que el de Prim y el de Kruskal, el algoritmo de Boruvka también es un algoritmo Greedy. A continuación se muestra el algoritmo completo.

1) Input is a connected, weighted and un-directed graph.
2) Initialize all vertices as individual components (or sets).
3) Initialize MST as empty.
4) While there are more than one components, do following
   for each component.
      a)  Find the closest weight edge that connects this 
          component to any other component.
      b)  Add this closest edge to MST if not already added.  
5) Return MST.

A continuación se muestra la idea detrás del algoritmo anterior (la idea es la misma que el algoritmo MST de Prim ). 
Un árbol de expansión significa que todos los vértices deben estar conectados. Entonces, los dos subconjuntos disjuntos (discutidos anteriormente) de vértices deben estar conectados para hacer un árbol de expansión. Y deben estar conectados con el borde de peso mínimo para convertirlo en un árbol de expansión mínimo.
Entendamos el algoritmo con el siguiente ejemplo. 
 

Boruvka's algorithm Image 1

Inicialmente, MST está vacío. Cada vértice es un componente único como se resalta en color azul en el diagrama a continuación. 
 

Boruvka's algorithm Image 2

  
Para cada componente, encuentre el borde más barato que lo conecte a algún otro componente. 

Component                Cheapest Edge that connects 
                         it to some other component
  {0}                           0-1
  {1}                           0-1
  {2}                           2-8
  {3}                           2-3
  {4}                           3-4
  {5}                           5-6
  {6}                           6-7
  {7}                           6-7
  {8}                           2-8 

Los bordes más baratos se resaltan con color verde. Ahora MST se convierte en {0-1, 2-8, 2-3, 3-4, 5-6, 6-7}. 
 

Boruvka's algorithm Image 3

Después del paso anterior, los componentes son {{0,1}, {2,3,4,8}, {5,6,7}}. Los componentes están rodeados de color azul. 
 

Boruvka's algorithm Image 4

  
Volvemos a repetir el paso, es decir, para cada componente, busque el borde más barato que lo conecte a algún otro componente.

Component                Cheapest Edge that connects 
                         it to some other component
  {0,1}                        1-2 (or 0-7)
  {2,3,4,8}                    2-5
  {5,6,7}                      2-5

Los bordes más baratos se resaltan con color verde. Ahora MST se convierte en {0-1, 2-8, 2-3, 3-4, 5-6, 6-7, 1-2, 2-5} 
 

Boruvka's algorithm Image 5

En esta etapa, solo hay un componente {0, 1, 2, 3, 4, 5, 6, 7, 8} que tiene todos los bordes. Como solo queda un componente, detenemos y devolvemos MST.

Implementación:  A continuación se muestra la implementación del algoritmo anterior. El gráfico de entrada se representa como una colección de aristas y la estructura de datos de búsqueda de unión se utiliza para realizar un seguimiento de los componentes. 

Python

# Boruvka's algorithm to find Minimum Spanning
# Tree of a given connected, undirected and weighted graph
 
from collections import defaultdict
 
#Class to represent a graph
class Graph:
 
    def __init__(self,vertices):
        self.V= vertices #No. of vertices
        self.graph = [] # default dictionary to store graph
         
  
    # function to add an edge to graph
    def addEdge(self,u,v,w):
        self.graph.append([u,v,w])
 
    # A utility function to find set of an element i
    # (uses path compression technique)
    def find(self, parent, i):
        if parent[i] == i:
            return i
        return self.find(parent, parent[i])
 
    # A function that does union of two sets of x and y
    # (uses union by rank)
    def union(self, parent, rank, x, y):
        xroot = self.find(parent, x)
        yroot = self.find(parent, y)
 
        # Attach smaller rank tree under root of high rank tree
        # (Union by Rank)
        if rank[xroot] < rank[yroot]:
            parent[xroot] = yroot
        elif rank[xroot] > rank[yroot]:
            parent[yroot] = xroot
        #If ranks are same, then make one as root and increment
        # its rank by one
        else :
            parent[yroot] = xroot
            rank[xroot] += 1
 
    # The main function to construct MST using Kruskal's algorithm
    def boruvkaMST(self):
        parent = []; rank = [];
 
        # An array to store index of the cheapest edge of
        # subset. It store [u,v,w] for each component
        cheapest =[]
 
        # Initially there are V different trees.
        # Finally there will be one tree that will be MST
        numTrees = self.V
        MSTweight = 0
 
        # Create V subsets with single elements
        for node in range(self.V):
            parent.append(node)
            rank.append(0)
            cheapest =[-1] * self.V
     
        # Keep combining components (or sets) until all
        # components are not combined into single MST
 
        while numTrees > 1:
 
            # Traverse through all edges and update
               # cheapest of every component
            for i in range(len(self.graph)):
 
                # Find components (or sets) of two corners
                # of current edge
                u,v,w =  self.graph[i]
                set1 = self.find(parent, u)
                set2 = self.find(parent ,v)
 
                # If two corners of current edge belong to
                # same set, ignore current edge. Else check if
                # current edge is closer to previous
                # cheapest edges of set1 and set2
                if set1 != set2:    
                     
                    if cheapest[set1] == -1 or cheapest[set1][2] > w :
                        cheapest[set1] = [u,v,w]
 
                    if cheapest[set2] == -1 or cheapest[set2][2] > w :
                        cheapest[set2] = [u,v,w]
 
            # Consider the above picked cheapest edges and add them
            # to MST
            for node in range(self.V):
 
                #Check if cheapest for current set exists
                if cheapest[node] != -1:
                    u,v,w = cheapest[node]
                    set1 = self.find(parent, u)
                    set2 = self.find(parent ,v)
 
                    if set1 != set2 :
                        MSTweight += w
                        self.union(parent, rank, set1, set2)
                        print ("Edge %d-%d with weight %d included in MST" % (u,v,w))
                        numTrees = numTrees - 1
             
            #reset cheapest array
            cheapest =[-1] * self.V
 
             
        print ("Weight of MST is %d" % MSTweight)
                           
 
     
g = Graph(4)
g.addEdge(0, 1, 10)
g.addEdge(0, 2, 6)
g.addEdge(0, 3, 5)
g.addEdge(1, 3, 15)
g.addEdge(2, 3, 4)
 
g.boruvkaMST()
 
#This code is contributed by Neelam Yadav
Producción

Edge 0-3 with weight 5 included in MST
Edge 0-1 with weight 10 included in MST
Edge 2-3 with weight 4 included in MST
Weight of MST is 19

Datos interesantes sobre el algoritmo de Boruvka: 

  1. La complejidad temporal del algoritmo de Boruvka es O (E log V), que es igual a los algoritmos de Kruskal y Prim.
  2. El algoritmo de Boruvka se usa como un paso en un algoritmo aleatorio más rápido que funciona en tiempo lineal O(E) .
  3. El algoritmo de Boruvka es el algoritmo de árbol de expansión mínimo más antiguo, fue descubierto por Boruuvka en 1926, mucho antes de que existieran las computadoras. El algoritmo fue publicado como un método para construir una red eléctrica eficiente.

Ejercicio: 
El código anterior asume que el gráfico de entrada está conectado y falla si se proporciona un gráfico desconectado. Extienda el algoritmo anterior para que también funcione para un gráfico desconectado y produzca un bosque.

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *