Laborator 10: Arbori minimi de acoperire

Bitdefender provides cybersecurity solutions with leading security efficacy, performance and ease of use to small and medium businesses, mid-market enterprises and consumers. Guided by a vision to be the world’s most trusted cybersecurity solutions provider, Bitdefender is committed to defending organizations and individuals around the globe against cyberattacks to transform and improve their digital experience.

În acest laborator vom introduce contextul pentru minimum spanning tree problem și vom studia algoritmi care pot rezolva această problemă.

• Prezentarea problemei (diverse variante).
• Prezentarea algoritmilor pentru calcul a unui arbore minim de acoperire.

Algoritmii pentru determinarea unor arbori (minimi) de acoperire au multiple aplicații practice. Câteva exemple de aplicații sunt:

• Designul circuitelor electronice:
  • Maparea pinilor pe un circuit astfel încât să se foloseacă o lungime minimă de traseu.
• Rețele de calculatoare:
  • Interconectarea mai multor stații în rețea, cu un cost / latență redus(ă).
  • STP Protocol: protocol care previne apariția buclelor într-un LAN.
• Segmentarea imaginilor:
  • Împărțirea unei imagini în regiuni cu proprietăți asemănătoare.
  • Minimum spanning tree-based segmentation.
• Clustering:
  • Single-linkage clustering.

Puteți consulta capitolul Minimum Spanning Trees din Introduction to Algorithms [0] pentru mai multe definiții formale. Această secțiune sumarizează principalele notații folosite în laboratoarele de PA.

Cele mai uzuale notații din laboratoarele de grafuri sunt descrise în Precizări laboratoare 07-12 (ex. $n$, $m$, $adj$, $adj\_trans$, $(x, y)$, etc).

Vom adăuga alte notații în continuarea celor introduse anterior.

Arbore de acoperire / spanning tree: Într-un graf neorientat conex $G = (V, E)$, cu funcția de cost $w: E -> W$, numim un arbore de acoperire un subgraf al lui G cu număr minim de muchii și care interconectează toate nodurile din graf.

Pădure de arbori de acoperire / spanning tree forest: Se definește similar, dar pentru graf neorientat neconex. Fiecare componentă conexă are un arbore de acoperire / spanning tree. Spunem că acești arbori formează împreună o pădure (forest).

Arbore minim de acoperire (AMA)/ minimum spanning tree (MST): Un arbore de acoperire este ȘI arbore minim de acoperire dacă costul total al muchiilor din arbore este minim posibil. Analog se poate defini și noțiunea de pădure de arbori minimi de acoperire (pornind de la cea de pădure de arbori de acoperire).

Pentru minimum spanning tree problem există mai mulți algoritmi, dintre care amintim:

• Kruskal: abordare greedy care se bazează pe sortarea muchiile după cost. Mai multe detalii în Introduction to Algorithms [0].
• Prim: abordare greedy care extinde arborele căutat pornind de la o rădăcină (nod ales oarecare). Mai multe detalii în Introduction to Algorithms [0].
• Karger, Klein & Tarjan: algoritm randomizat cu complexitate liniară (mai bună decât Kruskal și Prim). Mai multe detalii în A Randomized Linear-Time Algorithm to Find Minimum Spanning Trees [1].
• Bernard Chazelle: algoritm determinist cu o complexitate liniară (cu complexitate mai bună decât soluția anterioară). Mai multe detalii în A Minimum Spanning Tree Algorithm with Inverse Ackermann Type Complexity [2].

În acest laborator vom studia și vom implementa algoritmul lui Kruskal. De asemenea, oferim ca studiu de caz pentru acasă, un material pentru algoritmul lui Prim.

Algoritmul lui Joseph Bernard **Kruskal** (Kruskal’s algorithm) rezolvă minimum spanning tree problem în grafuri neorientate G = (V, E) cu costurile muchiilor oarecare aplicând o strategie greedy foarte simplă: muchiile de cost minim probabil fac parte din MST!

// apply Kruskal's algorithm for computing a Minimum Spanning Tree (MST).
//
// nodes     = list of all nodes from G
// edges     = the list of all edges in G
//             example: edge (node, neigh, weight)
//
// returns: cost, mst
//          cost = the cost of the MST
//          mst = the actual set of edges in MST
//
Kruskal(G=(nodes, edges)) {
  // STEP 0: initialize results
  cost = 0; // cost of the built MST
  mst = {}; // the actual set of edges (u, v) in the built MST
 
  // STEP 1: initialize disjoint set data structure
  // (a tree is created for each node)
  disjointset = DisjointSet(nodes);
 
  // STEP 2:
  sort(edges, compare=nondecreasing order by weight);
 
  // STEP 3: Add edge by edge to MST if no cycles are created.
  foreach ( (u, v, w) in edges ) {
    // STEP 3.1: Check if u anv v are in different trees.
    if (disjointset.setOf(u) != disjointset.setOf(v)) {
      // STEP 3.2: Merge these 2 trees (no cycles created).
      disjointset.union(u, v);
 
      // STEP 3.3: Extend MST with the current edge.
      cost += w;
      mst += { (u, v) };
    }
  }
 
  return cost, mst;
}
 
// Usage example:
cost, mst = Kruskal(G=(nodes, edges));
// 1. Use cost of MST.
// 2. Use edges of MST (e.g. actually build the tree).

Algoritmul lui Kruskal pornește cu structura de date Păduri de mulțimi disjuncte inițializată cu n noduri izolate. Muchiile sunt sortate crescător după cost și se încearcă adăugarea lor, rând pe rând la pădurea de arbori.

• Dacă o muchie $(u, v)$ are capetele în 2 arbori diferiți, atunci prin adăugarea acesteia, nu vom crea ciclu, ci vom crea un arbore mai mare (din cei 2 mici reuniți).
• Altfel, nu putem adăuga muchia, deoarece am crea un ciclu. Această muchie se ignoră.

Un MST găsit cu algoritmul lui Kruskal este: ${ (1, 2); (2, 4); (2, 3); (3, 5)}$ de cost 5.

• complexitate temporală: $T = O(m * log m)\ sau\ O(|E| * log |E|)$
• complexitate spațială : $S = O(n)$

Algoritmul lui Robert C **Prim** (Prim’s algorithm) rezolvă minimum spanning tree problem în grafuri neorientate G = (V, E) cu costurile muchiilor oarecare aplicând o strategie constructivă greedy, asemănătoare cu algoritmul lui Dijkstra: merge pe muchiile de cost minim, din aproape în aproape, considerând o sursă inițial aleasă aleator și extinzând MST-ul curent cu muchia de cost minim neadăugată încă la arbore.

• complexitate temporală: $T = O(m * log n)\ sau\ O(|E| * log |V|)$
• complexitate spațială : $S = O(n)$

• Pentru minimum spanning tree problem, am studiat 2 algoritmi (Kruskal și Prim) cu aceeași complexitate ($O(m log m)$).
• Algoritmul lui Kruskal este de preferat pentru simplitatea / intuitivitatea lui, dificultatea reducându-se la a implementa structura de date DisjointSet.

Se dă un graf neorientat și conex cu n noduri și m muchii (cu costuri oarecare pe muchii).

Folosiți algoritmul lui Kruskal pentru a găsi un MST.

Task-uri:

1. Găsiți costul MST.
2. Găsiți care sunt muchiile din MST. ATENȚIE! Se poate găsi orice MST (în caz că există mai mulți). Ordinea muchiilor din vectorul rezultat NU este relevantă.

La acest laborator, asistentul va alege 1-2 probleme din secțiunea extra.

• infoarena/desen
• infoarena/radiatie
• infoarena/bile
• codeforces/aviamachinations

[0] Chapters Minimum Spanning Trees, “Introduction to Algorithms”, Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest and Clifford Stein.

[1] A Randomized Linear-Time Algorithm to Find Minimum Spanning Trees, David R. Karger, Philip N. Klein, Robert E. Tarjan.

[2] A Minimum Spanning Tree Algorithm with InverseAckermann Type Complexity|, Bernard, Chazelle.