Show page
Recent changes

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

pa:laboratoare:laborator-09 [2022/03/01 23:56]
darius.neatu [Laborator 09: Drumuri minime] 		pa:laboratoare:laborator-09 [2025/05/21 17:19] (current)
matei.mantu fix typo
Line 1: Line 1:
-====== Laborator 09: Drumuri minime (1/2) ======+====== Laborator 09: Drumuri minime ​în grafuri: surse / destinații multiple. ​(2/2) ======
  
  
 +{{:​pa:​new_pa:​partners:​adobe-logo.png?​155 |}}
 +\\ \\ \\ Changing the world through digital experiences is what Adobe’s all about. We give everyone - from emerging artists to global brands - everything they need to design and deliver exceptional digital experiences! We’re passionate about empowering people to create beautiful and powerful images, videos, and apps, and transform how companies interact with customers across every screen.
  
 ===== Obiective laborator ===== ===== Obiective laborator =====
  
-  ​*Înțelegerea conceptelor de cost, relaxare a unei muchii, drum minim +În laboratorul anterior am introdus contextul pentru ​**Shortest-paths problem** și **Single-source shortest-paths problem**. ​În laboratorul 10 vom continua cu **All-pairs shortest-paths problem**.
-  ​*Prezentarea si asimilarea algoritmilor pentru calculul drumurilor minime+
  
-===== Importanţă – aplicaţii practice =====+  * Înțelegerea conceptelor de cost asociat unei muchii, relaxare a unei muchii. 
 +  * Prezentarea problemei drumului de cost minim (diverse variante). 
 +  * Prezentarea algoritmilor pentru calculul drumurilor minime.
  
-Algoritmii pentru determinarea drumurilor minime au multiple aplicații practice si reprezintă clasa de algoritmi pe grafuri cel mai des utilizata:+===== Shortest-paths problem: all-pairs =====
  
-  *Rutare in cadrul unei rețele (telefonice,​ de calculatoare etc.) +Vă rugăm să parcugeți [[https://​ocw.cs.pub.ro/courses/​pa/​laboratoare/​shortest-paths-problem|Shortest-paths problem]] pentru a vă familiariza cu contextul, problema ​și notațiile folosite.
-  *Găsirea drumului minim dintre doua locații (Google Maps, GPS etc.) +
-  *Stabilirea unei agende de zbor in vederea asigurării unor conexiuni optime +
-  *Asignarea unui peer / server de fișiere in funcție de metricile definite pe fiecare linie de comunicație+
  
-===== Concepte ​=====+Concepte ​necesare:
  
-==== Costul ​unei muchii ​si al unui drum ====+  * **cost muchie** / **edge cost** 
 +  * **cost drum** / **path cost** 
 +  * **problema drumurilor minime: surse / destinații multiple** / **all-pairs shortest-paths problem** 
 +  * **relaxarea ​unei muchii** / **edge relaxation** 
 +  * **reconstruirea ​unui drum** / **RebuildPath**
  
->> Fiind dat un graf orientat G = (V, E), se considera funcția w: E -> W, numita funcție de cost, care asociază fiecărei muchii o valoare numerica. ​+===== Algoritmi =====
  
-Domeniul funcției poate fi extins, pentru a include si perechile de noduri intre care nu exista muchie directa, caz in care valoarea este +∞ . +În acest laborator vom studia **all-pairs shortest-paths problem**. Pentru această problemă, vom prezenta 2 algoritmi:
  
->> ​Costul unui drum format din muchiile p12 p23 … p(n-1)n, având costurile w12, w23, …, w(n-1)n, este suma w = w12 + w23 + … + w(n-1)n.+  * **Roy-Floyd**:​ eficient pentru grafuri **dense** ($m >> n$ sau $|E| >> |V|$ - a.k.a. număr de muchii mult mai decât număr de noduri). 
 +  * **Johnson**:​ eficient pentru grafuri **rare** ​($n >> m$ sau $|V| >> |E|$ - a.k.a. număr de noduri mult mai mare decât număr de muchii).
  
-In exemplul alăturat, costul drumului de la nodul 1 la 5 este:+Vom prezenta fiecare algoritm, îl vom analiza, iar la final vom vedea când îl vom folosi pe fiecare.
  
-drumul 1: w14 + w45 = 30 + 20 = 50+Puteți consulta capitolul **All-Pairs Shortest Paths** din **Introduction to Algorithms** [0] pentru mai multe detalii despre acești algoritmi.
  
-drumul 2: w12 + w23 + w35 = 10 + 20 + 10 = 40+===== Roy-Floyd =====
  
-drumul 3: w13 + w35 = 50 + 10 = 60 +Algoritmul [[https://​en.wikipedia.org/​wiki/​Floyd%E2%80%93Warshall_algorithm|Roy-Floyd]] (**Roy-Floyd** / **Floyd–Warshall** algorithm) rezolvă **shortest-paths problem** în grafuri **G = (V, E)** care sunt **dense**.
-         +
-{{:​pa:​laboratoare:​8_1.png?300|}}+
  
-==== Drumul de cost minim ====+==== Roy-Floyd - Pseudocod ​====
  
->> Costul minim al drumului dintre doua noduri este minimul dintre costurile drumurilor existente intre cele doua noduri.+<code cpp> 
 +// apply Roy-Floyd'​s algorithm for all-pairs shortest-paths problem 
 +// 
 +// nodes     = list of all nodes from G 
 +// adj[node] = the adjacency list of node 
 +//             ​example:​ adj[node] = {..., neigh, ...} => edge (node, neigh) of cost w[node][neigh] 
 +// 
 +// 
 +// returns: d, p 
 +//          d = distance matrix 
 +//          p = parent matrix 
 +// 
 +Roy-Floyd(G=(nodes,​ adj)) { 
 +  // STEP 1: initialize results 
 +  // d[i][j] = minimum distance from i to j 
 +  // p[i][j] = parent of node j, on shortest path from i to j 
 +  for (i in nodes) { 
 +    for (j in nodes) { 
 +      d[i][j] = w[i][j]; ​                         // edge cost (or infinity if missing) 
 +      p[i][j] = (w[i][j] != infinity ? i : null); // parent (or null if missing) 
 +    } 
 +  }
  
-In exemplul de mai sus, drumul de cost minim de la nodul 1 la 5 este prin nodurile ​2 si 3.+  // STEP 2: For each intermediar node k, 
 +  // try to update shortest path from i to j. 
 +  for (k in nodes) { 
 +    for (i in nodes) { 
 +      for (j in nodes) { 
 +        // Is (i -> ... -> k) reunion with (k -> ... -> j) shorter than (i -> ... -> j)? 
 +        if (d[i][k] + d[k][j] < d[i][j]) { 
 +          d[i][j] = d[i][k] + d[k][j]; 
 +          p[i][j] = p[k][j]; 
 +        } 
 +      } 
 +    } 
 +  }
  
-Deși, in cele mai multe cazuri, costul este o funcție cu valori nenegative, exista situații in care un graf cu muchii de cost negativ are relevanta practica. O parte din algoritmi pot determina drumul corect de cost minim inclusiv pe astfel de grafuri. Totuși, nu are sens căutarea drumului minim in cazurile in care graful conține cicluri de cost negativ – un drum minim ar avea lungimea infinita, intrucat costul sau s-ar reduce la fiecare reparcurgere a ciclului:+  return d, p; 
 +}
  
-In exemplul alăturat, ciclul 1 -> 2 -> 3 -> 1 are costul -20.        ​{{:​pa:​laboratoare:​8_2.png?200|}}+// Usage example: 
 +d, p = Roy-Floyd(G=(nodes,​ adj)); 
 +// 1. Use distances from d 
 +// 2. Rebuild path from node to source using parents (p) 
 +RebuildPath(source,​ destination,​ p); 
 +</​code>​ 
 +==== Exemple ====
  
-drumul 1: w12 + w23 + w35 = 10 + 20 + 10 = 40 +=== Exemplu Roy-Floyd ===
  
-drumul 2: (w12 + w23 + w31) + w12 + w23 + w35 = -20 + 10 + 20 + 10 = 20 +{{https://​ocw.cs.pub.ro/​courses/​_media/​pa/​new_pa/​lab10-graph-royfloyd-example.png?​512| Exemplu Roy-Floyd}}
  
-drumul 3: (w12 + w23 + w31) + (w12 + w23 + w31) + w12 + w23 + w35 = -20 + (-20) + 10 + 20 + 10 = 0 +Drumurile minime calculate de algoritmul Roy-Floyd sunt:
  
-==== Relaxarea unei muchii ====+|-|1|2|3|4| \\ 
 +|1|0|-1|-2|0| \\ 
 +|2|4|0|2|4| \\ 
 +|3|5|1|0|2| \\ 
 +|4|3|-1|1|0| \\
  
->> Relaxarea unei muchii **(u, v)** constă în a testa dacă se poate **reduce distanța / costul drumului** de la **sursă s** până la nodul **v**, trecând prin nodul intermediar **u** și apoi circuland pe muchia **(u, v)**.  
  
-<note> +<spoiler Explicație pas cu pas> În exemplul atașat, avem un graf **orientat** cu următoare configurație:
-Fie **w[u][v]** costul inițial al muchiei **(u, v)**, **d[s][u]** costul ** drumului** ​ de la sursa **s** la **u** și **d[s][v]** costul **drumului** de la sursa **s** la **v**. ​+
  
-Daca **d[s][v] > d[s][u] + w[u][v]**, muchia ​**(u, v)** este **relaxată** și drumul anterior ​**s - ... - v** (care **nu** trece prin **u**) este înlocuit cu drumul ​**s - ... - u - v** (care trece prin u și care are cost mai mic). +  * ''​%%n = 4%%'',​ ''​%%m = 5%%''​ 
-</​note>​+  * Funcția de cost ''​%%w%%''​ are valorile menționate pe muchii. 
 +  * Avem mai multe drumuri de cost diferite între diverse perechi de noduri din graf. 
 +  * Construim tabloul **d** al distanțelor minime: 
 +    * **d[u][v] = w[u][v]**, ​dacă există ​muchia ​$(u, v)$. 
 +    ​* **d[u][v] = +∞, dacă **NU%%**%% există muchia $(u, v)$. 
 +    ​* **d[u][u] = 0**, convenție. 
 +    ​* Obținem matricea ​**d_0**:
  
 +|-|1|2|3|4| \\
 +|1|0|+∞|-2|+∞| \\
 +|2|4|0|3|+∞| \\
 +|3|+∞|+∞|0|2| \\
 +|4|+∞|-1|+∞|0| \\
  
  
-In exemplul alăturat, sursa este **s = 1**. +  * Rulăm algoritmul Roy-Floyd, vom scrie matricea pentru fiecare $ k = 1, 2, 3, 4$. 
-Muchia de la 1 la 3 are cost w[1][3] = 50, deci inițial **d[1][3] = 50**. Analog, ​**d[1][2] = 10** și **d[2][3] ​= 20**.+    ​* $d_1$ (matricea dupa primul pas din algoritm; se modifică doar **d[2][3]**)
  
 +|-|1|2|3|4| \\
 +|1|0|+∞|-2|+∞| \\
 +|2|4|0|**2**|+∞| \\
 +|3|+∞|+∞|0|2| \\
 +|4|+∞|-1|+∞|0| \\
  
-Prin relaxarea muchiei **(u, v) = (2, 3)**, distanța de la **s = 1** la **v = 3** se poate actualiza la **30** (**d[1][3] > d[1][2] + w[2][3]**). 
  
-{{:​pa:​laboratoare:​8_3.png?​200|}}+  * $d_2$ (matricea dupa primul pas din algoritm; se modifică doar **d[4][3]** și **d[4][1]**)
  
-<​note>​ +|-|1|2|3|4| \\ 
-Toți algoritmii prezentați in continuare se bazează pe relaxare pentru a determina drumul minim. +|1|0|+∞|-2|+∞| \\ 
-</​note>​ +|2|4|0|2|+∞| \\ 
-===== Drumuri minime de sursa unica =====+|3|+∞|+∞|0|2| \\ 
 +|4|**3**|-1|**1**|0| v
  
-Algoritmii ​din aceasta secțiune determina drumul de cost minim de la un nod sursa, la restul nodurilor din graf, pe baza de relaxări repetate.+  * $d_3$ (matricea dupa primul pas din algoritm; se modifică doar **d[1][4]** și **d[2][4]**)
  
-==== Algoritmul lui Dijkstra ====+|-|1|2|3|4| \\ 
 +|1|0|+∞|-2|**0**| \\ 
 +|2|4|0|2|**4**| \\ 
 +|3|+∞|+∞|0|2| \\ 
 +|4|3|-1|1|0| \\
  
-Dijkstra poate fi folosit doar in grafuri care au toate muchiile nenegative. 
  
-Algoritmul este de tip Greedy: \\ +  * $d_4$ (matricea dupa primul pas din algoritm; ​se modifică doar **d[1][2]**, **d[3][1]** și **d[3][2]**)
-optimul local căutat este reprezentat de costul drumului dintre nodul sursa s si un nod v. Pentru fiecare nod se retine un cost estimat ​d[v], inițializat la început cu costul muchiei s -> v, sau cu +∞, daca nu exista muchie.+
  
-In exemplul următor, sursa s este nodul 1. Inițializarea va fi: \\ \\ +|-|1|2|3|4| ​\\ 
- {{:​pa:​laboratoare:​8_4.png?​500|}} \\ \\ +|1|0|**-1**|-2|0| ​\\ 
-Aceste drumuri sunt îmbunătățite la fiecare pas, pe baza celorlalte costuri estimate.+|2|4|0|2|4| ​\\ 
 +|3|**5**|**1**|0|2| ​\\ 
 +|4|3|-1|1|0| \\
  
-Algoritmul selectează,​ in mod repetat, nodul u care are, la momentul respectiv, costul estimat minim (fata de nodul sursa). In continuare, se încearcă sa se relaxeze restul costurilor d[v]. Daca d[v] >= d[u] + wuv , d[v] ia valoarea d[u] + wuv. 
  
-Pentru a tine evidenta muchiilor care trebuie relaxate, se folosesc doua structuri: S (mulțimea de vârfuri deja vizitate) si Q (o coada cu priorități,​ in care nodurile se afla ordonate după distanta fata de sursa) din care este mereu extras nodul aflat la distanta minima. In S se afla inițial doar sursa, iar in Q doar nodurile spre care exista muchie directa de la sursa, deci care au d[nod] < +∞.+  * Drumurile minime sunt finale ​(cele menționate anterior - $d_4$).
  
-In exemplul de mai sus, vom inițializa S = {1} si Q = {2, 4, 3}.+</​spoiler>​ \\
  
-La primul pas este selectat nodul 2, care are d[2] = 10. \\  
-Singurul nod pentru care d[nod] poate fi relaxat este 3 : d[3] = 50 > d[2] + w23 = 10 + 20 = 30 \\ \\ 
- ​{{:​pa:​laboratoare:​8_5.png?​500|}} \\ \\ 
-După primul pas, S = {1, 2} si Q = {4, 3}. 
  
-La următorul pas este selectat nodul 4, care are d[4] = 30. \\  +==== Complexitate ====
-Pe baza lui, se poate modifica d[5] : d[5] = +∞ > d[4] + w45 = 30 + 20 = 50 \\ \\ +
- ​{{:​pa:​laboratoare:​8_6.png?​500|}} \\ \\ +
-După al doilea pas, S = {1, 2, 4} si Q = {3, 5}.+
  
-La următorul pas este selectat nodul 3, care are d[3] = 30, si se modifica din nou d[5]: +  * **complexitate temporală**: $T = O(n^3)\ sau\ O(|V|^3)$ 
-d[5] = 50 > d[3] + w35 = 30 + 10 = 40.+  * **complexitate spațială** ​: $S = O(1)$
  
-Algoritmul se încheie când coada Q devine vida, sau când S conține toate nodurile. Pentru a putea determina si muchiile din care este alcătuit drumul minim căutat, nu doar costul sau final, este necesar sa reținem un vector de părinți P. Pentru nodurile care au muchie directa de la sursa, P[nod] este inițializat cu sursa, pentru restul cu null.+<spoiler Detalii (analiză + optimizări)>
  
-Pseudocodul ​pentru ​determinarea drumului ​minim de la o sursa către celelalte noduri utilizând algoritmul lui Dijkstra este:+  * **complexitate temporală**:​ Se aplică recurența discutată anterior care pentru ​fiecare nod intermediar **k**, încearcă să actualizeze drumul ​minim de la **i** la **j**. Cele 3 foruri dau complexitatea temporară. 
 +  * **complexitate spațială** ​: Nu stocăm tablouri auxilare.
  
-<code cpp> +</spoiler> \\
-Dijkstra(sursa,​ dest): +
-introdu sursa in Q +
-d[sursa] = 0 +
-d[nod] = +∞ // pentru orice nod != sursa +
-P[nod] = null // pentru orice nod din V+
  
-// relaxari succesive 
-cat timp Q nu e vida 
-    u = extrage_min (Q) 
-    selectat(u) = true 
-    foreach nod in vecini[u] // (*) 
-        /* daca drumul de la sursa la nod prin u este mai mic decat cel curent */ 
-        daca not selectat(nod) si d[nod] > d[u] + w[u, nod] 
-     // actualizeaza distanta si parinte 
-            d[nod] = d[u] + w[u, nod] 
-            P[nod] = u 
-            /* actualizeaza pozitia nodului in coada prioritara */ 
-            actualizeaza (Q,nod) 
  
-// gasirea drumului efectiv +===== Johnson =====
-Initializeaza Drum = {} +
-nod = P[dest] +
-cat timp nod != null +
-    insereaza nod la inceputul lui Drum +
-    nod = P[nod] +
-</​code>​+
  
-Reprezentarea grafului ca matrice de adiacenta duce la o implementare ineficienta pentru orice graf care nu este complet, datorita parcurgerii vecinilor nodului u, din linia (*), care se va executa în |V| pași pentru fiecare extragere din Q, iar pe întreg algoritmul vor rezulta |V|^2 pași. Este preferata reprezentarea grafului cu liste de adiacenta, pentru care numărul total de operații cauzate de linia (*) va fi egal cu |E|. +Algoritmul lui [[https://​en.wikipedia.org/​wiki/​Johnson%27s_algorithm|Johnson]] ​(**Johnson’s algorithm**) rezolvă **shortest-paths problem** în grafuri **G = (V, E)** care sunt **rare**.
-Complexitatea algoritmului este O(|V|^2+|E|) în cazul în care coada cu priorități este implementata ca o căutare liniara. În acest caz funcția extrage_min se executa în timp O(|V|), iar actualizează(Q) in timp O(1).+
  
-O varianta mai eficienta ​este implementarea cozii ca heap binar. Funcția extrage_min se va executa în timp O(lg|V|); funcția actualizează(Q) se va executa tot în timp O(lg|V|), dar trebuie cunoscuta poziția cheii nod în heap, adică heapul trebuie sa fie indexat. Complexitatea ​obținută este O(|E|lg|V|) pentru un graf conex.+Ideea de la care pornește acest algoritm ​este de a rula cel mai rapid algorithm pentru **shortest-paths single source**, adică algoritmul lui Dijkstra, pentru fiecare sursă ​(nod) din graf. Dacă toate costurile sunt pozitive, putem face direct acest lucru. Dacă însă există costuri negative, nu putem aplica Dijkstra pe acest graf. Algoritmul lui Johnson face o preprocesare ​(în **ComputeH**) și calculează un graf echivalent, în care toate costurile sunt pozitive. Pe acest graf se poate aplica Dijkstra și să se afle toate distanțele. Ulterior se face translatarea inversă și se obțin **distanțele în graful inițial**.
  
-Cea mai eficienta implementare se obține folosind un heap Fibonacci pentru coada cu priorități:+Observație: Dacă se știe că toate costurile din graf sunt pozitive (nenegative),​ algoritmul lui Johnson se poate înlocui ​cu rularea directă a algoritmului Dijkstra pentru toate nodurile din graf.
  
-Aceasta este o structura de date complexa, dezvoltata în mod special pentru optimizarea algoritmului Dijkstra, caracterizata de un timp amortizat de O(lg|V|) pentru operația extrage_min si numai O(1) pentru actualizeaza(Q). Complexitatea obținută este O(|V|lg|V| + |E|), foarte bună pentru grafuri rare.+==== Johnson - Pseudocod ====
  
-==== Algoritmul Bellman – Ford ====+<code cpp> 
 +// apply Johnson'​s algorithm for all-pairs shortest-paths problem 
 +// 
 +// nodes     = list of all nodes from G 
 +// adj[node] ​= the adjacency list of node 
 +//             ​example:​ adj[node] ​= {..., neigh, ...} => edge (node, neigh) of cost w[node][neigh] 
 +// 
 +// returns: has_cycle, d, p 
 +//          has_cycle ​= negative cycle detection flag (true if found) 
 +//          d = distance matrix (defined only if has_cycle ​== false) 
 +//          p = parent matrix (defined only if has_cycle == false) 
 +// 
 +Johnson(G=(nodes,​ adj)) { 
 +  // STEP 1: Compute adjustment distances h (using Bellmand-Ford). 
 +  has_cycle, h = ComputeH(G);​ 
 +  if (has_cycle) { 
 +    return true, null, null; 
 +  }
  
-Algoritmul Bellman Ford poate fi folosit si pentru grafuri ce conțin muchii de cost negativ, dar nu poate fi folosit pentru grafuri ce conțin cicluri de cost negativ ​(când căutarea unui drum minim nu are sens). \\  +  // STEP 2: Update all costs in G to obtain all costs nonnegative. 
-Cu ajutorul sau putem afla daca un graf conține cicluri. +  foreach ((u, v) in edges) { 
-Algoritmul folosește același mecanism de relaxare ca si Dijkstra, dar, spre deosebire de acesta, nu optimizează o soluție folosind un criteriu de optim local, ci parcurge fiecare muchie de un număr de ori egal cu numărul de noduri si încearcă sa o relaxeze de fiecare data, pentru a îmbunătăți distanta până la nodul destinație al muchiei curente.+    if (w[u][v] != infinity) { 
 +      ​w[u][v] = w[u][v] + (h[u] - h[v]); 
 +    } 
 +  }
  
-Motivul pentru care se face acest lucru este ca drumul minim dintre sursa si orice nod destinație poate sa treacă prin maximum |V| noduri ​(adică toate nodurile grafului), respectiv |V|-1 muchii; prin urmare, relaxarea tuturor muchiilor de |V|-1 ori este suficienta pentru a propaga până la toate nodurile informația despre distanta minima de la sursa.+  // STEP 3: Now all costs are nonnegative,​ so we can apply Dijsktra. 
 +  // Start Dijkstra for each source u, saving just distances. 
 +  foreach ​(u in nodes) { 
 +    d_dijkstra, p_dijkstra = Dijkstra(u, G);
  
-Daca, la sfârșitul acestor |E|*(|V|-1) relaxări, mai poate fi îmbunătățită o distanță, atunci graful are un ciclu de cost negativ si problema nu are soluție.+    // STEP 4: Compute distance (u, v) on initial graph. 
 +    foreach ​(v in nodes) { 
 +      d[u][v] = d_dijkstra[v] + (h[v] - h[u]); 
 +      p[u][v] = p_dijkstra[v];​ 
 +    } 
 +  }
  
-Menținând notațiile anterioare, pseudocodul algoritmului este:+  return false, d, p;  // no negative cycles detected 
 +}
  
-<code cpp> +ComputeH(G=(nodes,​ adj)){ 
-BellmanFord(sursa):+  // STEP 0: Create a new **temporary** graph 
 +  // * add a new node 
 +  source = new node; 
 +  new_nodes = nodes + { source }; 
 +  new_adj = adj; 
 +  // * add a new edge (source, node) with cost 0 for all existing nodes 
 +  for (node in nodes) { 
 +    new_adj[source].push_back(node);​ 
 +    w[source][node] = 0; 
 +  } 
 + 
 +  // STEP 1: Run Bellman-Ford on the new graph. Save just flag and distances. 
 +  has_cycle, h, _ = Bellmann-Ford(source,​ new_G=(new_nodes,​ new_adj))) 
 +  if (has_cycle) { 
 +    return true, null; // negative cycle detected 
 +  } 
 + 
 +  return false, d; 
 +}
  
-d[sursa] = 0 
-d[nod] = +∞ // pentru orice nod != sursa 
-p[nod] = null // pentru orice nod din V 
  
-// relaxari succesive +// Usage example: 
-// cum in initializare se face o relaxare (daca exista drum direct de la sursa la nod =>  +has_cycle, ​d, p = Johnson(source, G=(nodes, adj)); 
-// d[nod] = w[sursa, nod]) mai sunt necesare |V-1| relaxari  +if (has_cycle) { 
-for i = 1 to |V|-1  +  print "Has Cycle!"​ 
-    foreach ​(u, v) in E  // ​E = multimea muchiilor +  STOP. 
-        daca d[v] > d[u] + w(u,v) +} else { 
-            ​d[v] = d[u] + w(u,v) +  // ​1. Use distances from d 
-            p[v] = u; +  // ​(e.g. d[node] = distance from source to node) 
-            ​ +  // 
-// daca se mai pot relaxa muchii +  // 3. Rebuild path from node to source using parents ​(p) 
-foreach ​(u, v) in E +  ​RebuildPath(source, destination,​ p); 
-    daca d[v] > d[u] + w(u,v) +}
-        fail (”exista cicluri negativ”)+
 </​code>​ </​code>​
 +==== Exemple ====
  
-Complexitatea algoritmului este O(|E|*|V|). +=== Exemplu Johnson ​===
-  +
-===== Drumuri minime intre oricare doua noduri =====+
  
-==== Floyd-Warshall ====+În această secțiune exemplificăm grafic cum rulează algoritmul lui Johnson pe un graf dat.
  
-Algoritmii din aceasta secțiune determina drumul de cost minim dintre oricare doua noduri dintr-un graf. Pentru a rezolva aceasta problema s-ar putea aplica unul din algoritmii de mai sus, considerând ca sursa fiecare nod, pe rând, dar o astfel de abordare ar fi ineficienta.+<spoiler Explicație pas cu pas> {{https://​ocw.cs.pub.ro/​courses/​_media/​pa/​new_pa/​lab10-graph-johnson-example01.png?512| Exemplu Johnson 1/3}}
  
-Algoritmul Floyd-Warshall(intalnit si sub numele de Roy-Floyd) compara toate drumurile posibile din graf dintre fiecare 2 noduri, si poate fi utilizat si in grafuri ​cu muchii de cost negativ.+În exemplul atașat, avem un graf **orientat** ​cu următoare configurație:​
  
-Estimarea drumului optim poate fi reținut intr-o structura tridimensionala d[v1, v2, k], cu semnificația – costul minim al drumului ​de la v1 la v2, folosind ca noduri ​intermediare doar noduri pana la nodul k. Daca nodurile sunt numerotate ​de la 1, atunci d[v1, v2, 0] reprezintă costul muchiei directe ​de la v1 la v2, considerând +∞ daca aceasta nu exista. Exemplu, pentru v1 = 1, respectiv 2: \\ \\  +  * ''​%%n = 5%%''​, ''​%%m = 8%%''​ 
- ​{{:​pa:​laboratoare:​8_7.png?​500|}} \\ \\  +  * Funcția de cost ''​%%w%%''​ are valorile menționate pe muchii. 
-Pornind cu valori ale lui k de la 1 la |V|, ne interesează să găsim cea mai scurta cale de la fiecare ​v1 la fiecare v2 folosind doar noduri intermedire ​din mulțimea {1, ..., k}. De fiecare data, comparam costul deja estimat al drumului de la v1 la v2, deci d[v1, v2,   k-1] obținut la pasul anterior, cu costul drumurilor ​de la v1 la k si de la k la v2, adică d[v1, k, k-1] + d[k, v2, k-1], obținutae la pasul anterior. +  * Avem mai multe drumuri de cost diferite între diverse perechi de noduri ​din graf. (Observăm că nu avem ciclu de cost negativ, deci are sens să rulăm un algoritm ​de drumuri minime). 
-Atunci, d[v1, v2, |V|] va conține costul drumului minim de la v1 la v2.+  * ''​%%STEP ​1%%''​: Adăugăm un nod fictiv (exemplu nodul ''​%%6%%''​). Îl vom uni de fiecare ​nod din graful inițial (1, 2, 3, 4, 5) cu muchie ​de cost 0. Obținem graful din figura următoare:
  
-Pseudocodul acestui algoritm este:+{{https://​ocw.cs.pub.ro/​courses/​_media/​pa/​new_pa/​lab10-graph-johnson-example02.png?​512| Exemplu Johnson - 2/3}}
  
-<code cpp> +  * Pe acest graf putem rula o dată algoritmul Bellman-Ford, considerând sursă noul nod adăugat. 
-FloydWarshall(G):​ +  * Obținem vectorul de distanțe $h[node] = distanța\ de\ la\ nodul\ fictiv\ ​(6)\ la\ nodul\ node$
-n = |V| +
-int d[n, n, n] +
-foreach (i, j) in (1..n,1..n) +
-    d[i, j, 0] = w[i,j] // costul muchiei, sau infinit +
-for k = 1 to n +
-    foreach ​(i,j) in (1..n,​1..n) +
-        d[i, j, k] = min(d[i, j, k-1], d[i, k, k-1] + d[k, j, k-1]) +
-</​code>​+
  
-Complexitatea temporala este O(|V|^3), iar cea spațială este tot O(|V|^3). +|node|1|2|3|4|5|6| \\ 
-O complexitate spațială cu un ordin mai mic se obține observând ca la un pas nu este nevoie decât de matricea de la pasul precedent d[i, j, k-1] si cea de la pasul curent d[i, j, k]. O observație și mai bună este că, de la un pas k-1 la k, estimările lungimilor nu pot decât sa scadă, deci putem sa lucram pe o singura matrice. Deci, spațiul de memorie necesar este de dimensiune ​|V|^2.+|h[node]|-1|-7|-4|0|-2|0| \\
  
-Rescris, pseudocodul algoritmului arata astfel: 
  
-<code cpp> +  * ''​%%STEP 2%%'':​ Revenim la graful inițial ​(cel cu 5 noduri, 8 muchii) și îi alterăm costurile: 
-FloydWarshall(G): +    * $w[1][4] ​= w[1][4] + (h[1] - h[4]) = 2 + [ (-1) - (0) ] = 1$ 
-n = |V| +    * $w[2][1] = w[2][1] + (h[2] - h[1]) = 6 + [ (-7) - (-1) ] = 0$ 
-int d[n, n] +    ​* $w[2][3] = w[2][3] + (h[2] - h[3]) = 3 + [ (-7) - (-4) ] = 0$ 
-foreach ​(i, j) in (1..n,1..n) +    * $w[3][1] ​= w[3][1] + (h[3] - h[1]) = 4 + [ (-4) - (-1) ] = 1$ 
-    ​d[i, j] = w[i,j] // costul muchiei, sau infinit +    ​* $w[3][4] = w[3][4] + (h[3] - h[4]) = 5 + [ (-4) - (0) ] = 1$ 
-for k = 1 to n +    * $w[4][2] = w[4][2] + (h[4] - h[2]) = -7 + [ (0) - (-7) ] = 0$ 
-    ​foreach ​(i,j) in (1..n,1..n) +    * $w[4][5] = w[4][2] + (h[4] - h[2]) = -2 + [ (0) - (-2) ] = 0$ 
-        d[i, j] = min(d[i, j], d[i, k] + d[k, j]) +    * $w[5][4] = w[5][4] + (h[5] - h[4]) = -1 + [ (-2) - (-4) ] = 1$ 
-</​code>​+  * Obținem graful din următoarea figură:
  
-Pentru a determina drumul efectiv, nu doar costul acestuia, avem doua variante:+{{https://​ocw.cs.pub.ro/​courses/​_media/​pa/​new_pa/​lab10-graph-johnson-example03.png?​512| Exemplu Johnson - 2/3}}
  
-1. Se retine o structura de părinți, similara cu cea de la Dijkstra, ​dar, bineînțeles, bidimensionala. \\ +  * ''​%%STEP 3%%'':​ Deoarece toate costurile sunt pozitive, putem rula Dijkstra ​pe rând, pentru fiecare sursă ''​%%source = 1, 2, 3, 4, 5%%''​ din graf. 
-2. Se folosește divide et impera astfel:+  * ''​%%STEP 3%%'':​ $ source = 1 $ 
 +    * Vectorul de distanțe este ''​%%d_dijkstra%%''​ atașat mai jos. 
 +    * Distanțele față de nodul ''​%%1%%''​ pe graful inițial sunt: 
 +      * $d[1][1] = 0$ 
 +      * $d[1][2] = d_{dijkstra}[2] + (h[2] - h[1]) = 1 + [ (-7) - (-1) ] = -5$ 
 +      * $d[1][3] = d_{dijkstra}[3] + (h[3] - h[1]) = 1 + [ (-4) - (-1) ] = -2$ 
 +      * $d[1][4] = d_{dijkstra}[4] + (h[4] - h[1]) = 1 + [ (0) - (-1) ] = 2$ 
 +      * $d[1][5] = d_{dijkstra}[5] + (h[5] - h[1]) = 1 + [ (-2) - (-1) ] = 0$
  
-- se caută un pivot k astfel încât cost[i][j] = cost[i][k] + cost[j][k] ​\\ +|node|1|2|3|4|5| ​\\ 
-- se apelează funcția recursiv pentru ambele drumuri -> (i,k),(k,j) \\ +|d_dijkstra[node]|0|1|1|1|1| ​\\
-- dacă pivotul nu poate fi găsit, afișăm i \\ +
-- după terminarea funcției recursie afișăm extremitatea dreapta a drumului ​\\+
  
-===== TL;DR===== 
  
-1. Daca avem un graf **neorientat**,​ **fara cicluri** (un arbore), exista un singur +|node|1|2|3|4|5| \\ 
-drum intre oricare doua noduri, care poate fi aflat printr-o simpla parcurgere DFS. +|d[1][node]|0|-5|-2|2|0| \\
-Folosind diferite preprocesari ​[8],[9], putem calcula distanta intre oricare doua noduri +
-in timp constant, O(1).+
  
-2. Daca avem un graf **orientat**,​ **fara cicluri** (un DAG [10]), putem sa sa relaxam muchiile nodurilor, parcurgandu-le pe acestea in ordinea data de sortarea topologica. O(|V|+|E|) 
  
-3. Daca avem un graf unde toate muchiile au **cost egal**, putem afla distanta minima de la +  * ''​%%STEP ​3%%'':​ $ source = 2 $ 
-un nod sursa la orice alt nod printr-o parcurgere BFS. (de asemenea, tinand cont de faptul ca  +    * Vectorul de distanțe este ''​%%d_dijkstra%%''​ atașat mai jos. 
-pot exista mai multe drumuri pana la un anumit nod). O(|V|+|E|)+    ​* Distanțele față de nodul ''​%%2%%''​ pe graful inițial sunt: 
 +      ​* $d[2][1] = d_{dijkstra}[1] + (h[1] - h[2]) = 0 + [ (-1) - (-7) ] = 6$ 
 +      ​* $d[2][2] = 0$ 
 +      * $d[2][3] = d_{dijkstra}[3] + (h[3] - h[2]) = 0 + [ (-4) - (-7) ] = 3$ 
 +      * $d[2][4] = d_{dijkstra}[4] + (h[4] - h[2]) = 1 + [ (0) - (-7) ] = 8$ 
 +      * $d[2][5] = d_{dijkstra}[5] ​+ (h[5] - h[2]) = 1 + [ (-2) - (-7) ] = 6$
  
-4. Pentru grafuri orientate, **rare** (relativ putine muchii), putem folosi algoritmul lui Johnson([11]) pentru  +|node|1|2|3|4|5| \\ 
-calcularea distantei minime de la un nod, la oricare alt nod. O(|V|^2log|V| + |V||E|)+|d_dijkstra[node]|0|0|0|1|1| \\
  
-===== Concluzii ===== 
  
-    ***Dijkstra*** +|node|1|2|3|4|5| ​\\ 
-– calculează drumurile minime de la o sursa către celelalte noduri ​\\ +|d[2][node]|6|0|3|8|6| \\
-– nu poate fi folosit daca exista muchii de cost negativ \\ +
-– complexitate minima O(|V|lg|V| + |E|) utilizând heapuri Fibonacci;\\+
  
-    ***Bellman – Ford** 
-– calculează drumurile minime de la o sursă către celelalte noduri \\ 
-– detectează existența ciclurilor de cost negativ \\ 
-– complexitate O(|V| * |E|) \\ 
  
-    ​***Floyd – Warshall** +  ​* ''​%%STEP 3%%'':​ $ source = 3 $ 
-– calculează drumurile minime intre oricare doua noduri din graf \\ +    ​* Vectorul de distanțe este ''​%%d_dijkstra%%''​ atașat mai jos. 
-– poate fi folosit in grafuri cu cicluri de cost negativ, dar nu le detectează \\ +    ​* Distanțele față de nodul ''​%%3%%''​ pe graful inițial sunt: 
-– complexitate O(|V|^3) \\+      ​* $d[3][1] = d_{dijkstra}[1] + (h[1] - h[3]) = 1 + [ (-1) - (-4) ] = 4$ 
 +      ​* $d[3][2] = d_{dijkstra}[2] + (h[2] - h[3]) = 1 + [ (-7) - (-4) ] = -2$ 
 +      * $d[3][3] = 0$ 
 +      * $d[3][4] = d_{dijkstra}[4] + (h[4] - h[3]) = 1 + [ (0) - (-4) ] = 5$ 
 +      * $d[3][5] = d_{dijkstra}[5] + (h[5] - h[3]) = 1 + [ (-2) - (-4) ] = 3$
  
 +|node|1|2|3|4|5| \\
 +|d_dijkstra[node]|1|1|0|1|1| \\
  
-===== Exercitii ===== 
-<​note>​ 
-Scheletul de laborator se găsește pe pagina [[https://​github.com/​acs-pa/​pa-lab/​tree/​main/​skel/​lab09|pa-lab::​skel/​lab09]]. 
-</​note>​ 
  
-<note warning>​ +|node|1|2|3|4|5| \\ 
-Inainte de a rezolva exercitiile,​ asigurati-va ca ati citit si inteles toate precizarile din sectiunea +|d[3][node]|4|-2|0|5|3| \\
-[[https://​ocw.cs.pub.ro/​courses/​pa/​skel_graph ​| Precizari laboratoare 07-12]].+
  
-Prin citirea acestor precizari va asigurati ca: 
-   * cunoasteti **conventiile** folosite 
-   * evitati **buguri** 
-   * evitati **depunctari** la lab/​teme/​test 
  
-</​note>​+  * ''​%%STEP 3%%'':​ $ source = 4 $ 
 +    * Vectorul de distanțe este ''​%%d_dijkstra%%''​ atașat mai jos. 
 +    * Distanțele față de nodul ''​%%4%%''​ pe graful inițial sunt: 
 +      * $d[4][1] = d_{dijkstra}[1] + (h[1] - h[4]) = 0 + [ (-1) - (0) ] = -1$ 
 +      * $d[4][2] = d_{dijkstra}[2] + (h[2] - h[4]) = 0 + [ (-7) - (0) ] = -7$ 
 +      * $d[4][3] = d_{dijkstra}[4] + (h[3] - h[4]) = 0 + [ (-4) - (0) ] = -4$ 
 +      * $d[4][4] = 0$ 
 +      * $d[4][5] = d_{dijkstra}[5] + (h[5] - h[4]) = 0 + [ (-2) - (0) ] = 2$
  
-=== Dijkstra === +|node|1|2|3|4|5| \\ 
-Se da un graf **orientat** cu **n** noduri si **m** arce. Graful are pe arce **costuri pozitive**.+|d_dijkstra[node]|0|0|0|0|0| \\
  
-Folositi **Dijkstra** pentru a gasi **costul minim** (**lungimea minima**) a unui drum de la o sursa data (**source**) la toate celelalte n - 1 noduri din graf. 
  
-Costul / lungimea unui drum este suma costurilor/​lungimilor arcelor care compun drumul.+|node|1|2|3|4|5| \\ 
 +|d[4][node]|-1|-7|-4|0|2| \\
  
-<note warning> 
-Restrictii si precizari: 
-  * $ n <= 50.000 $ 
-  * $ m <= 2.5 * 10^5 $ 
-  * $ 0 <= c <= 20.000$, unde c este costul/​lungimea unui arc 
-  * timp de executie 
-    * C++: 1s 
-    * Java: 2s 
-</​note>​ 
  
-<​note>​ +  * ''​%%STEP 3%%'':​ $ source = 5 $ 
-Rezultatul se va returna sub forma unui vector ​**d** cu ** n  ​+ 1** elemente.+    * Vectorul de distanțe este ''​%%d_dijkstra%%''​ atașat mai jos. 
 +    * Distanțele față de nodul ''​%%4%%''​ pe graful inițial sunt: 
 +      ​* $d[5][1] = d_{dijkstra}[1] + (h[1] - h[5]) = 2 + [ (-1) - (-2) ] = 3$ 
 +      ​* $d[5][2] = d_{dijkstra}[2] + (h[2] - h[5]) = 2 + [ (-7) - (-2) ] = -3$ 
 +      ​* $d[5][3] = d_{dijkstra}[4] ​+ (h[3] - h[5]) = 1 + [ (-4) - (-2) ] = -1$ 
 +      ​* $d[5][4] = d_{dijkstra}[5] + (h[4] - h[5]) = 2 + [ (0) - (-2) ] = 4$ 
 +      ​* $d[5][5] = 0$
  
-Conventie:​ +|node|1|2|3|4|5| \\ 
-  * ** d[node] ** = costul minim / lungimea minima a unui drum de la **source** la nodul **node** +|d_dijkstra[node]|2|2|1|2|0| \\
-  * ** d[source] = 0 ** +
-  * ** d[node] ​= -1 **, daca nu se poate ajunge de la **source** la **node**+
  
-d[0] nu este folosit, deci ca fi initializat cu 0! (am pastrat indexarea nodurilor de la 1) 
-</​note>​ 
  
 +|node|1|2|3|4|5| \\
 +|d[5][node]|3|-3|-1|4|0| \\
  
-=== Bellman-Ford === 
-Se da un graf **orientat conex** cu **n** noduri si **m** arce. Graful are pe arce **costuri pozitive sau negative**. 
  
-Folositi ​**Bellman-Ford** pentru a gasi **costul minim** (**lungimea minima**) a unui drum de la o sursa data (**source**) la toate celelalte n - 1 noduri din graf. In caz ca se va detecta un ciclu de cost negativ, se va semnala acest lucru.+  ​* STOP! Am obținut ​toate distanțele $d[u][v]$ cerute!
  
-Costul ​/ lungimea unui drum este suma costurilor/​lungimilor arcelor care compun drumul.+</spoiler> \\
  
-<note warning> 
  
-Restrictii si precizari:​ +==== Complexitate ====
-  * $ n <= 50.000 $ +
-  * $ m <= 2.5 * 10^5 $ +
-  * $ -1.000 <= c <= +1.000$, unde c este costul/​lungimea unui arc +
-  * timp de executie +
-    * C++: 1s +
-    * Java: 2s +
-  * Pentru punctaj maxim, implementarea din laborator trebuie sa treaca toate testele, cu exceptia testelor 8 si 9, pe care va lua TLE. Pentru cei curiosi, exista si o implementare mai eficienta a algoritmului,​ oarecum similara cu cea de la Dijkstra (pentru mai multe detalii: [[https://​infoarena.ro/​problema/​bellmanford]]) +
-</​note>​+
  
-<​note>​ +  ​* **complexitate temporală**: $T = O(n * m * log (n))\ sau\ O(|V| * |E| * log (|V|))$ 
-Rezultatul se va returna sub forma unui vector ​**d** cu ** n + 1 ** elemente.+  * **complexitate spațială** : $S = O(n + m)\ sau \ O(|V| + |E|)$
  
-Conventie:​ +<spoiler Detalii (analiză + optimizări)>​
-  * ** d[node] ** = costul minim / lungimea minima a unui drum de la **source** la nodul **node** +
-  * ** d[source] = 0 ** +
-  * ** d[node] = -1 **, daca nu se poate ajunge de la **source** la **node**+
  
-d[0] nu este folosit, deci ca fi initializat ​cu 0! (am pastrat indexarea nodurilor ​de la 1)+  * **complexitate temporală**:​ 
 +    * **ComputeH**:​ 
 +      * Construire graf nou - $O(n + m))$. 
 +      * Aplicare Bellman-Ford pe noul graf - $O(n * m)$. 
 +    * **Update edges** - pasul se face în $O(m)$. 
 +    * Rularea Dijkstra pentru fiecare nod din graf - este complexitatea de la rulare Dijkstra pentru un singur nod sursă (a.k.a. $O(m log n)$), multiplicată ​cu numărul ​de noduri. 
 +    * În final ajungem ​la un total de $O(n * m * log(n) + n * m + n + m) = O(n * m + log(n))$. 
 +  * **complexitate spațială** : Se construiește un alt graf (**new_node** - n, **new_adj** - m), se produc câțiva vectori temporari de lungime n (**h**, **d_dijkstra**,​ **p_dijkstra**). 
 +  * **optimizare**:​ Deoarece Dijsktra se poate optimiza (vezi laborator anterior), putem obține $O(n^2 * log n + n * m)$ complexitatea pentru ultima etapă. Complexitatea finală este $O(n ^ 2 log (m) + n * m)$.
  
-**ATENTIE!!!** Este posibil ca un astfel de graf sa aiba ciclu de cost negativ. In cazul detectarii unui ciclu de cost negativ, functia voastra va returna un vector gol! (**std::​vector<​int>​() / {}** sau ** new ArrayList<​Integer>​()**). +</spoiler> \\
-</note>+
  
  
 +===== TLDR =====
  
-=== RoyFloyd === +  ​* Pentru cazul **shortest-path single source** am studiat în laboratorul anterior algoritmul lui Dijkstra / algoritmul Bellman-Ford. 
-Se da un graf **orientat**  ​cu **n** noduri. Graful are ** costuri pozitive** pe arce.+  ​* ​Pentru cazul **shortest-path all-pairs**, discuția se facă după numărul de muchii din graf: 
 +    * **graf dens**: aplicăm Roy-Floyd și obținem $O(n ^ 3)$. 
 +    ​* **graf rar**: aplicăm Johnson și obținem $O(n * m * log (n))$.
  
-Se da ** matricea ponderilor **, se cere **matricea drumurilor minime**.+===== Exerciții =====
  
-<note warning> 
-Restrictii si precizari: 
-  * $ n <= 100 $ 
-  * $ 0 <= c <= 1.000$, unde c este costul unui arc 
-  * daca **nu exista muchie** intre o pereche de noduri x si y, distanta de la nodul x la nodul y din **matricea ponderilor** va fi 0 
-  * daca dupa aplicarea algoritmului **nu se gaseste drum** pentru o pereche de noduri x si y, se va considera **distanta** dintre ele egala cu 0 (se stocheaza in **matricea distantelor** valoarea 0) 
-  * drumul de la nodul i la nodul i are lungime 0 (prin conventie) 
-  * timp de executie 
-    * C++: 1s 
-    * Java: 2s 
-</​note>​ 
  
 <​note>​ <​note>​
-Rezultatul se va **stoca** in matricea **d** declarata in schelet! Algoritmul vostru trebuie doar sa o populeze corect, tinand cont ca nodurile sunt indexate ​de la 1.+ 
 +Scheletul ​de laborator se găsește pe pagina [[https://​github.com/​acs-pa/​pa-lab/​tree/​main/​skel/​lab10|pa-lab::​skel/​lab10]]. 
 </​note>​ </​note>​
 +<note warning>
  
-=== BONUS === +Înainte ​de a rezolva exercițiile,​ asigurați-vă că ați citit și înțeles toate precizările ​din secțiunea [[https://​ocw.cs.pub.ro/​courses/​pa/​skel_graph | Precizari laboratoare 07-12]].
-Pentru exercitiul cu Dijkstra, **reconstituiti** drumul ​de lungime minima **source** la celelalte noduri ​din graf.+
  
-=== Extra === +Prin citirea acestor precizări vă asigurați că:
-<spoiler rfinv> +
-Rezolvati problema [[https://​infoarena.ro/​problema/​rfinv| rfinv]] pe infoarena. +
-</​spoiler>​+
  
 +  * știți **convențiile** folosite
 +  * evitați **buguri**
 +  * evitați **depunctări** la lab/​teme/​test
  
-<spoiler coach> 
-Rezolvati problema [[https://​infoarena.ro/​problema/​coach| coach]] pe infoarena. 
-</​spoiler>​ 
  
 +</​note>​
  
 +==== Task-1: Roy-Floyd ====
  
-<spoiler rf> +Se dă un graf **orientat** cu **n** noduri. Graful are **costuri strict pozitive**.
-Rezolvati problema [[https://​infoarena.ro/​problema/​rf| rf]] pe infoarena. +
-</​spoiler>​+
  
 +Se dă matricea ponderilor - **w**, se cere matricea drumurilor minime - **d**, aplicând algoritmul **Roy-Floyd**.
  
-<spoiler TODO> 
-Rezolvati problema [[https://​infoarena.ro/​problema/​TODO| TODO]] pe infoarena. 
-</​spoiler>​ 
  
 +<note warning>
  
-===== Referinţe: =====+Restricții și precizări:
  
-[1] [[http://en.wikipedia.org/​wiki/​Dijkstra'​s_algorithm]]+  * $ n <= 100 $ 
 +  * $ 0 <= c <= 1.000$, unde c este costul unui arc. 
 +    * Dacă **nu există arc** între o pereche de noduri x și y, distanța de la nodul x la nodul y din **matricea ponderilor** va fi 0. 
 +    * Dacă după aplicarea algoritmului **nu se găsește drum** pentru o pereche de noduri x și y, se va considera **distanța** dintre ele egală cu 0 (se stochează în **matricea distantelor** valoarea 0). 
 +    * Drumul de la nodul i la nodul i are lungime 0 (prin convenție). 
 +  * timp de execuție 
 +    * C++: 1s 
 +    * Java: 8s
  
-[2] [[http://​en.wikipedia.org/​wiki/​Bellman-Ford_algorithm]] 
  
-[3] [[http://​www.algorithmist.com/​index.php/​Floyd-Warshall'​s_Algorithm]]+</note>
  
-[4] [[http://​en.wikipedia.org/​wiki/​Binary_heap]]+==== Task-2: Johnson ====
  
-[5] [[http://en.wikipedia.org/​wiki/​Fibonacci_heap]]+Se dă un graf **orientat** cu **n** noduri. Graful are **costuri oarecare** (pot fi și negative).
  
-[6] T. Cormen, C. Leiserson, R. Rivest, C. Stein – Introducere ​în Algoritmi+Se dă lista de adiacență cu costurile aferente, se cere matricea drumurilor minime - **d**, aplicând algoritmul **Johnson**. 
 + 
 + 
 +<note warning>​ 
 + 
 +Restricții și precizări:​ 
 + 
 +  * $ n <= 1000 $ 
 +  * $ m <= 25000 $ 
 +  * $ -1000 <= c <= 1.000$, unde c este costul unui arc. 
 +    * Dacă **nu există arc** între o pereche de noduri x și y, distanța de la nodul x la nodul y din **matricea ponderilor** va fi 0. 
 +    * Dacă după aplicarea algoritmului **nu se găsește drum** pentru o pereche de noduri x și y, se va considera **distanța** dintre ele egală cu 0 (se stochează ​în **matricea distantelor** valoarea 0). 
 +    * Drumul de la nodul i la nodul i are lungime 0 (prin convenție). 
 +    * Dacă graful conține un ciclu de cost negativ, se va afișa mesajul: Ciclu negativ! 
 +  * timp de execuție 
 +    * C++: 1s 
 +    * Java: 8s 
 + 
 + 
 +</​note>​
  
-[7] C. Giumale – Introducere în analiza algoritmilor+=== Task-3: Orașul care poate accesa cele mai puține noduri (dându-se o distanță limită) === 
 +Rezolvați problema ​[[ https://​leetcode.com/​problems/​find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance/​description/​ | Find the City With the Smallest Number of Neighbors at a Threshold Distance ]] pe LeetCode.
  
-[8] http://​en.wikipedia.org/​wiki/​Range_Minimum_Query 
  
-[9] http://​en.wikipedia.org/​wiki/​Lowest_common_ancestor+==== BONUS ====
  
-[10] http://en.wikipedia.org/​wiki/​Directed_acyclic_graph+La acest laborator, asistentul va alege 1-2 probleme din secțiunea extra.
  
-[11] http://​en.wikipedia.org/​wiki/​Johnson%27s_algorithm+==== Extra ====
  
 +  * [[https://​infoarena.ro/​problema/​rfinv|infoarena/​rfinv]]
 +  * [[https://​infoarena.ro/​problema/​rf|infoarena/​rf]]
 +  * [[https://​infoarena.ro/​problema/​coach|infoarena/​coach]]
 +  * [[https://​codeforces.com/​contest/​295/​problem/​B|codeforces/​greg-and-graph]]
 +  * [[https://​codeforces.com/​contest/​25/​problem/​C|codeforces/​roads-in-berland]]
 +  * [[https://​codeforces.com/​problemset/​problem/​21/​D|codeforces/​traveling-graph]]
 +  * [[https://​codeforces.com/​gym/​101498/​problem/​L|codeforces/​the-shortest-path]]
  
 +===== Referințe =====
  
 +[0] Chapters **Single-Source Shortest Paths** / **All-Pairs Shortest Paths**, “Introduction to Algorithms”,​ Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest and Clifford Stein.
  

Diverse

Concursuri și teste practice

Laboratoare

Tutoriale

Materiale Suplimentare Test Practic

Crash-course Opțional

pa/laboratoare/laborator-09.1646171817.txt.gz · Last modified: 2022/03/01 23:56 by darius.neatu
Show pageOld revisions
Media ManagerBack to top
CC Attribution-Share Alike 3.0 Unported
www.chimeric.de Valid CSS Driven by DokuWiki do yourself a favour and use a real browser - get firefox!! Recent changes RSS feed Valid XHTML 1.0