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

• înțeleagă operațiile de parcurgere a grafurilor și diferențele dintre ele.
• implementeze parcurgerile pe grafuri având la dispoziție structurile de date studiate.
• evalueze complexitatea parcurgerii grafurilor.

Un graf este o pereche de mulţimi G = (V, E). Mulțimea V conține nodurile grafului (vertices), iar mulțimea E conține muchiile sale (edges), fiecare muchie stabilind o relație de vecinătate între două noduri. Mulţimea E este inclusă în mulţimea VxV.

Dacă pentru orice element al mulţimii E, e = (u, v), elementul e' = (v, u) aparţine de asemenea mulţimii E, atunci spunem că graful este neorientat. În caz contrar, graful este orientat. În cazul grafului orientat, muchiile se mai numesc şi arce.

În funcţie de problemă şi de tipul grafurilor, avem 2 reprezentări: liste de adiacenţă sau matrice de adiacenţă.

Reprezentarea prin liste de adiacenţă constă într-un tablou Adj cu |V| liste, una pentru fiecare vârf din V. Pentru fiecare u din V, lista de adiacenţă Adj[u] conţine referinţe către toate vârfurile v pentru care există muchia (u, v) în E. Cu alte cuvinte, Adj[u] este formată din totalitatea vârfurilor adiacente lui u în G.

Această reprezentare este preferată pentru grafurile rare ( |E| este mult mai mic decât |V|x|V|).

Pentru graful de mai sus, lista de adiacenţă este următoarea:

• 0: 1→2
• 1: 0→2→3→4
• 2: 0→1→3
• 3: 1→2→4
• 4: 1→3

Reprezentarea prin matrice de adiacenţă a unui graf constă într-o matrice A[i][j] de dimensiune |V|x|V| astfel încât:

• A[i][j] = 1, dacă muchia (i,j) aparţine lui E
• A[i][j] = 0, în caz contrar.

Această reprezentare este preferată pentru grafurile dense ( |E| este aproximativ egal cu |V|x|V|).

Pentru graful de mai sus, matricea de adiacenţă este următoarea:

Parcurgerea în lățime (Breadth-first Search - BFS) presupune vizitarea nodurilor în următoarea ordine:

• nodul sursă (considerat a fi pe nivelul 0)
• vecinii nodului sursă (aceștia constituind nivelul 1)
• vecinii încă nevizitați ai nodurilor de pe nivelul 1 (aceștia constituind nivelul 2)
• vecinii încă nevizitați ai nodurilor de pe nivelul 2
• ş.a.m.d.

Caracteristica esențială a acestui tip de parcurgere este, deci, că se preferă explorarea în lățime, a nodurilor de pe același nivel (aceeași depărtare față de sursă) în detrimentul celei în adâncime, a nodurilor de pe nivelul următor.

• colorarea nodurilor. Pe parcurs ce algoritmul avansează, se colorează nodurile în felul următor:
  • alb - nodul este nedescoperit încă
  • gri - nodul a fost descoperit și este în curs de procesare
  • negru - procesarea nodului s-a încheiat
• păstrarea informațiilor despre distanța până la nodul sursă.
  • pentru fiecare nod în d[u] se reține distanța până la nodul sursă (poate fi util în unele probleme)
• obținerea arborelui BFS.
  • în urma aplicării algoritmului BFS se obține un arbore de acoperire (prin eliminarea muchiilor pe care nu le folosim la parcurgere). Pentru a putea reconstitui acest arbore, se păstrează pentru fiecare nod dat informația despre părintele său în p[u].

Pentru implementarea BFS se utilizează o coadă (Q) în care inițial se află doar nodul sursă. Se vizitează pe rând vecinii acestui nod şi se pun și ei în coada. În momentul în care nu mai există vecini nevizitați, nodul sursă este scos din coadă.

// inițializări
pentru fiecare nod u din V
{
    culoare[u] = alb
    d[u] = infinit
    p[u] = null
}

culoare[sursa] = gri
d[sursa] = 0
enqueue(Q,sursa) // punem nodul sursă în coada Q
 
// algoritmul propriu-zis
cât timp coada Q nu este vidă
{
    v = dequeue(Q) // extragem nodul v din coadă
    pentru fiecare u dintre vecinii lui v
        dacă culoare[u] == alb
        {
            culoare[u] = gri
            p[u] = v
            d[u] = d[v] + 1
            enqueue(Q,u) // adăugăm nodul u în coadă
        }
    culoare[v] = negru // am terminat de explorat toți vecinii lui v
}

Dacă graful are mai multe componente conexe, algoritmul, în forma dată, va parcurge doar componenta din care face parte nodul sursă. Pe grafuri cu mai multe componente conexe se va aplica în continuare algoritmul pentru fiecare nod rămas nevizitat și astfel se vor obține mai mulți arbori, câte unul pentru fiecare componentă.

O(|E|+|V|) - unde |E| este numărul de muchii, iar |V| este numărul de noduri.

• explicație: în cazul cel mai defavorabil, vor fi explorate toate muchiile și toate nodurile (când nodurile sunt liniarizate).

Arborele obținut în urma execuției este următorul:

Parcurgerea în adâncime (Depth-First Search - DFS) presupune explorarea nodurilor în următoarea ordine:

• nodul sursă
• primul vecin nevizitat al nodului sursă (îl vom numi V1)
• primul vecin nevizitat al lui V1 (îl vom numi V2)
• primul vecin nevizitat al lui V2
• s.a.m.d.
• în momentul în care am epuizat vecinii unui nod Vn, continuăm cu următorul vecin nevizitat al nodului anterior, Vn-1

Așadar, spre deosebire de BFS, acest tip de parcurgere pune prioritate pe explorarea în adâncime (la distanțe tot mai mari față de nodul sursă), în detrimentul celei în lățime (pe același nivel).

• colorarea nodurilor. Pe parcurs ce algoritmul avansează, se colorează nodurile in felul următor:
  • alb - nodul este nedescoperit încă
  • gri - nodul a fost descoperit și este în curs de procesare
  • negru - procesarea nodului s-a încheiat
• păstrarea informațiilor despre timp. Fiecare nod are două momente de timp asociate:
  • tDesc[u] - momentul descoperirii nodului (și a schimbării culorii din alb în gri)
  • tFin[u] - momentul în care procesarea nodului s-a încheiat (și culoarea acestuia s-a schimbat din gri în negru)
• obținerea arborelui DFS.
  • în urma aplicării algoritmului DFS asupra fiecărei componente conexe a grafului, se obține pentru fiecare dintre acestea câte un arbore de acoperire (prin eliminarea muchiilor pe care nu le folosim la parcurgere). Pentru a putea reconstitui acest arbore, păstram pentru fiecare nod dat informația despre părintele său în p[u].

// inițializări
pentru fiecare nod u din V
{
    culoare[u] = alb
    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
    culoare[nod] = gri
    printeaza nod;
}

// algoritmul propriu-zis
DFS(nod)
{
    stiva s;
     
    viziteaza 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ă
        {
            p[v] = nodTop
            viziteaza v;
            s.introdu(v);
        }  
        altfel
        {
            contor_timp = contor_timp + 1
            tFin[nodTop] = contor_timp
            culoare[nodTop] = negru  
            s.scoate(nodTop);   
        }     
    }
}

La fel ca în cazul BFS, complexitatea este O(|E|+|V|) - unde |E| este numărul de muchii, iar |V| este numărul de noduri.

• explicație: în cazul cel mai defavorabil, vor fi explorate toate muchiile şi toate nodurile (când graful este liniarizat).

Nodul de pornire este I, iar pentru simplificare vecinii sunt aleși în ordine alfabetică. În stânga nodului este notat tDesc, iar în dreapta tFin. Dacă se afișează nodurile, în urma parcurgerii se obține următorul output: I, E, B, A, C, D, G, F, H

Arborele obținut în urma parcurgerii este următorul:

Header-ul pentru clasa Graph:

graph.h

#ifndef __GRAPH__H
#define __GRAPH__H
 
// Structura Node este utila doar pentru implementarea cu liste de vecini
struct Node {
    std::vector<int> neighbors;
};
 
class Graph {
    private:
        // std::vector<Node> nodes; // Implementare cu liste de vecini
        // int **adiacency_matrix;  // Implementare cu matrice de adiacenta
 
    public:
        Graph(int size);
        ~Graph();
 
        void add_node(int node);    // Atentie: pentru implementarea cu matrice
        void remove_node(int node); // puteti ignora aceaste doua functii
 
        void add_edge(int src, int dst);
        void remove_edge(int src, int dst);
        bool has_edge(int src, int dst);
 
        std::vector<int> get_neighbors(int node);
};
 
#endif //__GRAPH__H

Această secțiune nu este punctată și încearcă să vă facă o oarecare idee a tipurilor de întrebări pe care le puteți întâlni la un job interview (internship, part-time, full-time, etc.) din materia prezentată în cadrul laboratorului.

Cum multe din companiile mari folosesc date stocate sub formă de grafuri (Facebook Open Graph, Google Social Graph şi Page Rank, etc.) la angajare vor dori să vadă ca ştiţi grafuri:

• cum se reprezintă grafurile
• cum funcţionează şi cum se implementează parcurgerile (BFS, DFS)

Puteţi căuta mai multe întrebări pe http://www.careercup.com/ şi pe http://www.glassdoor.com/

[1] - BFS

[2] - DFS