Differences
This shows you the differences between two versions of the page.
|
sd-ca:laboratoare:lab-08 [2026/05/11 21:45] valentin.carauleanu [Graf bipartit] |
sd-ca:laboratoare:lab-08 [2026/05/11 22:09] (current) valentin.carauleanu [Interviu] |
||
|---|---|---|---|
| Line 4: | Line 4: | ||
| * [[stef.dascalu@gmail.com|Ștefan-Teodor Dascălu]] | * [[stef.dascalu@gmail.com|Ștefan-Teodor Dascălu]] | ||
| * [[melih.riza03@gmail.com|Melih Riza]] | * [[melih.riza03@gmail.com|Melih Riza]] | ||
| + | * [[valentin.carauleanu@stud.fim.upb.ro|Cărăuleanu Valentin Gabriel]] | ||
| ===== Obiective ===== | ===== Obiective ===== | ||
| Line 25: | Line 26: | ||
| ==== Componente conexe ==== | ==== Componente conexe ==== | ||
| - | Se numeşte componentă conexă a unui graf neorientat ''G = (V, E)'' un subgraf ''G1 = (V1, E1)'' în care pentru orice pereche de noduri ''(A, B)'' din V1 există un lanţ de la ''A'' la ''B'', implicit şi de la ''B'' la ''A''. | + | Se numește **componentă conexă** a unui graf neorientat ''G = (V, E)'' un subgraf ''G1 = (V1, E1)'' în care pentru orice pereche de noduri ''(A, B)'' din ''V1'' există un lanț de la ''A'' la ''B'' și implicit de la ''B'' la ''A''. |
| - | **Observaţie** Nu există un alt subgraf al lui ''G'', ''G2 = (V2, E2)'' care să îndeplinească această condiţie şi care să îl conţină pe ''G1''. În acest caz, ''G2'' va fi componenta conexă, iar ''G1'' nu. | + | <note> |
| + | **Observație:** Nu există un alt subgraf al lui ''G'', ''G2 = (V2, E2)'', care să îndeplinească această condiție și care să îl conțină pe ''G1''. În acest caz, ''G2'' ar fi componenta conexă, iar ''G1'' nu. | ||
| + | </note> | ||
| === Algoritm === | === Algoritm === | ||
| - | * Atât o parcurgere ''BFS'', cât şi una ''DFS'', pornind dintr-un nod A, va determina componenta conexa din care face parte ''A''. | + | * Atât o parcurgere **BFS**, cât și una **DFS**, pornind dintr-un nod ''A'', va determina componenta conexă din care face parte ''A''. |
| - | * Pentru a determina toate componentele conexe ale unui graf ''G = (V, E)'', se vor parcurge nodurile din ''V''. | + | * Pentru a determina toate componentele conexe ale unui graf ''G = (V, E)'', se parcurg toate nodurile din ''V''. |
| - | * Din fiecare nod care nu face parte dintr-o componentă conexă găsită anterior, se va porni o parcurgere ''BFS'' sau ''DFS''. | + | * Din fiecare nod care nu face parte dintr-o componentă conexă găsită anterior se pornește o nouă parcurgere BFS sau DFS. |
| + | |||
| + | === Complexitate === | ||
| + | |||
| + | ^ Complexitate ^ Reprezentare prin liste de adiacență ^ Reprezentare prin matrice de adiacență ^ | ||
| + | ^ **Timp** | ''O(|V| + |E|)'' | ''O(|V|²)'' | | ||
| + | ^ **Spațiu** | ''O(|V| + |E|)'' | ''O(|V|²)'' | | ||
| === Pseudocod === | === Pseudocod === | ||
| Line 45: | Line 54: | ||
| componente_conexe = 0 | componente_conexe = 0 | ||
| - | // Funcţie de vizitare a nodului | + | // Funcție de vizitare a nodului |
| vizitare(nod) | vizitare(nod) | ||
| { | { | ||
| Line 56: | Line 65: | ||
| { | { | ||
| stiva s | stiva s | ||
| - | + | ||
| - | viziteaza nod | + | vizitare(nod) |
| s.introdu(nod) | s.introdu(nod) | ||
| - | | + | |
| cât timp stiva s nu este goală | cât timp stiva s nu este goală | ||
| { | { | ||
| - | nodTop = nodul din vârful stivei | + | nodTop = nodul din vârful stivei |
| - | | + | |
| - | vecin = află primul vecin nevizitat al lui nodTop. | + | vecin = află primul vecin nevizitat al lui nodTop |
| dacă vecin există | dacă vecin există | ||
| { | { | ||
| - | viziteaza v | + | vizitare(vecin) |
| - | s.introdu(v) | + | s.introdu(vecin) |
| - | } | + | } |
| altfel | altfel | ||
| { | { | ||
| Line 82: | Line 91: | ||
| dacă stare[u] == nevizitat | dacă stare[u] == nevizitat | ||
| { | { | ||
| - | componente_componente = componente_conexe + 1 | + | componente_conexe = componente_conexe + 1 |
| DFS(u) | DFS(u) | ||
| } | } | ||
| Line 92: | Line 101: | ||
| Graful din imagine are 4 componente conexe. | Graful din imagine are 4 componente conexe. | ||
| - | {{sd-ca:laboratoare:componenteConexe.png}} | + | {{sd-ca:laboratoare:componenteConexe.png?400}} |
| + | ==== Aflarea distanței minime între două noduri ==== | ||
| - | ==== Aflarea distanţei minime între două noduri ==== | + | Dacă toate muchiile au același cost, putem afla distanța minimă între două noduri ''A'' și ''B'' efectuând o parcurgere **BFS** din nodul ''A'' și oprindu-ne atunci când nodul ''B'' a fost descoperit. Deoarece BFS descoperă nodurile în ordinea crescătoare a distanței față de sursă, nivelul nodului ''B'' în parcurgere corespunde distanței minime între ''A'' și ''B''. |
| - | Dacă toate muchiile au același cost, putem afla distanța minimă între două noduri ''A'' și ''B'' efectuând o parcurgere ''BFS'' din nodul ''A'' și oprindu-ne atunci când nodul ''B'' a fost descoperit. Reamintindu-ne că nivelul unui nod este analog distanței, în muchii, față de sursă, și că ''BFS'' descoperă un nod de pe nivelul ''N'' numai după ce toate nodurile de pe nivele inferioare au fost descoperite, este ușor de văzut că nivelul nodului ''B'' în parcurgere corespunde distanței minime între ''A'' și ''B''. | + | Pentru a reține distanța și drumul exact de la ''A'' la ''B'', se păstrează pentru fiecare nod: |
| + | * ''d[x]'' - distanța de la sursă la nodul ''x'' | ||
| + | * ''p[x]'' - părintele lui ''x'' în drumul de la sursă spre ''x'' | ||
| - | Pentru a reține distanța și drumul exact de la ''A'' la ''B'', se vor reține pentru fiecare nod ''d[x]'' (distanța de la ''sursă'' la ''x'') și ''p[x]'' (părintele lui ''x'' în drumul de la sursă spre ''x''). În momentul descoperirii unui nod ''y'' al cărui părinte este ''x'', se vor face următoarele atribuiri: | + | În momentul descoperirii unui nod ''y'' al cărui părinte este ''x'', se fac atribuirile: |
| <code> | <code> | ||
| Line 105: | Line 117: | ||
| </code> | </code> | ||
| - | sursa având ''d[A] = 0'' și ''p[A] = NULL''. | + | Sursa având ''d[A] = 0'' și ''p[A] = NULL''. |
| - | Observații: | + | <note important> |
| - | *dacă parcurgerea BFS se încheie fără ca nodul B să fi fost descoperit, nu există drum între A și B și deci distanța între acestea este infinită. | + | * Dacă parcurgerea BFS se încheie fără ca nodul ''B'' să fi fost descoperit, nu există drum între ''A'' și ''B'', deci distanța este infinită. |
| - | *Algoritmul funcționează corect numai în situații de cost uniform (toate muchiile au același cost). Pentru grafuri cu muchii de costuri diferite, sunt necesari algoritmi mai avansați, cum ar fi: Dijkstra, Bellman-Ford sau Floyd-Warshall. | + | * Algoritmul funcționează corect **numai pentru grafuri cu cost uniform** (toate muchiile au același cost). Pentru grafuri cu muchii de costuri diferite sunt necesari algoritmi mai avansați: **Dijkstra**, **Bellman-Ford** sau **Floyd-Warshall**. |
| + | </note> | ||
| + | |||
| + | === Complexitate === | ||
| + | |||
| + | ^ Complexitate ^ Reprezentare prin liste de adiacență ^ Reprezentare prin matrice de adiacență ^ | ||
| + | ^ **Timp** | ''O(|V| + |E|)'' | ''O(|V|²)'' | | ||
| + | ^ **Spațiu** | ''O(|V| + |E|)'' | ''O(|V|²)'' | | ||
| === Pseudocod === | === Pseudocod === | ||
| Line 123: | Line 142: | ||
| // Distanța între sursă și destinație | // Distanța între sursă și destinație | ||
| - | distanța(sursă, destinație) | + | distanta(sursa, destinatie) |
| { | { | ||
| + | stare[sursa] = vizitat | ||
| + | d[sursa] = 0 | ||
| + | enqueue(Q, sursa) // Punem nodul sursă în coada Q | ||
| - | stare[sursă] = vizitat | ||
| - | d[sursă] = 0 | ||
| - | enqueue(Q,sursă) // Punem nodul sursă în coada Q | ||
| - | |||
| // BFS | // BFS | ||
| cât timp coada Q nu este vidă | cât timp coada Q nu este vidă | ||
| Line 140: | Line 158: | ||
| p[u] = v | p[u] = v | ||
| d[u] = d[v] + 1 | d[u] = d[v] + 1 | ||
| - | enqueue(Q,u) // Adăugăm nodul u în coadă | + | enqueue(Q, u) // Adăugăm nodul u în coadă |
| } | } | ||
| } | } | ||
| - | return d[destinație] // Dacă este infinit, nu există drum | + | return d[destinatie] // Dacă este infinit, nu există drum |
| } | } | ||
| </code> | </code> | ||
| - | |||
| ==== Sortarea topologică ==== | ==== Sortarea topologică ==== | ||
| - | Se dă un graf orientat aciclic. Orientarea muchiilor corespunde unei relații de ordine de la nodul sursă către cel destinație. O sortare topologică a unui astfel de graf este o ordonare liniară a vârfurilor sale astfel încât, dacă ''(u,v)'' este una dintre muchiile grafului, ''u'' trebuie să apară înaintea lui ''v'' în înșiruire. Dacă graful ar fi ciclic, nu ar putea exista o astfel de înșiruire (nu se poate stabili o ordine între nodurile care alcătuiesc un ciclu). | + | Se dă un graf orientat aciclic (**DAG** - Directed Acyclic Graph). Orientarea muchiilor corespunde unei relații de ordine de la nodul sursă către cel destinație. O **sortare topologică** a unui astfel de graf este o ordonare liniară a vârfurilor sale astfel încât, dacă ''(u, v)'' este una dintre muchiile grafului, ''u'' apare înaintea lui ''v'' în înșiruire. |
| - | Sortarea topologică poate fi văzută și ca plasarea nodurilor de-a lungul unei linii orizontale astfel încât toate muchiile să fie direcționate de la stânga la dreapta (să nu existe nici o muchie înapoi, spre părinte). | + | <note important> |
| + | Dacă graful este ciclic, sortarea topologică **nu este posibilă**, deoarece nu se poate stabili o ordine între nodurile care alcătuiesc un ciclu. | ||
| + | </note> | ||
| + | |||
| + | Sortarea topologică poate fi vizualizată ca plasarea nodurilor de-a lungul unei linii orizontale astfel încât toate muchiile să fie orientate de la stânga la dreapta, fără nicio muchie îndreptată înapoi spre un părinte. | ||
| + | |||
| + | === Algoritm === | ||
| + | |||
| + | Sortarea topologică se realizează printr-o parcurgere **DFS**, în care se rețin pentru fiecare nod: | ||
| + | * ''tDesc[u]'' - momentul descoperirii nodului ''u'' | ||
| + | * ''tFin[u]'' - momentul finalizării procesării nodului ''u'' | ||
| + | |||
| + | La final, nodurile sunt sortate **descrescător** după ''tFin''. Nodul care se finalizează cel mai târziu trebuie să apară primul în sortare, deoarece nu depinde de niciun alt nod nedescoperit încă. | ||
| + | |||
| + | === Complexitate === | ||
| + | |||
| + | ^ Complexitate ^ Reprezentare prin liste de adiacență ^ Reprezentare prin matrice de adiacență ^ | ||
| + | ^ **Timp** | ''O(|V| + |E|)'' | ''O(|V|²)'' | | ||
| + | ^ **Spațiu** | ''O(|V| + |E|)'' | ''O(|V|²)'' | | ||
| === Pseudocod === | === Pseudocod === | ||
| Line 166: | Line 201: | ||
| contor_timp = 0 | contor_timp = 0 | ||
| - | // Funcţie de vizitare a nodului | + | // Funcție de vizitare a nodului |
| vizitare(nod) | vizitare(nod) | ||
| { | { | ||
| Line 175: | Line 210: | ||
| } | } | ||
| - | // Parcurgere în adâncime | + | // Parcurgere în adâncime (recursiv) |
| DFS(nod) | DFS(nod) | ||
| { | { | ||
| - | stiva s | + | vizitare(nod) |
| - | + | pentru fiecare vecin al lui nod | |
| - | viziteaza nod | + | |
| - | s.introdu(nod) | + | |
| - | | + | |
| - | cât timp stiva s nu este goală | + | |
| { | { | ||
| - | nodTop = nodul din vârful stivei | + | dacă stare[vecin] == nevizitat |
| - | + | ||
| - | vecin = află primul vecin nevizitat al lui nodTop. | + | |
| - | dacă vecin există | + | |
| { | { | ||
| - | p[v] = nodTop | + | p[vecin] = nod |
| - | viziteaza v | + | DFS(vecin) |
| - | s.introdu(v) | + | |
| - | } | + | |
| - | altfel | + | |
| - | { | + | |
| - | contor_timp = contor_timp + 1 | + | |
| - | tFin[nodTop] = contor_timp | + | |
| - | s.scoate(nodTop) | + | |
| } | } | ||
| } | } | ||
| + | contor_timp = contor_timp + 1 | ||
| + | tFin[nod] = contor_timp | ||
| } | } | ||
| Line 206: | Line 229: | ||
| pentru fiecare nod u din V | pentru fiecare nod u din V | ||
| { | { | ||
| - | dacă u nu a fost vizitat | + | dacă stare[u] == nevizitat |
| { | { | ||
| - | DFS(u) | + | DFS(u) |
| } | } | ||
| } | } | ||
| - | // Sortare topologica | + | // Sortare topologică |
| sortează nodurile din V descrescător în funcție de tFin[nod] | sortează nodurile din V descrescător în funcție de tFin[nod] | ||
| </code> | </code> | ||
| Line 218: | Line 241: | ||
| === Exemplu === | === Exemplu === | ||
| - | Profesorul Bumstead își sortează topologic hainele înainte de a se îmbrăca. | + | Profesorul Bumstead își sortează topologic hainele înainte de a se îmbrăca: |
| - | * fiecare muchie ''(u, v'') înseamna că obiectul de îmbrăcăminte ''u'' trebuie îmbrăcat înaintea obiectului de îmbrăcaminte ''v''. Timpii de descoperire ''(tDesc)'' și de finalizare ''(tFin)'' obținuți în urma parcurgerii DFS sunt notați lângă noduri. | + | * Fiecare muchie ''(u, v)'' înseamnă că obiectul de îmbrăcăminte ''u'' trebuie îmbrăcat înaintea obiectului ''v''. Timpii de descoperire ''tDesc'' și de finalizare ''tFin'' sunt notați lângă fiecare nod. |
| - | * același graf, sortat topologic. Nodurile lui sunt aranjate de la stânga la dreapta în ordinea descrescătoare a ''tFin''. Observați că toate muchiile sunt orientate de la stânga la dreapta. Acum profesorul Bumstead se poate îmbrăca liniștit. | + | * Același graf, sortat topologic: nodurile sunt aranjate de la stânga la dreapta în ordinea descrescătoare a ''tFin'', astfel toate muchiile sunt orientate de la stânga la dreapta. |
| - | {{sd-ca:laboratoare:topologie.jpg}} | + | {{sd-ca:laboratoare:topologie.jpg?500}} |
| - | + | ||
| - | Așa cum se observă din imagine, sortarea topologică constă în sortarea nodurilor descrescător după timpii de finalizare. Demonstrația acestei afirmații se face simplu, arătând că nodul care se termină mai târziu trebuie să fie efectuat înaintea celorlalte noduri finalizate. | + | |
| + | Sortarea topologică constă în sortarea nodurilor **descrescător după timpii de finalizare**. Nodul care se finalizează cel mai târziu nu depinde de niciun alt nod rămas, deci trebuie plasat primul în ordine topologică. | ||
| ==== Graf bipartit ==== | ==== Graf bipartit ==== | ||
| Line 232: | Line 254: | ||
| Altfel spus, nodurile grafului se pot împărți în 2 mulțimi astfel încât **nu** există muchii între noduri din aceeași mulțime. | Altfel spus, nodurile grafului se pot împărți în 2 mulțimi astfel încât **nu** există muchii între noduri din aceeași mulțime. | ||
| - | <note important> | + | <note info>Observație: Un graf nu este **bipartit** dacă conține un **ciclu de lungime impară**. |
| - | Implicație: Un graf nu este **bipartit** dacă conține un **ciclu de lungime impară**. | + | |
| </note> | </note> | ||
| Line 290: | Line 311: | ||
| ==== Ciclu hamiltonian ==== | ==== Ciclu hamiltonian ==== | ||
| - | Un lanţ hamiltonian într-un graf orientat sau neorientat ''G = (V, E)'', este o cale ce trece prin fiecare nod din ''V'' o singură dată. Dacă nodul de început şi cel de sfârşit coincid (este vizitat de două ori) vom spune că lanţul formează un **ciclu hamiltonian**. | + | Un **lanț hamiltonian** într-un graf orientat sau neorientat ''G = (V, E)'' este o cale ce trece prin fiecare nod din ''V'' o singură dată. Dacă nodul de început și cel de sfârșit coincid, lanțul formează un **ciclu hamiltonian**. |
| - | Un graf ce conţine un ciclu hamiltonian se numeşte graf hamiltonian. | + | Un graf ce conține un ciclu hamiltonian se numește **graf hamiltonian**. |
| + | |||
| + | <note important> | ||
| + | Problema găsirii unui ciclu hamiltonian este **NP-completă**, ceea ce înseamnă că nu se cunoaște niciun algoritm eficient (polinomial) pentru cazul general. | ||
| + | </note> | ||
| === Algoritm === | === Algoritm === | ||
| - | În cadrul acestui laborator, vom folosi metoda backtracking pentru găsirea unui ciclu hamiltonian. Pentru contruirea soluţiei, se menţine o listă în care sunt adăugate nodurile parcurse: | + | În cadrul acestui laborator, vom folosi metoda **backtracking** pentru găsirea unui ciclu hamiltonian. Se menține o listă în care sunt adăugate nodurile parcurse: |
| - | * La fiecare pas, vom adăuga unul dintre nodurile care nu se află deja in listă | + | * La fiecare pas, se adaugă unul dintre nodurile care nu se află deja în listă. |
| - | * Se construieşte recursiv lanţul de lungime_lanţ + 1 | + | * Se construiește recursiv lanțul de ''lungime_lant + 1''. |
| - | * Dacă dimensiunea listei este ''n'' (numărul de noduri din graf), se verifică dacă primul şi ultimul nod din listă sunt adiacente. În caz contrar, s-a găsit un lanţ hamiltonian, dar nu şi un ciclu hamiltonian. | + | * Dacă dimensiunea listei este ''n'', se verifică dacă există o muchie de la ultimul nod din listă către primul. Dacă nu există o astfel de muchie, lanțul curent nu poate fi închis într-un ciclu hamiltonian și se continuă cu backtracking. |
| - | * Pentru a afla toate ciclurile hamiltoniene, la revenirea cu succes din apelul recursiv nu se iese din funcţie la găsirea primei potriviri, ci se încearcă în continuare alte posibilităţi. | + | * Pentru a afla **toate** ciclurile hamiltoniene, la revenirea din apelul recursiv nu se iese din funcție la prima potrivire, ci se încearcă în continuare alte posibilități. |
| + | |||
| + | === Complexitate === | ||
| + | |||
| + | ^ Complexitate ^ Valoare ^ | ||
| + | ^ **Timp** | ''O(|V|!)'' în cazul cel mai defavorabil | | ||
| + | ^ **Spațiu** | ''O(|V|)'' pentru stiva de recursivitate și lanț | | ||
| === Pseudocod === | === Pseudocod === | ||
| Line 307: | Line 338: | ||
| <code> | <code> | ||
| // Inițializări | // Inițializări | ||
| - | număr_noduri = număr de noduri din V | + | numar_noduri = număr de noduri din V |
| - | // Verifica dacă un nod este nou în lanţ | + | // Verifică dacă un nod este nou în lanț |
| - | nouÎnLanţ(nod, lanţ) | + | nouInLant(nod, lant) |
| { | { | ||
| - | return !lanţ.conţine(nod) | + | return !lant.contine(nod) |
| } | } | ||
| - | // Construieste lanţul hamiltonian | + | // Construiește lanțul hamiltonian |
| - | construireLanţ(lanţ, lungime_lanţ) | + | construireLant(lant, lungime_lant) |
| { | { | ||
| - | dacă lungime_lanţ == număr_noduri | + | dacă lungime_lant == numar_noduri |
| { | { | ||
| - | început = lanţ[0] | + | inceput = lant[0] |
| - | sfârşit = ultimul element din lanţ | + | sfarsit = ultimul element din lant |
| - | + | // Verifică dacă există muchie de la sfarsit spre inceput | |
| - | // Există muchie între cele 2 noduri | + | dacă muchie(sfarsit, inceput) |
| - | dacă muchie(început, sfârşit) | + | |
| { | { | ||
| - | // Lanţul este ciclu | + | afiseaza ciclul |
| - | afişează ciclul | + | |
| return true | return true | ||
| } | } | ||
| Line 335: | Line 364: | ||
| pentru orice nod u din V | pentru orice nod u din V | ||
| { | { | ||
| - | sfârşit = ultimul element din lanţ | + | sfarsit = ultimul element din lant |
| - | dacă muchie(u, sfârşit) şi nouÎnLanţ(u, lanţ) | + | // Verifică dacă există muchie de la sfarsit spre u |
| + | dacă muchie(sfarsit, u) si nouInLant(u, lant) | ||
| { | { | ||
| - | addLast(lanţ, u) // Adaugă u la lanţ | + | addLast(lant, u) // Adaugă u la lanț |
| - | + | ||
| - | construireLanţ(lanţ, lungime_lanţ + 1) | + | |
| - | // Pentru afişarea unui singur ciclu hamiltonian linia anterioară este inlocuită cu: | + | construireLant(lant, lungime_lant + 1) |
| - | // dacă construireLanţ(lanţ, lungime_lanţ + 1) == true | + | // Pentru afișarea unui singur ciclu hamiltonian, |
| - | // return true | + | // linia anterioară se înlocuiește cu: |
| - | + | // dacă construireLant(lant, lungime_lant + 1) == true | |
| - | removeLast(lanţ, u) // Backtrack | + | // return true |
| + | |||
| + | removeLast(lant, u) // Backtrack | ||
| } | } | ||
| } | } | ||
| Line 354: | Line 384: | ||
| // Apelează construirea ciclurilor hamiltoniene | // Apelează construirea ciclurilor hamiltoniene | ||
| - | cicluriHamiltoniene | + | cicluriHamiltoniene() |
| { | { | ||
| - | // Din moment ce ar trebui să formeze un ciclu, lanţul poate incepe cu orice nod | + | // Din moment ce formează un ciclu, lanțul poate începe cu orice nod |
| - | sursă = alegem un nod aleator din V | + | sursa = alegem un nod aleator din V |
| - | addLast(lanţ, sursă) | + | addLast(lant, sursa) |
| - | construireLanţ(lanţ, 1) | + | construireLant(lant, 1) |
| } | } | ||
| </code> | </code> | ||
| - | |||
| === Exemplu === | === Exemplu === | ||
| - | {{sd-ca:laboratoare:hamilton.png}} | + | {{sd-ca:laboratoare:hamilton.png?400}} |
| - | + | ||
| - | ===== Schelet ===== | + | |
| - | <note important> | + | |
| - | Daca folositi **Github Classroom**, va rugam sa va actualizati scheletul cu cel de mai jos. Cel din repo-ul clonat initial nu este la cea mai recenta versiune. | + | |
| - | </note> | + | |
| - | + | ||
| - | {{:sd-ca:laboratoare:lab07_2024.zip|Scheletul de laborator}} | + | |
| ===== Exerciții ===== | ===== Exerciții ===== | ||
| <note> | <note> | ||
| - | Trebuie să vă creați cont de [[https://code.devmind.ro/ | Devmind]], dacă nu v-ați creat deja, pe care îl veți folosi la SD pe toată durata semestrului. Aveti grija sa selectati contestul corect la submit, si anume **[[https://beta.lambdachecker.io/contest/34 |SD-CA-LAB-11 Grafuri (Advanced) ]]** | + | Trebuie să vă creați cont de [[https://code.devmind.ro/|Devmind]], dacă nu v-ați creat deja, pe care îl veți folosi la SD pe toată durata semestrului. |
| </note> | </note> | ||
| 1) [**3.5p**] Rezolvați problema **Connected Components**. | 1) [**3.5p**] Rezolvați problema **Connected Components**. | ||
| + | 2) [**3.5p**] Rezolvați problema **Minimum Path**. | ||
| + | 3) [**3p**] Rezolvați problema **Check Bipartite**. | ||
| + | ===== Interviu ===== | ||
| - | 2) [**3.5p**] Rezolvați problema **Minimum Path**. | + | Această secțiune nu este punctată și încearcă să vă ofere o idee despre tipurile de întrebări pe care le puteți întâlni la un job interview din materia prezentată în cadrul laboratorului. |
| + | === Probleme recomandate === | ||
| - | 3) [**3p**] Rezolvati problema **Check Bipartite**. | + | **Sortare topologică:** |
| + | * [[https://leetcode.com/problems/course-schedule-ii/description|210. Course Schedule II]] (returnarea ordinii topologice efective) | ||
| + | * [[https://leetcode.com/problems/longest-increasing-path-in-a-matrix/description|329. Longest Increasing Path in a Matrix]] (DAG implicit pe matrice) | ||
| + | **Componente conexe și grafuri bipartite:** | ||
| + | * [[https://leetcode.com/problems/is-graph-bipartite/description|785. Is Graph Bipartite?]] (verificare bipartitivitate cu BFS/DFS) | ||
| + | * [[https://leetcode.com/problems/accounts-merge/description|721. Accounts Merge]] (componente conexe cu Union-Find) | ||
| + | * [[https://leetcode.com/problems/satisfiability-of-equality-equations/description|990. Satisfiability of Equality Equations]] (componente conexe pe graf implicit) | ||
| + | **Drumuri minime:** | ||
| + | * [[https://leetcode.com/problems/network-delay-time/description|743. Network Delay Time]] (Dijkstra clasic) | ||
| + | * [[https://leetcode.com/problems/find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance/description|1334. Find the City with the Smallest Number of Neighbors]] (Floyd-Warshall) | ||
| + | * [[https://leetcode.com/problems/cheapest-flights-within-k-stops/description|787. Cheapest Flights Within K Stops]] (Bellman-Ford cu constrângeri) | ||
| + | **Probleme avansate:** | ||
| + | * [[https://leetcode.com/problems/reconstruct-itinerary/description|332. Reconstruct Itinerary]] (circuit eulerian pe graf orientat) | ||
| + | * [[https://leetcode.com/problems/critical-connections-in-a-network/description|1192. Critical Connections in a Network]] (punți în graf cu algoritmul Tarjan) | ||
| + | * [[https://leetcode.com/problems/swim-in-rising-water/description|778. Swim in Rising Water]] (BFS/Dijkstra pe matrice cu cost variabil) | ||
| ===== Bibliografie ===== | ===== Bibliografie ===== | ||
