Prims -Algorithmus

Minimum Spanning Tree:

Eine Grafik, die keine Anweisungen hat. Jedes Diagramm muss einen Pfad von einem Knoten zum anderen Knoten haben. Ein Spanning -Baum ist auch ein ungerichteter verbundenes Diagramm, in dem alle Knoten des Diagramms mit minimalen Kanten vorhanden sind. Wenn ein Spanning -Baum nicht alle Knoten des Diagramms hat, können wir nicht sagen, dass es sich um einen Spanning -Baum handelt. Das Spanning-Tree-Gesamtgewicht ist geringer als das ursprüngliche Gewicht des Diagramms. Der Spanning-Tree hat auch keinen Zyklus. Jedes Diagramm hat mehr als einen Spannungsbaum, aber nur eine davon wird einzigartig sein. Wir nennen es einen minimalen Spannungsbaum, da wir versuchen, ein vollständiges Diagramm mit allen Knoten zu erstellen, während wir das Gewicht niedrig halten.

Mit Hilfe der folgenden zwei Methoden können wir einen Spanning -Baum zeichnen:

1. Kruskals Algorithmus
2. Prims Algorithmus

In diesem Artikel werden wir den Algorithmus von Prim diskutieren. Der Algorithmus von Kruskal wird im nächsten Artikel erörtert.

Prims Algorithmus:

Der Algorithmus von Prim wird verwendet, um den minimalen Spannungsbaum eines Diagramms zu finden. Der Algorithmus des Prims startet von jedem Knoten und fügt dann jeden benachbarten Knoten hinzu, dessen Gewicht das Minimum ist, und dieser Vorgang wird fortgesetzt, bis alle Knoten in den Diagrammen besucht sind. Beim Erstellen des minimalen Spannungsbaums eines Graphen müssen wir auch keine Zyklen erstellen.

Prims Algorithmus Schritte:

Der Algorithmus des Prims verwendet den gierigen Ansatz für den minimalen Spannungsbaum. Wir müssen einen Scheitelpunkt des Diagramms auswählen und dann den nächsten Adjazenzscheitelpunkt auswählen, dessen Gewicht geringer ist, und wir setzen diesen Prozess fort.

Schritt 1: Wählen Sie in der Grafik einen Quellscheitelpunkt in der Grafik.

Schritt 2: Finden Sie die minimale Gewichtskante, die an die Quelle angrenzt, und schließen Sie sie dann an den Spanning -Baum an.

Schritt 3: Wiederholen Sie Schritt 2, bis alle Knoten nicht in den minimalen Spannungsbaum hinzugefügt werden.

Beispiel :

Das folgende ist ein Beispiel, um einen minimalen Spannungsbaum mit dem Prim -Algorithmus zu durchsuchen.

1. Wir wählen einen zufälligen Knoten aus Grafik G und fügen ihn zum MST hinzu (Minimum Spanning Tree). Wir wählen hier Knoten 0.

2. Jetzt wählen wir diese Kante aus, die an den Quellknoten (0), jedoch mit dem kleinsten Gewicht liegt.

3. Jetzt wählen wir diese Kante aus, die neben dem Quellknoten (0 oder 1) jedoch mit dem kleinsten Gewicht liegt, und fügen dann den kleinsten Gewichtknoten zum minimalen Spannungsbaum hinzu.

4. Jetzt wählen wir diese Kante aus, die neben dem Quellknoten (0, 1 oder 3) jedoch mit dem kleinsten Gewicht liegt, und fügen dann den kleinsten Gewichtknoten zum minimalen Spannungsbaum hinzu.

5. Jetzt wählen wir diese Kante aus, die neben dem Quellknoten (0, 1, 3 oder 4) jedoch mit dem kleinsten Gewicht liegt, und fügen dann den kleinsten Gewichtknoten zum minimalen Spannungsbaum hinzu.

6. Jetzt wählen wir diese Kante aus, die neben dem Quellknoten (0, 1, 3, 4 oder 6) jedoch mit dem kleinsten Gewicht liegt, und fügen Sie dann den kleinsten Gewichtknoten zum minimalen Spannungsbaum hinzu.

7. Jetzt wählen wir diese Kante aus, die neben dem Quellknoten (0, 1, 3, 4, 6 oder 2) jedoch mit dem kleinsten Gewicht liegt, und fügen Sie dann den kleinsten Gewichtknoten zum minimalen Spannungsbaum hinzu.

Oben ist unser endgültiger MST (minimaler Spanning Tree), und die Gesamtkosten betragen 6.

C ++ Prims MST -Programm (Minimum Spanning Tree):

#enthalten
#enthalten
#enthalten
#enthalten
#enthalten
typedef std :: pair Sii;
typedef std :: vector Ssii;
int primsmst (int Sourcenode, std :: vector & graph)
// Diese Warteschlange speichert Details jedes Knotens
// zusammen mit ihrem Gewichtswert.
std :: priority_queue, std :: größer> k;
k.push (std :: make_pair (0, saurcende));
bool nodesadded [Diagramm.Größe()];
memset (nodesadded, false, sizeof (bool)*graph.Größe());
int mst_tree_cost = 0;
während (!k.leer())
// Wir wählen hier den Knoten aus, der Mindestkosten hat
Sii itemnode;
itemNode = k.Spitze();
k.Pop();
int node = itemNode.zweite;
int cost = itemNode.Erste;
// Hier prüfen wir, ob kein Knoten zum MST hinzugefügt wurde,
// dann diesen Knoten hinzufügen.
Wenn (!nodesadded [Knoten])
MST_TREE_COST += Kosten;
nodesadded [Knoten] = true;
// über die kürzlich genommenen Negibelknoten iterieren
// aus der vorrangigen Warteschlange.
// und zum MST hinzugefügt, der noch nicht hinzugefügt wird
for (auto & paton_node_cost: graph [node])
int appoxcency_node = pair_node_cost.zweite;
if (nodesAdded [appycy_node] == false)
k.push (pace_node_cost);




return mst_tree_cost;

int main ()
// die Details des Diagramms mit Kosten- und Annäherungsknoten.
Ssii fromnode_0_in_graph_1 = 1,1, 2,2, 1,3,
1,4, 2,5, 1,6;
Ssii fromnode_1_in_graph_1 = 1,0, 2,2, 2,6;
Ssii fromnode_2_in_graph_1 = 2,0, 2,1, 1,3;
Ssii fromnode_3_in_graph_1 = 1,0, 1,2, 2,4;
Ssii fromnode_4_in_graph_1 = 1,0, 2,3, 2,5;
Ssii fromnode_5_in_graph_1 = 2,0, 2,4, 1,6;
Ssii fromnode_6_in_graph_1 = 1,0, 2,2, 1,5;
int num_of_nodes = 7; // Gesamtknoten (0 bis 6)
STD :: Vektor PrimsGraph;
PrimsGraph.Größe (num_of_nodes);
primsGraph [0] = fromnode_0_in_graph_1;
primsGraph [1] = fromnode_1_in_graph_1;
primsGraph [2] = fromnode_2_in_graph_1;
primsGraph [3] = fromnode_3_in_graph_1;
primsGraph [4] = fromnode_4_in_graph_1;
primsGraph [5] = fromnode_5_in_graph_1;
primsgraph [6] = fromnode_6_in_graph_1;
// Wie wir bereits wissen, müssen wir den Quellscheitelpunkt auswählen,
// Also starten wir vom Scheitelpunkt 0 Knoten.
std :: Cout << "Total cost of minimum spanning tree after Prim's algorithm : "
"" " << PrimsMST(0, primsgraph) << std :: endl;
Rückkehr 0;

Ausgang:

Gesamtkosten für minimale Spannungsbaum nach Prims Algorithmus: 6

Zeitkomplexität des MST -Algorithmus von Prim:

1. Die Gesamtzeit, die für die Verarbeitung und Auswahl des spezifischen Prioritäts -Warteschlangenknotens erforderlich ist, der dem MST noch hinzugefügt werden muss, ist Logv.Aber da es für jeden Scheitelpunkt funktioniert, ist die Gesamtzeitkomplexität V (logv).

2. Die Grafik ist ungerichtet und die Gesamtkanten werden 2e betragen. Da wir die Knoten in die Prioritätswarteschlange drücken müssen, wird ein Gesamtprotokoll (V) erforderlich sein (V). Da wir jedoch insgesamt 2E -Kanten haben, beträgt unser Gesamt -Push -Betrieb 2E (log (v)).

3. Gesamtkomplexität nach dem Betrieb 1 und 2 ist O ((e + v) log (v)).

Abschluss:

Wir haben den minimalen Spanning -Baum des Prims untersucht, was die erste Präferenz der meisten Menschen ist, wenn sie das MST -Diagramm aus einem Diagramm finden müssen. Der Algorithmus des Prims ist in einer realen Anwendung einfach zu erfassen und zu implementieren.Der Algorithmus von Prim ist in realen Anwendungen sehr nützlich, z. Es ist also nur ein einziges Beispiel, aber seine Anwendung ist riesig, also müssen wir diesen Algorithmus verstehen müssen.