Show page

Differences

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

--- pa:laboratoare:laborator-12 [2013/05/20 10:39]
traian.rebedea [K-means++]
+++ pa:laboratoare:laborator-12 [2022/05/24 15:59] (current)
darius.neatu
@@ Line 1: / Line 1: @@
-====== Laborator 12 : Algoritmi aleatori ======
+====== Laborator 12: Flux maxim în rețele de transport ======
+{{:pa:new_pa:partners:bitdefender-logo.png?190 |}} 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.
 ===== Obiective laborator =====
-  *Înțelegerea noțiunilor de bază legate de algoritmii aleatori – Algoritmi Las Vegas și Monte Carlo;
+În acest laborator vom introduce contextul pentru **maximum flow problem** și vom studia algoritmi care pot rezolva această problemă.
-  *Familiarizarea cu rezolvarea folosind algoritmi aleatori a problemelor clasice;
-  *Diversificarea perspectivei de analiză și rezolvare a problemelor.
-===== Aplicații practice =====
+  * Prezentarea noțiunii de rețea de transport și a termenilor asociați.
+  * Prezentarea problemei (diverse variante).
+  * Prezentarea algoritmilor pentru calcul unui flux maxim într-o rețea de transport.
-Algoritmii aleatori se împart în principal în 2 clase:
+===== Maximum flow problem =====
-  *Algoritmi care rezolvă probleme de optim: soluția calculată de algoritm este garantat corectă, dar este aproximativă (nu este optimală). În acest caz, soluția suboptimală este considerată acceptabilă având o marjă de aproximare controlată probabilistic – **algoritmi de aproximare, algoritmi genetici și algoritmi aleatori de tip Las Vegas**;
+Vă rugăm să parcugeți [[https://ocw.cs.pub.ro/courses/pa/laboratoare/maximum-flow-problem|Maximum flow problem]] pentru a vă familiariza cu contextul, problema și notațiile folosite.
-  *Algoritmi care rezolvă o problema ce acceptă o singură soluție: se renunță la exactitatea rezolvării preferându-se o soluție rapidă care se apropie cu o probabilitatea suficient de mare de soluția exactă – corectitudinea **nu** este garantată – **algoritmi aleatori de tip Monte Carlo și stocastici (Markov)**.
-Printre implicațiile practice ale algoritmilor aleatori se numără:
+Concepte necesare:
-  *optimizarea diverșilor algoritmi, în general în vederea asigurării dispersiei corespunzătoare a valorilor;
+  * **rețea de transport** / **flow network**
-  *diverse inițializări (ex. Algoritmi Genetici pentru indivizi) sau selecții de date după o distribuție prestabilită (în general Gaussiană);
+  * **flux** / **flow**
-  *reducerea complexității unor probleme specifice.
+  * **flux maxim** / **maximum flow**
+  * **capacitate reziduală** / **residual capacity**
+  * **rețea reziduală** / **residual network**
+  * **drum de ameliorare** / **augmenting path**
+  * **capacitate reziduală a unui drum de ameliorare** / **residual capacity of augmenting path**
-===== Descrierea problemei și a rezolvărilor =====
+===== Algoritmi =====
-Primele aspecte care trebuie clarificate sunt caracteristicile algoritmilor aleatori:
+Pentru **maximum flow problem** există mai mulți algoritmi, dintre care amintim:
-  *necesitatea micșorării timpului de rezolvare a problemei prin relaxarea restricțiile impuse soluțiilor;
+  * **Ford–Fulkerson**: Este o metodă (nu un algorithm concret), a cărui complexitate este direct proporțională cu valoarea fluxului maxim - $O(m * f_{max})$. [1]
-  *este suficientă o singură soluție care se apropie cu o probabilitate măsurabilă de soluția exactă;
+  * **Edmonds-Karp**: Este o implementare concretă / optimizare a metodei anterioare - $O(n * m^2)$. [2]
-  *în final se poate obține o soluție suboptimală cu o marjă de eroare garantată prin calcul probabilistic.
+  * **Dinic**: O optimizare bazată pe construirea progresivă a unui graf folosind BFS. În fiecare etapă se poate afla fluxul în $O(n * m)$, iar în total sunt $n -1$ etape. Complexitate finală $O(n^2 * m)$. [3]
+  * **Preflow-push / push-relabel**: Un algoritm care poate fi optimizat pentru a obține complexitate $O(n^3)$ sau $O(n^2 * m)$.
-Generatorul de numere aleatorii se află la baza construcției și funcționării algoritmilor aleatori. Astfel, pentru rulări diferite există șansa ca algoritmul să se comporte diferite, chiar dacă datele de intrare, respectiv rezultatele sunt aceleași. Astfel, pentru același set de date de intrare, algoritmii familiei se comportă diferit, chiar dacă rezultatele sunt aceleași.
+Puteți consulta capitolul **Maximum Flow** din **Introduction to Algorithms** [0] pentru mai multe detalii despre acești algoritmi.
-==== Algoritmi Las Vegas ====
+În acest laborator vom studia și analiza **metoda Ford-Fulkerson**, apoi vom implementa **algoritmul Edmonds-Karp** (care este o optimizare peste Ford-Fulkerson).
-**Caracteristici:**
-  *Determină soluția corectă a problemei, însă timpul de rezolvare nu poate fi determinat cu exactitate;
+===== Ford-Fulkerson =====
-  *Creșterea timpului de rezolvare implică creșterea probabilității de terminare a algoritmului;
-  *După un timp infinit se ajunge la soluția optimă și algoritmul se termină sigur;
-  *Probabilitatea de găsire a soluției crește extrem de repede încât să se determine soluția corectă într-un timp suficient de scurt.
-**Complexitate teoretică:**
+Algoritmul lui [[https://en.wikipedia.org/wiki/L._R._Ford_Jr.|Lester Randolph **Ford** Jr. ]] și [[https://en.wikipedia.org/wiki/D._R._Fulkerson|Delbert Ray **Fulkerson**]], cunoscut ca și algoritmul / metoda [[https://en.wikipedia.org/wiki/Ford%E2%80%93Fulkerson_algorithm|Ford-Fulkerson]] este un algoritm **greedy** pentru calcularea fluxului maxim într-o rețea de transport.
-	f(n)=O(g(n)) daca ∃c>0, n0 > 0 a.i.:
+Atât timp cât în graf încă există drumuri de ameliorare (augmenting paths), înseamnă că mai putem adauga flux in rețea prin acele drumuri. La fiecare pas alegem un drum de ameliorare, prin care adăugăm cantitatea maximă posibilă de flux.
-  *∀n>n0 0 < f(n) < cαg(n) cu o probabilitate de cel puțin 1 - n<sup>-α</sup> , α fixat și suficient de mare.
+<spoiler Ford-Fulkerson - Pseudocod>
-**Implicații:**
-Procentul algoritmilor Las Vegas care consumă cel mult cαg(n) resurse de calcul din totalul unei familii de algoritmi de complexitate O(g(n)) este 1 - n<sup>-α</sup>. Pentru α suficient de mare există șanse foarte mici să se folosească un algoritm al familiei care nu respectă limita de complexitate.
+<code cpp>
+// apply Ford-Fulkerson's algorithm for computing maximum flow in network G
+//
+// nodes     = list of all nodes from G
+// edges     = the list of all edges in G
+//             example: edge (node, neigh, capacity)
+// S         = source in network G
+// T         = sink in network G
+//
+// returns: maxFlow (maximum flow in G from S to T)
+//
+Ford-Fulkerson(G=(nodes, edges), S, T) {
+  // STEP 0: initialize
+  // * flow in network
+  foreach ((u, v) in edges) {
+      f[u][v] = 0;
+  }
+  // * maximum total flow
+  totalFlow = 0;
+  while (exists augmenting path p in G) {
+      augment flow f along p;
+      update totalFlow;
+  }
+  return totalFlow;
+}
+// Usage example:
+maxFlow = Ford-Fulkerson(G=(nodes, edges), S, T);
+// Use maxFlow.
+</code>
+După cum se observă, metoda Ford-Fulkerson descrie care este abordarea generală, însă nu ne spune concret cum să găsim drumurile de ameliorare și cum să creștem fluxul pe ele.
+Putem să alegem drumurile la întâmplare. Vom obține un rezultat corect (nu vom demonstra).
+Din punct de vedere al performanței, în cel mai rău caz, pornind o parcurgere oarecare vom găsi în $O(n + m)$ un drum de ameliorare pe care vom putea crește cu exact o unitate cantitatea de flux. Această abordare duce la o complexitate de $O((n + m) * |f_{max}|)$ - adică un timp de execuție proporțional cu cantitea de flux pompată. Abordarea este ineficientă.
+</spoiler> \\
-**Problemă:**
-  *Capitolele unei cărți sunt stocate într-un fișier text sub forma unei secvențe nevide de linii;
+În practică **NU** vom folosi direct metoda Ford-Fulkerson, ci **vom folosi algoritmul Edmonds-Karp**, pe care îl vom analiza în secțiunea următoare.
-  *Fiecare secvență este precedată de o linie contor ce indică numărul de linii din secvență, iar specificul indică fiecare astfel de secvență este lungă;
-  *Fiecare linie din fișier este terminată prin CR,LF;
-  *Toate liniile din secvență au aceeași lungime;
-  *Fiecare secvență de linii conține o linie (titlul capitolului) ce se repetă și care apare în cel puțin q = 10% din numărul de linii al secvenței.
-**Cerință:**
+===== Edmonds-Karp =====
-  *Pentru fiecare secvență de linii să se tipărească titlul capitolului (linia care se repetă).
+Algoritmul lui [[https://en.wikipedia.org/wiki/Jack_Edmonds|Jack **Edmonds**]] și [[https://en.wikipedia.org/wiki/Richard_M._Karp|Richard M. **Karp**]], cunoscut ca și algoritmul [[https://en.wikipedia.org/wiki/Edmonds%E2%80%93Karp_algorithm|Edmonds-Karp]] reprezintă o implementare concretă a metodei Ford-Fulkerson. Acest algoritm rezolvă problema drumurilor de ameliorare folosind **BFS** - adică drumul cel mai scurt (ca și număr de arce), pe care se poate merge ținând cont de restricția de capacitate ($f(u, v) \lt c(u, v)$).
-Complexitate variantă iterativă: O(n<sup>2</sup>) în cazul cel mai defavorabil
-**Rezolvare aleatoare:**
+==== Edmonds-Karp - pseudocod ====
 <code cpp>
-selectie_linii(n,Secv) // Pp n = dim secv > 100
+// apply Edmonds-Karp's algorithm for computing maximum flow in network G
-    while (1)
+//
-        i = random(0,n-1) // selectez o linie
+// nodes     = list of all nodes from G
-        j = random(0,n-1) // si inca una
+// adj[node] = the adjacency list of node
-        if (i != j && linie(i,Secv) = linie(j,Secv)) // le compar
+//             example: adj[node] = {..., neigh, ...} => edge (node, neigh)
-            return linie(i,Secv) // am gasit linia
+// S         = source in network G
+// T         = sink in network G
+// f         = flow in network G
+// c         = capacity in network G
+//
+// returns: maxFlow (maximum flow in G from S to T)
+//
+Edmonds-Karp(G=(nodes, adj), S, T) {
+  // STEP 0: initialize
+  // * flow in network
+  foreach (u in nodes) {
+      foreach(v in nodes) {
+          f[u][v] = 0;
+      }
+  }
+  // * maximum total flow
+  totalFlow = 0;
+  // STEP 1: Start BFS for finding augmenting path(s).
+  while (BFS finds at least one augmenting path in G) {
+    // STEP 2.1: Compute residual capacity of augmenting path.
+    rc = +oo; // residual capacity
+    foreach ((u, v) in path) {
+        rc = min(rc, c[ u ][ v ] - f[ u ][ v ]);
+    }
+    // STEP 2.2: Update flow on path with rc.
+    foreach ((u, v) in path) {
+        f[ u ][ v ] += rc;      // Increase on edge (u, v).
+        f[ v ][ u ] -= rc;      // Decrease on edge (v, u).
+    }
+    // STEP 2.3: Update total flow.
+    totalFlow += rc;
+  }
+  return totalFlow;
+}
+// Usage example:
+maxFlow = Edmonds-Karp(G=(nodes, adj), S, T);
+// Use maxFlow.
 </code>
+Algoritmul Edmons-Karp pornește o parcurgere BFS la fiecare pas. Pentru un drum de ameliorare găsit, calculează capacitatea reziduală a acestuia, apoi crește corespunzător fluxul pe acesta.
-Complexitate variantă aleatoare: O(lg<sup>-1</sup>(1/a)lg(n))=O(lg(n)), unde a = 1 - q(q-1)/10000, q=10 – probabilitatea de regăsire a titlului capitolului.
+La **fiecare** pas, atunci când se crește fluxul pe un arc, se scade fluxul pe arcul invers (vom demonstra într-o subsecțiune viitoare necesitatea acestui pas pentru corectitudinea algoritmului).
-**Observații:**
+Algoritmul se oprește când nu mai există drumuri de ameliorare. Fluxul pompat până atunci în rețea este maxim.
-De exemplu pentru n=100 și q=10%, după 3500 de iterații, probabilitatea ca soluția să fie corectă poate fi considerată 1; dacă q=30%, atunci numărul de iterații devine 500. Aproprierea probabilității de 1 este atât de mare încât precizia de calcul cu 12 zecimale nu mai asigură obținerea valorii exacte și, practic, terminarea algoritmului devine certă.
+==== Exemple ====
-Algoritmul se comportă foarte bine chiar și atunci când în condițiile teoretice nu sunt respectate întrucât avem de-a face cu numere pseudo-aleatorii și secvența de linii nu este formată aleator.
+=== Edmonds-Karp: exemplu rezultat ===
-==== Algoritmi Monte Carlo ====
-**Caracteristici:**
+{{https://ocw.cs.pub.ro/courses/_media/pa/new_pa/lab12-edmonds-karp-example.png?512| Exemplu Edmonds-Karp}}
-  *Determină o soluție a problemei care e garantat corectă doar după un timp infinit de rezolvare – soluție aproximativă;
+Fluxul maxim calculat cu Edmonds-Karp pentru rețeaua atașată este: **2**.
-  *Presupun un număr finit de iterații după care răspunsul nu este garantat corect;
-  *Creșterea timpului de rezolvare implică creșterea probabilității ca soluția găsită să fie corectă;
-  *Soluția găsită într-un timp acceptabil este aproape sigur corectă (există o probabilitate mică ca soluţia să nu fie corectă).
-**Complexitate teoretică:**
+Drumurile de ameliorare folosite sunt:
-	f(n)=O(g(n)) daca ∃c>0, n0 > 0 a.i.:
+  * $1 - 2 - 4 - 6$ (capacitate reziduală **+1**)
+  * $1 - 3 - 5 - 6$ (capacitate reziduală **+1**)
-∀n>n0 0 < f(n) < cαg(n) cu o probabilitate de cel puțin 1 - n<sup>-α</sup> , α fixat și suficient de mare.
+=== Exemplu Edmonds-Karp: exemplu simplu pas cu pas ===
-  *Probabilitatea ca soluția determinată de algoritm să fie corectă este de cel puțin 1 - n<sup>-α</sup>.
-**Implicații:**
+În această secțiune vom exemplifica de ce doar simpla incrementare a fluxului pe arcele directe nu este suficientă pentru a găsi fluxul maxim în rețea. Următoarea secțiunea conține soluția.
-Procentul algoritmilor Monte Carlo care consumă cel mult cαg(n) resurse de calcul din totalul unei familii de algoritmi de complexitate O(g(n))  pentru a găsi o soluție corectă cu o probabilitate de cel puțin 1 - n<sup>-α</sup> este 1 - n<sup>-α</sup>. Pentru α suficient de mare există șanse foarte mici să se folosească un algoritm al familiei care nu respectă limita de complexitate și nu se termină cu o soluție corectă.
+<spoiler Exemplu>
-**Problemă:**
+Pornim de la rețeaua din figura următoare:
-  *Testarea dacă un număr dat n este prim.
+{{https://ocw.cs.pub.ro/courses/_media/pa/new_pa/lab12-edmonds-karp-example.png?512| Exemplu Edmonds-Karp}}
-Complexitate variantă clasică: O(√n)=O(<sup>k/2</sup>)  unde k = nr. de biți ocupați de n
+  * ''%%n = 6%%'', ''%%m = 7%%''
+  * Sursa este ''%%S = 1%%'', iar terminalul este ''%%T = 6%%''.
+  * Funcția de capacitate ''%%c%%'' are valorile din figură.
-Rezolvare aleatoare folosind teorema lui Fermat (Dacă n este prim atunci pentu ∀ 0 < x < n, x<sup>n-1</sup> mod n = 1):
+Dacă rulăm Edmonds-Karp, o posibilă succesiune de stări pentru rețea este cea din figura următoare:
-<code cpp>
+{{https://ocw.cs.pub.ro/courses/_media/pa/new_pa/lab12-edmonds-karp-basic-example-01.png?512| Exemplu Edmonds-Karp}}
-prim1(n,α) // detectează daca n e număr prim
-    if (n <= 1 || n mod 2 == 0) return false
-    limit = limita_calcul(n,α) //nr min pași pt sol corectă cu P=1-n^-α
-    for (i = 0 ; i < limit ; i++)
-        x = random(1,n-1) // aleg un număr oarecare
-        if (pow_mod(x,n) != 1) return false // T. Fermat
-    return true
-pow_mod(x,n) // calculează xn-1 mod n
-    r = 1
-    for (m = n – 1 ; m > 0 ; m = m / 2)
-        if (m mod 2 != 0) // testez daca m e par sau nu
-            r = x*r mod n
-        x = (x*x) mod n
-    return r;
-</code>
-Problema acestei abordări constă în faptul că nu putem stabili cu exactitate care este limita de calcul.
+  * Inițial fluxul în rețea este zero.
+  * Se vor găsi 2 drumuri de ameliorare $1 - 2 - 4 - 6$ și $ 1 - 3 - 5 - 6$. Pe fiecare drum se pompează câte o unitate de flux.
+  * În rețeaua reziduală obținută se observă că nu se mai poate ajunge de la S la T.
+  * Prin urmare fluxul obținut este maxim și are valoare $1 + 1 = 2$.
-Pornind de la următoarea teoremă: Pentru orice număr prim ecuația x<sup>2</sup> mod n = 1 are exact 2 soluții: x<sub>1</sub> egal 1 și x<sub>2</sub> egal n – 1, obținem următoarea definiție pentru X = martor al divizibilității lui n : Fie n > 1 și 0 < x < n două numere astfel încât x<sup>n-1</sup> mod n != 1 sau x<sup>2</sup> mod n != 1, x != 1 si x != n – 1.
-<code cpp>
+<note warning>
-prim2(n,α)
-    if(n <= 1 || n mod 2 == 0) return false
-    limit = limita_calcul(n,α)
-    for (i = 0 ; i < limit ; i++)
-        x = random(1, n-1)
-    if (martor_div(x,n)) return false
-    return true;
-martor_div(x,n) // determina daca X=martor al divizibilitatii lui n
-    r = 1; y = x;
-    for(m = n – 1 ; m > 0 ; m = m / 2) // puterea
-        if (m mod 2 != 0) // putere impara
-            r = y * r mod n
-        z = y // salvez valoarea lui y
-        y = y * y mod n // calculez y2 mod n
-        if (y == 1 && z != 1 && z != n-1)//verific teorema anterioară
-            return 1
-    return r != 1 // teorema Fermat
-</code>
-Complexitate: O(lg<sup>2</sup>n)=O(k<sup>2</sup>)
+NU avem control asupra drumurilor găsite de BFS, adică ordinea în care acestea vor fi alese, ci știm doar că se va alege cele mai scurte drumuri.
-===== Concluzii și observații =====
+</note>
-Metodele descrise pot fi aplicate și se adresează unei plaje largi de probleme, iar abordările prezentate pot duce la scăderi drastice a timpilor de execuție.
+O altă succesiune posibilă și corectă de stări pentru rețea se găsește în figura următoare:
-===== Referințe =====
+{{https://ocw.cs.pub.ro/courses/_media/pa/new_pa/lab12-edmonds-karp-basic-example-02.png?512| Exemplu Edmonds-Karp}}
-[1] C. Giumale – Introducere în Analiza Algoritmilor – cap. 6.1
+  * Inițial fluxul în rețea este zero.
+  * Se găsește drumul de ameliorare $1 - 2 - 5 - 6$ (tot de lungime 3 arce) cu capacitatea reziduală 1. Se pompează această unitate de flux.
+  * În rețeaua reziduală obținută se observă că nu se mai poate ajunge de la S la T.
+  * Fluxul total obținut este **1**, care **NU** este maxim.
-[2] T. H. Cormen & all – Introducere în algoritmi – cap. 8.3, 1990
+Prin urmare ajungem într-un punct în care algoritmul a greșit și nu mai poate pompa flux în plus. Parcugeți următorul exemplu pentru a vedea concret cum se rezolvă această problemă.
-[3] [[http://www.soe.ucsc.edu/classes/cmps102/Spring04/TantaloAsymp.pdf]]
+</spoiler> \\
-[4] [[http://www.mersenne.org/]]
+=== Exemplu Edmonds-Karp: exemplu detaliat cu flux pe arce inverse ===
-===== Probleme =====
+În această secțiune vom arăta ce face algoritmul pas cu pas și vom observa necesitatea și corectitudinea scăderii fluxului pe arcele inverse.
-==== K-means ====
+Pornim de la rețeaua din figura următoare:
-Fie n puncte într-un spațiu bidimensional. Se dorește o grupare a acestora în k clustere - un grup de puncte situate într-o vecinătate spațială care să maximizeze coeziunea intra-cluster și să asigure o cuplare slabă inter-clustere.
+{{https://ocw.cs.pub.ro/courses/_media/pa/new_pa/lab12-edmonds-karp-negative-flow-01.png?512| Exemplu Edmonds-Karp}}
-Spre exemplu, pentru setul de puncte:
+  * ''%%n = 6%%'', ''%%m = 7%%''
+  * Sursa este ''%%S = 1%%'', iar terminalul este ''%%T = 6%%''.
+  * Funcția de capacitate ''%%c%%'' are valorile din figură.
+  * Observăm că pentru fiecare arc $(u, v)$ am dus un arc imaginar $(v, u)$ de capacitate **0**. Aceste arce fictive reprezintă cheia funcționării algoritmului Edmonds-Karp: de fiecare dată când vom pompa (adăuga) flux pe un arc $(u, v)$, vom scădea cu aceeași valoare fluxul pe arcul $(v, u)$.
-''(2, 5), (2, 9), (3, 2), (3, 3), (3, 4), (3, 10), (4, 1), (5, 1), (8, 2), (8, 3), (9, 4), (10, 5), (10, 6), (10, 7)''
+Să vedem în continuare la ce ne ajută dacă alegem din nou, ghinionist, drumul de amelioarare $1 - 2 - 5 - 6$ și dacă de data aceasta putem corecta. Vom face acțiunile marcate în figura următoare:
-Se poate observa o grupare naturală în 3 clustere:
+{{https://ocw.cs.pub.ro/courses/_media/pa/new_pa/lab12-edmonds-karp-negative-flow-02.png?512| Exemplu Edmonds-Karp}}
+  * Se pompează o unitate de flux pe drumul $1 - 2 - 5 - 6$. Prin urmare pe arcele marcate cu verde creștem fluxul cu **+1** unități de flux, iar pe arcele marcate cu roșu scădem (**-1** unități de flux).
+  * La pasul următor, se pornește BFS din 1 și se înaintează folosind aceeași condiție - se poate merge pe o muchie $(u, v)$ dacă $f(u, v) \lt c(u, v)$. De data aceasta, această condiție se îndeplinește și pentru unele dintre muchiile inverse - cele cu **-1/0**.
+Vom face acțiunile marcate în figura următoare:
+{{https://ocw.cs.pub.ro/courses/_media/pa/new_pa/lab12-edmonds-karp-negative-flow-03.png?512| Exemplu Edmonds-Karp}}
+  * Drumul de ameliorare găsit este $1 - 3 - 5 - 2 - 4 - 6$, care are capacitatea reziduală **1**. Se pompează **+1** pe acest drum (arcele cu verde), se scade în sens invers (arcele cu roșu).
+  * La următoarea incercare de apelare BFS, nu se mai poate ajunge de la S la T, prin urmare algoritmul se oprește!
+  * Fluxul găsit este **1 + 1 = 2**, care este maxim!
+<note warning>
+Să observăm că starea finală a rețelei conține 2 unități de flux. Dacă ne uităm cu atenție, observăm că avem o unitate de flux pe drumul $1 - 2 - 4 - 6$ și alta pe $1 - 3 - 5 - 6$.
+Deși Edmonds-Karp nu a ales inițial aceste 2 drumuri, s-a corectat pe parcurs, iar în final, dacă fluxul maxim trebuia să treacă pe aici, rețeaua reziduală a fost actualizată / corectată până s-a întâmplat acest lucru!
+Semnificația înaintării pe un arc fictiv este că defapt cautăm să deviem fluxul de pe un drum ales anterior (de exemplu, $1 - 2 - 5 - 6$), pe o altă cale (de exemplu, porțiunea $1 - 2$ să se continue cu $2 - 4 - 6$), astfel încât să putem folosi partea eliberată (de exemplu, $5 - 6$), în construcția unui nou drum la pasul curent.
+</note>
+==== Complexitate ====
+  * **complexitate temporală**: $T = O(n * m^2)\ sau\ O(|V| * |E|^2)$
+  * **complexitate spațială** : $S = O(n)\ sau \ O(|V|)$
+<spoiler Detalii (analiză + optimizări)>
+  * **complexitate temporală**: Demonstrația se găsește în **Introduction to Algorithms**. Ideea de bază este că de fiecare dată când creștem fluxul pe un drum de ameliorare, o muchie devine saturată. Dacă vreodată această muchie va mai fi folosită în alt drum de ameliorare (în cazul unei corecții), aceasta va fi folosită într-un drum mai lung. Respectivele distanțe sunt monotone și limitate de $O(|V|)$.
+  * **complexitate spațială** : Stocăm o coadă pentru algoritmul BFS. De asemenea, în implementare vom stoca și un vector de părinți pentru a putea parcurge un drum de ameliorare de la T la S (sens invers).
+</spoiler> \\
+===== TLDR =====
+  * Ford-Fulkerson este un tipar general, **în practică** vom folosi doar algoritmul Edmonds-Karp.
+    * Algoritmul de bazează pe pomparea fluxului pe arcele directe și scăderea pe arcele inverse.
+    * Ordinea în care drumurile de amelioare sunt găsite nu contează. Este un algoritm greedy de tip constructiv care își corectează deciziile pe parcurs. În final mereu găsește fluxul maxim!
+  * Dacă în plus avem și costuri pe arce, putem determina flux maxim de cost minim cu Edmonds-Karp înlocuind BFS cu Dijkstra pentru găsirea drumurilor de ameliorare.
+===== Exerciții =====
+<note>
+Scheletul de laborator se găsește pe pagina [[https://github.com/acs-pa/pa-lab/tree/main/skel/lab12|pa-lab::skel/lab12]].
+</note>
+<note warning>
+Î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]].
+Prin citirea acestor precizări vă asigurați că:
+  * știți **convențiile** folosite
+  * evitați **buguri**
+  * evitați **depunctări** la lab/teme/test
+</note>
+==== Edmonds-Karp ====
+Se dă un graf orientat cu n noduri și m arce. Graful are pe arce **capacitati pozitive**.
+Folosiși Edmonds-Karp pentru a găsi fluxul maxim între nodul sursă 1 și nodul destinație n în graful dat.
+<note warning>
+Restricții și precizări:
+  * $ n <= 10^3 $
+  * $ m <= 5 * 10^3 $
+  * $ 1 <= c <= 110.000$, unde c este capacitatea unui arc
+  * Nu există arce de la n la 1.
+  * timp de execuție
+    * C++: ''%%1s%%''
+    * Java: ''%%2s%%''
+</note>
+<note>
+Rezultatul se va returna sub forma unui singur număr, reprezentând fluxul maxim ce poate fi trimis prin rețea.
+</note>
+==== BONUS ====
+La acest laborator, asistentul va alege 1-2 probleme din secțiunea extra.
+==== Extra ====
+  * [[https://infoarena.ro/problema/cuplaj|infoarena/cuplaj]]
+  * [[https://infoarena.ro/problema/fmcm|infoarena/fcmm]]
+  * [[https://infoarena.ro/problema/drumuri2|infoarena/drumuri2]]
+  * [[https://infoarena.ro/problema/joc4|inforena/joc4]]
+  * [[https://acm.timus.ru/problem.aspx?space=1&num=1533|acm/fat-hobbits]]
+===== Referințe =====
-{{ :pa:laboratoare:l12.jpg |}}
+[0] Chapter **Maximum Flow**, “Introduction to Algorithms”, Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest and Clifford Stein.
-Coeziunea internă este determinată drept 1 / media distanțelor către clustroid (punctul din cluster cel mai apropiat de toate celelalte noduri), iar cuplarea inter-clustere este 1 / distanța dintre clustere (distanța dintre clustroizii aferenți). Pașii algoritmului k-Means sunt următorii (pentru N și k date):
+[1] [[http://www.cs.yale.edu/homes/lans/readings/routing/ford-max_flow-1956.pdf|Maximal flow through a network]], L.R. Ford, D.R. Fulkerson
-  - Se selectează k puncte random din spațiu care vor fi centroizii inițiali ai clusterelor.
+[2] [[http://www.eecs.umich.edu/~pettie/matching/Edmonds-Karp-network-flow.pdf|Theoretical improvements in algorithmic efficiency for network flow problems]], Edmonds, Jack; Karp, Richard M.
-  - Se efectuează iterativ următorii pași cât timp atribuirile fiecărui nod la un cluster rămân neschimbate:
-    - Asignarea fiecărui nod unui cluster (distanța minimă euclidiană către centroizii din pasul curent este minimă);
-    - Recalcularea centroidului drept media aritmetică a coordonatelor punctelor asignate.
-Pentru un set de date și un k stabilit se vor determina clusterele aferente.
+[3] [[https://www.cs.bgu.ac.il/~dinitz/Papers/Dinitz_alg.pdf|Dinitz Algorithm]], Yefim Dinitz
-Se va implementa și o optimizare a selecției inițiale de puncte pornind de la principiul că acestea ar trebui să fie geografic cât mai dispersate (se dorește maximizarea distanței între centroizii inițiali; mai multe detalii la [1]).
-[1] http://en.wikipedia.org/wiki/K-means%2B%2B#Initialization_algorithm

Diverse

Concursuri și teste practice

Test practic

Laboratoare

05: Backtracking

10: Arbori minimi de acoperire

Tutoriale

Tutorial Minimax

Materiale Suplimentare Test Practic

Crash-course Opțional

pa/laboratoare/laborator-12.1369035545.txt.gz · Last modified: 2013/05/20 10:39 by traian.rebedea

Show page Old revisions

Media Manager Back to top