Laborator 11 - Grafuri - Advanced

Responsabili

• Ștefan-Teodor Dascălu
• Melih Riza
• Cărăuleanu Valentin Gabriel

În urma parcurgerii acestui laborator, studentul va fi capabil să:

• găsească soluțiile unor probleme folosind algoritmii de parcurgere
• să folosească şi să adapteze algoritmii de parcurgere pentru implementarea soluţiilor găsite

Grafurile sunt utile pentru a modela diverse probleme şi se regăsesc implementaţi în multiple aplicaţii practice:

• reţele de calculatoare (ex: stabilirea unei topologii fără bucle)
• pagini Web (ex: Google PageRank)
• rețele sociale (ex: calcul centralitate)
• hărţi cu drumuri (ex: drum minim)
• modelare grafică (ex: prefuse, graph-cut)

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.

• 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 parcurg toate nodurile din V.
• Din fiecare nod care nu face parte dintr-o componentă conexă găsită anterior se pornește o nouă parcurgere BFS sau DFS.

// Inițializări
pentru fiecare nod u din V
{
    stare[u] = nevizitat
}
componente_conexe = 0

// Funcție de vizitare a nodului
vizitare(nod)
{
    stare[nod] = vizitat
    printeaza nod
}

// Parcurgerea în adâncime
DFS(nod)
{
    stiva s

    vizitare(nod)
    s.introdu(nod)

    cât timp stiva s nu este goală
    {
        nodTop = nodul din vârful stivei

        vecin = află primul vecin nevizitat al lui nodTop
        dacă vecin există
        {
            vizitare(vecin)
            s.introdu(vecin)
        }
        altfel
        {
            s.scoate(nodTop)
        }
    }
}

// Parcurgerea nodurilor din V
pentru fiecare nod u din V
{
    dacă stare[u] == nevizitat
    {
        componente_conexe = componente_conexe + 1
        DFS(u)
    }
}

Graful din imagine are 4 componente conexe.

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.

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

În momentul descoperirii unui nod y al cărui părinte este x, se fac atribuirile:

d[y] = d[x] + 1
p[y] = x

Sursa având d[A] = 0 și p[A] = NULL.

// Inițializări
pentru fiecare nod u din V
{
    stare[u] = nevizitat
    d[u] = infinit
    p[u] = null
}

// Distanța între sursă și destinație
distanta(sursa, destinatie)
{
    stare[sursa] = vizitat
    d[sursa] = 0
    enqueue(Q, sursa)               // Punem nodul sursă în coada Q

    // BFS
    cât timp coada Q nu este vidă
    {
        v = dequeue(Q)              // Extragem nodul v din coadă
        pentru fiecare u dintre vecinii lui v
            dacă stare[u] == nevizitat
            {
                stare[u] = vizitat
                p[u] = v
                d[u] = d[v] + 1
                enqueue(Q, u)       // Adăugăm nodul u în coadă
            }
    }
    return d[destinatie]            // Dacă este infinit, nu există drum
}

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 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.

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ă.

// Inițializări
pentru fiecare nod u din V
{
    stare[u] = nevizitat
    p[u] = NULL
    tDesc[u] = 0
    tFin[u] = 0
}
contor_timp = 0

// Funcție de vizitare a nodului
vizitare(nod)
{
    contor_timp = contor_timp + 1
    tDesc[nod] = contor_timp
    stare[nod] = vizitat
    printeaza nod
}

// Parcurgere în adâncime (recursiv)
DFS(nod)
{
    vizitare(nod)
    pentru fiecare vecin al lui nod
    {
        dacă stare[vecin] == nevizitat
        {
            p[vecin] = nod
            DFS(vecin)
        }
    }
    contor_timp = contor_timp + 1
    tFin[nod] = contor_timp
}

// Parcurgere noduri și calculare tDesc și tFin pentru fiecare nod
pentru fiecare nod u din V
{
    dacă stare[u] == nevizitat
    {
        DFS(u)
    }
}

// Sortare topologică
sortează nodurile din V descrescător în funcție de tFin[nod]

Profesorul Bumstead își sortează topologic hainele înainte de a se îmbrăca:

• 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 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.

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ă.

Se numește graf bipartit un graf G = (V, E) în care mulțimea nodurilor poate fi împărțită în două mulțimi disjuncte A și B astfel încât V = A ∪ B și E ⊆ A × B.

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.

• Pentru a determina dacă un graf este bipartit, una din metode constă în efectuarea unei parcurgeri BFS și atribuirea de etichete nodurilor în funcție de paritatea nivelului acestora: A pentru nodurile de pe nivel par, B pentru nodurile de pe nivel impar.
• Atunci când se adaugă vecinii nevizitați ai unui nod în coadă, se verifică și etichetele vecinilor deja vizitați: dacă un vecin deja vizitat are aceeași etichetă ca nodul curent, înseamnă că există o muchie între noduri de pe același nivel, deci graful nu este bipartit.
• În caz contrar, dacă parcurgerea BFS se finalizează fără a apărea această situație, graful este bipartit și nodurile sunt etichetate cu mulțimea din care fac parte.
• Nodurile izolate pot fi atribuite oricăreia dintre cele două mulțimi, deci nu afectează bipartitivitatea grafului.

cât timp încă sunt noduri nevizitate
{
    n = primul nod nevizitat

    nivel[n] = par
    enqueue(Q, n)        // Punem nodul sursă în coada Q

    // BFS
    cât timp coada Q nu este vidă
    {
        v = dequeue(Q)   // Extragem nodul v din coadă
        pentru fiecare u dintre vecinii lui v
        {
            dacă nivel[u] nedefinit
            {
                nivel[u] = (nivel[v] == par) ? impar : par
                enqueue(Q, u)    // Adăugăm nodul u în coadă
            }
            altfel dacă nivel[u] == nivel[v]
            {
                // Două noduri adiacente au același nivel
                // Graful nu este bipartit
                return false
            }
        }
    }
}
// Parcurgerea BFS s-a finalizat fără noduri adiacente pe același nivel
// Graful este bipartit
return true

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.

Î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, se adaugă unul dintre nodurile care nu se află deja în listă.
• Se construiește recursiv lanțul de lungime_lant + 1.
• 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 din apelul recursiv nu se iese din funcție la prima potrivire, ci se încearcă în continuare alte posibilități.

// Inițializări
numar_noduri = număr de noduri din V

// Verifică dacă un nod este nou în lanț
nouInLant(nod, lant)
{
    return !lant.contine(nod)
}

// Construiește lanțul hamiltonian
construireLant(lant, lungime_lant)
{
    dacă lungime_lant == numar_noduri
    {
        inceput = lant[0]
        sfarsit = ultimul element din lant
        // Verifică dacă există muchie de la sfarsit spre inceput
        dacă muchie(sfarsit, inceput)
        {
            afiseaza ciclul
            return true
        }
    }
    altfel
    {
        pentru orice nod u din V
        {
            sfarsit = ultimul element din lant
            // Verifică dacă există muchie de la sfarsit spre u
            dacă muchie(sfarsit, u) si nouInLant(u, lant)
            {
                addLast(lant, u)       // Adaugă u la lanț

                construireLant(lant, lungime_lant + 1)
                // Pentru afișarea unui singur ciclu hamiltonian,
                // linia anterioară se înlocuiește cu:
                // dacă construireLant(lant, lungime_lant + 1) == true
                //     return true

                removeLast(lant, u)    // Backtrack
            }
        }
    }
    return false
}

// Apelează construirea ciclurilor hamiltoniene
cicluriHamiltoniene()
{
    // Din moment ce formează un ciclu, lanțul poate începe cu orice nod
    sursa = alegem un nod aleator din V
    addLast(lant, sursa)
    construireLant(lant, 1)
}

1) [3.5p] Rezolvați problema Connected Components. 2) [3.5p] Rezolvați problema Minimum Path. 3) [3p] Rezolvați problema Check Bipartite.

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.

Sortare topologică:

• 210. Course Schedule II (returnarea ordinii topologice efective)
• 329. Longest Increasing Path in a Matrix (DAG implicit pe matrice)

Componente conexe și grafuri bipartite:

• 785. Is Graph Bipartite? (verificare bipartitivitate cu BFS/DFS)
• 721. Accounts Merge (componente conexe cu Union-Find)
• 990. Satisfiability of Equality Equations (componente conexe pe graf implicit)

Drumuri minime:

• 743. Network Delay Time (Dijkstra clasic)
• 1334. Find the City with the Smallest Number of Neighbors (Floyd-Warshall)
• 787. Cheapest Flights Within K Stops (Bellman-Ford cu constrângeri)

Probleme avansate:

• 332. Reconstruct Itinerary (circuit eulerian pe graf orientat)
• 1192. Critical Connections in a Network (punți în graf cu algoritmul Tarjan)
• 778. Swim in Rising Water (BFS/Dijkstra pe matrice cu cost variabil)

1. Componente conexe
2. Distanţa minimă
3. Sortare topologică
4. Graf bipartit
5. Lanţ hamiltonian si ciclu hamiltonian
6. Dijkstra
7. Bellman-Ford
8. Floyd-Warshall
9. A*