CursuriAG2017 1 14

Cuprins
1 Introducere ı̂n algoritmi 3

1.1 Limbajul pseudocod . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.3 Elemente de analiza algoritmilor . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.3.1 Metoda substituţiei . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.3.2 Schimbarea de variabilă . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.3.3 Metoda iterativă . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.3.4 Teorema master . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
1.4 Exerciţii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2 Grafuri. Grafuri neorientate 28

2.1 Noţiuni de bază . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.2 Moduri de reprezentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.3 Parcurgerea grafurilor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
2.3.1 Parcurgerea ı̂n lăţime (BFS-Breadth First Search) . . . . . . . . . . . . 37
2.3.2 Parcurgerea D (D - Depth) . . . . . . . . . . . . . . . . . . . . . . . . 41
2.3.3 Parcurgerea ı̂n adâncime (DFS-Depth First Search) . . . . . . . . . . . 41
2.4 Componente conexe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
2.5 Muchie critică . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
2.6 Puncte de articulaţie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
2.7 Exerciţii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3 Grafuri euleriene şi hamiltoniene 57

3.1 Grafuri Euleriene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.1.1 Algoritm pentru determinarea unui ciclu eulerian . . . . . . . . . . . . 58
3.1.2 Algoritmul lui Rosenstiehl . . . . . . . . . . . . . . . . . . . . . . . . . 61
3.2 Grafuri Hamiltoniene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
3.2.1 Problema comis–voiajorului . . . . . . . . . . . . . . . . . . . . . . . . 68
3.3 Exerciţii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
4 Arbori. Arbori binari 81

4.1 Arbori binari . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
4.1.1 Moduri de reprezentare . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
4.1.2 Metode de parcurgere . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
4.2 Arbori binari de căutare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
4.3 Exerciţii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
1
5 Heap-uri 103
5.1 Heap-uri binare (Min-heapuri sau Max -heapuri) . . . . . . . . . . . . . . . . . 104
5.1.1 Inserarea unui element . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
5.1.2 Ştergerea elementului minim . . . . . . . . . . . . . . . . . . . . . . . . 105
5.1.3 Crearea unui heap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
5.1.4 Ordonare folosing heap-uri - HeapSort . . . . . . . . . . . . . . . . . . 110
5.2 Aplicatie - Coadă cu priorităţi . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
5.3 Exerciţii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
6 Arbori oarecare 121

6.1 Moduri de reprezentare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
6.2 Metode de parcurgere . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
6.3 Arbori de acoperire de cost minim . . . . . . . . . . . . . . . . . . . . . . . . . 129
6.3.1 Algoritmul lui Boruvka . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
6.3.2 Algoritmul lui Prim . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
6.3.3 Structuri de date pentru mulţimi disjuncte . . . . . . . . . . . . . . . . 137
6.3.4 Algoritmul lui Kruskal . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
6.4 Exerciţii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
7 Grafuri orientate 146

7.1 Noţiuni de bază . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
7.2 Parcurgerea grafurilor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
7.3 Sortarea topologică . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
7.4 Componente tare conexe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
7.4.1 Algoritmul lui Kosaraju . . . . . . . . . . . . . . . . . . . . . . . . . . 156
7.4.2 Algoritmul lui Tarjan . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
7.5 Exerciţii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
8 Distanţe ı̂n grafuri 167

8.1 Drumul minim de la un vârf la celelalte vârfuri . . . . . . . . . . . . . . . . . . 168
8.1.1 Algoritmul lui Moore . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
8.1.2 Algoritmul lui Dijkstra . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
8.1.3 Distanţe ı̂ntr-un graf orientat şi fără circuite . . . . . . . . . . . . . . . 177
8.1.4 Algoritmul Bellman-Ford-Moore . . . . . . . . . . . . . . . . . . . . . . 179
8.2 Drumuri minime ı̂ntre toate perechile de vârfuri . . . . . . . . . . . . . . . . . 182
8.2.1 Algoritmul lui Roy-Floyd-Warshall . . . . . . . . . . . . . . . . . . . . 183
8.3 Diametrul unui graf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
8.4 Graf pe mai multe niveluri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
8.5 Exerciţii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
9 Fluxuri ı̂n reţele de transport 194

9.1 Reţea de transport. Flux. Tăietură . . . . . . . . . . . . . . . . . . . . . . . . 195
9.2 Graf rezidual. Drum de ameliorare. Flux maxim–tăietură minimă . . . . . . . 200
9.3 Metoda Ford-Fulkerson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
9.4 Algoritmul Edmonds-Karp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
9.5 Algoritmul lui Dinic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
9.5.1 Varianta originală . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
9.6 Aplicaţii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
9.7 Exerciţii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
2
Capitolul 1
Introducere ı̂n algoritmi
Definiţia 1.1 Algoritmul constituie o reprezentare finită a unei metode de calcul ce per-
mite rezolvarea unei anumite probleme. Se poate spune că un algoritm reprezintă o secvenţă
finită de operaţii, ordonată şi complet definită, care, pornind de la datele de intrare, produce
rezultate.
Termenul de algoritm ı̂i este atribuit matematicianului persan Abu Ja‘far Mohammed
ibn Musa al-Khowarizmi (sec. VIII-IX), care a scris o carte de matematică cunoscută ı̂n tra-
ducere latină sub titlul de ”Algorithmi de numero indorum”, iar apoi ca ”Liber algorithmi ”,
unde termenul de ”algorithm” provine de la ”al-Khowarizmi ”, ceea ce literal ı̂nseamnă ”din
orasul Khowarizm”. Matematicienii din Evul Mediu ı̂nţelegeau prin algoritm o regulă (sau
o mulţime de reguli) pe baza căreia se efectuau calcule aritmetice: de exemplu ı̂n secolul al
XVI-lea, algoritmii se foloseau la ı̂nmulţiri sau ı̂njumătăţiri de numere.
Fiecare propoziţie ce face parte din descrierea unui algoritm este, de fapt, o comandă ce
trebuie executată de cineva, acesta putând fi o persoană sau o maşină de calcul. De altfel,
un algoritm poate fi descris cu ajutorul oricărui limbaj, de la limbajul natural şi până la
limbajul de asamblare al unui calculator. Denumim limbaj algoritmic un limbaj al cărui scop
este acela de a descrie algoritmi.
Algoritmul specifică succesiuni posibile de transformări ale datelor. Un tip de date poate
fi caracterizat printr-o mulţime de valori ce reprezintă domeniul tipului de date şi o mulţime
de operaţii definite peste acest domeniu. Tipurile de date pot fi organizate ı̂n următoarele
categorii:
1. tipuri de date elementare (de exemplu tipul ı̂ntreg, tipul real ) - valorile sunt unităţi
atomice de informaţie;
2. tipuri de date structurate (de exemplu tipul tablou, tipul ı̂nregistrare) - valorile sunt
structuri relativ simple rezultate ı̂n urma combinaţiei unor valori elementare;
3. tipuri de date structurate de nivel ı̂nalt (de exemplu stiva) - se pot descrie independent
de limbaj iar valorile au o structură mai complexă.
Un algoritm trebuie să posede următoarele trăsături caracteristice:
1. claritate - la fiecare pas trebuie să specifice operaţia pe care urmează să o efectueze
algoritmul asupra datelor de intrare;
2. corectitudine - rezultatele trebuie să fie corecte;
3
3. generalitate - algoritmul trebuie să ofere soluţia nu numai pentru o singură problemă
ci pentru o ı̂ntreagă clasă de probleme;
4. finitudine - algoritmul trebuie să se termine ı̂ntr-un timp finit;
5. eficienţă - un algoritm poate fi utilizat numai ı̂n situaţia ı̂n care resursele de calcul
necesare acestuia sunt ı̂n cantităţi rezonabile, şi nu depăşesc cu mult posibilităţile cal-
culatoarelor la un moment dat.
Un program reprezintă implementarea unui algoritm ı̂ntr-un limbaj de programare.
Studiul algoritmilor cuprinde mai multe aspecte:
• elaborare - activitatea de concepere a unui algoritm are şi un caracter creativ, din
această cauză nefiind posibilă deprinderea numai pe cale mecanică. Pentru a facilita
obţinerea unei soluţii la o problemă concretă se recomandă folosirea tehnicilor generale
de elaborare a algoritmilor la care se adaugă ı̂n mod hotărâtor intuiţia programatorului;
• exprimare - implementarea unui algoritm intr-un limbaj de programare se poate face

utilizând mai multe stiluri: programare structurată, programare orientată pe obiecte
etc.;
• validare - verificarea corectitudinii algoritmului prin metode formale;

• analiză - stabilirea unor criterii pentru evaluarea eficienţei unui algoritm pentru a-i
putea compara şi clasifica.
Un model de reprezentare al memoriei unei maşini de calcul este acela al unei structuri
liniare compusă din celule, fiecare celulă fiind identificată printr-o adresă şi putând păstra o
valoare corespunzătoare unui anumit tip de dată. Accesul la celule este facilitat de variabile.
O variabilă se caracterizează prin:
• un identificator - un nume ce referă variabila;
• o adresă - desemnează o locaţie de memorie;

• un tip de date - descrie tipul valorilor memorate ı̂n celula de memorie asociată.
1.1 Limbajul pseudocod

Limbajul natural nu permite o descriere suficient de riguroasă a algoritmilor, de aceea, pentru
reprezentarea acestora se folosesc alte modalităţi de descriere precum:
• scheme logice;
• limbajul pseudocod.
În continuare vom prezenta pricipalele construcţii din cadrul limbajului pseudocod.
Intrări/ieşiri
Citirea datelor de intrare se poate realiza prin intermediul enunţului Input:
1: Input {lista variabile}
Afişarea rezultatelor este reprezentată cu ajutorul instrucţiunii Output:
1: Output {lista de valori}
4
Instrucţiunea de atribuire
Este instrucţiunea cel mai des utilizată ı̂ntr-un algoritm şi realizează ı̂ncărcarea unei variabile
(locaţii de memorie) cu o anumită valoare. Are următoarea sintaxă:
1: < variabila >←< expresie >
unde < expresie > este o expresie aritmetică sau logică.
Se evaluează expresia < expresie > iar rezultatul se atribuie variabilei < variabila >,
memorându-se ı̂n locaţia de memorie asociată. Această variabilă trebuie să fie de acelaşi tip
de dată cu expresia sau un tip de dată care să includă şi tipul expresiei.
O expresie este constituită din operanzi şi operatori. Operanzii pot fi variabile şi valori
constante, iar operatorii pot fi:
• operatori aritmetici - + (adunare), − (scădere), ∗ (ı̂nmulţire), / (ı̂mpărţire), ˆ (ridicare
la putere), div (câtul ı̂mpărţirii ı̂ntregi), mod (restul ı̂mpărţirii ı̂ntregi);
• operatori relaţionali - = (egal), 6= (diferit), < (strict mai mic), ≤ (mai mic sau egal),
> (strict mai mare), ≥ (mai mare sau egal);
• operatori logici - OR sau ∨ (disjuncţie), AND sau ∧ (conjuncţie), NOT sau ¬ (negaţie).
Cea mai simplă expresie este formată dintr-o variabilă sau o constantă (operand). Ex-
presiile mai complicate se obţin din operaţii efectuate ı̂ntre variabile şi constante. La scrierea
expresiilor trebuie să se ţină cont de faptul că, ı̂n momentul evaluării lor, ı̂n primul rând
se vor evalua expresiile din paranteze, iar operaţiile se execută ı̂n ordinea determinată de
priorităţile lor.
Enunţuri de ramificare
1: if <expresie-booleana> then
2: <instructiune1> 1: if (a mod 2 = 0) then
[ 2: Output {”Numarul este par”}
3: else 3: else
4: <instructiune2> 4: Output {”Numarul este impar”}
] 5: end if
5: end if
Enunţul if . . . then . . . else evaluează mai ı̂ntâi expresia booleană pentru a determina
unul din cele două drumuri pe care le poate lua execuţia algoritmului. Ea poate include
opţional o clauză else.
Dacă <expresie-booleana> se evaluează la valoarea de adevăr true, atunci se execută
<instructiune1> şi se continuă cu următoarea instrucţiune după if. Dacă <expresie-booleana>
are valoarea de adevăr false, atunci se execută <instructiune2>. <instructiune1> şi
<instructiune2> sunt instrucţiuni compuse ce pot să conţină, la rândul lor, o altă instrucţiune
if.
Exemplul 1.1 Un algoritm simplu este cel ce rezolvă ecuaţia de gradul I, ax+b = 0, a, b ∈ R
(algoritmul 1). Acesta se bazează pe rezolvarea matematică a ecuaţiei de gradul I:
1. dacă a = 0, atunci ecuaţia devine 0 · x + b = 0. Pentru cazul ı̂n care b 6= 0 avem
0 · x + b = 0, egalitate ce nu poate fi satisfăcută pentru nicio valoare a lui x ∈ R sau
C. Spunem, ı̂n acest caz, că ecuaţia este incompatibilă. Dacă b = 0, avem 0 · x + 0 =
0, relaţia fiind adevărată pentru orice valoare a lui x ∈ R. Spunem că ecuaţia este
compatibil nedeterminată.
5
2. dacă a 6= 0, ecuaţia are o singură soluţie, x1 = − ab ∈ R.
Algoritm 1 Algoritm pentru rezolvarea ecuaţiei de gradul I

1: Input {a, b}
2: if (a = 0) then
3: if (b = 0) then
4: Output { ”Ecuatie compatibil nedeterminata” }
5: else
6: Output { ”Ecuatie incompatibila” }
7: end if
8: else
9: x ← − ab
10: Output { ”Solutia este:”, x }
11: end if
Având acest algoritm drept model să se realizeze un algoritm pentru rezolvarea ecuaţiei
generale de gradul al II-lea, ax2 + bx + c = 0, unde a, b, c ∈ R.
Enunţuri repetitive
Enunţurile repetitive permit descrierea unor prelucrări ce trebuie efectuate ı̂n mod repetat,
ı̂n funcţie de poziţia condiţiei de continuare existând două variante de structuri repetitive:
structura repetitivă condiţionată anterior şi structura repetitivă condiţionată posterior.
Structura repetitivă condiţionată anterior while (sau instrucţiune de ciclare cu test
iniţial) are următoarea sintaxă:
1: sum ← 0
2: i←1
1: while <expresie-booleana> do
3: while (i ≤ n) do
2: <instructiune>
4: sum ← sum + i
3: end while
5: i ← i+1
6: end while
Cât timp <expresie-booleana> este adevarată, se execută <instructiune>; dacă <expresie-
booleana> este falsă chiar la prima evaluare, atunci <instructiune> nu ajunge să fie realizată
niciodată. Acest comportament este opus celui corespunzător structurii repetitive condiţio-
nată posterior repeat, unde <instructiune> este executată cel puţin o dată. (Dacă o expresie
are valoarea de adevăr true spunem atunci că expresia este adevărată; dacă o expresie are
valoarea de adevăr false spunem atunci că expresia nu este adevărată - este falsă).
Exemplul 1.2 Vom realiza un algoritm pentru calculul câtului şi restului ı̂mpărţirii a două
numere ı̂ntregi, prin scăderi succesive (a se vedea algoritmul 2).
Mai ı̂ntâi, se iniţializează câtul cu valoarea zero (linia 3) şi restul cu valoarea deı̂mpărţi-
tului (linia 4). Apoi, atâta timp cât restul este mai mare decât valoarea ı̂mpărţitorului (liniile
5 - 8), vom incrementa câtul cu o unitate, şi decrementa restul cu valoarea ı̂mpărţitorului.
La final, sunt afişate valorile câtului şi restului.
Un caz particular de structură repetitivă condiţionată anterior este for, utilizată ı̂n cazul
ı̂n care o instrucţiune sau un grup de instrucţiuni trebuie să se repete de 0 sau mai multe
ori - numărul de repetiţii fiind cunoscut ı̂nainte de ı̂nceperea sa. Enunţurile repetitive bazate
6
Algoritm 2 Algoritm pentru calculul ı̂mpărţirii ı̂ntregi
1: Input {a, b}
2: if ((a > 0) ∧ (b > 0)) then
3: cat ← 0
4: rest ← a
5: while (rest ≥ b) do
6: rest ← rest − b
7: cat ← cat + 1
8: end while
9: Output {cat, rest}
10: else
11: Output {”Numerele trebuie sa fie strict pozitive!”}
12: end if
pe instrucţiunile while şi repeat sunt mult mai potrivite ı̂n cazul ı̂n care condiţia de ter-
minare trebuie reevaluată ı̂n timpul ciclării (atunci când numărul de repetiţii nu este cunoscut
apriori).
Instrucţiunea for are următoarea sintaxă:
1: for <Var> ← <Expresie1>, <Expresie2>, 1: sum ← 0
Step < p > do 2: for i ← 1, n do
2: <instructiune> 3: sum ← sum + i
3: end for 4: end for
Comportamentul enunţului repetitiv for se descrie cel mai bine prin comparaţie cu
enunţul repetitiv while. Astfel secvenţa următoare de limbaj pseudocod
1: for v ← e1 , e2 ST EP p do
2: < instructiune >
3: end for
este echivalentă cu secvenţa ce conţine enunţul repetitiv while:
1: v ← e1
2: while (v ≤ e2 ) do
3: <instructiune>
4: v ←v+p
5: end while
e1 reprezintă valoarea iniţială, e2 limita finală, iar p pasul de lucru: la fiecare pas, valoarea
variabilei v este incrementată cu valoarea variabilei p, valoarea ce poate fi atât pozitivă cât
şi negativă. Dacă p ≥ 0 atunci v va lua valori ı̂n ordine crescătoare, iar dacă p < 0 atunci v
va primi valori ı̂n ordine descrescătoare.
În cazul ı̂n care pasul de incrementare este 1, atunci el se poate omite din enunţul repetitiv
for, variabila contor fiind incrementată automat la fiecare repetiţie cu valoarea 1. Dacă pasul
de incrementare p are valoarea 1 atunci avem următoarele situaţii posibile pentru construcţia
for:
• Expresie1 > Expresie2: <instructiune> nu se execută niciodată;
• Expresie1 = Expresie2: <instructiune> se execută exact o dată;
• Expresie1 < Expresie2: <instructiune> se execută de Expresie2 − Expresie1 + 1 ori.
Exemplul 1.3 Un caz destul de frecvent ı̂ntâlnit ı̂n practică este cel ı̂n care se cere deter-
minarea elementului de valoare maximă, respectiv minimă dintr-un şir de elemente. Acest
7
şir de elemente poate fi păstrat ı̂ntr-o structură de date elementară, cunoscută sub numele
de vector. Un vector este un caz particular de matrice având o singură linie şi n coloane.
Prezentăm ı̂n continuare algoritmul pentru determinarea elementului de valoare minimă
ce aparţine unui şir de numere naturale (a se vedea algoritmul 3).
Algoritm 3 Algoritm pentru calculul elementului de valoare minimă dintr-un şir

1: Input {N, x1 , x2 , . . . , xN }
2: min ← x1
3: for i ← 2, N do
4: if (min > xi ) then
5: min ← xi
6: end if
7: end for
8: Output { min }
În acest algoritm se observă utilizarea enunţului repetitiv for, ı̂ntâlnit, ı̂n general, ı̂n
situaţiile ı̂n care se cunoaşte apriori numărul de paşi pe care trebuie să-l realizeze instrucţiunea
repetitivă.
Mai ı̂ntâi se iniţializează variabila min cu valoarea elementului x1 , presupunând că ele-
mentul de valoare minimă este primul element din cadrul vectorului X (linia 2). În continuare
vom compara valoarea variabilei min cu valoarea fiecărui element din şir (liniile 3–7): dacă
vom găsi un element a cărui valoare este mai mică decât cea a minimului calculat până la
momentul curent (linia 4), vom reţine noua valoare ı̂n variabila min (linia 5).
Structura repetitivă condiţionată posterior repeat . . . until prezintă următoarea sin-

taxă:
1: sum ← 0
2: i←1
1: repeat
3: repeat
2: <instructiune>
4: sum ← sum + i
3: until <expresie-booleana>
5: i ← i+1
6: until (i > n)
Atâta timp cât <expresie-booleana> este falsă, se execută <instructiune>. Se observă

faptul că instrucţiunile dintre repeat şi until se vor executa cel puţin o dată.
Exemplul 1.4 Algoritmul 4, prezentat ı̂n continuare, calculează suma primelor n numere
naturale, S = 1 + 2 + 3 + . . . + n.
Notăm cu Sn suma primelor n numere naturale (Sn = 1 + 2 + 3 + . . . + n). Aceasta se
poate calcula ı̂ntr-o manieră incrementală astfel:
S1 = 1
S2 = 1 + 2 = S1 + 2
S3 = (1 + 2) + 3 = S2 + 3
S4 = (1 + 2 + 3) + 4 = S3 + 4
...
Sn = (1 + 2 + . . . + n − 1) + n = Sn−1 + n
8
Algoritm 4 Algoritm pentru calculul sumei primelor n numere naturale (prima variantă)
1: Input {N }
2: S←0
3: i←1
4: repeat
5: S ←S+i
6: i←i+1
7: until (i > N )
8: Output {S}
Observaţia 1.5 1. Algoritmul 4 utilizează enunţul repetitiv cu test final, repeat . . .

until.
2. Enunţurile S ← 0 şi i ← 1 au rolul de a atribui valori iniţiale variabilelor S şi i.

Întotdeauna variabilele trebuie iniţializate corect din punctul de vedere al algoritmului
de calcul. Variabila ce reţine rezultatul unui proces de ı̂nsumări succesive se va iniţializa
ı̂ntotdeauna cu valoarea 0, valoare ce nu va influenţa rezultatul final. O variabilă ce
păstrează rezultatul unei operaţii (sumă sau produs) se va iniţializa cu elementul neutru
faţă de operaţia respectivă.
3. Atribuirile i = i + 1 şi S = S + i (liniile 5 şi 6) sunt lipsite de sens din punct de

vedere algebric. Însă, atunci când ne referim la un sistem de calcul electronic, aceste
operaţii se referă la valoarea curentă şi la cea anterioară a unei variabile. De aseme-
nea, trebuie să se facă o distincţie clară ı̂ntre operaţia de atribuire şi cea de egalitate:
operaţia de atribuire (’←’) face ca valoarea curentă a variabilei din stânga operatorului
de atribuire să fie iniţializată cu valoarea expresiei din dreapta acestuia (ı̂n expresia
’k ← i + 2’ variabila k primeşte valoarea rezultată ı̂n urma evaluării expresiei ’i + 2’),
pe când operaţia de egalitate verifică dacă valoarea elementului din stânga operatoru-
lui ’=’ (sau a expresiei aflate ı̂n partea stângă a operatorului) este egală cu valoarea
expresiei din dreapta acestuia (de exemplu rezultatul evaluării expresiei k = i + 2) are
valoarea de adevăr true dacă valoarea variabilei ’k’ este egală cu valoarea rezultată ı̂n
urma evaluării expresiei ’i + 2’ şi are valoarea de adevăr false ı̂n caz contrar).
Prin urmare, ı̂n cazul expresiei i ← i + 1, valoarea curentă a variabilei i devine valoarea
anterioară a aceleiaşi variabile incrementată cu o unitate.
Suma primelor n numere naturale se constituie ı̂n suma termenilor unei progresii arit-
metice ce se poate calcula direct cu formula sumei, astfel 1 + 2 + . . . + n = n(n+1)
2
. Având
ı̂n vedere această identitate, algoritmul de calcul a sumei primelor n numere naturale se
simplifică foarte mult (a se vedea algoritmul 5).
Algoritm 5 Algoritm pentru calculul sumei primelor n numere naturale (a doua variantă)
1: Input {N }
2: S ← n · (n + 1)/2
3: Output {S}
9
Proceduri şi funcţii
Procedurile sunt subrutine ale căror instrucţiuni se execută ori de câte ori acestea sunt apelate
prin numele lor.
Apelarea procedurilor se face ı̂n unitatea de program apelantă prin numele procedurii,
primit ı̂n momentul definirii, urmat de lista parametrilor actuali. Această listă trebuie să
corespundă ca număr şi tip cu lista parametrilor formali, ı̂n situaţia ı̂n care există o listă de
parametri formali ı̂n antetul subrutinei. Definiţia unei proceduri are următoarea sintaxă:
1: procedure <nume>(<lista parametri formali>)
2: <instructiune>
3: end procedure
lista parametri formali (opţională) simbolizează o listă de identificatori (parametri)
ce permite transferul datelor ı̂ntre subrutina apelantă şi subrutina apelată. Aceşti parametri
se specifică prin nume (identificator) urmat, eventual, de tipul de dată al parametrului. Mai
mulţi parametri de acelaşi tip pot fi grupaţi, folosindu-se drept separator virgula.
De fapt, lista parametrilor formali poate fi descrisă mai detaliat astfel:
1: procedure <nume>(<PFI; PFO>)
2: end procedure
unde
PFI = lista parametrilor formali de intrare.
PFO = lista parametrilor formali de ieşire.
Enunţul de apel al unei proceduri are următoarea sintaxă:
1: CALL <nume>(PAI; PAO)
PAI - lista parametrilor actuali de intrare, ce corespund parametrilor formali de intrare.
Corespondenţa se face de la stânga la dreapta şi trebuie să fie de acelaşi tip cu parametrii
formali.
PAO - lista parametrilor actuali de ieşire.
Exemplul 1.6 Să se realizeze un algoritm care determină cel mai mare divizor comun a
două numere naturale.
Reamintim câteva rezultate teoretice ce vor fi folositoare pentru ı̂nţelegerea procesului de
calcul al algoritmului ce va fi prezentat.
Teorema 1.7 (Teorema ı̂mpărţirii cu rest) Pentru două numere ı̂ntregi a şi b, cu b 6=
0, ∃ două numere ı̂ntregi q şi r, unice, astfel ı̂ncât:
a = b · q + r, 0 ≤ r < |b|
unde a se numeşte deı̂mpărţitul, b ı̂mpărţitorul, q câtul iar r restul.
Definiţia 1.2 Cel mai mare divizor comun (notat cmmdc) a două numere naturale a şi b
este un număr natural d cu proprietăţile:
1. d|a, d|b (d este un divizor comun al lui a şi b);
2. ∀d′ ∈ N astfel ı̂ncât d′ |a, d′ |b avem d′ |d (oricare alt divizor comun al lui a şi b, ı̂l divide
şi pe d).
Observaţia 1.8 1. cmmdc(a, 0) = a.
2. Dacă cmmdc(a, b) = 1 se spune că numerele a şi b sunt prime ı̂ntre ele.
10
3. Între cel mai mic multiplu comun şi cel mai mare divizor comun există următoarea
relaţie:
a·b
cmmmc(a, b) = . (1.1)
cmmdc(a, b)
Metoda de calcul pentru a obţine cel mai mare divizor comun a două numere a şi b prin
ı̂mpărţiri succesive, cunoscută sub numele de algoritmul lui Euclid, se poate descrie astfel:
Se ı̂mparte a la b şi se reţine restul r. Dacă r este nul atunci cel mai mare divizor comun
este b. În caz contrar, se ı̂mparte b la r şi se păstrează noul rest. Calculele se continuă,
folosindu-se ca deı̂mpărţit vechiul ı̂mpărţitor, iar, ca ı̂mpărţitor, ultimul rest obţinut, până
când restul obţinut devine nul.
Operaţiile anterioare pot fi transpuse prin intermediul următoarelor formule matematice:
a = bq1 + r1 0 ≤ r1 < b
b = r1 q2 + r2 0 ≤ r 2 < r1
r1 = r2 q3 + r3 0 ≤ r 3 < r2
...
rk = rk+1 qk+2 + rk+2 0 ≤ rk+2 < rk+1
...
rn−2 = rn−1 qn + rn 0 ≤ rn < rn−1
rn−1 = rn qn+1 + rn+1 0 ≤ rn+1 < rn
Aceste ı̂mpărţiri nu se constituie ı̂ntr-un proces infinit, deoarece secvenţa de numere natu-
rale r1 , r2 , . . . , rn+1 , . . . este strict descrescătoare (r1 > r2 > . . . > rn > . . .) şi mărginită
inferior de 0. Rezultă că ∃p ∈ N astfel ı̂ncât rp 6= 0, şi rp+1 = 0.
Algoritm 6 Algoritmul lui Euclid pentru calculul cmmdc a două numere

1: procedure cmmdc(x, y; b)
2: a←x
3: b←y
4: if (b = 0) then
5: b←a
6: else
7: r ← a mod b
8: while (r 6= 0) do ⊲ Procesul se ı̂ncheie atunci când r ia valoarea 0
9: a←b
10: b←r
11: r ← a mod b
12: end while
13: end if
14: end procedure
Dacă analizăm ı̂ntregul proces de calcul, se observă faptul că deı̂mpărţitul este ı̂mpărţitorul
de la etapa anterioară, iar ı̂mpărţitorul este restul de la etapa anterioară. De asemenea, tre-
buie menţionat că ı̂n acest proces de calcul, câtul nu participă ı̂n mod activ.
Algoritmul 6 este un foarte bun exemplu de utilizare a instrucţiunii de ciclare cu test
iniţial, while. Din analiza algoritmului reiese faptul că, mai ı̂ntâi, se efectuează o evaluare a
restului r (calculul său, liniile 7 şi 11), după care se testează condiţia egalităţii acestuia cu
valoarea 0 (linia 8).
11
Funcţiile au aceeaşi sintaxă ca şi procedurile:
1: function <nume>(<parametri>)
2: <instructiune>
3: end function
Funcţiile pot fi apelate prin numele lor, ca termen al unei expresii.
1.2 Exemple
Exemplul 1.9 Să se verifice printr-un algoritm dacă un număr natural este prim sau nu.
Definiţia 1.3 Un număr natural k ≥ 2 se numeşte prim dacă singurii săi divizori naturali
sunt 1 şi k.
Pe baza acestei definiţii se poate concluziona că un număr natural k este prim dacă nu are
niciun divizor propriu ı̂n intervalul [2, k − 1].
Algoritm 7 Algoritm pentru verificarea dacă un număr este prim

1: Input {N }
2: if (n < 2) then
3: Output {”Numarul nu este prim.”}
4: else
5: i←2
6: prim ← true
7: while ((i ≤ n − 1) ∧ (prim = true)) do
8: if (n mod i = 0) then
9: prim ← f alse
10: else
11: i ← i+1
12: end if
13: end while
14: if (prim = true) then
15: Output {”Numarul este prim.”}
16: else
18: end if
19: end if
Dacă n este număr prim, corpul enunţului de ciclare while se va executa de n − 2 ori (a
se vedea algoritmul 7).
Condiţia i ≤ n − 1 poate fi ı̂mbunătăţită cu i ≤ n/2, deoarece ı̂ntre jumătatea numărului
şi n nu mai există niciun alt divizor, pentru orice valoare a lui n.
Dacă 2 este un divizor al numărului n atunci şi n/2 este un divizor al lui n. Dacă 2 nu
este divizor al lui n atunci nici n/2 nu este divizor al lui n. Un enunţ asemănător este valabil
12
şi pentru numerele 3, 4, 5, . . .. Astfel se formează două şiruri:
corespunde n
2 →
2
corespunde n
3 →
3
corespunde n
4 →
4
.. ..
. .
corespunde n
k
|{z} →
k
|{z}
Sir1 Sir2
Se observă faptul că primul şir (Sir1 ) este compus din elemente cu valori consecutive,
iar al doilea şir (Sir2 ) nu respectă această proprietate. Numerele dintr-o pereche (p, np ) sunt
legate ı̂ntre ele astfel: ı̂n momentul ı̂n care am verificat faptul că numărul p nu este divizor
al lui n, implicit am dedus că nici n/p nu este un divizor al lui n. Prin urmare nu mai este
nevoie să verificăm şi valoarea n/p. Primul şir este strict crescător iar cel de-al doilea este
strict descrescător. Elementele din primul
√ şir devin mai mari decât cele din al doilea atunci
când k ≅ n/k√ ⇒ k 2 ≅ n ⇒ k ≅ n. Astfel rezultă condiţia pentru limita superioară a
ciclării: i ≤ ⌊ n⌋ (a se vedea algoritmul 8).
Algoritm 8 Algoritm pentru verificarea dacă un număr este prim (variantă optimizată)
1: Input {N }
2: if (n < 2) then
4: else
5: i←2
6: prim ← true
√
7: while ((i ≤ ⌊ n⌋) ∧ (prim = true)) do
8: if (n mod i = 0) then
9: prim ← f alse
10: else
11: i ← i+1
12: end if
13: end while
14: if (prim = true) then
15: Output {”Numarul este prim.”}
16: else
17: Output {”Numarul nu este prim.’}
18: end if
19: end if
Exemplul 1.10 Se spune că un vector este simetric dacă primul element este egal cu ultimul,
al doilea cu penultimul etc. Algoritmul următor verifică dacă un vector de numere ı̂ntregi este
simetric.
Vom utiliza două variabile de indici, ce pornesc, una din stânga, şi cealaltă din dreapta.
Atâta timp cât variabila din stânga este mai mică decât variabila din dreapta iar elementele
din vector corespunzătoare variabilelor de indiciere sunt egale, se incrementează variabila din
stânga şi se decrementează variabila din dreapta. După părăsirea instrucţiunii de ciclare, se
13
face o verificare pentru determinarea condiţiei care nu a mai fost ı̂ndeplinită şi a condus la
ieşirea din buclă. Dacă i ≥ j atunci condiţia (i < j) nu a mai fost ı̂ndeplinită. Acest lucru
conduce la concluzia că cealaltă condiţie, (xi = xj ) a fost ı̂ndeplinită tot timpul (∀i < j, i, j =
1, n). Deci şirul este simetric ı̂n această situaţie.
Algoritm 9 Algoritm pentru verificarea simetriei unui vector

1: Input {N, x1 , x2 , . . . , xN }
2: i ← 1, j ← N
3: while ((i < j) ∧ (xi = xj )) do
4: i←i+1
5: j ← j −1
6: end while
7: if (i ≥ j) then
8: Output {”Vectorul este simetric.”}
9: else
10: Output {”Vectorul nu este simetric.”}
11: end if
Exemplul 1.11 Se dă un număr format din n cifre. Vom prezenta un algoritm ı̂n care se
determină cel mai mare număr obţinut prin eliminarea a k cifre (k < n) dintre cele n (vezi
algoritmul 10).
Compararea a două numere naturale ce prezintă acelaşi număr de cifre se face ı̂ncepând
de la stânga spre dreapta (de la cifrele mai semnificative către cele mai puţin semnificative).
Fie A = a1 a2 . . . an numărul nostru.Vom nota prin m numărul de cifre ce vor rămâne din
numărul iniţial după eliminarea celor k cifre (m = n−k). Problema se reduce la determinarea
celui mai mare număr format cu m cifre dintre cele n cifre iniţiale.
La ı̂nceput numărul conţine n cifre, păstrate ı̂n ordine, ı̂n vectorul A: a1 , a2 , . . . , an .
Soluţia se construieşte ı̂n mod iterativ, la pasul i alegându–se o valoare corespunzătoare: se
determină prima cifră de valoare maximă şi poziţia acesteia ı̂n cadrul subsecvenţei de limite
l şi n − m + i, al , . . . , an−m+i .
• În instrucţiunea for (linia 4) pentru fiecare poziţie liberă din numărul rezultat, se va
alege cifra maximă dintre cele disponibile;
• linia 5 - se trece la poziţia următoare: l reprezintă indexul din şirul A al cifrei aleasă
la pasul anterior (i − 1) şi conţine poziţia pe care a fost găsită cifra maximă. Cifra
maximă pentru pasul curent va fi căutată ı̂n intervalul l . . . n − m + i, unde n − m + i
reprezintă limita superioară a indexului până la care se poate alege un element la pasul
curent;
a1 . . . a ...a . . . an
| l {zn−m+i}
subsecvenţa pentru care se determină cifra maximă
• liniile 6, 7 - se iniţializează variabila de ciclare j cu l şi valoarea maximă cu 0; Deoarece

ai ≥ 0, ∀i = 1, n, se poate iniţializa variabila max (unde se va păstra valoarea maximă)
cu 0;
• linia 8 - se caută cifra maximă până la limita din dreapta n − m + i (dacă se merge mai
la dreapta dincolo de această limită nu se mai pot alege restul de m − i cifre);
• linia 10 - se actualizează valoarea maximă;
14
Algoritm 10 Algoritm pentru determinarea numărului maxim obţinut după eliminarea a k
cifre
1: Input {n, a1 , . . . , an , k}
2: m← n−k
3: l←0
4: for i ← 1, m do
5: l ←l+1
6: j←l
7: max ← 0
8: while (j ≤ n − m + i) do
9: if (max < aj ) then
10: max ← aj
11: l←j
12: end if
13: j ←j+1
14: end while
15: Output {max}
16: end for
• linia 11 - se actualizează poziţia valorii maxime.
Exemplul 1.12 Vom prezenta doi algoritmi ce determină toate tripletele de numere naturale
(a, b, c) ce verifică relaţia a2 + b2 = c2 unde c ≤ 100.
Prima variantă de lucru prezintă generarea tuturor tripletelor (i, j, k) unde 2 ≤ i < j <
k ≤ n. Dintre acestea se vor alege doar acelea ce verifică relaţia k · k = i · i + j · j. Dacă vom
considera doar instrucţiunea de ciclare 4, atunci condiţia 5 se va verifica de n − (j + 1) + 1 =
n − j ori. Deoarece j = i + 1, n − 1, vom obţine faptul că instrucţiunea 5 se va executa de:
n−i−1
X (n − i) · (n − i − 1)
(n − i − 1) + (n − i − 2) + . . . + (n − n + 1) = j=
j=1
2
ori.
Din i = 2, n − 2 rezultă că
n−2 n−i−1
X X n−2
X n−2
(n − i) · (n − i − 1) 1X 2
j = = (i + (1 − 2n)i + n2 − n)
i=2 j=1 i=2
2 2 i=2
n−2 n−2
1X 2 X
= [ i + (1 − 2n) i + (n2 − n) · (n − 3)]
2 i=2 i=2
15
1: Input {n} 1: Input {n}
2: for i ← 2, n − 2 do 2: for i ← 2, n − 1 do
3: for j ← i + 1, n − 1 do 3: for j ← i + 1, n do
4: for k ← j + 1, n do 4: s ← i·i+j ·j
√
5: if (k · k = i · i + j · j) then 5: k ← ⌊ s⌋
6: Output {i, j, k} 6: if ((k · k = s) ∧ (k ≤ n)) then
7: end if 7: Output {i, j, k}
8: end for 8: end if
11: return 11: return
Pentru cea de-a doua variantă, cea din dreapta, se generează perechile de numere (i, j) cu
proprietatea că 2 ≤ i < j ≤ n, se calculează
√ 2 s ← i · i + j · j şi se verifică dacă numărul
obţinut este pătrat perfect (linia 6: (⌊ s⌋) = s). Condiţia de la linia 6 se va executa de
n − (i + 1) + 1 = n − i ori.
Deoarece linia 2 se va executa de n − 1 − 2 + 1 = n − 2 ori, valoarea totală reprezentând
numărul de verificări (linia 6) va fi:
n−1
X n−1
X n−1
X n(n − 1)
(n − i) = (n − i) − (n − 1) = i − (n − 1) = −n+1
i=2 i=1 i=1
2
1.3 Elemente de analiza algoritmilor

Gradul de dificultate al unei probleme P poate fi pus in evidenţă prin timpul de execuţie al
algoritmului corespunzător şi/sau prin spaţiul de memorie necesar. Timpul de execuţie ı̂n
cazul cel mai defavorabil ne dă durata maximă de execuţie a unui algoritm. Timpul mediu
de execuţie se obţine prin ı̂nsumarea timpilor de execuţie pentru toate mulţimile de date de
intrare urmată de raportarea la numărul acestora.
Definiţia 1.4 Timpul de execuţie ı̂n cazul cel mai defavorabil al unui algoritm A este o
funcţie TA : N −→ N unde TA (n) reprezintă numărul maxim de instrucţiuni executate de
către A ı̂n cazul unor date de intrare de dimensiune n.
Definiţia 1.5 Timpul mediu de execuţie al unui algoritm A este o funcţie TAmed : N −→ N
unde TAmed (n) reprezintă numărul mediu de instrucţiuni executate de către A ı̂n cazul unor
date de intrare de dimensiune n.
Fiind dată o problemă P , o funcţie T (n) se spune că este o margine superioară dacă există
un algoritm A ce rezolvă problema P iar timpul de execuţie ı̂n cazul cel mai defavorabil al
algoritmului A este cel mult T (n).
Fiind dată o problemă P , o funcţie T (n) se spune că este o margine pentru cazul mediu
dacă există un algoritm A ce rezolvă problema P iar timpul mediu de execuţie al algoritmului
A este cel mult T (n).
Fiind dată o problemă P , o funcţie T (n) se spune că este o margine inferioară dacă orice
algoritm A ce rezolvă problema P va avea cel puţin un timp T (n) pentru unele date de intrare
de dimensiune n, atunci când n tinde la infinit (n → ∞).
Definiţia 1.6 Fiind dată o funcţie g : N −→ R vom nota cu O(g(n)) mulţimea:

O(g(n)) = {f (n)| ∃c > 0, n0 ≥ 0 a.ı̂. 0 ≤ f (n) ≤ c · g(n), ∀n ≥ n0 }.
16
Vom spune despre f că nu creşte ı̂n mod sigur mai repede decât funcţia g. Pentru a indica
faptul că o funcţie f (n) este un membru al mulţimii O(g(n)), vom scrie f (n) = O(g(n)), ı̂n
loc de f (n) ∈ O(g(n)).
Observaţia 1.13 Vom prezenta câteva proprietăţi ale lui O(·):
• O(f (n) + g(n)) = O(max {f (n), g(n)}).

De exemplu pentru funcţia f (n) = 7 · n5 − n2 + 3 · log n aplicând regula valorii maxime
vom avea: O(f (n)) = O(max {7 · n5 , n2 , 3 · log n}) adică O(f (n)) = O(n5 ).
• O(loga n) = O(logb n);
• f (n) = O(f (n)) (reflexivitate);
• f (n) = O(g(n)) şi g(n) = O(h(n)) atunci f (n) = O(h(n)) (tranzitivitate).
Definiţia 1.7 Fiind dată o funcţie g : N −→ R vom nota cu Θ(g(n)) mulţimea:

Θ(g(n)) = {f (n)| ∃c1 , c2 > 0, ∃n0 ≥ 0 a.ı̂. 0 ≤ c1 · g(n) ≤ f (n) ≤ c2 · g(n), ∀n ≥ n0 }.
Spunem că g(n) este o margine asimptotic tare pentru f (n).
Definiţia 1.8 Fiind dată o funcţie g : N −→ R vom nota cu Ω(g(n)) mulţimea:

Ω(g(n)) = {f (n)| ∃c > 0, n0 ≥ 0 a.ı̂. 0 ≤ c · g(n) ≤ f (n), ∀n ≥ n0 }.
La fel cum O furnizează o delimitare asimptotică superioară pentru o funcţie, Ω furnizează

o delimitare asimptotică inferioară pentru aceasta.
Teorema 1.14 Pentru orice două funcţii f (n) şi g(n), avem f (n) = Θ(g(n)) ⇐⇒ f (n) = O(g(n))
şi f (n) = Ω(g(n)).
Definiţia 1.9 Fiind dată o funcţie g : N −→ R vom nota cu o(g(n)) mulţimea:

o(g(n)) = {f (n)| ∀c > 0, ∃n0 > 0 a.ı̂. 0 ≤ f (n) < c · g(n), ∀n ≥ n0 }.
f (n)
Observaţia 1.15 f (n) = o(g(n)) ⇐⇒ limn→∞ g(n)
= 0.
Definiţia 1.10 f (n) ∈ ω(g(n)) ⇐⇒ g(n) ∈ o(f (n))

ω(g(n)) este o mulţime ce se defineşte astfel:
ω(g(n)) = {f (n)| ∀c > 0, ∃n0 > 0 a.ı̂. 0 ≤ c · g(n) < f (n), ∀n ≥ n0 }
Observaţia 1.16 1. f (n) = Θ(g(n)), g(n) = Θ(h(n)) =⇒ f (n) = Θ(h(n)) (tranzitivi-

tate);
2. f (n) = Θ(f (n)) (reflexivitate);
3. f (n) = Θ(g(n)) ⇐⇒ g(n) = Θ(f (n)) (simetrie).
Definiţia 1.11 O funcţie f are o creştere exponenţială dacă ∃c > 1 a.ı̂. f (x) = Ω(cx ) şi
∃d a.ı̂. f (x) = O(dx). O funcţie f este polinomială de gradul d dacă f (n) = Θ(nd ) şi
′
f (n) = O(nd ), ∀d′ ≥ d.
17
Teorema 1.17 
c ⇒ g(n) ∈ Θ(f (n)), c > 0
g(n) 
lim = 0 ⇒ g(n) ∈ o(f (n)) (1.2)
n→∞ f (n) 

∞ ⇒ f (n) ∈ o(g(n)).
Exemplul 1.18 • Pentru x ∈ R∗+ avem xn ∈ o(n!).

Deoarece
xn xn xn xn 1
< 4 4 ≤ 4 n/2
= 2n
= ( )n , (1.3)
n! x
| .{z
. . x} (x ) x x
⌈n/2⌉ori
rezultă că
xn
lim = 0. (1.4)
n→∞ n!
• log n ∈ o(n).
1
log x (log x)′ x ln 2
lim = lim = lim = 0.
x→∞ x x→∞ (x)′ x→∞ 1
• Pentru a, b > 1, a, b ∈ R∗ avem loga n ∈ Θ(logb n).
Calcularea cu exactitate a timpului de execuţie al unui program oarecare se poate dovedi

o activitate dificilă. De aceea, ı̂n practică se utilizează estimări ı̂ncercându-se eliminarea
constantelor şi simplificarea formulelor ce intervin ı̂n cadrul evaluării.
Dacă două părţi ale unui program, P1 şi P2 , au timpii de execuţie corespunzători T1 (n) şi
T2 (n), unde T1 (n) = O(f (n)) şi T2 (n) = O(g(n)), atunci programul P1 ⊕ P2 va avea timpul
de execuţie T1 (n) + T2 (n) = O(max(f (n), g(n))) (regula sumei ), unde ⊕ reprezintă operaţia
de concatenare.
Prin aplicarea acestei reguli, rezultă faptul că, timpul necesar execuţiei unui număr finit
de operaţii este, neluând ı̂n considerare constantele, caracterizat ı̂n principal de către timpul
de execuţie al operaţiei cele mai costisitoare.
Cea de-a doua regulă, regula produsului, spune că, fiind date două funţii f (n) şi g(n) astfel
ı̂ncât T1 (n) = O(f (n)) şi T2 (n) = O(g(n)), atunci avem T1 (n) · T2 (n) = O(f (n) · g(n)).
Pe baza regulilor produsului şi sumei putem face următoarele reduceri:
O(1) ⊆ O(log n) ⊆ O(n) ⊆ O(n log n) ⊆ O(n2 ) ⊆ O(n3) ⊆ O(2n )
Prezentăm ı̂n continuare câteva reguli generale pentru evaluarea complexităţii unui algoritm:
• timpul de execuţie al unei instrucţiuni de atribuire, citire sau afişare a unei variabile
este O(1).
• timpul de execuţie al unei secvenţe de instrucţiuni este proporţional cu timpul instrucţiunii

care durează cel mai mult.
• timpul de execuţie al unei instrucţiuni de decizie (if) este timpul executării instrucţiu-
nilor de pe ramura aleasă plus timpul necesar evaluării condiţiei.
• timpul de execuţie pentru o instrucţiune de ciclare este suma, după numărul de paşi
pe care ı̂i realizează instrucţiunea de ciclare, dintre timpul necesar executării corpului
instrucţiunii plus timpul necesar evaluării condiţiei.
1: for i ← 1, n do
18
2: A(i)
3: end for
Dacă instrucţiunii compuse A(i) ı̂i corespunde un timp de execuţie constant t, ce nu

depinde de i, atunci timpul corespunzător ı̂ntregii instrucţiuni de ciclare for anterioare
este: n n
X X
t=t 1 = t · n = O(n) (1.5)
i=1 i=1
În cazul general, timpul de execuţie al instrucţiunii compuse A(i) depinde

P de pasul i,
notat cu ti . Astfel timpul total corespunzător instrucţiunii for este ni=1 ti .
• Instrucţiunile de ciclare al căror număr de paşi depinde de ı̂ndeplinirea unei condiţii
(while) sau de neı̂ndeplinirea acesteia (repeat . . . until), sunt mult mai dificil de
analizat deoarece nu există o metodă generală de a afla cu exactitate numărul de repetări
al corpului instrucţiunii. De exemplu, pentru fragmentul următor
1: i ← l
2: while (ai < x) do
3: ... ⊲ calcule ce pot modifica, direct sau indirect, valoarea lui ai
4: i←i+1
5: end while
nu se poate preciza de câte ori se va ajunge la realizarea instrucţiunii de incrementare

din interiorul instrucţiunii while. În marea majoritate a cazurilor se utilizează elemente
de teoria probabilităţilor ı̂n vederea obţinerii unei estimări a numărului de repetări al
corpului instrucţiunii.
Exemplul 1.19 De exemplu

1: for i ← 1, n do
2: instructiune1
3: end for
are timpul de execuţie O(n).

1: for i ← 1, n do
2: for j ← 1, m do
3: instructiune2
4: end for
5: end for
Timpul de execuţie pentru secvenţa de cod ce conţine două instrucţiuni de ciclare imbricate
este O(n · m).
Exemplul 1.20 Să considerăm un alt exemplu: se dă un şir A cu Pin numere reale, şi se
1
doreşte calcularea elementelor unui şir B astfel ı̂ncât să avem bi = i · j=1 aj , pentru i = 1, n.
1: for i ← 1, n do
2: s←0
3: for j ← 1, i do
4: s ← s + aj
5: end for
6: bi ← si
7: end for
19
8: return
Dacă notăm cu o constantă cx , timpul necesar pentru efectuarea unei operaţii atomice,
vom obţine: costul efectuării liniei 1 este c1 · n, al liniei 2 este c2 · n, al liniei 3 este c3 · i, al
liniei 4 este c4 · i, al liniei 6 este c5 · n iar al liniei ?? este c6 .
n
X n
X n
X n
X
T (n) = c1 n + c2 n + c3 i + c4 i + c5 n + c6 = c1 n + c2 n + c3 i + c4 i + c5 n + c6
i=1 i=1 i=1 i=1
n(n + 1)
= (c3 + c4 ) + n(c1 + c2 + c5 ) + c6
2
1 1
= (c3 + c4 )n2 + (c3 + c4 )n + n(c1 + c2 + c5 ) + c6
2 2
1 1
= (c3 + c4 )n + [ (c3 + c4 ) + c1 + c2 + c5 ]n + c6 = n2 · p + n · q + c6 .
2
2 2
De obicei nu se efectuează o analiză atât de detaliată a algoritmului, dar se ı̂ncearcă o eva-
luare a blocurilor principale, cum ar fi instrucţiunile de ciclare, atribuindu-le direct valori
corespunzătoare complexităţii timp, atunci când este posibil:
T (n) = O(n2 ) + O(n) + O(1) = O(n2 ). (1.6)

Vom modifica algoritmul anterior astfel ı̂ncât să reducem numărul de calcule efectuate:
1: s←0
2: for i ← 1, n do
3: s ← s + ai
4: bi ← si
5: end for
6: return
Pentru această variantă de lucru, complexitatea timp este următoarea:
T (n) = O(1)(linia 1) + O(n)(liniile 2–4) + O(1)(linia 6) = O(n) (1.7)
În urma analizei de complexitate, putem concluziona faptul că cea de-a doua variantă a
algoritmului rulează ı̂ntr-un timp liniar.
1.3.1 Metoda substituţiei

Metoda substituţiei presupune mai ı̂ntâi ghicirea (estimarea) formei soluţiei pentru relaţia
de recurenţă şi apoi, demonstrarea prin inducţie matematică, a corectitudinii soluţiei alese.
Metoda poate fi aplicată ı̂n cazul unor ecuaţii pentru care forma soluţiei poate fi estimată.
Să considerăm următoarea relaţie de recurenţă:
(
1 , dacă n = 1
T (n) = n
(1.8)
2T ( 2 ) + n , ı̂n rest.
Vom presupune că soluţia acestei relaţii de recurenţă este T (n) = O(n log n) (notăm
log2 n = log n). Folosind metoda inducţiei matematice, vom ı̂ncerca să demonstrăm inegali-
tatea:
T (n) ≤ cn log n. (1.9)
n
Presupunem mai ı̂ntâi, că inecuaţia (1.9) are loc pentru ∀k < n, inclusiv pentru 2
, adică
T ( n2 ) ≤ c · n2 · log ( n2 ).
20
Vom demonstra că inecuaţia (1.9) este ı̂ndeplinită şi pentru n: T (n) = 2T ( n2 ) + n.
n n n
T (n) ≤ 2(c log ) + n = cn log + n
2 2 2
= cn log n − cn log 2 + n = cn log n − cn + n (1.10)
≤ cn log n.
Metoda inducţiei matematice presupune să arătăm că soluţia respectă şi cazurile particulare
(T (1) = 1). Pentru n = 1 vom avea T (1) = c · 1 · log 1 = 0 ceea ce contrazice relaţia T (1) = 1.
Această situaţie poate fi rezolvată dacă considerăm că T (n) = cn log n, ∀n ≥ n0 (n0 este
o constantă).
Din T (2) = 4 şi T (3) = 5 vom alege valoarea parametrului c astfel ı̂ncât să fie ı̂ndeplinite
inegalităţile T (2) ≤ 2c log 2 şi T (3) ≤ 3c log 3. Se observă că orice valoare a lui c ≥ 2 satisface
inegalităţile anterioare.
1.3.2 Schimbarea de variabilă

Această metodă presupune realizarea unei schimbări de variabilă ı̂n vederea simplificării
formulei sau pentru regăsirea unei formule
√ deja cunoscută.
Să considerăm ecuaţia T (n) = 2T ( n) + log n. Dacă ı̂nlocuim pe n cu 2m obţinem:
m m
T (2m ) = 2T (2 2 ) + log 2m = 2T (2 2 ) + m. (1.11)
Notăm cu S(m) = T (2m ) şi ı̂nlocuind ı̂n (1.11), obţinem o nouă relaţie de recurenţă:
m
S(m) = 2S( ) + m. (1.12)
2
Se observă că această relaţie are o formă similară cu cea din formula (1.8).
Soluţia relaţiei (1.12) este:
S(m) = O(m log m) ⇒ T (n) = T (2m ) = S(m) = O(m log m) = O(log n log log n). (1.13)
În final se obţine faptul că T (n) = O(log n log log n).
1.3.3 Metoda iterativă

Metoda iterativă este mult mai eficientă deoarece nu presupune ’ghicirea’ soluţiei, variantă ce
conduce deseori la rezultate greşite şi timp pierdut. De exemplu, să considerăm următoarea
formulă de recurenţă: (
1 , dacă n = 1
T (n) = (1.14)
T ( n2 ) + 1 , ı̂n rest.
Pentru rezolvarea acestei recurenţe vom substitui succesiv pe n cu n2 :
n
T (n) = T ( ) + 1
2
n
= T( ) + 2
4
n (1.15)
= T( ) + 3
8
...
n
= T ( k ) + k.
2
21
Prin urmare atunci când 1 = 2nk ⇒ k = log n, vom avea
T (n) = 1 + k = 1 + log n ⇒ T (n) = O(log n).
Să analizăm o altă formulă de recurenţă:
(
1 , dacă n = 1
T (n) = n
(1.16)
2T ( 2 ) + n , ı̂n rest.
n
Înlocuind succesiv pe n cu 2
vom obţine următoarea serie de identităţi:
n
T (n) = 2T ( ) + n
2
n n n
= 2(2T ( ) + ) + n = 4T ( ) + 2n
2 2 4
n n n (1.17)
= 4(2T ( ) + ) + 2n = 8T ( ) + 3n
8 4 8
...
n
= 2k T ( k ) + kn.
2
n
Deoarece substituţia se opreşte atunci când 2k
= 1, adică pentru k = log n, vom avea:
T (n) = 2k + kn = n + n log n = O(n log n). (1.18)
1.3.4 Teorema master

Metoda master pune la dispoziţie o variantă de rezolvare a unor recurenţe de forma
n
T (n) = aT ( ) + f (n), (1.19)
b
unde a ≥ 1, b > 1 sunt constante, iar f (n) este o funcţie asimptotic pozitivă. Formula de
recurenţă (1.19) descrie timpul de execuţie al unui algoritm ce presupune descompunerea unei
probleme de dimensiune n ı̂n a subprobleme, fiecare având dimensiunea datelor de intrare nb .
f (n) reprezintă costul asociat ı̂mpărţirii datelor de intrare cât şi costul combinării rezultatelor
celor a subprobleme.
Teorema 1.21 (Teorema master) [30] Fie a ≥ 1 şi b > 1 două constante, f (n) o funcţie
asimptotic pozitivă, şi T (n) definită de relaţia de recurenţă
n
T (n) = aT ( ) + f (n),
b
unde nb va fi ⌊ nb ⌋ sau ⌈ nb ⌉.
Atunci T (n) este mărginită asimptotic după cum urmează:
1. dacă f (n) = O(nlogb a−ǫ ) pentru o constantă ǫ > 0, atunci T (n) = Θ(nlogb a );
2. dacă f (n) = Θ(nlogb a logk n), atunci T (n) = Θ(nlogb a logk+1 n) (de obicei k = 0);
3. dacă f (n) = Ω(nlogb a+ǫ ) pentru o constantă ǫ > 0, şi dacă af ( nb ) ≤ cf (n) pentru o
constantă c < 1 şi oricare număr n suficient de mare, atunci T (n) = Θ(f (n)).
Corolarul 1.22 Pentru o funcţie f de tip polinomial unde f (n) = cnk avem:
22
1. dacă a > bk atunci T (n) = O(nlogb a );
2. dacă a = bk atunci T (n) = O(nk log n);
3. dacă a < bk atunci T (n) = O(nk ).
Cu alte cuvinte, dacă

n
T (n) ≤ aT ( ) + O(nk ),
b
atunci avem 
k k
O(n log n) , dacă a = b

T (n) = O(nk ) , dacă a < bk


O(nlogb a ) , dacă a > bk .
Exemplul 1.23 • Fie T (n) = 2T ( n2 )+n. Avem a = 2, b = 2, k = 1, f (n) = nk . Aplicând

corolarul pentru cazul a = bk , se obţine soluţia T (n) = O(nk log n) = O(n log n).
• Pentru T (n) = 9T ( n3 ) + n, avem a = 9, b = 3, k = 1. Aplicând corolarul pentru cazul

a > bk , se obţine soluţia T (n) = O(nlog3 9 ) = O(n2 ).
• Fie T (n) = 4T ( n2 ) + n3 . Avem a = 4, b = 2, k = 3, f (n) = n3 . Aplicând corolarul

pentru cazul a < bk , se obţine soluţia T (n) = O(n3 ).
• Fie T (n) = 2n T ( n2 ) + nn . Nu se poate aplica Teorema master deoarece a = 2n nu este

constant.
• Fie T (n) = 2T ( n2 ) + n log n. Atunci avem a = 2, b = 2, k = 1, f (n) = Θ(nlog2 2 logk n),

şi aplicând Teorema master, cazul al doilea, obţinem: T (n) = Θ(n log2 n).
• Fie T (n) = 12 T ( n2 ) + n1 . Nu se poate aplica Teorema master deoarece a = 12 < 1.

√ √
• Fie T (n) = 2T ( n2 ) + log n. Aplicând Teorema master pentru a = 2, b = 2, f (n) =
1 √
O(n 2 −ǫ ) obţinem: T (n) = Θ( n).
• Fie T (n) = 3T ( n4 ) + n log n. Aplicând Teorema master pentru a = 3, b = 4, f (n) =

Ω(nlog4 3+ǫ ) obţinem: T (n) = Θ(n log n).
• Fie T (n) = 16T ( n4 ) − n log n. Nu se poate aplica Teorema master deoarece f (n) =
−n log n nu este o funcţie asimptotic pozitivă.
Exemplul 1.24 Analiza acţiunilor

Deschiderea unei acţiuni la o anumită dată calendaristică reprezintă numărul maxim de
zile consecutive (până la acea dată) ı̂n care preţul acţiunii a fost mai mic sau egal cu preţul
din ziua respectivă. Fie pk preţul unei acţiuni ı̂n ziua k iar dk deschiderea calculată ı̂n aceeaşi
zi.
În continuare se prezintă un exemplu de calcul al deschiderii unei acţiuni pentru un număr
de 7 zile:
p0 p1 p2 p3 p4 p5 p6
9 6 3 4 2 5 7
d0 d1 d2 d3 d4 d5 d6
1 1 1 2 1 4 6
23
Algoritm 11 Algoritm de calcul al deschiderii unei acţiuni (prima variantă)
1: procedure ComputeSpan1(p, n; d)
2: for k ← 0, n − 1 do
3: j←1
4: while ((j < k) ∧ (pk−j ≤ pk )) do
5: j ←j+1
6: end while
7: dk ← j
8: end for
9: return
10: end procedure
Algoritmul 11 calculează deschiderea unei acţiuni pentru un interval mai lung de timp pe
baza evoluţiei preţurilor acesteia. Timpul de execuţie al acestui algoritm este O(n2 ).
Vom prezenta un alt mod de calcul al deschiderii unei acţiuni folosind o stivă (a se vedea
algoritmul 12).
Stiva este o structură de date de tip container deoarece ea depozitează elemente de un
anumit tip. Pentru a putea să operăm asupra unei colecţii de elemente păstrate ı̂ntr-o stivă,
se definesc următoarele operaţii, ı̂n afară de operaţiile fundamentale push şi pop:
• push(x:object) – adaugă obiectul x ı̂n vârful stivei.
• pop():object – elimină şi ı̂ntoarce obiectul din vârful stivei; dacă stiva este goală
avem o situaţie ce generează o excepţie.
• peek():object – ı̂ntoarce valoarea obiectului din vârful stivei fără a-l extrage.
• size():integer – ı̂ntoarce numărul de obiecte din stivă.
• isEmpty():boolean – ı̂ntoarce true dacă stiva nu conţine nici un obiect.
• isFull(): boolean – ı̂ntoarce true dacă stiva este plină.
• init(capacitate:integer) – iniţializează stiva.
Timpul de execuţie al noului algoritm este O(n).
1.4 Exerciţii
1. (a) Să se determine dacă un număr natural este simetric sau nu.
(b) Să se determine toate cifrele distincte dintr-un număr natural.
(c) Să se determine reprezentarea ı̂n baza 2 a unui număr natural.
(d) Să se determine forma corespunzătoare ı̂n baza 10 a unui număr reprezentat ı̂n
baza 2.
(e) Să se elimine dintr–un număr natural toate cifrele de forma 3k + 1 şi să se afişeze
numărul rezultat.
(f) Pentru un număr natural dat să se construiască din cifrele acestuia cel mai mare
număr prin amplasarea mai ı̂ntâi a cifrelor impare şi apoi a cifrelor pare.
24
Algoritm 12 Algoritm de calcul al deschiderii unei acţiuni (a doua variantă)
1: procedure ComputeSpan2(p, n; d)
2: call init(S)
3: for k ← 0, n − 1 do
4: ind ← 1
5: while (isEmpty(S) = f alse) ∧ (ind = 1) do
6: if (pk ≥ ppeek(S)) then
7: call pop(S)
8: else
9: ind ← 0
10: end if
11: end while
12: if (ind = 1) then
13: h ← −1
14: else
15: h ← peek(S)
16: end if
17: dk ← k − h
18: call push(S, k)
19: end for
20: return
21: end procedure
2. (a) Să se determine toţi divizorii unui număr natural.

(b) Să se verifice dacă două numere naturale sunt prime ı̂ntre ele.
(c) Să se determine toţi divizorii comuni a două numere naturale.
(d) Să se calculeze toate numerele prime mai mici decât o valoare specificată.
(e) Să se descompună ı̂n factori primi un număr natural.
(f) Să se determine cel mai mare divizor comun a două numere naturale folosindu–se
descompunerea ı̂n factori primi.
3. Să se determine toate numerele naturale n (1 ≤ n ≤ 106 ) cu proprietatea că atât n cât
şi oglinditul său sunt numere prime.
4. Pentru o secvenţă de numere naturale de lungime n, să se realizeze un algoritm care să
determine cea mai lungă subsecvenţă de elemente consecutive având aceeaşi valoare.
5. Să se realizeze un algoritm care să determine primele n numere prime, pentru un număr
natural n dat.
6. Să se realizeze un algoritm pentru calcularea tuturor soluţiilor ecuaţiei:
3x + y + 4xz = 100, x, y, z ∈ N. (1.20)
Indicaţie Pentru o valoare z ≥ 25 şi x 6= 0 (x > 0) avem:
3x + y + 4xz ≥ 3x + 4xz ≥ 3 + 4z > 100.
Astfel pentru z obţinem că 0 ≤ z ≤ 24.
25
Ecuaţia 1.20 se poate scrie astfel:
100 − y
3x + y + 4xz = 100 ⇔ x(3 + 4z) = 100 − y ⇔ x = (1.21)
3 + 4z
100−y
100−y 100−y
Dacă x 6= 0 şi y ≥ 0 ⇒ x = 3+4z
≥ 3+4z
⇒ x ∈ [1, 3+4z
].
Astfel, pentru fiecare pereche de numere (z, x) vom calcula pe y astfel: y = 100 − 3x −
4xz.
De asemenea, ı̂n 1.21 dacă luăm x = 0 obţinem mulţimea de soluţii (0, 100, z), ∀z ∈ N.
7. Să se evalueze complexitatea algoritmului 13, ce realizează descompunerea ı̂n factori

primi a unui număr natural.
Algoritm 13 Algoritm pentru descompunerea ı̂n factori primi a unui număr natural
1: Input {n}
2: j←2
3: while (j ≤ n) do
4: if (n mod j = 0) then
5: k←0
6: while (n mod j = 0) do
7: k ←k+1
8: n ← n div j
9: end while
10: Output {j k }
11: end if
12: j ← j +1
13: end while
8. Pentru fiecare dintre următoarele relaţii de recurenţă calculaţi complexitatea timp:
(a) T (n) = 2T ( n2 ) + n
log n
;
(b) T (n) = 16T ( n4 ) + n!;
√
(c) T (n) = 3T ( n3 ) + n;
(d) T (n) = 3T ( n3 ) + n2 .
9. Să se calculeze timpul mediu de lucru T (n) al algoritmului 14.
Algoritm 14 Algoritm Calcul5

1: for i ← 1, n do
2: j←n
3: while (j ≥ 1) do
4: ...
5: j ← ⌊ 2j ⌋
6: end while
7: end for
10. Să se calculeze timpul mediu de lucru T (n) al algoritmului 15.
26
Algoritm 15 Algoritm Calcul6
1: i ← n
2: while (i ≥ 1) do
3: j←i
4: while (j ≤ n) do
5: ...
6: j ←j·2
7: end while
8: i ← ⌊ 2i ⌋
9: end while
11. Să se rezolve următoarele ecuaţii recurente:
• T (n) = 2 · T ( n2 ) + n lg n, n = 2k ;
• T (n) = 3 · T ( n2 ) + c · n, n = 2k > 1.
12. Să se rezolve ecuaţia recurentă T (n) = n · T 2 ( n2 ), n = 2k , T (1) = 6.
13. Să se arate că ex = 1 + x + Ω(x2 ) unde x → ∞.
14. Să se determine primele n elemente ale şirurilor ak şi bk date prin următoarele relaţii
de recurenţă:
5ak + 3 ak + 3
ak+1 = , bk = , k ≥ 0, a0 = 1. (1.22)
ak + 3 ak + 1
15. Să se verifice dacă următoarele afirmaţii sunt adevărate:
(a) n2 ∈ O(n3 );
(b) n3 ∈ O(n2 );
(c) 2n+1 ∈ O(2n );
(d) (n + 1)! ∈ O(n!);
(e) ∀f : N −→ R∗ , f ∈ O(n) ⇒ f 2 ∈ O(n2 );
(f) ∀f : N −→ R∗ , f ∈ O(n) ⇒ 2f ∈ O(2n ).
27
Capitolul 2
Grafuri. Grafuri neorientate
2.1 Noţiuni de bază

Fie V o mulţime finită şi nevidă având n elemente (V = {x1 , x2 , . . . , xn }). Fie E o mulţime
finită astfel ı̂ncât E ⊆ V × V (unde V × V este produsul cartezian al mulţimii V cu ea ı̂nsăşi)
şi E = {(x, y)|x, y ∈ V } (E este mulţimea perechilor (x, y) cu proprietatea că x şi y aparţin
mulţimii V ).
Definiţia 2.1 Se numeşte graf o pereche ordonată G = (V, E).

Elementele xi ∈ V se numesc noduri sau vârfuri. Elementele mulţimii E sunt arce
sau muchii. O muchie (xk , xl ) ∈ E se mai notează şi cu [xk , xl ].
|V | se numeşte ordinul grafului G şi reprezintă numărul vârfurilor acestuia, iar |E| se
numeşte dimensiunea grafului G şi reprezintă numărul muchiilor/ arcelor grafului G.
Graful Φ = (∅, ∅) se numeşte graful vid.
Dacă ı̂ntr-o pereche [xk , xl ] nu ţinem cont de ordine atunci graful este neorientat iar
perechea reprezintă o muchie ([xk , xl ] = [xl , xk ]). Dacă se introduce un sens fiecărei muchii
atunci aceasta devine arc iar graful se numeşte orientat ([xk , xl ] 6= [xl , xk ]). Muchiile ce au
aceleaşi vârfuri se spune că sunt paralele. O muchie de forma [u, u] se numeşte buclă.
Un graf G se numeşte simplu dacă oricare două vârfuri ale sale sunt extremităţi pentru
cel mult o muchie. Un graf este finit dacă mulţimile V şi E sunt finite.
În continuare vom considera un graf neorientat, simplu şi finit. Dacă [x, y] ∈ E vom
spune că x şi y sunt adiacente, iar muchia [x, y] este incidentă cu vârfurile x şi y. x şi y se
Fig. 2.1: a) Un exemplu de graf neorientat cu 6 vârfuri b) Graful complet K5
28
mai numesc capetele muchiei. Două muchii sunt adiacente dacă au un vârf comun. Un graf
este trivial dacă are un singur vârf. Dacă E = ∅ atunci graful G = (V, E) se numeşte graf
nul.
Observaţia 2.1 Un graf neorientat, simplu, finit poate fi utilizat drept model de reprezentare
al unei relaţii simetrice peste o mulţime.
Definiţia 2.2 Se numeşte graf complet de ordinul n, şi se notează cu Kn , un graf cu pro-
prietatea că oricare două vârfuri distincte ale sale sunt adiacente (∀x ∈ V, y ∈ V, x 6= y ⇒
[x, y] ∈ E).
Exemplul 2.2 Să considerăm grafurile din figura 2.1.
a) G = (V, E), V = {1, 2, 3, 4, 5, 6}, E = {[1, 2], [1, 5], [2, 3], [2, 6], [3, 4], [4, 5], [5, 6]} (vezi
figura 2.1 a));
b) K5 este graful complet cu 5 vârfuri. Vârfurile 3 şi 5 sunt adiacente (vezi figura 2.1 b)).
Fig. 2.2: a) Un exemplu de graf neorientat cu 5 vârfuri. b) Subgraf al grafului din figura 2.1 b). c) Graf
parţial al grafului din figura 2.1 b).
Definiţia 2.3 Un graf parţial al unui graf dat G = (V, E) este un graf G1 = (V, E1 ) unde
E1 ⊆ E.
Definiţia 2.4 Un subgraf al unui graf G = (V, E) este un graf H = (V1 , E1 ) unde V1 ⊂ V
iar muchiile din E1 sunt toate muchiile din E care au ambele extremităţi ı̂n mulţimea V1
(E1 = E|V1 ×V1 = {[x, y]|[x, y] ∈ E, x, y ∈ V1 }).
Se spune că graful H este indus sau generat de submulţimea de vârfuri V1 şi se notează
H = G|V1 sau H = [V1 ]G .
Iată alte câteva notaţii des ı̂ntâlnite:
- G − V1 = subgraful ce se obţine din G prin eliminarea submulţimii de vârfuri V1 (V1 ⊆

V );
- G − x = subgraful G − {x};
- < E1 >G = graful parţial al lui G generat de E1 ;
29
- G − E1 =< E \ E1 >G ;
- G − e = G − {e}, graful parţial obţinut prin eliminarea unei muchii e.
Exemplul 2.3 Graful parţial din figura 2.2 c) se obţine din graful 2.1 b) prin ştergerea
muchiilor [2, 4], [2, 5], [3, 5], [4, 5]. Subgraful din figura 2.2 b) este indus de mulţimea V1 =
{1, 3, 4, 5} din graful complet K5 (H = K5 |V1 ).
Definiţia 2.5 Gradul unui vârf este egal cu numărul muchiilor incidente cu vârful x şi se
notează cu d(x) (d(x) = |{[x, u]|[x, u] ∈ E, u ∈ V }|). Un vârf cu gradul 0 (d(x) = 0) se
numeşte vârf izolat.
Notăm δ(G) = min{dG (u)|u ∈ G} şi ∆(G) = max{dG (u)|u ∈ G}.
Fig. 2.3: Graful lui Petersen
Exemplul 2.4 Graful lui Petersen din figura 2.3 este un exemplu de graf trivalent sau cubic
(toate vârfurile grafului au acelaşi grad, 3).
Propoziţia 2.5 Pentru un graf G = (V, E), V = {x1 , x2 , . . . , xn }, |E| = m, avem următoarea
relaţie:
Xn
d(xk ) = 2m. (2.1)
k=1
Astfel ı̂n orice graf G există un număr par de vârfuri al căror grad este un număr impar.
Definiţia 2.6 Se numeşte secvenţă grafică un şir de numere naturale d1 , d2 , . . . , dn cu

proprietatea că ele reprezintă gradele vârfurilor unui graf neorientat.
Corolarul 2.6 Pentru ca o secvenţă de numere naturale d1 , d2 , . . . , dn să fie secvenţă grafică,
este necesar ca:
1. ∀k = 1, n, dk ≤ n − 1;
Pn
2. k=1 dk este un număr par.
Definiţia 2.7 Un lanţ L = [v0 , v1 , . . . , vm ] este o succesiune de vârfuri cu proprietatea că

oricare două vârfuri vecine sunt adiacente ([vi , vi+1 ] ∈ E, ∀i = 0, m − 1). Vârfurile v0 şi vm
se numesc extremităţile lanţului, iar m reprezintă lungimea lanţului.
30
Dacă vârfurile v0 , v1 , . . . , vm sunt distincte două câte două, lanţul se numeşte elementar
(vi 6= vj , ∀i, j = 0, m).
Definiţia 2.8 Un lanţ L pentru care v0 = vm se numeşte ciclu.
Definiţia 2.9 Se numeşte ciclu hamiltonian un ciclu elementar ce trece prin toate vârfurile
grafului. Un graf ce admite un ciclu hamiltonian se numeşte graf Hamilton sau graf
hamiltonian.
Definiţia 2.10 Un lanţ L ce conţine fiecare muchie exact o singură dată se numeşte lanţ
eulerian. Dacă v0 = vm şi lanţul este eulerian atunci ciclul se numeşte ciclu eulerian.
Un graf ce conţine un ciclu eulerian se numeşte graf eulerian.
Exemplul 2.7 [1, 2, 3, 1, 4] este un exemplu de lanţ ı̂n graful din figura 2.2 c). Vârfurile 1
şi 4 sunt extremităţile lanţului. Lanţul nu este elementar deoarece vârful 1 se ı̂ntâlneşte de
două ori, ı̂n schimb [1, 2, 3, 4, 1] este un ciclu elementar.
[3, 4, 5, 1, 2, 3] este un ciclu hamiltonian ı̂n graful din figura 2.2 a). [4, 5, 1, 2, 4, 3] este un
lanţ eulerian, precum şi [2, 4, 3, 2, 1, 5, 4]. În acest graf nu există nici un ciclu eulerian.
Fig. 2.4: Componente conexe
Definiţia 2.11 Un graf se numeşte conex dacă pentru orice pereche de vârfuri x şi y există
un lanţ de la x la y (∀x, y ∈ V, ∃x y).
Se numeşte componentă conexă un subgraf conex maximal, adică un subgraf conex ı̂n
care nici un vârf din subgraf nu este adiacent cu unul din afara lui prin intermediul unei
muchii aparţinând grafului iniţial.
Definiţia 2.12 O muchie e ∈ E se numeşte muchie critică dacă prin eliminarea acesteia
o componentă conexă se ı̂mparte ı̂n două componente conexe.
Exemplul 2.8 Graful din figura 2.4 are două componente conexe: {1, 2, 3, 4, 5, 6} şi {7, 8, 9}.
Muchia [2, 5] este muchie critică.
Definiţia 2.13 Un graf planar este un graf ce poate fi reprezentat ı̂n plan astfel ı̂ncât
muchiile sale să nu se intersecteze două câte două.
Definiţia 2.14 Un graf G = (V, E) se numeşte graf bipartit dacă există o partiţie a
mulţimii nodurilor {V1 , V2 } (V = V1 ∪V2 , V1 ∩V2 = ∅, V1 , V2 6= ∅) astfel ı̂ncât orice muchie din
E va avea o extremitate ı̂n mulţimea V1 şi cealaltă extremitate ı̂n mulţimea V2 (∀[x, y] ∈ E
avem x ∈ V1 şi y ∈ V2 ).
31
Propoziţia 2.9 Un graf este bipartit dacă şi numai dacă nu conţine cicluri de lungime
impară.
Definiţia 2.15 Un graf bipartit este complet dacă ∀x ∈ V1 , ∀y ∈ V2 , ∃[x, y] ∈ E (G =

(V, E), V = V1 ∪ V2 , V1 ∩ V2 = ∅). Dacă |V1 | = p, |V2 | = q atunci graful bipartit complet se
notează Kp,q .
Fig. 2.5: Un exemplu de graf bipartit şi graf bipartit complet.
Exemplul 2.10 În figura 2.5 a) este ilustrat un graf bipartit (V1 = {1, 2, 3}, V2 = {4, 5}),
iar ı̂n cazul b) avem un graf bipartit complet, K2,3 .
Definiţia 2.16 Se numeşte izomorfism de la graful G la graful G′ o funcţie bijectivă ϕ :

V (G) → V (G′ ) astfel ı̂ncât [u, v] ∈ E(G) ⇔ ϕ([u, v]) ∈ E(G′ ).
Dacă există un izomorfism de la graful G la graful G′ atunci se spune că G este izomorf
cu G′ şi notăm acest lucru astfel: G ≅ G′ .
Definiţia 2.17 Un graf etichetat este un graf ı̂n care fiecare muchie şi vârf poate avea
asociată o etichetă.
Vom prezenta ı̂n continuare câteva operaţii dintre cele mai ı̂ntâlnite ce se pot efectua
asupra unui graf oarecare:
• fiind dat un nod se cere lista vecinilor săi. Această operaţie este cea mai utilizată pentru
o serie ı̂ntreagă de algoritmi pe grafuri;
• fiind dată o pereche de noduri {u, v} se cere să se determine dacă aceasta constituie o
muchie sau un arc al grafului;
• adăugarea sau ştergerea unui nod sau a unei muchii/arc;
• translatarea dintr–un mod de reprezentare ı̂n altul. De foarte multe ori modul de
reprezentare sub forma căruia au fost introduse datele, diferă de modul de reprezentare
optim recomandat pentru un anumit algoritm. În această situaţie este indicată trans-
formarea primului mod de reprezentare ı̂n modul de reprezentare optim;
• fiind dată o muchie sau un nod se cere o informaţie asociată acestui element: de exemplu
lungimea muchiei sau distanţa de la sursă la nodul specificat.
32
2.2 Moduri de reprezentare
Fig. 2.6: Un exemplu de graf neorientat
Pentru o mulţime de noduri V vom presupune un mod de ordonare a nodurilor grafului

(primul nod, al doilea nod, etc.), deoarece reprezentarea unui graf depinde de această or-
donare. Astfel, numerotăm ı̂n mod arbitrar vârfurile grafului cu 1, 2, . . . , |V |.
1. Matricea de adiacenţă - este o matrice pătratică A ∈ Mn×n (N), n = |V |, unde ai,j = 1

dacă există o muchie ı̂ntre nodurile numerotate i şi j (ı̂ntre xi şi xj ), sau ai,j = 0 dacă
nu există o muchie ı̂ntre aceste noduri.
(
1 , dacă [xi , xj ] ∈ E
ai,j =
0 , dacă [xi , xj ] ∈
/ E.
Observaţia 2.11 Pentru un graf neorientat această matrice este simetrică (ai,j = aj,i).
Exemplul 2.12 Matricea de adiacenţă A corespunzătoare grafului din figura 2.6 este:
 
0 1 1 1 0 0 0 0
1 0 0 0 1 0 0 0
 
1 0 0 0 1 0 0 0
 
1 0 0 0 0 1 0 0
A=
0

 1 1 0 0 0 1 0

0 0 0 1 0 0 1 1
 
0 0 0 0 1 1 0 0
0 0 0 0 0 1 0 0
Matricea de adiacenţă are un număr de n2 elemente, iar elementele neredundante sunt

ı̂n număr de n(n−1)
2
. Prin urmare complexitatea-spaţiu a matricii de adiacenţă este
2
O(n ).
2. Matricea costurilor - reprezintă o variantă a matricei de adiacenţă ce se obţine ı̂n mod
natural luându-se ı̂n considerare graful ponderat: fiecărei muchii i se ataşează un cost
d (d ∈ R), iar valorile matricii C (C ∈ Mn×n (R)) se definesc astfel:

0
 , dacă xi = xj
ci,j = +∞ , dacă [xi , xj ] ∈
/E (2.2)


d > 0 , dacă [xi , xj ] ∈ E
33
Fig. 2.7: Un exemplu de graf neorientat ponderat
sau 
0
ci,j = −∞ , dacă [xi , xj ] ∈
/E (2.3)


d > 0 , dacă [xi , xj ] ∈ E.
Exemplul 2.13 Matricea costurilor corespunzătoare grafului din figura 2.7 are următoarele
valori:
 
0 35 7 20 ∞ ∞ ∞ ∞
35 0 ∞ ∞ 50 ∞ ∞ ∞
 
7 ∞ 0 ∞ 22 ∞ ∞ ∞
 
20 ∞ ∞ 0 ∞ 15 ∞ ∞
C=
∞

 50 22 ∞ 0 ∞ 44 ∞
∞ ∞ ∞ 15 ∞ 0 10 27
 
∞ ∞ ∞ ∞ 44 10 0 ∞
∞ ∞ ∞ ∞ ∞ 27 ∞ 0
Observaţia 2.14 Notaţia (2.2) este folosită ı̂n aplicaţii ı̂n care se operează cu drumuri
de lungime minimă iar notaţia (2.3) este folosită ı̂n aplicaţii ı̂n care se operează cu
drumuri de lungime maximă ı̂ntre două noduri.
Matricea costurilor va ocupa un spaţiu de memorie mai mare decât cel ocupat de
matricea de adiacenţă: pentru reprezentarea unui element al matricii de adiacenţă este
suficient un bit, pe când pentru reprezentarea unui element al matricii costurilor se
foloseşte un byte, un ı̂ntreg (lung) sau un număr real, ı̂n funcţie de valoarea maximă pe
care o poate lua d.
Observaţia 2.15 Matricea costurilor pentru un graf neorientat este simetrică.
Prin urmare pentru reprezentarea unei matrici de adiacenţă de dimensiuni n × n sunt

necesari n · ⌈ n8 ⌉ octeţi, pe când pentru reprezentarea unei matrici de costuri cu elemente
numere ı̂ntregi sunt necesari 2 · n2 octeţi, dacă presupunem că un număr ı̂ntreg fără
semn este păstrat pe 2 octeţi.
34
3. Liste de adiacenţă - pentru fiecare nod se reţine lista tuturor nodurilor sale adiacente.
Mai exact, unui nod xk se ataşează lista tuturor vecinilor săi.
Această reprezentare se pretează mai bine pentru grafuri cu un număr mare de noduri şi
un număr mic de muchii (graf rar ). În cazul unui graf neorientat, numărul elementelor
din listele de adiacenţă este 2 · |E|, deoarece o muchie [u, v] va fi prezentă de două ori,
atât ı̂n lista de adiacenţă a nodului u cât şi ı̂n lista de adiacenţă a nodului v.
Exemplul 2.16 Listele de adiacenţă pentru graful din figura 2.6 sunt:
1: (2, 3, 4) 5: (2, 3, 7)
2: (1, 5) 6: (4, 7, 8)
3: (1, 5) 7: (5, 6)
4: (1, 6) 8: (6)
Aceste liste de adiacenţă (sau liste de vecini) pot fi reprezentate, ca structuri de date,
prin intermediul tablourilor sau prin intermediul listelor simplu sau dublu ı̂nlănţuite.
Pentru reprezentarea ce utilizează tablouri, se vor defini două tablouri notate Cap şi
List (Cap ∈ M1×n (N), List ∈ M2×2m (N), n = |V |, m = |E|) unde:

0 , dacă nodul respectiv nu are vecini

Capk = j , unde j indică numărul coloanei din matricea List unde se află memorat


primul vecin al vârfului xk .
List1,j = indicele unui vârf ce se află ı̂n lista de vecini a vârfului xk .



 0 , dacă vârful respectiv este ultimul (această valoare are aceeaşi

 semnificaţie ca şi valoarea NIL sau NULL utilizată ı̂n lucrul cu pointeri)
List2,j =
i , unde i reprezintă numărul coloanei unde se află memorat următorul



nod (vecin) din lista de vecini a nodului xk .
Exemplul 2.17 Pentru exemplul din figura 2.6 avem următoarea configuraţie pentru
cei doi vectori consideraţi, Cap şi List:
Nod 1 2 3 4 5 6 7 8
Cap 1 4 6 8 10 13 16 18

2 3 4 1 5 1 5 1 6 2 3 7 4 7 8 5 6 6
List =
2 3 0 5 0 7 0 9 0 11 12 0 14 15 0 17 0 0
De exemplu, ı̂n limbajul C putem defini următoarele structuri de date, având rolul de a
ne ajuta la menţinerea ı̂n memorie a listelor de adiacenţă ale unui graf oarecare folosind
liste liniare simplu ı̂nlănţuite (a se vedea figura 2.8):
typedef struct nod {
int nodeIndex;
struct nod *next;
}NOD;
#define MAXN 100

NOD* vecini[MAXN];
35
1 2 3 4 NULL
2 1 5 NULL
3 1 5 NULL
4 1 6 NULL
5 2 3 7 NULL
6 4 7 8 NULL
7 5 6 NULL
8 6 NULL
Fig. 2.8: Liste de adiacenţă
NOD* vecini[MAXN] este un array (tablou) de pointeri; un element al tabloului vecini[k]

păstrează capul listei de vecini ai nodului de indice k.
struct nod *next reprezintă un pointer către următoarea ı̂nregistrare de tip NOD,
ı̂nregistrare ce conţine informaţii referitoare la următorul vecin.
nodeIndex păstrează indicele (eticheta) unui nod.
Cantitatea de memorie necesară pentru păstrarea listelor de adiacenţă se poate aproxi-
ma astfel:
• reprezentarea folosind matricile Cap şi List - putem presupune că n, m ≤ 65535
adică sunt suficienţi 2 octeţi pentru reprezentarea acestor numere ı̂n memorie
(216 − 1 = 65535). În această situaţie, cantitatea de memorie necesară pentru
matricea Cap este 2n octeţi, iar pentru matricea List este 8m octeţi. Astfel
complexitatea-spaţiu este O(n + m).
• reprezentarea folosind pointeri - presupunem că folosim 2 octeţi pentru informaţia
utilă şi 2 octeţi pentru informaţia de legătură. Numărul de octeţi folosiţi pentru
reprezentarea unui pointer ı̂n limbajul C poate depinde de modelul de memorie
ales (de exemplu small, huge etc.) sau de dimensiunea instrucţiunilor (pe 16, 32
sau 64 de biţi).
Să presupunem că se utilizează 2n octeţi pentru vectorul ce conţine adresele primu-
lui element (capul) al fiecărei liste de vecini, şi 8m octeţi pentru ı̂nregistrările
listelor de vecini.
Din această cantitate de memorie, 4m reprezintă informaţie utilă (indicii vecinilor),
iar 2n + 4m informaţie auxiliară (pointeri).
4. Lista de muchii - ı̂ntr-o structură de date se păstrează lista tuturor muchiilor grafului,
practic, pentru fiecare muchie fiind memorate valorile indicilor nodurilor-extremităţi
ale acesteia. Aceasta constituie cea mai simplă modalitate de reprezentare a unui graf.
Operaţia de adăugare a unui nod sau a unei muchii se realizează ı̂ntr-un timp constant,
alte operaţii fiind mai costisitoare: de exemplu, determinarea listei de vecini a unui nod
necesită un timp Ω(m).
Exemplul 2.18 Pentru păstrarea ı̂n memorie se poate folosi o matrice M cu două linii
şi |E| coloane (M ∈ M2×|E|(N)), unde:
M1,k - indicele vârfului ce reprezintă prima extremitate a muchiei k;
36
M2,k - indicele vârfului ce reprezintă cea de-a doua extremitate a muchiei k.

1 1 1 2 3 4 5 6 6
M=
2 3 4 5 5 6 7 7 8
Complexitatea timp pentru diverse operaţii efectuate asupra fiecăruia dintre structurile
de date utilizate de modurile de reprezentare amintite se poate sintetiza astfel:
Matricea de adiacenţă Liste de vecini Lista de muchii
Gradul unui nod xi O(n) O(d(xi )) O(m)
(xi , xj ) ∈ E? O(1) O(d(xi )) O(m)
Următorul vecin al lui xi O(n) O(d(xi )) O(m)
2.3 Parcurgerea grafurilor

Pentru un graf dat este important să se stabilească o modalitate sistematică de vizitare
a tuturor vârfurilor grafului, parcurgere ce se realizează ı̂n scopul prelucrării informaţiei
conţinute de către acestea.
2.3.1 Parcurgerea ı̂n lăţime (BFS-Breadth First Search)

Metoda de parcurgere ı̂n lăţime vizitează nodurile grafului ı̂n felul următor (a se vedea algo-
ritmul 16):
• se vizitează mai ı̂ntâi vârful de pornire (să ı̂l notăm k);
• urmează, ı̂n ordine, toţi vecinii ı̂ncă nevizitaţi ai nodului k;
• se continuă cu vecinii ı̂ncă nevizitaţi ai acestora, ş.a.m.d.
Fig. 2.9: Arbore de acoperire ı̂n lăţime
Pentru graful considerat ı̂n figura 2.6 ordinea de parcurgere este următoarea: 1, 2, 3, 4,
5, 6, 7, 8. Dacă considerăm muchiile folosite ı̂n timpul parcurgerilor (muchiile prin intermediul
cărora s-a ı̂naintat ı̂n graf) se obţine un arbore/pădure de parcurgere/vizitare/acoperire. În
figura 2.9 este reprezentat arborele de acoperire ı̂n lăţime rezultat ı̂n urma parcurgerii grafului
din exemplu.
Algoritmul de parcurgere utilizează o structură de date de tip coadă ı̂n care vor fi memo-
rate nodurile vizitate, dar care nu au fost ı̂ncă prelucrate (nu au fost cercetaţi vecinii lor).
37
Reamintim că numărul de noduri din mulţimea V este n. Vectorul vizitat păstrează situaţia
vizitării nodurilor
( grafului G, astfel:
1 , dacă nodul k a fost vizitat
vizitatk =
0 , dacă nodul k nu a fost vizitat.
Algoritm 16 Algoritm de vizitare ı̂n lăţime

1: procedure BFS(k, n, V ecin)

k
 - nodul de la care ı̂ncepe vizitarea
Input: n - numărul de noduri din graf


V ecin - matricea de adiacenţă a grafului
2: for i ← 1, n do
3: vizitati ← 0
4: end for
5: vizitatk ← 1 ⊲ marcarea nodului curent ca fiind vizitat
6: Q⇐k ⊲ inserarea nodului curent k ı̂n coadă
7: call V izitare(k) ⊲ vizitarea nodului curent
8: while (Q 6= ∅) do
9: Q⇒k ⊲ extragere nod curent din coadă
10: for i ← 1, n do
11: if ((vizitati = 0) ∧ (vecink,i = 1)) then
12: vizitati ← 1 ⊲ marcarea nodului i ca fiind vizitat
13: Q⇐i ⊲ inserarea nodului i ı̂n coadă
14: call V izitare(i) ⊲ vizitarea nodului i
15: end if
16: end for
17: end while
18: end procedure
Implementarea ı̂n limbajul C a algoritmului 16 este următoarea:

Listing 2.1: parcurgerebf.c
#include <stdio.h>
#include <mem.h>
#define MAXN 100

#define TRUE 1
#define FALSE 0
int n; // Numarul de noduri din graf

char vecin[MAXN][MAXN]; // Matricea de adiacenta
int coada[MAXN]; // Structura de date ce pastreaza elementele cozii
int first; // Indicele primului element din coada
int last; // Indicele ultimului element din coada
int vida; // Pastreaza starea cozii
/**
* Initializarea cozii circulare.
*/
void initQueue(void) {
38
vida = TRUE;
first = 0;
last = MAXN-1;
}
/**
* Intoarce pentru pozitia k, urmatoarea pozitie din coada.
*/
int next(int k) {
return (k + 1) % MAXN;
}
/**
* Insereaza elementul a carui valoare este pastrata in variabila v in coada.
*/
void enQueue(int v) {
last = next(last);
coada[last] = v;
if (vida)
vida = FALSE;
}
/**
* Extrage un element din coada.
*/
int deQueue(void) {
int v = coada[first];
first = next(first);
if (first == next(last))
vida = TRUE;
return v;
}
/**
* Parcurge in latime graful pornind de la nodul de start k.
*/
void bfs(int k) {
int i;
char vizitat[MAXN];
memset(vizitat, 0, sizeof(vizitat));
vizitat[k] = 1;
enQueue(k);
printf("%d ", k);
while (!vida) {
k = deQueue();
for (i = 0; i < n; i++)
if ((vizitat[i] == 0) && (vecin[k][i] == 1)) {
vizitat[i] = 1;
enQueue(i);
printf("%d ", i);
}
39
}
}
/**
* Se citesc numarul de noduri precum si matricea de adiacenta.
*/
void readInput(void) {
int i, j;
printf("n = "); scanf("%d",&n);

for (i = 0; i < n - 1; i++)
for (j = i + 1; j < n; j++) {
printf("a[%d,%d] = ", i, j);
scanf("%d", &vecin[i][j]);
vecin[j][i] = vecin[i][j];
}
}
void main(void) {
readInput();
initQueue();
bfs(0);
}
• În exemplul anterior, funcţia de citire readInput() este una foarte simplă: se citeşte
mai ı̂ntâi numărul de noduri al grafului, iar apoi, se citesc elementele matricei de
adiacenţă a grafului. Variabilele n şi vecin sunt declarate drept variabile globale.
Deoarece matricea vecin este simetrică, pentru a reduce numărul de citiri, se vor
solicita numai valorile aflate deasupra diagonalei principale:
int i, j;
printf("n = "); scanf("%d",&n);

for (i = 0; i < n - 1; i++)
for (j = i + 1; j < n; j++) {
printf("a[%d,%d] = ", i, j);
}
}
• Funcţia memset() este o funcţie de bibliotecă a cărei declaraţie poate fi găsită ı̂n header-
ele mem.h şi string.h la Borland C sau memory.h şi string.h la Visual C++ 2010 1.
Funcţia respectivă prezintă următoarea semnătură2
void *memset(void *dest, int c, size t count);
şi are rolul de a iniţializa cu valoarea c primii count octeţi din zona de memorie ce
ı̂ncepe de la adresa identificată de pointerul dest.
1
http://msdn.microsoft.com/en-us/library/1fdeehz6.aspx
2
http://en.wikibooks.org/wiki/C_Programming/Strings#The_memset_function
40
• vida este o variabilă globală ce ia valoarea true atunci când coada nu conţine nici un
element, sau valoarea false ı̂n caz contrar.
• Structura de date abstractă de tip coadă este implementată static sub forma unei cozi
circulare.
• Vizitarea ı̂ncepe de la nodul 0 (bfs(0)).
• Subrutina vizitare(), ı̂n principiu, afişează valoarea etichetei nodului trimis ca argu-
ment, ı̂nsă poate efectua şi alte prelucrări necesare asupra nodului curent, ı̂n funcţie de
cerinţele specifice ale algoritmului.
Algoritmul BFS este utilizat de către metoda Branch-and-Bound ca metodă de explorare

a spaţiului soluţiilor, cât şi ı̂n cadrul problemelor de determinare a distanţei minime de la
un vârf la toate celelalte vârfuri, ı̂n cazul ı̂n care lungimea unui drum dintre două noduri se
consideră ca fiind egală cu numărul de noduri intermediare ale acestuia.
2.3.2 Parcurgerea D (D - Depth)

Metoda de parcurgere D este asemănătoare cu metoda de parcurgere ı̂n lăţime (BFS):
• la ı̂nceput se vizitează vârful de pornire (notat cu k);
• urmează, ı̂n ordine, toţi vecinii ı̂ncă nevizitaţi ai nodului de pornire;
• la pasul următor se consideră ultimul nod vizitat v şi se ı̂ncearcă vizitarea vecinilor ı̂ncă
nevizitaţi ai acestuia. Dacă nodul v nu mai are vecini nevizitaţi, se continuă procesul
de parcurgere cu nodul ce a fost vizitat exact ı̂naintea nodului v, etc.
Metoda de parcurgere D este o combinaţie ı̂ntre metoda de parcurgere ı̂n lăţime (a se

vedea secţiunea 2.3.1) şi metoda de parcurgere ı̂n adâncime (a se vedea secţiunea 2.3.3).
Pentru un nod, se vizitează toţi vecinii ı̂ncă nevizitaţi ai acestuia, ı̂nsă spre deosebire de
metoda de parcurgere ı̂n lăţime unde ordinea ı̂n care au fost vizitate nodurile se păstrează şi
la parcurgere, la metoda de parcurgere D se prelucrează mereu ultimul nod vizitat.
Pentru aceasta, ı̂n algoritmul BFS se ı̂nlocuieşte structura de date de tip coadă, cu o
structură de date de tip stivă şi se obţine algoritmul D (a se vedea algoritmul 17).
În figura 2.10 poate fi urmărit arborele de acoperire pentru parcurgerea D a grafului G
prezentat ı̂n figura 2.6.
2.3.3 Parcurgerea ı̂n adâncime (DFS-Depth First Search)

În cadrul acestei metode se va merge ı̂n adâncime ori de câte ori este posibil: prelucrarea
unui vârf constă ı̂n prelucrarea primului dintre vecinii săi ı̂ncă nevizitaţi.
• se vizitează vârful de pornire (notat cu k);
• urmează, primul vecin ı̂ncă nevizitat al acestuia;
• se caută primul vecin, ı̂ncă nevizitat, al primului vecin nevizitat al nodului de start,
ş.a.m.d.;
41
Fig. 2.10: Arbore de acoperire pentru parcurgerea D
Algoritm 17 Algoritm de vizitare D

1: procedure D(k, n, V ecin)
2: for i ← 1, n do
3: vizitati ← 0
4: end for
6: S⇐k ⊲ inserarea nodului curent k ı̂n stivă
8: while (S 6= ∅) do
9: S⇒k ⊲ extragerea nodului curent din stivă
10: for j ← 1, n do
11: if ((vizitatj = 0) ∧ (vecink,j = 1)) then ⊲ se cauta un vecin nevizitat
12: vizitatj ← 1 ⊲ marcarea nodului j ca fiind vizitat
13: S⇐j ⊲ inserarea nodului j in stivă
14: call V izitare(j) ⊲ vizitarea nodului j
15: end if
16: end for
17: end while
18: end procedure
• se merge ı̂n adâncime până când se ajunge la un vârf ce nu are vecini, sau pentru care
toţi vecinii săi au fost vizitaţi. În acest caz, se revine ı̂n nodul său părinte (nodul din
care a fost vizitat nodul curent), şi se continuă algoritmul, cu următorul vecin ı̂ncă
nevizitat al nodului curent.
Pentru graful considerat (vezi figura 2.6), ı̂n urma parcurgerii ı̂n adâncime, vom obţine
nodurile ı̂n ordinea următoare: 1, 2, 5, 3, 7, 6, 4, 8 (a se vedea figura 2.11). Dacă ne propunem
să vizităm exact o singură dată toate nodurile unui graf, aplicând algoritmul DFS de câte ori
este nevoie, şi selectăm numai muchiile utilizate ı̂n timpul explorării, rezultă o pădure de
arbori. Fiecare dintre aceşti arbori constituie un arbore de acoperire ı̂n adâncime.
În urma parcurgerii ı̂n adâncime, muchiile unui graf pot fi clasificate ı̂n următoarele ca-
tegorii:
1. muchie a arborelui de acoperire - muchia [u, v] este o muchie a arborelui de acoperire
42
Fig. 2.11: Arbore de acoperire ı̂n adâncime
dacă dfs(u) apelează direct dfs(v) sau invers;
2. muchie de ı̂ntoarcere - muchia [u, v] este o muchie de ı̂ntoarcere dacă dfs(u) apelează
indirect dfs(v) (∃x ∈ V a.ı̂. df s(u) df s(x) df s(v)) sau invers, dfs(v) apelează
indirect dfs(u).
Exemplul 2.19 Pentru graful din figura 2.6 avem:
• muchiile [1, 2], [2, 5], [3, 5], [4, 6], [5, 7], [6, 7], [6, 8] sunt muchii ale arborelui de acoperire;
• muchiile [1, 3], [1, 4] sunt muchii de ı̂ntoarcere;
Algoritm 18 Algoritm de vizitare ı̂n adâncime (varianta recursivă)

1: procedure DFS(k, n, V ecin)

k
 - nodul curent ce se vizitează


4: for i ← 1, n do
6: call DF S(i, n, vecin) ⊲ apelul recursiv al subrutinei DF S pentru nodul i
7: end if
8: end for
9: end procedure
Implementarea algoritmului se poate realiza fie ı̂n variantă recursivă (a se vedea algoritmul
18), fie ı̂n variantă nerecursivă (a se vedea algoritmul 19). În mod asemănător ca şi la
algoritmul de parcurgere ı̂n lăţime, vectorul vizitat gestionează situaţia vizitării nodurilor
grafului G:(
1 , dacă nodul k a fost vizitat
vizitatk =
0 , ı̂n caz contrar.
43
Subrutina DFS (algoritmul 18) ı̂ncepe cu marcarea nodului curent ca fiind vizitat (vizitatk ←
1) (linia 2) şi apelul procedurii Vizitare() (call Vizitare(k)) (linia 3). Se caută apoi
primul vecin nevizitat i al vârfului curent k (nod ce verifică condiţia (vizitati = 0)∧(vecink,i =
1)) şi se reia secvenţa de operaţii pentru nodul i cu această proprietate, printr-un apel recursiv
(call DFS(i)) (linia 6).
Enunţul repetitiv for i ← 1, n (linia 4) poate fi optimizat astfel ı̂ncât să nu se mai
verifice toate vârfurile grafului, ci numai nodurile adiacente cu nodul curent: ı̂n această
situaţie reprezentarea cu liste de adiacenţă este optimă din punct de vedere al numărului de
operaţii efectuate, fiind preferată reprezentării prin matricea de adiacenţă.
Algoritm 19 Algoritm de vizitare ı̂n adâncime (varianta nerecursivă)

1: procedure DFS Nerecursiv(k, n, V ecin)

k
 - nodul de la care se porneşte vizitarea


2: for i ← 1, n do
3: vizitati ← 0
4: end for
8: f ound ← f alse
9: while (S 6= ∅) do ⊲ cât timp stiva nu este vidă
10: if (¬f ound) then
11: S⇒k ⊲ extragerea nodului curent din stivă
12: end if
13: i←1
14: f ound ← f alse
15: while ((i ≤ n) ∧ (f ound = f alse)) do
17: vizitati ← 1 ⊲ marcarea nodului i ca fiind vizitat
19: call V izitare(i) ⊲ vizitarea nodului i
20: k←i
21: f ound ← true
22: else
23: i←i+1
24: end if
25: end while
26: end while
27: end procedure
Algoritmul 19 utilizează o structură de date de tip stivă S pentru a păstra tot timpul nodul
grafului din care s-a ajuns la nodul curent (tatăl nodului curent din arborele de acoperire ı̂n
adâncime). Secvenţa de instrucţiuni 19.13-19.25 nu este optimă deoarece, de fiecare dată când
se revine la un nod părinte, se verifică ı̂ntreaga mulţime de noduri V pentru a identifica un
vecin nevizitat al nodului curent. În vederea reducerii numărului de verificări, se poate utiliza
reprezentarea prin liste de adiacenţă, şi se salvează pe stivă, pe lângă valoarea nodului curent
k, valoarea vecinului nevizitat găsit al acestuia (să ı̂l notăm cu u), astfel ı̂ncât, la revenire,
să se continue căutarea următorului vecin nevizitat al nodului curent k, pornind de la acest
44
nod u. Dacă nu mai există nici un vecin nevizitat al vârfului k (linia 10), atunci se revine la
părintele nodului curent, păstrat pe stivă. Algoritmul se opreşte ı̂n cazul ı̂n care stiva este
vidă (atunci când nodul curent este rădăcina arborelui de vizitare ı̂n adâncime).
Am ales ı̂n vederea implementării, varianta recursivă pentru uşurinţa de programare şi
eleganţa ei. Prezentăm ı̂n continuare această implementare a algoritmului 18 ı̂n limbajul C:
Listing 2.2: dfsrec.c
#include <stdio.h>
#include <mem.h>
#define MAXN 100

char vizitat[MAXN]; // Vector ce pastreaza starea unui nod: vizitat sau nu
int n; // Numarul de varfuri din graf
int nodi; // Nodul din care se porneste vizitarea
/**
*/
int i, j;
printf("n = "); scanf("%d", &n);

for (i = 0; i < n - 1; i++)
for (j = i + 1; j < n; j++) {
printf("a[%d,%d] = ", i, j);
}
printf("Nodul initial = "); scanf("%d", &nodi);
}
/**
* Parcurgerea in adancime pornind din nodul k.
*/
void dfs(int k) {
int i;
vizitat[k] = 1;
printf("%d ",k);
for (i = 0; i < n; i++)
if (vizitat[i] == 0 && vecin[k][i] == 1)
dfs(i);
}
void main(void) {
readInput();
dfs(nodi);
}
45
Complexitatea algoritmilor de parcurgere
Complexitatea algoritmilor 18 şi 19 prezentaţi este O(n2 ) deoarece se utilizează matricea de
adiacenţă drept modalitate de reprezentare a grafului. Dacă se utilizează reprezentarea prin
liste de vecini, atunci complexitatea algoritmilor devine O(n + m), unde m = |E|.
Matricea de adiacenţă Liste de vecini Lista de muchii

BFS O(n2 ) O(n + m) O(n + m2 )
D O(n2 ) O(n + m) O(n + m2 )
DFS O(n2 ) O(n + m) O(n + m2 )
2.4 Componente conexe

Definim pe mulţimea vârfurilor V a unui graf neorientat G o relaţie ρ ı̂n felul următor: xρy
dacă x = y sau există ı̂n G un lanţ de la x la y.
Se demonstrează foarte uşor că relaţia ρ este o relaţie de echivalenţă (exerciţiu). Se
cunoaşte faptul că o relaţie de echivalenţă determină pe mulţimea pe care este definită o
partiţie. Componentele conexe vor fi elementele acestei partiţii, formate din vârfurile ce sunt
echivalente ı̂ntre ele (conform relaţiei de echivalenţă).
Cu alte cuvinte, există o partiţie a mulţimii vârfurilor V
m
[
V = Vi , Vi ∩ Vj = ∅, ∀i, j = 1, m, i 6= j (2.4)
i=1
şi o partiţie a mulţimii muchiilor E

m
[
E= Ei , Ei ∩ Ej = ∅, ∀i, j = 1, m, i 6= j (2.5)
i=1
astfel ı̂ncât fiecare graf Gi = (Vi , Ei ), ∀i = 1, m, este conex (Ei = E|Vi ×Vi ).
Algoritm 20 Algoritm pentru determinarea componentelor conexe
( ComponenteConexe(n, V ecin)
1: procedure
n - numărul de noduri din graf
Input:
2: for i ← 1, n do
3: vizitati ← 0
4: end for
5: cmp conex nr ← 0
6: for i ← 1, n do
7: if (vizitati = 0) then
8: cmp conex nr ← cmp conex nr + 1
9: call DF S(i, n, V ecin) ⊲ determinarea componentei conexe ce conţine nodul i
10: end if
11: end for
12: end procedure
Pentru determinarea componentelor conexe vom utiliza metoda de vizitare ı̂n adâncime a
unui graf. Paşii algoritmului descrişi ı̂n limbaj natural sunt următorii (algoritmul 20 prezintă
descrierea formalizată ı̂n pseudo-cod):
46
Pas 1. La ı̂nceput, toate nodurile sunt marcate ca nevizitate.
Pas 2. Se caută un nod ı̂ncă nevizitat.
Pas 3. Începând cu acesta se parcurg toate nodurile accesibile şi nevizitate, având grijă să
marcăm vizitarea acestora. Toate aceste noduri formează o componentă conexă.
Pas 4. Dacă mai există noduri nevizitate, se reia procesul de calcul de la pasul 2, altfel procesul
de calcul se ı̂ncheie.
2.5 Muchie critică

Reamintim faptul că ı̂ntr-un graf neorientat G = (V, E), o muchie critică este acea muchie
care prin eliminarea ei conduce la creşterea numărului de componente conexe ale grafului.
Se cere să se determine toate muchiile critice ale unui graf dat. În continuare sunt prezen-
tate două variante de rezolvare.
Soluţia I
Pentru simplitate, vom trata situaţia ı̂n care graful considerat este conex (dacă graful nu este
conex se determină componentele conexe şi numărul acestora şi se aplică algoritmul pentru
fiecare componentă conexă ı̂n parte). Se elimină, pe rând, fiecare muchie a grafului şi apoi
se verifică dacă graful rezultat mai este conex (a se vedea algoritmul 21).
Algoritm 21 Algoritm de determinare a muchiilor critice (prima variantă)

1: procedure MuchiiCriticeI(n, m, V ecin)

n
 - numărul de noduri din graf
Input: m - numărul de muchii din graf


V ecin - matricea de adiacenţă
2: for k ← 1, m do
3: elimină muchia k
4: if (Conex(n, V ecin) = f alse) then
5: Output {”Muchia k este critica”}
6: end if
7: adaugă muchia k ⊲ reface graful iniţial
8: end for
9: end procedure
10: function Conex(n, V ecin)
11: for i ← 1, n do
12: vizitati ← 0
13: end for
14: call DF S(1, n, V ecin) ⊲ vizitarea ı̂n adâncime a grafului
15: for i ← 1, n do
17: return f alse
18: end if
19: end for
20: return true
21: end function
47
Subrutina Conex() verifică dacă graful identificat prin matricea de adiacenţă Vecin este
conex (este compus dintr-o singură componentă conexă). Subrutina ı̂ntoarce valoarea true
ı̂n cazul ı̂n care graful considerat este conex şi false, ı̂n caz contrar. Pentru aceasta, la
ı̂nceput, se marchează toate nodurile ca fiind nevizitate, şi se ı̂ncearcă parcurgerea nodurilor
grafului, prin intermediul unui apel al subrutinei de vizitare, DFS(1, n, Vecin).
Implementarea algoritmului 21 ı̂n limbajul C este următoarea:
Listing 2.3: muchiecriticav1.c
#include <stdio.h>
#include <mem.h>
#define MAXN 100

#define TRUE 1
#define FALSE 0

/**
*/
int i, j;

for (i = 0; i < n - 1; i++)
for (j = i + 1; j < n; j++) {
printf("a[%d,%d] = ", i, j);
}
}
/**
* Parcurgerea in adancime a grafului pornind din nodul de start k.
*/
void dfs(int k) {
int i;
vizitat[k] = TRUE;
printf("%d ", k);
for (i = 0; i < n; i++)
if ((vizitat[i] == FALSE) && (vecin[k][i] == 1))
dfs(i);
}
/**
* Functia verifica daca graful este conex.
*/
int conex(void) {
int i;
48
dfs(0);
for (i = 0; i < n; i++)
if (vizitat[i] == FALSE) {
return FALSE;
}
return TRUE;
}
int main() {
int i, j;
readInput();
for (i = 1; i < n; i++)
for (j = 0; j < i; j++)
if (vecin[i][j] == 1) {
vecin[i][j] = 0;
vecin[j][i] = 0;
if (conex() == FALSE) {
printf("Muchia (%d,%d) este critica! \n", i, j);
}
vecin[i][j] = 1;
vecin[j][i] = 1;
}
return 0;
}
Observaţia 2.20 Am presupus că numerotarea nodurilor se face de la 0 şi că există un nod
cu eticheta 0.
Complexitatea-timp a acestui algoritm, presupunând că avem o singură componentă
conexă, este O(m(n + m)): se consideră fiecare muchie (O(m)), se elimină din graf, şi se
verifică dacă graful rămas este conex (O(n + m)).
Soluţia a II-a
Cea de-a doua variantă de abordare pentru identificarea unei soluţii foloseşte următoarea
proprietate:
Observaţia 2.21 O muchie nu este critică dacă ea face parte din cel puţin un ciclu elemen-
tar al grafului respectiv.
În urma vizitării DFS, toate muchiile unui graf se ı̂mpart ı̂n muchii ale arborelui de
acoperire şi muchii de ı̂ntoarcere.
Vom numerota toate nodurile grafului ı̂n preordine (numerotarea se realizează efectiv ı̂n
momentul ı̂n care un nod este marcat ca fiind vizitat), toate valorile fiind păstrate ı̂ntr-un
vector prenum. Fie lowu valoarea unui nod u, calculată după formula următoare [75], [124]:

prenumu

lowu = min prenumx , dacă [u, x] este muchie de ı̂ntoarcere (2.6)


lowy , ∀y descendent direct al lui u.
49
Dacă prenumu ≥ lowv , ∀v descendent direct al lui u, atunci ı̂nseamnă că nodul v sau un
descendent al lui v prezintă o muchie de ı̂ntoarcere la u sau la un strămoş al acestuia. Astfel
muchia [u, v] aparţine unui ciclu elementar, şi, prin urmare, nu este muchie critică (a se vedea
algoritmul 22). Prin negaţie, dacă există cel puţin un vârf v, descendent direct al lui u, cu
proprietatea că prenumu < lowv atunci [u, v] este muchie critică. După fiecare apel recursiv
al subrutinei DFS (linia 16) se verifică gradul de adevăr al expresiei (prenumk < lowi ) (linia
18).
Algoritm 22 Algoritm de determinare a muchiilor critice (a doua variantă)
( MuchiiCriticeII(n, V ecin)
1: procedure
Input:
2: for i ← 1, n do
3: vizitati ← 0
4: end for
5: counter ← 0
6: call DF S critic(1, n, V ecin) ⊲ vizitarea ı̂n adâncime a grafului
7: end procedure
8: procedure DFS critic(k, n, V ecin)
9: vizitatk ← 1
10: counter ← counter + 1
11: prenumk ← counter, lowk ← counter
12: for i ← 1, n do
13: if (vecink,i = 1) then
15: tatai ← k
16: call DF S critic(i, n, V ecin)
17: lowk ← M in(lowk , lowi )
18: if (prenumk < lowi ) then
19: Output {’Muchia (k,i) este critica’}
20: end if
21: else
22: if (tatak 6= i) then
23: lowk ← M in(lowk , prenumi )
24: end if
25: end if
26: end if
27: end for
28: end procedure
Variabila counter este globală pentru cele două subrutine, MuchieCriticaII() şi
DFS critic(). La numerotarea ı̂n preordine se folosesc atribuirile: counter ← counter + 1,
şi prenumk ← counter. Când un nod i este vecin cu nodul curent k, şi nu a fost ı̂ncă vizitat,
valoarea lui lowk se calculează astfel: lowk ← min {lowk , lowi}. În situaţia ı̂n care pentru un
nod i, vecin cu nodul curent k, deja vizitat, avem o muchie de ı̂ntoarcere (nodului k i s-a
atribuit deja un număr ı̂n preordine), atunci valoarea lowk se calculează după formula
lowk ← min {lowk , prenumi}.
50
Listing 2.4: muchiecriticav2.c
#include <stdio.h>
#include <mem.h>
#define MAXN 100

int n; // Numarul de noduri din graf
int tata[MAXN]; // Pastreaza tatal fiecarui nod in arborele de acoperire
// in adincime generat de metoda DFS.
int prenum[MAXN]; // prenum[k] - numerotarea in preordine
int low[MAXN];
int counter; // contor global ce numara momentul cand este vizitat un
nod
int i, j;

for (i = 0; i < n - 1; i++)
for (j = i + 1; j < n; j++) {
printf("a[%d,%d] = ", i, j);
}
}
int min(int x, int y) {

return (x < y) ? x : y;
}
void dfs(int k) {
int i;
vizitat[k] = 1;
counter++;
prenum[k] = counter; low[k] = counter;
for (i = 0; i < n; i++)
if (vecin[k][i] == 1)
if (vizitat[i] == 0) {
tata[i] = k;
dfs(i);
low[k] = min(low[k], low[i]);
if (prenum[k] < low[i])
printf("%d -> %d \n", k, i);
}
else
if (tata[k] != i)
low[k] = min(low[k], prenum[i]);
/*printf("prenum[%d] = %d low[%d] = %d\n", k, prenum[k], k, low[k]);*/
}
51
void critic(void) {
counter = 0;
dfs(0);
}
int main(void) {
printf("\n");
readInput();
critic();
return 0;
}
Fig. 2.12: Algoritmul 22 aplicat pentru graful din figura 2.6
Exemplul 2.22 Pentru graful din figura 2.6, valorile prenum şi low sunt cele din figura 2.12
(valoarea din partea dreaptă a unui vârf reprezintă valoarea sa la numerotarea ı̂n preordine,
prenum, iar numărul din stânga reprezintă valoarea calculată low). Condiţia prenumu <
lowv , unde [u, v] este o muchie a grafului, este ı̂ndeplinită doar pentru u = 6 şi v = 8. Prin
urmare [6, 8] este muchie critică ı̂n graful considerat.
Deoarece acest algoritm este constituit din algoritmul modificat de vizitare ı̂n adâncime
a unui graf, complexitatea-timp este O(n + m) atunci când graful este reprezentat prin liste
de adiacenţă şi O(n2 ) ı̂n situaţia ı̂n care graful este reprezentat prin matricea de adiacenţă.
2.6 Puncte de articulaţie

Definiţia 2.18 Într-un graf neorientat conex G = (V, E), un nod u ∈ V se numeşte punct
de articulaţie dacă prin eliminarea sa şi a muchiilor incidente cu nodul u, se obţine un
graf care nu mai este conex.
Un prim algoritm ce determină punctele de articulaţie dintr-un graf neorientat conex

G este următorul: se parcurge fiecare nod u ∈ V ı̂n parte, se elimină din graful G nodul u
52
Fig. 2.13: a) Nodul 3 este punct de articulaţie. b) Nodurile 2 şi 3 sunt puncte de articulaţie. c) Graf fără
puncte de articulaţie.
ı̂mpreună cu muchiile ce au una din extremităţi ı̂n acest nod, şi se verifică dacă graful obţinut
mai este conex. Dacă graful nu este conex atunci u este punct de articulaţie (G = (V, E),
V1 = V \ {u}, E1 = E|V1 ×V1 , G1 = (V1 , E1 ), G1 conex?).
Algoritm 23 Algoritm de determinare a punctelor de articulaţie (prima variantă)
( PuncteDeArticulatieI(G = (V, E); L)

1: procedure
V - mulţimea de noduri a grafului
Input:
E - mulţimea de muchii a grafului
2: L←∅
3: for each u ∈ V do
4: V1 ← V \ {u}
5: E1 ← E|V1 ×V1
6: G1 ← (V1 , E1 )
7: if (Conex(G1 ) = 0) then ⊲ u este punct de articulaţie al grafului?
8: L ← L ∪ {u} ⊲ se adaugă nodul u la lista L
9: end if
10: end for
11: end procedure
Un alt algoritm se bazează pe metoda de parcurgere a grafurilor ı̂n adâncime, DFS. Al-
goritmul de fost propus de R. E. Tarjan [75], [124]. Reamintim că ı̂n cazul parcurgerii DFS,
muchiile grafului iniţial G se ı̂mpart ı̂n:
• muchii ale arborelui de acoperire ı̂n adâncime;
• muchii de ı̂ntoarcere.
Un nod u ∈ V al grafului G este punct de articulaţie dacă:
1. nodul u este rădăcina arborelui de acoperire ı̂n adâncime şi acesta are cel puţin doi
copii;
2. nodul u are un descedent v ∈ V astfel ı̂ncât nici unul din descendenţii nodului v să nu
constituie extremitate unei muchii de ı̂ntoarcere către unul din strămoşii nodului u din
arborele de acoperire ı̂n adâncime (∃v copil al nodului u astfel ı̂ncât ∀w descendent al
nodului v, w ∈ V , ∄ [w, x] muchie de ı̂ntoarcere unde x este un strămoş al nodului u ı̂n
arborele de acoperire ı̂n adâncime - a se vedea figura 2.14).
53
Fig. 2.14: Ce condiţie trebuie să ı̂ndeplinească un nod u ca să nu fie punct de articulaţie?
Prima condiţie se poate verifica cu ajutorul vectorului tata (tatau reprezintă părintele
nodului u ı̂n arborele de acoperire ı̂n adâncime) şi păstrând un contor cu numărul de copii
ai fiecărui nod.
A doua condiţie se poate verifica păstrând pentru fiecare nod u două valori: prenumu ce
reprezintă momentul ı̂n care este ı̂ntâlnit nodul u pentru prima dată şi lowu ce este definită
astfel: 
prenumu

lowu = min prenumx , dacă [u, x] este muchie de ı̂ntoarcere (2.7)


Se observă că definiţia lowu este similară cu cea ı̂ntâlnită ı̂n a doua metodă de determinare
a muchiilor critice dintr-un graf. Astfel dacă pentru un nod u şi un copil al acestuia v este
ı̂ndeplinită condiţia (tatav = u) ∧ (prenumu ≤ lowv ), atunci u este punct de articulaţie ı̂n
graful G.
2.7 Exerciţii
1. Un graf neorientat cu n noduri, G = (V, E) se numeşte graf scorpion dacă posedă trei
noduri speciale:
(a) acul - dG (u) = 1 şi este legat de coadă;

(b) coada - dG (u) = 2 şi este legată de ac şi corp;
(c) corpul - dG (u) = n − 2 fiind legat de toate nodurile din graf cu excepţia acului.
Nu există alte restricţii cu privire la nodurile grafului.

Să se realizeze un algoritm care determină dacă un graf este graf scorpion folosind O(n)
ı̂ntrebări de forma ”Există o muchie ı̂ntre nodurile u şi v? ”.
2. Să se parcurgă ı̂n lăţime şi ı̂n adâncime graful din figura 2.15, să se construiască arborii
de parcurgere şi să se pună ı̂n evidenţă muchiile de ı̂ntoarcere.
3. Se dă un graf neorientat G = (V, E). Să se elaboreze un algoritm ce verifică dacă ı̂n
graful G există cel puţin un ciclu.
54
Algoritm 24 Algoritm de determinare a punctelor de articulaţie (a doua variantă)
( PuncteDeArticulatieII(n, V ecin; Lpa)

1: procedure
Input:
2: for i ← 1, n do
3: vizitati ← 0, lpai ← 0
4: end for
5: counter ← 0
6: call DF S P A(1, n, V ecin; Lpa) ⊲ vizitarea ı̂n adâncime a grafului
7: end procedure
8: procedure DFS PA(k, n, V ecin; L)
9: vizitatk ← 1, children ← 0
10: counter ← counter + 1, prenumk ← counter, lowk ← counter
11: for i ← 1, n do
14: tatai ← k, children ← children + 1
15: call DF S P A(i, n, V ecin)
17: if ((tatak 6= 0) ∧ (prenumk ≤ lowi )) then
18: Lk ← 1
19: end if
20: else
21: if (tatak 6= i) then
23: end if
24: end if
25: end if
26: end for
27: if ((tatak = 0) ∧ (children > 1)) then
28: Lk ← 1
29: end if
30: end procedure
4. Se dă un graf neorientat G = (V, E). Să se elaboreze un algoritm ce verifică dacă ı̂n
graful G există cel puţin un ciclu de lungime impară.
5. Se dă un graf neorientat G = (V, E). Să se elaboreze un algoritm ce determină numărul
de triunghiuri formate de nodurile grafului (numărul de cicluri având lungimea egală
cu valoarea 3).
6. Se dă un graf neorientat G = (V, E) şi un nod u ∈ V . Să se elaboreze un algoritm ce

determină dacă există un lanţ elementar de lungime cel puţin k (k dat), ce are drept
extremitate iniţială nodul u şi extremitate finală un nod oarecare al grafului G.
7. Fiind dat un graf neorientat G = (V, E), să se elaboreze un algoritm eficient ce deter-
mină dacă graful G este bipartit.
8. Se dă un graf neorientat G = (V, E). Să se elaboreze un algoritm ce determină numărul
maxim de muchii ce se pot adăuga la graful G astfel ı̂ncât acesta să rămână bipartit.
55
Fig. 2.15: Un exemplu de graf neorientat cu 8 vârfuri
9. Fie G = (V, E) un graf simplu, finit neorientat. Pentru ∀u, v ∈ V , u 6= v, să se

determine toate lanţurile elementare având ca extremităţi nodurile u şi v.
10. Se dă o matrice A având n linii şi m coloane, având ca valori numerele 0 sau 1 (A ∈
Mn×m ({0, 1})). Să se elaboreze un algoritm ce determină numărul de insule din cadrul
matricei (o insulă este formată dintr-un un grup de elemente vecine având valoarea 1,
elementele fiind vecine pe verticală sau orizontală).
11. Compania TLC (Telephone Line Company) a stabilit o nouă reţea de cablu telefonic.
Ea leagă mai multe locaţii numerotate cu numere ı̂ntregi de la 1 la N. Nu există două
locaţii numerotate cu acelaşi număr. Liniile sunt bidirecţionale şi conectează două
locaţii; fiecare locaţie are un post telefonic. Din orice locaţie poate fi apelată oricare
altă locaţie, prin legătura directă sau conexiuni intermediare. Uneori reţeaua cade ı̂n
unele locaţii şi conexiunea aferentă nu mai este posibilă. Tehnicienii de la TLC au
realizat că, ı̂n acest caz, nu numai că locaţia respectivă nu mai poate fi apelată, dar
ea ı̂ntrerupe legătura şi ı̂ntre alte locaţii pentru care asigură conexiunea. În această
situaţie spunem că locaţia (unde a apărut căderea) este critică.
Se cere să se elaboreze un algoritm care să determine numărul tuturor acestor puncte
critice.
(ACM Europa Centrală, 1996)
12. Se consideră o tablă de şah de dimensiune n × n (n ≤ 100) pe care sunt dispuse

obstacole. Se cere să se determine numărul minim de mutări necesare unui nebun
pentru a se deplasa, respectând regulile jocului de şah şi ocolind obstacolele, dintr-o
poziţie iniţială dată ı̂ntr-o poziţie finală dată.
Se consideră că obstacolele nu coincid cu poziţia iniţială şi nici cu cea finală a nebunului.
(Concurs studenţesc, 1993)
13. Se dă un graf neorientat conex G = (V, E). Să se elaboreze un algoritm eficient ce
determină un drum ı̂n graful G care să traverseze fiecare muchie din E exact o dată ı̂n
fiecare direcţie.
56
Capitolul 3
Grafuri euleriene şi hamiltoniene
3.1 Grafuri Euleriene

În anul 1736, matematicianul Leonhard Euler publica o lucrare asupra problemei podurilor
din Königsberg1 (a se vedea figura 3.1) ı̂n care se prezintă un studiu teoretic asupra lanţurilor
şi ciclurilor Euleriene.
Fig. 3.1: Podurile din Königsberg
Să considerăm un graf neorientat G = (V, E).
Definiţia 3.1 Un lanţ L ce conţine fiecare muchie a unui graf G o singură dată se numeşte
lanţ Euler sau lanţ eulerian. Dacă extremităţile lanţului sunt identice şi lanţul este
eulerian atunci ciclul se numeşte ciclu Euler sau ciclu eulerian. Un graf ce conţine un
ciclu eulerian se numeşte graf eulerian.
O problemă mai cunoscută legată de noţiunile de ciclu şi lanţ eulerian este aceea de a
desena cu o singură linie neı̂ntreruptă o anumită figură (a se vedea figura 3.2).
Teorema 3.1 (Euler) Un graf G conex (|V | ≥ 3) este eulerian dacă şi numai dacă gradul
fiecărui vârf este par.
1
http://en.wikipedia.org/wiki/Seven Bridges of Königsberg
57
Fig. 3.2: Două figuri geometrice ce pot fi desenate folosind o singură linie
Demonstraţie: ”⇒” Fie G un graf conex eulerian ⇒ ∃ un ciclu eulerian C. Acesta

trece o singură dată prin toate muchiile grafului. Gradul fiecărui vârf u este par, deoarece
pentru fiecare muchie incidentă cu u prin intermediul căreia se ajunge ı̂n vârful respectiv,
există o altă muchie prin intermediul căreia se părăseşte vârful u.
”⇐” Presupunem că ∀u ∈ V , dG (u) este par. Fie L un lanţ de lungime maximă ı̂n graful
G şi fie u şi v extremităţile lanţului.
Presupunem că u 6= v. Deoarece dG (v) este par, ∃[v, w] ∈ E astfel ı̂ncât [v, w] ∈ / L.
Lanţul L ∪ {[v, w]} va avea lungimea mai mare decât lanţul iniţial L, contradicţie. Prin
urmare u = v. Rezultă că L = C este un ciclu de lungime maximă.
Presupunem că ciclul C nu este ciclu eulerian. Atunci ∃x, y ∈ V, [x, y] ∈ E, [x, y] ∈ / C şi
x ∈ C (există o muchie a grafului G ce nu aparţine ciclului C cu proprietatea că cel puţin o
extremitate aparţine ciclului).
Fie L1 = [x, . . . , u, v, . . . , x] un lanţ ı̂n graful G ce conţine exact muchiile ciclului C.
Atunci L2 = [x, . . . , u, v, . . . , x, y] este un lanţ ı̂n G ce are lungimea mai mare decât cea a
lanţului L, contradicţie. Rezultă atunci că ciclul C este eulerian ⇒ G este un graf eulerian.
Teorema 3.2 (Euler) Un graf G conex are un lanţ eulerian dacă şi numai dacă există exact
două vârfuri ı̂n G al căror grad să fie impar.
Demonstraţie: ”⇒” Se demonstrează la fel ca la teorema 3.1.

”⇐” Fie G = (V, E) un graf conex ce are exact două vârfuri de grad impar, u şi v. Să
consideră un nod w ∈ / V ı̂mpreună cu muchiile [u, w] şi [v, w]. Fie G′ = (V ′ , E ′ ), V ′ = V ∪{w},
E ′ = E ∪ {[u, w], [v, w]}, graful obţinut din G prin adăugarea nodului w şi a muchiilor [u, w],
[v, w]. Atunci dG′ (u) este par, ∀u ∈ V ′ ⇒ există un ciclu eulerian C ı̂n graful G′ . Dacă
eliminăm muchiile [u, w] şi [v, w] obţinem un lanţ eulerian ı̂n graful G.
Corolarul 3.3 Un graf G conex (|V | ≥ 3) este eulerian dacă şi numai dacă mulţimea muchi-
ilor sale poate fi descompusă ı̂n cicluri disjuncte.
Teorema 3.4 Pentru un graf conex cu 2k vârfuri de grad impar, k ≥ 1, există k lanţuri ı̂n
G ale căror mulţimi de muchii formează o partiţie a mulţimii E, şi din care cel mult unul
are lungimea impară.
3.1.1 Algoritm pentru determinarea unui ciclu eulerian

Pornind de la Teorema 3.1 construim un ciclu eulerian. Se consideră drept punct de plecare
un vârf oarecare al grafului. La fiecare pas se alege pentru vârful curent u, un vârf adiacent
58
Fig. 3.3: Exemplu de graf eulerian
v, diferit de vârful din care s–a ajuns ı̂n u. Parcurgerea se continuă până ı̂n momentul ı̂n
care ajungem ı̂ntr–un vârf ce a fost deja vizitat şi se ı̂nchide ciclul C. Dacă ciclul C nu
este eulerian, atunci se elimină din graful G toate muchiile ciclului C, rezultând mai multe
componente conexe G11 , G12 , . . . , G1k .
Pentru fiecare astfel de componentă G1i , ce are cel puţin două vârfuri, aplicăm recursiv
algoritmul. Conform teoremei 3.1, fiecare componentă G1i este euleriană. Fie Ci1 ciclul
eulerian corespunzător componentei G1i .
Ciclul C are cel puţin câte un vârf comun cu fiecare ciclu Ci1 . Fie acest vârf ui . Definim
un ciclu C0 astfel: pentru fiecare i, i = 1, k, adăugăm la ciclul C, ı̂n vârful ui, ciclul Ci1 .
Ciclul C0 conţine toate muchiile grafului G, prin urmare este eulerian.
Funcţia IsEulerian() verifică dacă un graf este eulerian conform teoremei 3.1 (a se vedea
algoritmul 25).
Algoritm 25 Algoritm de verificare dacă un graf conex este eulerian

1: function IsEulerian(G = (V, E))
2: if (|V | < 3) then
3: return f alse
4: end if
5: for i ← 1, n do
6: s←0
7: for j ← 1, n do
8: s ← s + vecini,j
9: end for
10: if (s mod 2 = 1) then
11: return false
12: end if
13: end for
14: return true
15: end function
După cum se poate vedea din funcţia IsEulerian() numai componentele conexe ce au
ordinul mai mare sau egal cu 3 vor fi luate ı̂n considerare.
59
În algoritmul 26 este prezentată funcţia EulerRec() pentru determinarea unui ciclu eu-
lerian.
Procedura FindCycle(G) (a se vedea algoritmul 26) construieşte un ciclu: se alege un
vârf u0 şi se caută prima muchie [u0 , u1 ]. În vârful u1 se caută o muchie [u1 , u2 ] astfel ı̂ncât
vârful u2 să fie distinct de vârful din care s-a ajuns ı̂n u1 (u2 6= u0 ) şi să nu mai fi fost vizitat.
Dacă u2 a fost vizitat atunci funcţia se termină. Se continuă procedeul de căutare până când
se ajunge la un vârf ce a fost vizitat anterior şi se returnează ciclul cuprins ı̂ntre cele două
apariţii ale aceluiaşi vârf.
Procedura F indComponents(G′ ; k, G11 , G12 , . . . , G1k ) determină componentele conexe ale
grafului G′ = G − E(C), obţinut prin eliminarea din graful G a muchiilor ciclului C, unde
G11 , G12 , . . . , G1k sunt cele k componente conexe returnate de aceasta.
Procedura MergeCycles(C, C11 , . . . , Ck1 ; C0 ) construieşte un ciclul C0 obţinut prin adăugarea
la ciclul C, succesiv, a ciclurilor C11 , . . . , Ck1 .
Algoritm 26 Algoritm de determinare a unui ciclu eulerian ı̂ntr–un graf conex

1: function EulerRec(G = (V, E))
2: if (IsEulerian(G) = f alse) then
3: return ∅
4: end if
5: call F indCycle(G; C)
6: if (E(G) \ E(C) = ∅) then
7: return C
8: end if
9: G′ ← G − E(C)
10: call F indComponents(G′ ; k, G11 , G12 , . . . , G1k )
11: for i ← 1, k do
12: Ci1 ← EulerRec(G1i )
13: end for
14: call M ergeCycles(C, C11 , . . . , Ck1 ; C0 )
15: return C0
16: end function
Fig. 3.4: Grafurile parţiale obţinute ı̂n urma primelor două etape ale algoritmului 26
Exemplul 3.5 Să aplicăm algoritmul 26 pentru graful din figura 3.3. Presupunem că primul
element (elementul de start) este vârful u0 = 1. Procedura F indCycle construieşte lanţul
60
Fig. 3.5: Grafurile parţiale obţinute ı̂n urma etapelor 3 şi 4 ale algoritmului 26
L = [1, 2, 3, 4, 5, 3]. Se observă prezenţa ciclului C1 = [3, 4, 5, 3]. În urma eliminării acestuia
rămâne graful din figura 3.4 a) care este un graf conex.
Continuăm procesul de construire a unui ciclu eulerian, prin apelul procedurii F indCycle
pentru noul graf. Aceasta returnează ciclul C2 = [1, 2, 3, 9, 1]. Prin eliminarea muchiilor
acestuia, E(C2 ), se obţine graful din figura 3.4 b). În continuare se construieşte lanţul
L = [2, 8, 7, 5, 6, 4, 10, 2], ce conţine ciclul C3 = [2, 8, 7, 5, 6, 4, 10, 2]. Graful obţinut prin
eliminarea muchiilor ciclului este cel din figura 3.5 a). Apelul procedurii F indCycle conduce
la determinarea lanţului L = [6, 7, 9, 8, 10, 6] şi a ciclului C4 = [6, 7, 9, 8, 10, 6].
Ciclul eulerian se formează prin reuniunea ciclurilor intermediare determinate: C =
(((C4 ∪ C3 ) ∪ C2 ) ∪ C1 ) adică C = [1, 2, 8, 7, 5, 6, 7, 9, 8, 10, 6, 4, 10, 2, 3, 4, 5, 3, 9, 1] (C4 ∪ C3 =
[2, 8, 7, 5, 6, 7, 9, 8, 10, 6, 4, 10, 2]).
3.1.2 Algoritmul lui Rosenstiehl

Algoritmul lui Rosenstiehl [52] construieşte un lanţ L care la final va deveni un ciclu eulerian,
folosind pentru aceasta o stivă drept structură de date auxiliară.
Se porneşte de la un nod oarecare. Se ı̂naintează atâta timp cât este posibil: pentru
nodul curent u se caută o muchie incidentă cu el, şi care să nu mai fi fost parcursă la unul
din paşii anteriori. Dacă există o astfel de muchie (e = [u, v]), atunci se salvează pe stivă
nodul u, iar nodul v devine nodul curent. În momentul ı̂n care nodul curent u nu mai are
muchii nevizitate, se adaugă lanţului L, şi se extrage de pe stivă nodul anterior (din care s-a
ajuns ı̂n u) (a se vedea algoritmul 27). Vectorul vizit are drept scop să păstreze situaţia
muchiilor: (
1 , dacă e ∈ E a fost parcursă
vizite =
0 , dacă e ∈ E nu a fost ı̂ncă parcursă.
Exemplul 3.6 Să aplicăm algoritmul 27 pentru graful din figura 3.3. Să presupunem că
vârful u de la care porneşte algoritmul este vârful 1. La sfârşitul primului pas al enunţului
repetitiv while (liniile 6 – 14) avem valorile:
S = [1, 2, 3, 4, 5, 3, 9], L = [1], u = 1.
La pasul următor, se extrage valoarea 9 de pe stivă şi astfel u devine 9. La sfârşitul acestuia
61
Algoritm 27 Algoritm lui Rosenstiehl de determinare a unui ciclu eulerian ı̂ntr–un graf
conex
1: function Rosenstiehl(u, G)
2: for e ∈ E do
3: vizite ← 0
4: end for
5: S⇐u ⊲ Se inserează pe stivă nodul u
7: S⇒u ⊲ Se extrage din stivă nodul curent
8: while (∃e = [u, v] ∈ E) ∧ (vizite = 0)) do
9: vizite ← 1 ⊲ Se marchează muchia e ca fiind utilizată
10: S⇐u ⊲ Se salvează pe stivă nodul curent u
11: u←v ⊲ Nodul curent devine nodul v
12: end while
13: L⇐u ⊲ Se adaugă la lista L nodul curent
14: end while
15: return L
16: end function
avem:
S = [1, 2, 3, 4, 5, 3, 9, 7, 5, 6, 4, 10, 2, 8, 7, 6, 10, 8], L = [1, 9], u = 9.
În continuare, deoarece nu mai există muchii nevizitate, se vor extrage elementele aflate pe
stiva S câte unul la fiecare pas, formând secvenţa (8, 10, 6, 7, 8, 2, 10, 4, 6, 5, 7, 9, 3, 5, 4, 3, 2, 1),
şi se vor introduce ı̂n lista L:
P as 20 : S = [], L = [1, 9, 8, 10, 6, 7, 8, 2, 10, 4, 6, 5, 7, 9, 3, 5, 4, 3, 2, 1], u = 1.
Ciclul eulerian obţinut se află ı̂n lista L.
În continuare se prezintă implementarea ı̂n limbajul C++ a algoritmului lui Rosenstiehl :
Listing 3.1: rosenstiehl.cpp
#include <vector>
#include <stack>
#include <list>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <conio.h>
using namespace std;
#define INPUT_FILE "graf1.txt"
typedef vector<int> Linie;

typedef vector<Linie> Matrice;
int readInput(Matrice& ma) {

int n, i, j, value;
ifstream fin(INPUT_FILE);
62
fin >> n;
ma = Matrice(n, Linie(n, 0));
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
fin >> ma[i][j];
}
fin.close();
return n;
}
void print(list<int>& l) {
list<int>::iterator it;
cout << "Ciclu eulerian: [";

for (it = l.begin(); it != l.end(); it++)
cout << *it << ", ";
cout << "]\n";
}
void rosenstiehl(int n, Matrice& ma, int u, list<int>& l) {

stack<int> s;
int v;
s.push(u);
while (!s.empty()) {
u = s.top();
s.pop();
v = 0;
while (v < n) {
if (ma[u][v] == 1) {
ma[u][v] = 0;
ma[v][u] = 0;
s.push(u);
u = v;
v = 0;
}
else
v++;
}
l.push_back(u);
}
}
void main(void) {
Matrice ma;
list<int> l = list<int>();
int n = readInput(ma);
rosenstiehl(n, ma, 0, l);

print(l);
63
}
Datele de intrare vor fi preluate dintr-un fişier. Conţinutul fişierului de intrare graf1.txt
corespunzător grafului din figura 3.6 este următorul:
6
0 1 1 1 1 0
1 0 1 1 1 0
1 1 0 1 0 1
1 1 1 0 0 1
1 1 0 0 0 0
0 0 1 1 0 0
Pe prima linie avem numărul de vârfuri al grafului (cardinalul mulţimii V ), şi ı̂ncepând
cu cea de-a doua linie avem valorile matricei de adiacenţă, separate prin spaţii, câte un rând
al acesteia pe fiecare pe linie.
Fig. 3.6: Un alt exemplu de graf eulerian
Pentru a reduce timpul de implementare, am utilizat câteva structuri de date deja exis-
tente ı̂n limbajul C++, mai exact structuri de date implementate cu ajutorul template-urilor
din cadrul librăriei Standard Template Library - STL2 3 :
• stiva - stack 4. Am folosit o stivă de numere ı̂ntregi: stack<int> s;.
• lista - list 5 . Pentru a păstra elementele ciclului eulerian am folosit o listă liniară,
informaţia utilă din cadrul nodurilor fiind constituită din valori ı̂ntregi: list<int> l
= list<int>();.
• vector - vector 6 . Matricea de adiacenţă am implementat-o sub forma unui vector de
vectori cu elemente numere ı̂ntregi:
...
Matrice ma;
ma = Matrice(n, Linie(n, 0));
După cum se poate observa din programul anterior, pentru reprezentarea internă a
grafului s-a folosit matricea de adiacenţă.
2
http://en.wikipedia.org/wiki/Standard_Template_Library,
3
http://www.sgi.com/tech/stl/
4
http://www.sgi.com/tech/stl/stack.html
5
http://www.sgi.com/tech/stl/List.html
6
http://www.sgi.com/tech/stl/Vector.html
64
• Parcurgerea elementelor listei se realizează cu ajutorul unui iterator - iterator 7 . Declararea
unui obiect de tip list<int>::iterator se poate face astfel: list<int>::iterator
it;.
void print(list<int>& l) {
list<int>::iterator it;
cout << "Ciclu eulerian: [";

for (it = l.begin(); it != l.end(); it++)
cout << *it << ", ";
cout << "]\n";
}
Deoarece muchiile sunt parcurse o singură dată ı̂n cadrul acestui algoritm, şi pentru a
nu mai păstra o structură auxiliară care să marcheze faptul că o muchie a fost vizitată, vom
marca parcurgerea unei muchii prin ştergerea acesteia din matricea de adiacenţă astfel:
ma[u][v] = 0;
ma[v][u] = 0;
Ciclul eulerian obţinut pentru graful din figura 3.6 este: L = [1, 5, 2, 4, 6, 3, 4,
1, 3, 2, 1].
3.2 Grafuri Hamiltoniene

Definiţia 3.2 Se numeşte lanţ Hamilton sau lanţ hamiltonian un lanţ L ce trece o
singură dată prin toate vârfurile unui graf.
Definiţia 3.3 Se numeşte ciclu hamiltonian un ciclu elementar ce trece prin toate vârfurile
grafului. Un graf ce admite un ciclu hamiltonian se numeşte graf hamiltonian.
Problema determinării dacă un graf oarecare G este hamiltonian este o problemă dificilă,
atenţia cercetătorilor ı̂ndreptându–se către enunţarea unor condiţii suficiente de existenţă a
unui ciclu hamiltonian.
Lema 3.7 Fie G = (V, E) un graf neorientat şi fie u şi v două vârfuri neadiacente ale grafului
(u, v ∈ V , u 6= v, [u, v] ∈
/ E), astfel ı̂ncât dG (u) + dG (v) ≥ n. Atunci G este hamiltonian ⇔
G + [u, v] este hamiltonian.
Demonstraţie: ” ⇒ ” Dacă G este hamiltonian, atunci cu atât mai mult, graful G+[u, v]
este hamiltonian.
” ⇐ ” Presupunem că G + [u, v] este un graf hamiltonian. Atunci există un ciclu hamil-
tonian ı̂n graful G + [u, v] pe care ı̂l notăm cu C.
1. dacă [u, v] ∈
/ C atunci C este un ciclu hamiltonian şi ı̂n graful G ⇒ G este un graf
hamiltonian.
2. dacă [u, v] ∈ C atunci C = [u, v, x3 , x4 , . . . , xn−1 , xn , u]. Pentru fiecare muchie [u, xk ] ∈
E putem avea următoarele situaţii:
7
http://www.sgi.com/tech/stl/Iterators.html
65
(a) [v, xk+1] ∈ E. Atunci ciclul C1 = [u, xk , xk−1 , . . . , x3 , v, xk+1, . . . , xn , u] este hamil-
tonian ı̂n graful G ⇒ graful G este hamiltonian.
(b) [v, xk+1] ∈

/ E. Notăm dG+[u,v] (u) = k. Atunci dG+[u,v] (v) ≤ n − k − 1. şi De aici,
rezultă că dG (u) + dG (v) < dG+[u,v] (u) + dG+[u,v] (v) ≤ n − k + k − 1 = n − 1 < n.
Contradicţie cu dG (u) + dG (v) ≥ n, ∀u, v ∈ V, u 6= v, [u, v] ∈ / E.
Prin urmare lema este demonstrată.
Teorema 3.8 (Dirac, 1952) Un graf G = (V, E) (|V | ≥ 3) este hamiltonian dacă ∀u ∈ V
avem dG (u) ≥ n2 (orice vârf al grafului are gradul mai mare decât jumătate din numărul de
vârfuri din graf ).
Teorema 3.9 (Ore, 1961) Un graf G = (V, E) (|V | ≥ 3) este hamiltonian dacă ∀u, v ∈ V
avem dG (u) + dG (v) ≥ n unde u 6= v, [u, v] ∈ / E (pentru oricare două vârfuri distincte,
neadiacente, ale grafului suma gradelor lor este mai mare decât numărul de vârfuri din graf ).
Teorema 3.10 (Chvatal, 1972) Fie un graf G = (V, E) (|V | ≥ 3) şi d1 , d2 , . . . , dn o

secvenţă grafică. Dacă este satisfăcută relaţia
n
∀k a.i. dk ≤ k ≤ ⇒ dn−k ≥ n − k
2
atunci graful este hamiltonian.
Definiţia 3.4 Pentru un graf G construim un şir de grafuri G = G1 , G2 , . . . astfel: graful

Gk+1 se obţine din graful Gk prin adăugarea muchiei [uk , vk ], unde vârfurile uk , vk ∈ V nu
sunt adiacente ı̂n Gk şi dG (uk ) + dG (vk ) ≥ n. Procesul se ı̂ncheie ı̂n momentul ı̂n care nu
mai există două vârfuri neadiacente distincte astfel ı̂ncât dG (up ) + dG (vp ) ≥ n. Graful Gp se
numeşte ı̂nchiderea lui G şi se notează cu cl(G).
Lema 3.11 Orice graf prezintă o singură ı̂nchidere.
Corolarul 3.12 Un graf G = (V, E) (|V | ≥ 3) este hamiltonian dacă cl(G) ≅ Kn (dacă
ı̂nchiderea lui G este izomorfă cu graful complet de ordinul n).
Definim δ(G) = min{dG (u)|u ∈ V } şi ∆(G) = max{dG (u)|u ∈ V }.
Corolarul 3.13 Un graf G = (V, E) (|V | ≥ 3) este hamiltonian dacă δ(G) ≥ n2 .
Definiţia 3.5 O mulţime de vârfuri A a unui graf G se spune că este independentă dacă
oricare două elemente distincte din A sunt independente. Numărul de independenţă al lui G,
notat cu β(G), reprezintă numărul maxim de vârfuri dintr–o mulţime independentă.
β(G) = 1 dacă şi numai dacă graful G este complet.
Definiţia 3.6 Pentru un graf G se numeşte conectivitatea lui G, şi notăm cu κ(G),
numărul minim de vârfuri ale unei tăieturi. O tăietură este o submulţime U a lui V astfel
ı̂ncât graful G − U să fie neconex.
Teorema 3.14 Un graf G = (V, E) având ordinul n ≥ 3, este hamiltonian dacă κ(G) ≥
β(G).
66
Observaţia 3.15 Pentru un graf bipartit G = (V1 , V2 , E) condiţia necesară pentru a fi hamil-
tonian este |V1 | = |V2 |.
Problema comis–voiajorului include problema determinării existenţei unui ciclu hamilto-

nian ı̂ntr–un graf.
Căutarea optimului printre toate variantele de cicluri nu este o soluţie fezabilă deoarece
pentru un graf G numărul de cicluri poate fi foarte mare. De exemplu pentru graful complet
Kn avem (n−1)!
2
cicluri hamiltoniene distincte.
Exemplul 3.16 Graful din figura 2.15 nu este hamiltonian (nu admite un ciclu hamilto-
nian).
• Graful din figura 3.6 are mai multe cicluri hamiltoniene: de exemplu ciclurile C1 = [1, 5,
2, 3, 6, 4, 1] şi C2 = [1, 3, 6, 4, 2, 5, 1].
Nod 1 2 3 4 5 6
dG 4 4 4 4 2 2
Teorema lui Dirac (1952) nu se poate aplica deoarece nu este ı̂ndeplinită condiţia ”orice vârf
al grafului are gradul mai mare decât jumătate din numărul de vârfuri din graf”:
n 6
dG (5) = 2 < = = 3.
2 2
De asemenea, pentru teorema lui Ore (1961) nu este ı̂ndeplinită condiţia ”pentru oricare două
vârfuri dinstincte, neadiacente, ale grafului suma gradelor lor este mai mare decât numărul
de vârfuri din graf”: fie vârfurile 5 şi 6, neadiacente, pentru care avem
dG (5) + dG (6) = 2 + 2 = 4 < 6.
• Pentru graful din figura 3.7 avem:
Nod 1 2 3 4 5 6 7 8
dG 3 4 3 4 4 5 3 4
– condiţia teoremei lui Dirac (1952), nu este ı̂ndeplinită: dG (1) = 3 < 4 = n2 ;
– condiţia teoremei lui Ore (1961), nu este ı̂ndeplinită: dG (2) + dG (7) = 4 + 3 = 7 < 8;
– observăm că nici condiţiile teoremei lui Chvatal (1972) nu sunt ı̂ndeplinite: fie d1 , d2 , . . . , dn
o secvenţă grafică.
Nod 1 3 7 2 4 5 8 6
dG 3 3 3 4 4 4 4 5
Relaţia următoare nu este satisfăcută:

n
∀k a.i. dk ≤ k ≤ ⇒ dn−k ≥ n − k.
2
67
3.2.1 Problema comis–voiajorului
Un comis-voiajor trebuie să viziteze n oraşe etichetate cu numerele de la 1 la n. Pentru a
simplifica problema, acesta va pleca ı̂ntotdeauna din oraşul numărul 1 şi se va ı̂ntoarce tot ı̂n
1, trecând prin fiecare oraş o singură dată (cu excepţia oraşului 1 care va fi vizitat de două
ori). Cunoscând distanţele ı̂ntre oraşe, să se determine o parcurgere (ciclu hamiltonian) de
cost minim.
Pentru a reprezenta drumurile directe dintre oraşe (existenţa unei legături directe ı̂ntre
acestea) utilizăm matricea costurilor A = (aij ), i, j = 1, n:

0
ai,j = +∞ /E.
, dacă [xi , xj ] ∈ (3.1)


d > 0 , dacă [xi , xj ] ∈ E
Vectorul soluţiilor rezultat va fi X = (x1 , x2 , . . . , xn+1 ) ∈ V × . . . × V unde x1 = xn+1 = 1:

la pasul i, i = 2, n + 1, se vizitează oraşul xi ∈ V . Primul oraş, oraşul din care se pleacă,
este fixat la 1 (vezi algoritmul 28).
La pasul k (2 ≤ k ≤ n + 1) se ı̂ncearcă vizitarea oraşului xk + 1 dacă nu a fost vizitat
la un pas anterior, şi dacă costul parţial al lanţului este mai mic decât costul celui mai bun
ciclu hamiltonian obţinut până ı̂n acel moment ı̂n graf:
1 ≤ xk < n şi vizitatxk +1 = 0 şi cost + axk−1 ,xk +1 ≤ costoptim (3.2)
(pentru k = n + 1 trebuie verificată şi condiţia xk = 1).

La ı̂nceput costul celui mai scurt ciclu hamiltonian poate fi determinat cu un algoritm
de tip Greedy sau i se poate atribui valoarea +∞ (o valoare suficient de mare, de exemplu
n · max{ai,j |∀i, j = 1, n, i 6= j, ai,j 6= ∞}).
Dacă condiţiile anterioare sunt ı̂ndeplinite, atunci xk ← xk + 1. Se marchează oraşul ales
la pasul k ca fiind vizitat (vizitatk ← 1), se actualizează costul drumului până ı̂n momentul
curent (cost ← cost + axk−1 ,xk ), şi se trece la pasul k + 1.
În caz contrar, nu există nici o alegere convenabilă pentru oraşul de pe poziţia k şi va
trebui să ne ı̂ntoarcem pentru o altă alegere pentru oraşul vizitat la pasul k−1. Pentru aceasta
se marchează oraşul ales la pasul anterior ca nefiind vizitat (vizitatxk ← 0), şi se scade din
costul drumului până ı̂n momentul curent, costul muchiei [xk−1 , xk ] (cost ← cost − axk−1 ,xk ).
Fig. 3.7: Exemplu de graf pentru problema comis-voiajorului
68
Exemplul 3.17 Matricea costurilor corespunzătoare grafului din figura 3.7 are următoarele
valori:
 
0 14 6 ∞ 5 ∞ ∞ ∞
14 0 ∞ 12 16 20 ∞ ∞
 
6 ∞ 0 ∞ ∞ 12 ∞ 12
 
∞ 12 ∞ 0 21 ∞ 24 10
A=  5 16 ∞ 21 0

 16 ∞ ∞
∞ 20 12 ∞ 16 0 14 6
 
∞ ∞ ∞ 24 ∞ 14 0 10
∞ ∞ 12 10 ∞ 6 10 0
Graful respectiv are mai multe cicluri hamiltoniene:
• C1 = [1, 2, 4, 5, 6, 7, 8, 3, 1].
• C2 = [1, 2, 5, 4, 8, 7, 6, 3, 1].
• C3 = [1, 5, 6, 2, 4, 7, 8, 3, 1].
• C4 = [1, 3, 6, 7, 8, 4, 2, 5, 1].
Fig. 3.8: Rezultatul rulării programului pentru determinarea ciclului hamiltonian optim
Programul corespunzător scris ı̂n limbajul C este următorul:

Listing 3.2: hamilton.c
#include <stdio.h>
#include <memory.h>
#define NMAX 100 //numarul maxim de noduri din graf

#define LIMIT 100000 //lungimea maxima a unei muchii echivalenta cu infinit
typedef int Matrice[NMAX][NMAX];

typedef int Vector[NMAX];
long cost_optim; //costul circuitului hamiltonian optim

Vector x_optim; //elementele circuitului hamiltonian optim
/**
* Functia citeste valorile datelor de intrare.
69
Algoritm 28 Algoritm pentru problema comis-voiajorului
(
A - matricea de costuri ce conţine distanţele dintre oraşe
Input:
n - numărul de oraşe
1: function CanContinue(A, X, k, cost)
2: if (vizitatxk = 1) ∨ (cost + axk−1 ,xk > costoptim ) ∨ ((k 6= n + 1) ∧ (xk = x1 ))) then
3: return f alse
4: else
5: return true
6: end if
7: end function
8: procedure Evaluare Solutie(X, cost)

9: X optim ← X
10: costoptim ← cost
11: end procedure
12: procedure ComisVoiajorBacktracking(A, n)

13: x1 ← 1, cost ← 0, costoptim ← ∞
14: k ← 2, xk ← 1
15: while (k > 1) do
16: gasit ← f alse
17: while ((xk + 1 ≤ n) ∧ (gasit = f alse)) do
18: xk ← xk + 1
19: gasit ← CanContinue(A, X, k, cost)
20: end while
21: if (gasit = true) then
22: if (k = n + 1) then
23: call Evaluare Solutie(X, cost + axk−1 ,xk )
24: else
25: vizitatxk ← 1
26: cost ← cost + axk−1 ,xk
27: k ←k+1
28: xk ← 0
29: end if
30: else
31: k ←k−1
32: vizitatxk ← 0
33: if (k > 1) then
34: cost ← cost − axk−1 ,xk
35: end if
36: end if
37: end while
38: Output {’Solutia optima: ’, xoptim
1 , . . . , xoptim
n+1 , cost
optim }
39: end procedure
*/
int readInput(Matrice a) {
int n;
int i, j, max = 0;
70
scanf("%d", &n);
for (i = 1; i <= n; i++)

for (j = 1; j <= n; j++) {
scanf("%d", &a[i][j]);
if (max < a[i][j])
max = a[i][j];
if (a[i][j] < 0)
a[i][j] = LIMIT;
}
cost_optim = n * max;
return n;
}
/**
* Functia verifica daca a + b > c.
*/
int mai_mare(long a, long b, long c) {
if (a + b > c)
return 1;
else
return 0;
}
/**
* Functia afiseaza solutia calculata a problemei.
*/
void AfisareSolutie(int n) {
int i;
printf("Costul ciclului optim: %ld \n", cost_optim);

printf("Ciclu hamiltonian: [");
for (i = 1; i < n+1; i++)
printf("%d, ", x_optim[i]);
printf("%d]\n", x_optim[n+1]);
}
/**
* Functia de continuare: aici se verifica daca elementul de pe pozitia k
* nu se mai afla in sirul A.
*/
int CanContinue(int n, Matrice a, int k, long cost, Vector vizitat, Vector x) {
if ((vizitat[x[k]] == 1) || (mai_mare(cost, a[x[k-1]][x[k]], cost_optim))
|| ((k != n+1) && (x[k] == 1)))
return 0;
else
return 1;
}
/**
* Functia salveaza solutia optima (circuitul hamiltonian de cost minim)
71
* determinata/gasita pana in momentul curent.
*/
void EvaluareSolutie(int n, long cost, Vector x) {
int i;
cost_optim = cost;
for (i = 1; i <= n+1; i++)
x_optim[i] = x[i];
AfisareSolutie(n);
}
/**
* Metoda backtracking implementata.
*/
void ComisVoiajorBacktracking(int n, Matrice a) {
Vector x;
Vector vizitat;
int k, gasit;
long cost;
x[1] = 1;
cost = 0;
k = 2; x[k] = 1;
while (k > 1) {
gasit = 0;
while ((x[k] + 1 <= n) && (gasit == 0)) {
x[k] = x[k] + 1;
gasit = CanContinue(n, a, k, cost, vizitat, x);
}
if (gasit == 1) {
if (k == n+1)
EvaluareSolutie(n, cost + a[x[k-1]][x[k]], x);
else {
vizitat[x[k]] = 1;
cost = cost + a[x[k-1]][x[k]];
k = k + 1;
x[k] = 0;
}
}
else {
k = k - 1;
vizitat[x[k]] = 0;
if (k > 1)
cost = cost - a[x[k-1]][x[k]];
}
}
}
void main(void) {
Matrice a;
int n = readInput(a);
72
ComisVoiajorBacktracking(n, a);
}
Conţinutul fişierului graf1.txt este:
8
0 14 6 -1 5 -1 -1 -1
14 0 -1 12 16 20 -1 -1
6 -1 0 -1 -1 12 -1 12
-1 12 -1 0 21 -1 24 10
5 16 -1 21 0 16 -1 -1
-1 20 12 -1 16 0 14 6
-1 -1 -1 24 -1 14 0 10
-1 -1 12 10 -1 6 10 0
Corespunzător valorii ∞ am utilizat ı̂n fişierul de test valoarea negativă −1. În timpul
citirii datelor aceasta a fost ı̂nlocuită cu o constantă suficient de mare:
...
scanf("%d", &a[i][j]);
if (max < a[i][j])
max = a[i][j];
if (a[i][j] < 0)
a[i][j] = LIMIT;
În timpul citirii se determină valoarea maximă, max{ai,j |∀i, j = 1, n, i 6= j, ai,j 6= ∞}, pentru
a se iniţializa mai apoi costul optim cu valoarea n · max.
Funcţia ı̂n care se verifică condiţiile de continuare este următoarea:
int CanContinue(int n, Matrice a, int k, long cost, Vector vizitat, Vector x) {
if ((vizitat[x[k]] == 1) || (mai_mare(cost, a[x[k-1]][x[k]], cost_optim))
|| ((k != n+1) && (x[k] == 1)))
return 0;
else
return 1;
}
Folosim o funcţie (mai mare()) cu scopul de a realiza verificarea inegalităţii cost +
axk−1 ,xk +1 > costoptim :
if (a + b > c)
return 1;
else
return 0;
}
şi a preveni eventualele depăşiri (overflow )8 ı̂n timpul calculelor.
Nu am afişat numai soluţia optimă, ci am ales să afişăm toate ciclurile hamiltoniene care
ı̂mbunătăţeau soluţia anterioară:
void EvaluareSolutie(int n, long cost, Vector x) {
int i;
8
http://en.wikipedia.org/wiki/Arithmetic_overflow
73
cost_optim = cost;
for (i = 1; i <= n+1; i++)
x_optim[i] = x[i];
AfisareSolutie(n);
}
Partea principală a programului, motorul, este constituită din funcţia:
void ComisVoiajorBacktracking(int n, Matrice a) {
Vector x;
Vector vizitat;
int k, gasit;
long cost;
x[1] = 1;
cost = 0;
k = 2; x[k] = 1;
while (k > 1) {
gasit = 0;
while ((x[k] + 1 <= n) && (gasit == 0)) {
x[k] = x[k] + 1;
gasit = CanContinue(n, a, k, cost, vizitat, x);
}
if (gasit == 1) {
if (k == n+1)
EvaluareSolutie(n, cost + a[x[k-1]][x[k]], x);
else {
vizitat[x[k]] = 1;
cost = cost + a[x[k-1]][x[k]];
k = k + 1;
x[k] = 0;
}
}
else {
k = k - 1;
vizitat[x[k]] = 0;
if (k > 1)
}
}
}
Pentru n = 8, mulţimea Ai va fi alcătuită din elementele {1, 2, . . . , 8}. La ı̂nceput, x1 va
primi valoarea 1, iar pentru k = 2, x2 va primi tot valoarea 1:
x1 x2 x3 x4 x5 x6 x7 x8 x9
1 1
Pentru k = 2, se verifică condiţiile de continuare pentru x2 = x2 + 1 = 1 + 1 = 2, şi
deoarece acestea sunt respectate, se trece la pasul următor (oraşul următor) (la iniţializare
avem k = k + 1 = 3, x3 = 0):
x1 x2 x3 x4 x5 x6 x7 x8 x9
1 2 0
74
Se verifică mai multe valori (1, 2 şi 3) pentru x3 , pentru care condiţiile de continuare nu
sunt ı̂ndeplinite. Pentru x3 = 4 condiţiile de continuare sunt ı̂ndeplinite, şi se trece la pasul
următor, k = k + 1 = 4:
x1 x2 x3 x4 x5 x6 x7 x8 x9
1 2 4 0
Pentru k = 4, prima valoare ce verifică condiţiile de continuare este 5:
x1 x2 x3 x4 x5 x6 x7 x8 x9
1 2 4 5 0
În mod asemănător se aleg valorile pentru paşii k = 5, 6, 7, 8:
x1 x2 x3 x4 x5 x6 x7 x8 x9
1 2 4 5 6 3 8 7 0
La pasul k = 9, nici una dintre valorile 1, 2, . . . , 8 nu verifică condiţiile de continuare (fiind
la ultimul oraş, acesta ar trebui să fie 1, adică oraşul de unde s-a pornit). Astfel, se trece la
pasul anterior:
k = k - 1;
vizitat[x[k]] = 0;
if (k > 1)
adică la pasul k = k − 1 = 9 − 1 = 8.
Valoarea 8, următoarea valoare din domeniul de valori neverificată şi singura ce mai
rămăsese de atribuit pentru x8 , nu verifică condiţiile de continuare, şi deoarece nu mai sunt
valori de testat la pasul k = 8, se trece la nivelul anterior: k = k − 1 = 8 − 1 = 7.
La pasul k = 7, deoarece nu au mai rămas valori netestate din mulţimea A7 = {1, 2, . . . , 8},
se trece la pasul k = 6:
x1 x2 x3 x4 x5 x6 x7 x8 x9
1 2 4 5 6 3
Aici continuăm cu verificarea valorilor 4, 5, 6 şi 7. Pentru x6 = 7 sunt verificate condiţiile
de continuare şi se poate trece la pasul următor, k = 7:
x1 x2 x3 x4 x5 x6 x7 x8 x9
1 2 4 5 6 7 0
Doar pentru valoarea 8 sunt ı̂ndeplinite condiţiile de continuare:
x1 x2 x3 x4 x5 x6 x7 x8 x9
1 2 4 5 6 7 8 0
La pasul k = 8, xk = 3 ı̂ndeplineşte conţiile de continuare şi se poate trece la nivelul
următor, k = 9:
x1 x2 x3 x4 x5 x6 x7 x8 x9
1 2 4 5 6 7 8 3 0
Aici soluţia optimă găsită este următoarea:
x1 x2 x3 x4 x5 x6 x7 x8 x9
1 2 4 5 6 7 8 3 1
având un cost al ciclului hamiltonian de 105.
Se păstrează soluţia optimă identificată până ı̂n acest moment, se afişează, şi se continuă
efectuarea calculelor metodei până la epuizarea spaţiului soluţiilor posibile.
75
Fig. 3.9: Pasii efectuati de algoritm pentru determinarea ciclului hamiltonian asociat grafului din figura 3.7
76
Fig. 3.10: Pasii efectuati de algoritm pentru determinarea ciclului hamiltonian asociat grafului din figura 3.7
(continuare)
77
3.3 Exerciţii
1. Să se determine un ciclu hamiltonian, dacă există, ı̂n grafurile din figura 3.11.
Fig. 3.11: Exemple de grafuri neorientate pentru cicluri hamiltoniene
2. Să se verifice dacă există şi, ı̂n caz afirmativ, să se pună ı̂n evidenţă un ciclu eulerian
ı̂n grafurile din figura 3.12.
Fig. 3.12: Exemple de grafuri neorientate pentru cicluri euleriene
78
3. Să se verifice dacă există şi, ı̂n caz afirmativ, să se pună ı̂n evidenţă un ciclu hamiltonian
ı̂n grafurile din figura 3.13.
Fig. 3.13: Exemple de grafuri neorientate pentru cicluri hamiltoniene
4. Să se determine un ciclu eulerian, dacă există, ı̂n grafurile din figura 3.14.
Fig. 3.14: Exemple de grafuri neorientate pentru cicluri euleriene
79
5. Se dă un graf neorientat G = (V, E), n = |V |, m = |E|. Să se elaboreze un algoritm
ce determină numărul minim de muchii ce trebuie adăugate astfel ı̂ncât ı̂n graful G să
existe un ciclu eulerian.
6. Se dă un graf neorientat conex G = (V, E), n = |V |, m = |E|. Să se elaboreze un

algoritm ce determină numărul de cicluri de lungime k.
7. Se dă un graf orientat G = (V, E). Ce condiţii trebuie să fie ı̂ndeplinite astfel ı̂ncât
graful G să fie eulerian?
8. Se dau N dominouri. Să se determine o modalitate de construire al unui şir, care să
conţină toate dominourile, respectând regula jocului domino. Această regulă ı̂nseamnă
că numerele ı̂nscrise pe feţele corespunzătoare a două dominouri consecutive trebuie să
fie egale. Dominourile pot fi alese ı̂n ordine oarecare şi rotite.
Date de intrare
Pe prima linie a fişierului de intrare domino.in se va afla numărul N al dominourilor.
Pe următoarele N linii se vor afla câte două numere separate printr-un singur spaţiu,
reprezentând cele două numere ı̂nscrise pe dominoul corespunzător.
Date de ieşire
Pe prima linie a fişierul domino.out va trebui să afişaţi 1, dacă există soluţie şi 0 dacă
nu. Dacă există soluţie vor urma exact N linii, care descriu şirul construit. Cele N
linii vor trebui să conţină numerele de ordine ale dominourilor ı̂n ordinea ı̂n care apar
ı̂n şir. Fiecare număr de ordine va fi urmat de un spaţiu şi de un număr, care poate fi
0 sau 1 şi va fi egal cu 1 ı̂n cazul ı̂n care dominoul corespunzător a fost rotit.
1 ≤ N ≤ 50.000. Numerele ı̂nscrise pe dominouri pot fi cuprinse ı̂ntre 0 şi 9 inclusiv.
Exemplu
domino.in domino.out
12 1
1 4 3 0
3 7 11 0
1 5 12 1
2 4 9 1
2 5 8 1
2 6 2 0
2 7 7 1
3 4 6 0
4 6 10 1
5 6 5 1
5 7 4 0
6 7 1 1
(Domino, Grigore Moisil By Net 2006 şi http://acm.sgu.ru/problem.php?contest=0&problem=101)
80
Capitolul 4
Arbori. Arbori binari
Definiţia 4.1 Fiind dată o mulţime M de elemente denumite noduri, vom numi arbore o
submulţime finită de noduri astfel ı̂ncât:
1. există un nod cu destinaţie specială, numit rădăcina arborelui;

2. celelalte noduri sunt repartizate ı̂n n mulţimi distincte, disjuncte două câte două, A1 , A2 , . . .,
An , fiecare mulţime Ai constituind la rândul ei un arbore.
Această definiţie este una recursivă, construcţia unui arbore depinzând de alţi arbori.
Descendenţii direcţi ai rădăcinii arborelui sunt rădăcinile subarborilor A1 , A2 , . . . , An , n ≥ 1.
Orice nod al unui arbore poate constitui rădăcina unui subarbore compus din nodul respectiv
şi toţi descendenţii săi.
Se observă că un arbore impune o structură de organizare ierarhică asupra elementelor
unei mulţimi.
Definiţia 4.2 Se numeşte arbore liber (”free tree”) un graf G = (V, E) neorientat, conex
şi aciclic.
Teorema 4.1 (Proprietăţile arborilor liberi) Fie G = (V, E) un graf neorientat. Următoarele
afirmaţii sunt echivalente:
1. G este un arbore liber.

2. Oricare două vârfuri din graful G sunt conectate printr-un drum elementar unic.
3. G este conex, dar, dacă eliminăm o muchie oarecare din E, graful obţinut nu mai este conex.
4. G este conex, şi |E| = |V | − 1.
5. G este aciclic, şi |E| = |V | − 1.
6. G este aciclic, dar dacă adăugăm o muchie oarecare ı̂n E, graful obţinut conţine un ciclu.
Definiţia 4.3 Dacă se alege un vârf sau nod drept rădăcina arborelui, atunci un arbore
liber devine arbore cu rădăcină. În general, vom folosi termenul de arbore ı̂n loc de
termenul corect arbore cu rădăcină.
Definiţia 4.4 Un vârf terminal (frunză) este un vârf fără descendenţi. Vârfurile care
nu sunt terminale sunt neterminale (sau noduri interioare). De obicei, se consideră că
există o ordonare a descendenţilor aceluiaşi părinte.
81
1
2 3
4 5 6 7
8 9 10 11 12 13 14 15
Fig. 4.1: Exemplu de arbore binar plin cu 24 − 1 vârfuri
Definiţia 4.5 Adâncimea unui vârf este dată de lungimea drumului de la rădăcină la acel
vârf. Înălţimea unui vârf se determină ca fiind valoarea celui mai lung drum dintre acel
vârf şi un vârf terminal. Înălţimea rădăcinii determină ı̂nălţimea arborelui. Nivelul
unui vârf se calculează ca diferenţa dintre ı̂nălţimea arborelui şi adâncimea acestui vârf.
Toate vârfurile unui arbore ce au aceeaşi adâncime se spune că sunt pe acelaşi nivel. Un
arbore oarecare cu rădăcină este n-ar dacă fiecare vârf are până la n descendenţi direcţi.
O mulţime de arbori disjuncţi formează o pădure.
Din punct de vedere grafic, un arbore se poate reprezenta descriind nodurile cu ajutorul
unor cercuri sau pătrate ı̂n care se află informaţia aferentă, iar relaţia de descendenţă prin
legăturile ce unesc nodurile cu fii lor.
4.1 Arbori binari

Definiţia 4.6 Un arbore binar este un arbore oarecare cu rădăcină, fiecare vârf al său
având cel mult doi descendenţi, indicându-se cine este descendentul stâng al rădăcinii şi cine
este cel drept.
Trebuie menţionat că un arbore binar nu este un caz particular de arbore oarecare,
deoarece ı̂n cazul unui arbore oarecare este suficient să spunem că un vârf are un singur
decendent spre deosebire de cazul arborelui binar când trebuie precizat dacă descendentul
este drept sau stâng. Arborele binar ce nu conţine nici un nod se numeşte arbore vid sau
arbore nul.
Definiţia 4.7 Se numeşte arbore binar plin un arbore binar cu 2k − 1 vârfuri aşezate pe
k nivele astfel ı̂ncât pe fiecare nivel i avem 2i−1 vârfuri.
Se observă că fiecare nod al unui arbore binar plin are doi descendenţi, descendentul stâng
şi descendentul drept, cu excepţia nodurilor terminale.
În figura 4.1 este prezentat un arbore binar plin ı̂n care vârfurile sunt aşezate pe 4 niveluri
(k = 4). De regulă, nodurile unui arbore binar plin se numerotează ı̂n ordinea nivelurilor, iar
ı̂n cadrul unui nivel, de la stânga la dreapta.
Definiţia 4.8 Se numeşte arbore binar complet cu n vârfuri un arbore binar plin având
k nivele, unde 2k−1 ≤ n < 2k , din care se elimină vârfurile numerotate n+ 1, n+ 2, . . . , 2k −1.
82
1
2 3
4 5 6 7
8 9 10 11 12
Fig. 4.2: Exemplu de arbore binar complet cu 12 vârfuri
În figura 4.2 este ilustrat un exemplu de arbore binar complet.

Un arbore binar poate fi transformat ı̂ntr-un arbore binar plin ı̂n modul următor: com-
pletăm arborele cu noi vârfuri astfel ı̂ncât fiecare vârf să aibă doi descendenţi sau nici unul,
renumerotăm vârfurile, iar vârfurilor nou introduse li se asociază o valoare ce va indica faptul
că ele sunt fictive.
4.1.1 Moduri de reprezentare

Cele mai cunoscute modalităţi de reprezentare a arborilor binari sunt:
1. expresii cu paranteze;
2. forma standard ;
3. reprezentarea tip tată.
2 8
3 5 9
4 6 7
Fig. 4.3: Exemplu de arbore binar
1. expresii cu paranteze - expresia ı̂ncepe cu rădăcina arborelui şi, după fiecare vârf k,
urmează expresiile subarborilor ce au ca rădăcini descendenţii vârfului respectiv, sepa-
rate prin virgulă şi incluse ı̂ntre paranteze. Dacă un descendent al unui vârf nu există,
atunci expresia respectivă este ı̂nlocuită cu 0 sau NULL. Un arbore cu un singur vârf
(rădăcina), etichetat cu a1 , se reprezintă astfel: a1 (0, 0). Un arbore format din rădăcină
a1 şi doi descendenţi, a2 şi a3 , se reprezintă astfel: a1 (a2 (0, 0), a3(0, 0)).
Pentru arborele din figura 4.3 avem:
1(2(3(0, 4(0, 0)), 5(6(0, 0), 7(0, 0))), 8(0, 9(0, 0))).
83
2. forma standard (stâng-drept) - se folosesc doi vectori identificaţi prin Stang şi Drept.
Se indică rădăcina arborelui, iar pentru fiecare vârf k se precizează descendentul său
stâng şi/sau drept, astfel:
(
i , dacă nodul i este descendentul stâng al nodului k
Stangk =
0 , dacă nu există descendentul stâng
(
i , dacă nodul i este descendentul drept al nodului k
Dreptk =
0 , dacă nu există descendentul drept.
Pentru arborele din figura 4.3 avem următoarea reprezentare (Rad = 1):
Nod 1 2 3 4 5 6 7 8 9
Stang 2 3 0 0 6 0 0 0 0
Drept 8 5 4 0 7 0 0 9 0
Fig. 4.4: Exemplu de arbore binar cu 8 noduri
Luând ca model o listă liniară dublu ı̂nlăţuită, putem folosi o structură de date asemănătoare
pentru reprezentarea unui arbore binar. Un nod al arborelui are următoarea structură:
TipOarecare data;
struct nod* stang;
struct nod* drept;
} Nod;
Nod *rad; - rad este o variabilă de tip pointer la Nod (variabila rad păstrează adresa
unei zone de memorie ce conţine date numerice de tip Nod). rad desemnează adresa
nodului rădăcină al arborelui.
În figura 4.5 avem reprezentarea arborelui din figura 4.4.
3. reprezentarea tip tată - pentru fiecare vârf k se indică tatăl nodului respectiv, astfel:
(
i , dacă nodul i este părintele nodului k
tatak =
0 , dacă nu există părintele nodului k.
Pentru arborele din figura 4.3 vom avea:

Nod 1 2 3 4 5 6 7 8 9
Tata 0 1 2 3 2 5 5 1 8
84
Fig. 4.5: Exemplu de arbore binar cu 8 noduri
Observaţia 4.2 Următoarea numerotare este utilizată pentru anumite tipuri de arbori
binari, şi are drept caracteristică faptul că structura arborelui se poate deduce printr-o
numerotare adecvată a vârfurilor:
(
⌊ k2 ⌋ , k≥2
T atak =
nu există , k = 1.
( (
2·k , 2·k ≤n 2·k+1 , 2·k+1≤n
Stangk = Dreptk =
nu există , 2 · k > n. nu există , 2 · k + 1 > n.
4.1.2 Metode de parcurgere

Un arbore binar poate fi parcurs ı̂n mai multe moduri. Indiferent de metoda de parcurgere
aleasă, se vizitează mai ı̂ntâi subarborele stâng şi apoi subarborele drept al fiecărui nod.
Diferenţa ı̂ntre aceste metode de parcurgere este dată de momentul ı̂n care un nod k este
vizitat ı̂n raport de subarborii săi stâng şi drept:
• parcurgere ı̂n preordine (rădăcină, subarbore stâng, subarbore drept).

În urma parcurgerii ı̂n preordine a arborelui din figura 4.3 rezultă următoarea ordine
de vizitare pentru noduri: 1, 2, 3, 4, 5, 6, 7, 8, 9.
În figura 4.6 este prezentată parcurgerea ı̂n preordine a unui arbore binar, detaliată ı̂n
mai mulţi paşi, conform descrierii recursive a acestei metode.
Vom da exemplu de o subrutină nerecursivă de vizitare ı̂n preordine (a se vedea algo-
ritmul 29).
Se pleacă de la rădăcină şi se coboară ı̂n arbore spre stânga, atâta timp cât este posibil
acest lucru (liniile 5-8). Dacă nu se mai poate ı̂nainta pe ramura stângă, se ı̂ncearcă
continuarea algorimului din descendentul drept al nodului curent, dacă este posibil.
Dacă nu se poate face un pas spre dreapta, deoarece descendentul drept al nodului
curent nu există (linia 10), se va urca ı̂n arbore câte un nivel (liniile 12-22), până când
se ı̂ntâlneşte situaţia de a se ajunge ı̂n nodul curent din descendentul său stâng (linia
85
Fig. 4.6: Parcurgerea ı̂n preordine a unui arbore binar a) arborele iniţial; b) arborele vizitat ı̂n preordine,
primul nivel; c) arborele vizitat ı̂n preordine, al doilea nivel; d) arborele vizitat ı̂n preordine, al treilea nivel.
19) şi există şi descendentul său drept. În continuare, se reia algoritmul trecând ı̂n
descendentul drept (linia 25).
În momentul ı̂n care s-a ajuns ı̂n nodul rădăcină venind din dreapta, algoritmul se
ı̂ncheie. Datorită faptului că atunci când se urcă ı̂n arbore este necesar să ştim din ce
descendent venim, stâng sau drept, vom utiliza şi vectorul tata.
Observaţia 4.3 Această procedură poate fi utilizată şi pentru celelalte moduri de par-
curgere, modificările necesare referindu-se la momentul când trebuie vizitat nodul curent
(prin apelul procedurii Vizitare - instrucţiunea call Vizitare(k)).
Implementarea ı̂n limbajul C a algoritmului de parcurgere ı̂n preordine este prezentată

ı̂n cele ce urmează:
Listing 4.1: preordine.c
#include <stdio.h>
#define MAXN 100
/** stang[k] - descendentul stang al nodului k; 0 daca nu exista */

char stang[MAXN];
/** drept[k] - descendentul drept al nodului k */
char drept[MAXN];
/** tata[k] - parintele nodului k */
char tata[MAXN];
/** numarul de noduri din arbore */
int n;
/** nodul radacina */
int rad;
86
Algoritm 29 Algoritm de parcurgere ı̂n preordine
1: procedure Preordine(Rad, Stang, Drept, T ata)
2: k ← rad
3: q←0
4: while (q = 0) do
5: while (stangk 6= 0) do
6: call V izitare(k) ⊲ prelucrarea informaţiei din nodul vizitat
7: k ← stangk
8: end while
9: call V izitare(k)
10: while ((q = 0) ∧ (dreptk = 0)) do
11: f ound ← 0
12: while ((q = 0) ∧ (f ound = 0)) do
13: j←k
14: k ← tatak
15: if (k = 0) then
16: q←1
17: else
18: if (j = stangk ) then
19: f ound ← 1
20: end if
21: end if
22: end while
23: end while
24: if (q = 0) then
25: k ← dreptk
26: end if
27: end while
28: return
29: end procedure
void vizitare(int nod) {

printf("%2d ", nod);
}
int k;

printf("rad = "); scanf("%d", &rad);
for (k = 1; k <= n; k++) {

printf("stang[%d] = ", k); scanf("%d", &stang[k]);
}
for (k = 1; k <= n; k++) {

printf("drept[%d] = ", k); scanf("%d", &drept[k]);
}
for (k = 1; k <= n; k++) {
87
printf("tata[%d] = ", k); scanf("%d", &tata[k]);
}
}
void preord(int rad) {

int k, j;
int q, found;
k = rad; q = 0;
while (q == 0) {
while (stang[k] != 0) {
vizitare(k);
k = stang[k];
}
vizitare(k);
while ((q == 0) && (drept[k] == 0)) {
found = 0;
while ((q == 0) && (found == 0)) {
j = k;
k = tata[k];
if (k == 0)
q = 1;
else
if (j == stang[k])
found = 1;
}
}
if (q == 0)
k = drept[k];
}
}
void main(void){
readInput();
preord(rad);
}
• parcurgere ı̂n inordine (arbore stâng, rădăcină, arbore drept): 3, 4, 2, 6, 5, 7, 1, 8, 9.

Metoda de parcurgere ı̂n inordine este ilustrată de algoritmul 30 [96], [131].
Se utilizează o structură de date de tip stivă, S, ı̂n care se vor păstra nodurile din care
se coboară spre stânga ı̂n arbore (liniile 6-9). Atunci când nu se mai poate ı̂nainta pe
ramura stângă, se ı̂ncearcă să se continue algoritmul din descendentul drept al nodului
curent. Dacă descendentul drept al nodului curent nu există, se reface drumul ı̂napoi
spre rădăcină, drum compus numai din nodurile din care s-a ı̂naintat spre stânga,
trecându-se ı̂n descendentul stâng (liniile 11-18). Urcarea ı̂n arbore spre rădăcină, se
ı̂ncheie fie când se identifică un nod ce posedă şi descendent drept, pe lângă cel stâng,
fie stiva devine vidă. Dacă se găseşte un nod ce are şi descendent drept, atunci nodul
curent devine descendentul drept, şi se reia procesul de ı̂naintare ı̂n arbore spre stânga.
Parcurgerea se termină ı̂n momentul ı̂n care stiva S este vidă (a se vedea algoritmul
30).
88
Algoritm 30 Algoritm de parcurgere ı̂n inordine
1: procedure Inordine(Rad, Stang, Drept)
2: k ← rad
3: S←∅ ⊲ iniţializare stivă vidă
4: q←0
5: while (q = 0) do
6: while (stangk 6= 0) do
7: S⇐k ⊲ S.push(k)
8: k ← stangk
9: end while
11: while ((q = 0) ∧ (dreptk = 0)) do
12: if (S = ∅) then ⊲ verificare dacă stiva este vidă
13: q←1
14: else
15: S⇒k ⊲ S.pop(k)
17: end if
18: end while
19: if (q = 0) then
20: k ← dreptk
21: end if
22: end while
23: return
24: end procedure

Listing 4.2: inordine.c
#include <stdio.h>
#define MAXN 100
/** stang[k] - descendentul stang al nodului k; 0 daca nu exista */

char stang[MAXN];
/** drept[k] - descendentul drept al nodului k */
char drept[MAXN];
/** Numarul de noduri din arbore */
int n;
/** Nodul radacina */
int rad;
void vizitare(int nod) {

printf("%2d ", nod);
}
int k;

printf("rad = "); scanf("%d", &rad);
89
for (k = 1; k <= n; k++) {
printf("stang[%d] = ", k); scanf("%d", &stang[k]);
}
for (k = 1; k <= n; k++) {

printf("drept[%d] = ", k); scanf("%d", &drept[k]);
}
}
void inord(int rad) {

int k, cap;
int q;
int stack[MAXN];
k = rad; q = 0;
cap = -1;
while (q == 0) {
while (stang[k] > 0) {
cap++;
stack[cap] = k;
k = stang[k];
}
vizitare(k);
while ((q == 0) && (drept[k] == 0)) {
if (cap < 0)
q = 1;
else {
k = stack[cap];
cap--;
vizitare(k);
}
}
if (q == 0)
k = drept[k];
}
}
void main(void) {
readInput();
inord(rad);
}
• parcurgere ı̂n postordine (subarbore stâng, subarbore drept, rădăcină): 4, 3, 6, 7, 5, 2,

9, 8, 1.
Metoda de parcurgere ı̂n postordine este ilustrată de algoritmul 31.
O implementare a algoritmului de vizitare recursivă a arborilor binari este exemplificată
la arborii binari de sortare.
Dacă presupunem realizarea unei acţiuni de vizitare pe exteriorul frontierei arborelui,
deplasarea efectuându-se ı̂n sens trigonometric şi având drept punct de plecare rădăcina
90
Algoritm 31 Algoritm de parcurgere ı̂n postordine
1: procedure Postordine(K, Stang, Drept)
2: if (k 6= 0) then
3: call P ostordine(stangk , stang, drept)
4: call P ostordine(dreptk , stang, drept)
6: end if
7: return
8: end procedure
2 8
3 5 9
6 7
Fig. 4.7: Vizitarea unui arbore pe frontieră
acestuia, vom ajunge să vizităm cel puţin o dată toate nodurile arborelui (vezi figura 4.7).
Ţinând cont de momentul vizitării se poate obţine oricare dintre metodele de parcurgere
(preordine, inordine, postordine): pentru preordine vom marca un nod ı̂n momentul ı̂n care
ı̂l vizităm pentru prima dată, ı̂n cazul metodei de vizitare ı̂n inordine vom marca un nod
ı̂n momentul ı̂n care ı̂l vizităm pentru prima dată dacă este frunză, respectiv a doua oară,
dacă este un nod interior, iar la postordine vom marca un nod ı̂n momentul ı̂n care ı̂l vizităm
pentru ultima oară.
Arborele asociat unei expresii aritmetice

Oricărei expresii aritmetice alcătuită din paranteze, operatori binari şi operanzi i se poate
asocia un arbore binar astfel:
• fiecărui operator ı̂i corespunde un nod neterminal având drept subarbori stâng şi drept
cei doi operanzi corespunzători.
• fiecare nod terminal este etichetat cu o variabilă sau o constantă.
Arborele din figura 4.8 corespunde expresiei matematice: 2 · ((a + b) − (c + b)). În urma
vizitării ı̂n postordine a acestui arbore se obţine forma poloneză postfixată asociată expresiei
anterioare: 2ab + cb + −∗. Pentru a obţine valoarea expresiei respective, arborele poate fi
parcurs ı̂n postordine.
91
Fig. 4.8: Arbore asociat expresiei aritmetice 2 · ((a + b) − (c + b))
4.2 Arbori binari de căutare

Definiţia 4.9 [96] Se numeşte arbore binar de căutare un arbore binar ce verifică următoarea
proprietate:
pentru orice vârf k aparţinând arborelui, avem

(
Infk ≥ Infj , pentru toate vârfurile j ce aparţin descendentului stâng al vârfului k
Infk ≤ Infj , pentru toate vârfurile j ce aparţin descendentului drept al vârfului k,
unde Infk este informaţia asociată vârfului k. Această informaţie este de un tip de date peste
care avem o relaţie de ordine (de obicei un tip numeric sau tipul şir de caractere).
Un arbore binar de căutare mai este cunoscut şi sub numele de arbore binar de sortare
deoarece parcurgerea ı̂n inordine a unui arbore binar de căutare ne conduce la obţinerea
elementelor vectorului Inf ı̂n ordine crescătoare. În principal, această structură de date este
utilizată pentru regăsirea eficientă a unor informaţii.
Operaţiile de creare a arborelui, ştergere a unui nod, modificare a informaţiei asociată
unui nod sau inserare a unui nod se pot realiza ı̂ntr-un mod optim astfel ı̂ncât să nu se
distrugă proprietatea de arbore de căutare.
Dacă dorim ca arborele să nu conţină chei duplicate, vom modifica definiţia anterioară
astfel:
pentru orice vârf k aparţinând arborelui, avem

(
Infk < Infj , pentru toate vârfurile j ce aparţin descendentului stâng al vârfului k
Infk > Infj , pentru toate vârfurile j ce aparţin descendentului drept al vârfului k.
Vom utiliza această ultimă definiţie pentru descrierea algoritmilor ce urmează.
Crearea unui arbore de căutare

Crearea (construirea) unui arbore de căutare se face aplicând ı̂n mod repetat operaţia de
inserare.
92
Algoritm 32 Algoritm de căutare a unei valori ı̂ntr-un arbore binar de căutare
1: function SearchNode(p, Key)
2: if (p 6= N U LL) then
3: if (p.inf o > key) then
4: return SearchN ode(p.lef t, key)
5: else
6: if (p.inf o < key) then
7: return SearchN ode(p.right, key)
8: else
9: return p
10: end if
11: end if
12: else
13: return N U LL
14: end if
15: end function
Căutarea unei informatii ı̂ntr-un arbore de căutare

Informaţia asociată unui nod mai poartă numele de cheie. Algoritmul de căutare a unei valori
ı̂ntr-un arbore binar de căutare este ilustrat prin algoritmul 32.
Să presupunem că dorim să căutăm o cheie x ı̂ntr-un arbore de căutare. Vom compara
mai ı̂ntâi cheia x cu informaţia asociată rădăcinii arborelui (a se vedea algoritmul 32):
1. dacă cheia x este mai mică decât cheia rădăcinii, atunci se va continua căutarea ı̂n
subarborele stâng;
2. dacă cheia x este mai mare decât cheia rădăcinii, atunci se va continua căutarea ı̂n
subarborele drept;
3. dacă cheia x este egală cu cheia rădăcinii, atunci căutarea se ı̂ncheie cu succes.
Inserarea unui nod ı̂ntr-un arbore de căutare

Operaţia de inserare a unui nod ı̂ntr-un arbore de căutare este descrisă ı̂n algoritmul 33.
Aceasta operaţie prezintă următoarele particularităţi:
• se verifică prin intermediul operaţiei de căutare dacă cheia x a nodului care se doreşte
să fie inserat mai există ı̂n arbore;
• ı̂n cazul ı̂n care căutarea se ı̂ncheie cu succes, inserarea nu va mai avea loc;
• ı̂n cazul ı̂n care operaţia de căutare se termină fără succes, se va crea un nod nou ı̂n
locul subarborelui vid unde s-a terminat căutarea.
În figura 4.9 este ilustrată inserarea unui nod ı̂ntr-un arbore binar.
93
Algoritm 33 Algoritm de inserare ı̂ntr-un arbore binar de căutare
1: function InsertNode(p, Key)
2: if (p = N U LL) then
3: call CreateN ode(p, key)
4: else
6: p.lef t ← InsertN ode(p.lef t, key)
7: else
9: p.right ← InsertN ode(p.right, key)
10: end if
11: end if
12: end if
13: return p
14: end function
Fig. 4.9: Arbore binar de căutare. Inserarea unui nod.
Ştergerea unui nod dintr-un arbore de căutare

Ştergerea unui nod dintr-un arbore de căutare este ilustrată prin algoritmul 35.
94
Mai ı̂ntâi se va căuta nodul ce se doreşte să fie eliminat, folosind, de exemplu, subrutina
SearchNode(p, Key).
Să presupunem că am găsit nodul ce urmează a fi şters. Avem următoarele situaţii, tratate
ı̂n algoritmul 35:
1. nodul ce urmează să fie şters este un nod terminal - se efectuează ştergerea având grijă
să se ı̂nlocuiască legătura din nodul său părinte către el cu null;
2. nodul ce urmează să fie şters are un singur descendent - nodul respectiv se şterge iar
părintele său va conţine acum noua legătură către descendentul fostului fiu;
3. nodul ce urmează a fi şters (notat A) are doi descendenţi:
• se determină cel mai din stânga nod (notat B) din subarborele drept al nodului
ce trebuie şters A (a se vedea algoritmul 34); acesta va fi şters ı̂n mod fizic, dar
la un pas ulterior;
• toate informaţiile legate de datele conţinute ı̂n nodul B vor fi copiate ı̂n nodul A;
• subarborele drept al nodului B se va lega, fie ca descendent drept al nodului A

(dacă nodul B este descendent direct al nodului A), fie ca descendent stâng al
tatălui nodului B;
• se va şterge fizic nodul B.
Algoritm 34 Algoritm pentru determinarea celui mai din stânga nod

1: function LeftmostNode(P arent, Curent)
2: while (curent.lef t 6= N U LL) do
3: parent ← curent
4: curent ← curent.lef t
5: end while
6: if (parent.right = curent) then
7: parent.right ← curent.right
8: else
9: parent.lef t ← curent.right
10: end if
11: return curent
12: end function
95
Fig. 4.10: Arbore binar de căutare. Ştergerea unui nod. a) Nod fără descendenţi b) Nod cu un singur
descendent c) Nod cu doi descendenţi.
96
Algoritm 35 Algoritm de ştergere a unui nod ı̂ntr-un arbore binar de căutare
1: function DeleteNode(p, Key)
4: p.lef t ← DeleteN ode(p.lef t, key)
5: else
7: p.right ← DeleteN ode(p.right, key)
8: else
9: if (p.lef t = N U LL) ∨ (p.right = N U LL) then
10: if (p.lef t 6= N U LL) then
11: tmp ← p.lef t
12: else
13: tmp ← p.right
14: end if
15: call DisposeN ode(p)
16: p ← tmp
17: else
18: tmp ← p.right
19: tmp ← Lef tmostN ode(p, tmp)
20: tmp.lef t ← p.lef t
21: tmp.right ← p.right
22: call DisposeN ode(p)
23: p ← tmp
24: end if
25: end if
26: end if
27: end if
28: return p
29: end function
Exemplul 4.4 Fie un arbore binar, eticheta fiecărui nod fiind un şir de caractere (un cuvânt).
Se cere să se realizeze un program care să creeze un arbore binar de sortare, să-l parcurgă ı̂n
inordine şi să permită inserarea şi ştergerea unui nod specificat.
Listing 4.3: arbsortare.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>

char *cuvint;
struct nod *left,*right;
} NOD;
NOD *rad;
NOD* Search(NOD *p, char *sir) {
97
int ind;
if (p != NULL) {
ind = strcmp(p->cuvint, sir);
if (ind < 0)
return Search(p->right, sir);
else
if (ind > 0)
return Search(p->left, sir);
else
return p;
}
else
return NULL;
}
NOD* CreareNod(char *sir) {

NOD *p;
p = (NOD*)malloc(sizeof(NOD));
p->left = p->right = NULL;
p->cuvint = (char*)malloc(sizeof(char) * (strlen(sir) + 1));
strcpy(p->cuvint, sir);
return p;
}
NOD* Insert(NOD *p, char *sir) {

int ind;
if (p == NULL)
p = CreareNod(sir);
else {
if (ind < 0)
p->right = Insert(p->right, sir);
else
if (ind > 0)
p->left = Insert(p->left, sir);
}
return p;
}
void VisitInord(NOD *p) {

if (p != NULL) {
VisitInord(p->left);
printf("[%s] ", p->cuvint);
VisitInord(p->right);
}
}
98
NOD* LeftmostNod(NOD* parent, NOD* curent) {
while (curent->left != NULL) {
parent = curent;
curent = curent->left;
}
if (parent->right == curent)
parent->right = curent->right;
else
parent ->left = curent->right;
return curent;
}
NOD* ElibNod(NOD *p) {

free(p->cuvint);
free(p);
return NULL;
}
NOD* DeleteNod(NOD* p, char *sir) {

NOD *tmp;
int ind;
if (p != NULL){
if (ind < 0)
p->right = DeleteNod(p->right, sir);
else
if (ind > 0)
p->left = DeleteNod(p->left, sir);
else
if (p->left == NULL || p->right == NULL) {
if (p->left != NULL)
tmp = p->left;
else
tmp = p->right;
ElibNod(p);
p = tmp;
}
else{
tmp = p->right;
tmp = LeftmostNod(p, tmp);
tmp->left = p->left;
tmp->right = p->right;
ElibNod(p);
p = tmp;
}
}
return p;
}
99
void main(void) {
char cuvint[100];
char ch;
NOD *p;
rad = NULL;
while (1) {
printf("***********************************\n");
printf("1. Inserare \n");
printf("2. Cautare\n");
printf("3. Stergere\n");
printf("4. Afisare arbore\n");
printf("0. Exit \n");
ch = getch();
if (ch != ’0’ && ch != ’4’) {
printf("Cuvint: "); scanf("%s", cuvint);
}
switch (ch) {
case ’1’: rad = Insert(rad, cuvint); break;
case ’2’: p = Search(rad, cuvint);
if (!p)
printf("Cuvintul %s nu a fost gasit! \n", cuvint);
else
printf("Cuvintul %s exista in arbore! \n", cuvint);
break;
case ’3’: rad = DeleteNod(rad, cuvint); break;
case ’4’: VisitInord(rad); break;
case ’0’: exit(1);
}
}
}
4.3 Exerciţii
1. Fiind dat un arbore binar T , să se elaboreze un algoritm nerecursiv care numără
nodurile frunză ale acestui arbore.
2. Fiind dat un arbore binar T , să se elaboreze un algoritm ce determină nivelul arborelui
având cele mai multe noduri frunză.
3. Fiind dat un arbore binar T , să se elaboreze un algoritm nerecursiv ce determină

ı̂năţimea acestuia.
4. Fiind dat un arbore binar T , să se elaboreze un algoritm pentru a determina toate
nodurile arborelui T aflate la distaţa k faţă de rădăcina acestuia.
5. Se dă un arbore binar T de rădăcină r. Să se elaboreze un algoritm ce determină pentru

un nod p al arborelui cel mai apropiat nod frunză de acesta.
100
6. Se dă un arbore binar T de rădăcină r. Să se elaboreze un algoritm ce determină
lăţimea arborelui T . Lăţimea unui nivel este dată de numărul de noduri aflate pe acel
nivel. Lăţimea unui arbore este valoarea cea mai mare dintre lăţimile tuturor nivelelor
arborelui.
7. Fiind dat un arbore binar T având nodul r drept rădăcină, să se elaboreze un algoritm
ce determină un arbore binar T oglindit ce reprezintă oglinditul arborelui iniţial T .
De exemplu, ı̂n figura 4.11 se poate vizualiza rezultatul procesului de oglindire al unui
arbore binar.
Fig. 4.11: a) Un arbore binar T b) ”Oglinditul” arborelui binar T
8. Se dau două secvenţe de numere ce reprezintă rezultatele parcurgerilor ı̂n preordine şi
inordine al unui arbore binar T . Să se elaboreze un algoritm ce construieşte arborele
binar T pe baza acestor secvenţe.
9. Fiind dat un arbore binar T , să se elaboreze un algoritm pentru a determina diametrul
acestui arbore. Diametrul unui arbore binar T este dat de numărul de noduri pe lanţul
de lungime maximă dintre oricare două noduri ale arborelui.
10. Se dă un arbore binar T de rădăcină r. Să se elaboreze un algoritm ce parcurge/afişează

nodurile frunză ı̂n ordinea apariţiei lor de la stânga la dreapta.
11. Se dă un arbore binar T de rădăcină r. Să se elaboreze un algoritm ce parcurge toate
nodurile de pe frontiera arborelui ı̂n sens trigonometric.
De exemplu, pentru arborele binar din figura 4.12, ”frontiera” sa este: 1, 2, 4, 8, 9, 10, 11, 12, 7, 3.
Fig. 4.12: Frontiera unui arbore binar
12. Se dă un arbore binar T de rădăcină r şi un nod al acestuia p. Să se elaboreze un
algoritm ce determină succesorul nodului p la vizitarea ı̂n inordine.
101
13. Se dă un arbore binar T de rădăcină r. Să se elaboreze un algoritm ce determină dacă
arborele este echilibrat ı̂n ı̂năţime.
Un arbore binar de rădăcină r este echilibrat ı̂n ı̂năţime dacă subarborii stâng şi drept
sunt, fiecare, echilibraţi ı̂n ı̂nălţime iar diferenţa dintre ı̂nălţimea subarborelui stâng şi
ı̂nălţimea subarborelui drept este cel mult 1.
14. Se dă un arbore binar T cu n noduri (numerotate de la 1 la n). Să se elaboreze un

algoritm ce determină matricea de strămoşi A. Matricea de strămoşi A (A ∈ M\×\ (N∗ ))
se defineşte astfel:
(
1, dacă xi este straămoşul lui xj
aij =
0, altfel.
15. Să se elaboreze un algoritm ce construieşte un arbore binar de căutare T fiind dat
rezultatul parcurgerii arborelui T pe nivele.
===============
16. Fiind dat un arbore binar T , să se elaboreze un algoritm ce verifică dacă arborele este
un arbore binar de căutare.
17. Fiind dat un arbore binar de căutare T , să se elaboreze un algoritm ce determină nodul
a cărui cheie are valoarea minimă / maximă din arbore.
18. Fiind dat un arbore binar de căutare T şi o cheie k, să se elaboreze un algoritm ce
determină nodul predecesor şi nodul succesor nodului u a cărui cheie este k, ı̂n cadrul
vizitării ı̂n inordine.
19. Fiind daţi doi arbori binari de căutare T1 şi T2 , să se elaboreze un algoritm ce determină
toate valorile cheilor celor doi arbori T1 şi T2 ı̂n ordine (algoritm de interclasare pentru
arbori binari de căutare).
20. Fiind daţi doi arbori binari de căutare T1 şi T2 , să se elaboreze un algoritm ce determină
toate valorile cheilor comune celor doi arbori T1 şi T2 (algoritm pentru determinarea
intersecţiei mulţimilor cheilor asociate celor doi arbori binari de căutare).
21. Se dă un arbore binar de căutare T şi două chei k1 şi k2 . Să se elaboreze un algoritm
ce determină toate nodurile ale căror chei se află ı̂n intervalul [k1 , k2 ].
22. Să se elaboreze un algoritm ce reconstruieşte un arbore binar de căutare T pe baza

valorilor rezultate ı̂n urma parcurgerii ı̂n preordine a nodurilor acestui arbore.
23. Pentru o valoare n ∈ N dată, să se elaboreze un algoritm ce construieşte toţi arborii
binari de căutare Tn cu n noduri unde valorile cheilor sunt numerele de la 1 la n.
24. Fiind dat un arbore binar de căutare T de rădăcină r, să se elaboreze un algoritm
ce determină nodul median (nodul care se află la mijlocul secvenţei rezultate ı̂n urma
parcurgerii ı̂n inordine).
102
Capitolul 5
Heap-uri
Un heap (eng. heap = movilă) reprezintă o structură de date abstractă organizată sub forma
unei structuri ierarhice (de arbore) şi care respectă următoarea proprietate: pentru oricare
două noduri ale arborelui, A şi B, astfel ı̂ncât nodul A este părintele nodului B (tataB = A),
avem relaţia cheieA ≥ cheieB (sau cheieA ≤ cheieB ). Fiecare nod X va avea o valoare
asociată numită cheieX . Se observă faptul că ı̂ntotdeauna cheia de valoare maximă/minimă
se va afla ı̂n rădăcina arborelui ı̂n funcţie de condiţia aleasă: ∀A, B, astfel ı̂ncât tataB = A,
avem cheieA ≥ cheieB sau cheieA ≤ cheieB .
Structura de date heap poate fi implementată sub mai multe forme: 2 − 3 heap [123], heap
binar [9], heap binomial [133], heap Fibonacci [55], heap ternar, treap 1 [7], [115].
Principalele operaţii definite pentru un heap H sunt următoarele:
1. FindMin(H; p) - determină cheia având cea mai mică valoare şi ı̂ntoarce o referintă
către nodul ce o conţine;
2. DeleteMin(H) - şterge nodul ce conţine cheia de valoare minimă şi reorganizează struc-
tura prin refacerea proprietăţii de heap;
3. Insert(H,p) - inserează nodul p ı̂n heap-ul H;
4. Delete(H,p) - şterge nodul p din heap-ul H;
5. DecreaseKey(H,p,v) - modifică valoarea cheii nodului p din heap-ul H, atribuindu-i

valoarea v şi reorganizează această structură, păstrându-i proprietatea de heap;
6. MergeHeaps(H1 , H2 , H) - unifică două heap-uri, H1 şi H2 , ı̂ntr-unul nou H ce va

conţine elementele celor două heap-uri.
Tabelul 5.1 ([30]) ilustrează complexitatea-timp a acestor operaţii pentru diferite tipuri
de implementări ale structurii de heap.
Structura de date de tip heap prezintă multiple aplicaţii dintre care amintim algoritmul
de ordonare heapsort a unei secvenţe de elemente, diferiţi algoritmi din teoria grafurilor
(algoritmi pentru determinarea drumurilor de cost minim) sau algoritmi de selecţie (pentru
determinarea valorii minime, maxime, mediane dintr-un vector).
1
http://acs.lbl.gov/~aragon/treaps.html
103
Table 5.1: Complexitatea-timp a principalelor operaţii ale unui heap
Heap binar Heap binomial Heap Fibonacci

FindMin Θ(1) O(log n) Θ(1)
DeleteMin Θ(log n) Θ(log n) O(log n)
Insert Θ(log n) O(log n) Θ(1)
Delete Θ(log n) Θ(log n) O(log n)
DecreaseKey Θ(log n) Θ(log n) Θ(1)
MergeHeaps Θ(n) O(log n) Θ(1)
Fig. 5.1: Un exemplu de heap
5.1 Heap-uri binare (Min-heapuri sau Max -heapuri)

Definiţia 5.1 Un min-heap este un arbore binar complet ı̂n care valoarea memorată ı̂n
orice nod al său este mai mică sau egală decât valorile memorate ı̂n nodurile fii ai acestuia.
Într-un mod similar se poate defini un max-heap, drept un arbore binar complet ı̂n care
valoarea memorată ı̂n orice nod este mai mare sau egală decât valorile memorate ı̂n nodurile
fii ai acestuia.
Această structură poate fi interpretată drept un arbore parţial ordonat ce este un arbore
binar complet cu n vârfuri.
Reprezentarea cea mai adecvată pentru un heap binar (min-heap) este reprezentarea
secvenţială. Pentru n noduri vom utiliza un tablou A cu dimensiunea egală cu numărul
de noduri, unde a1 reprezintă cheia nodului rădăcină al arborelui.
Pentru această
( reprezentare avem următoarele relaţii:
(
2·i dacă 2 · i ≤ n 2·i+1 dacă 2 · i + 1 ≤ n
Stangi = , Drepti =
nu există dacă 2 · i > n nu există dacă 2 · i + 1 > n
(
i
⌊2⌋ dacă i > 1
T atai =
nu există dacă i = 1.
Exemplul 5.1 Să considerăm heap-ul binar din figura 5.1. Acesta poate fi descris de următoarea
structură de date secvenţială:
Nod 1 2 3 4 5 6 7 8 9 10
Cheie 3 5 8 8 7 11 8 10 18 9
104
Conform relaţiilor anterioare, vom avea următoarea componenţă pentru vectorii Stang,
Drept şi Tata:
Nod 1 2 3 4 5 6 7 8 9 10
Stang 2 4 6 8 10 - - - - -
Drept 3 5 7 9 - - - - - -
Tata - 1 1 2 2 3 3 4 4 5
5.1.1 Inserarea unui element

Procedura Insert (a se vedea algoritmul 36) va insera elementul X ı̂n heap-ul reprezentat
de vectorul A. Se adaugă noul element pe ultimul nivel, pe prima poziţie liberă ı̂ntâlnită ı̂n
parcurgerea pe nivel de la stânga la dreapta. Se verifică dacă este respectată proprietatea
structurii de tip heap de către configuraţia curentă a elementelor şi se reorganizează această
structură, ı̂n cazul ı̂n care proprietatea nu este ı̂ndeplinită: dacă noul element are valoarea
cheii mai mică decât cea a părintelui său (ai < a⌊ i ⌋ ), atunci face schimb de chei cu acesta
2
(ai ↔ a⌊ i ⌋ ) şi se trece la verificarea situaţiei ı̂n părinte (practic nodul curent devine nodul
2
părinte, i ← ⌊ 2i ⌋). Procesul se repetă până când elementul curent este fie rădăcina (i = 1),
fie are cheia mai mare decât cea a părintelui său (ai ≥ a⌊ i ⌋ ).
2
Algoritm 36 Algoritm de inserare ı̂ntr-un heap

1: procedure Insert(A, last, N, X)
2: if (last ≥ n) then
3: Output {′ Heap plin!′ }
4: return
5: end if
6: last ← last + 1
7: alast ← x ⊲ adaugă elementul cel nou pe ultima poziţie
8: i ← last
9: while ((i > 1) ∧ (ai < a⌊ i ⌋ )) do
2
10: ai ↔ a⌊ i ⌋ ⊲ interschimbă valorile lui ai şi a⌊ i ⌋
2 2
11: i← ⌊ 2i ⌋
12: end while
13: end procedure
Exemplul 5.2 În figura 5.2 pot fi urmărite operaţiile necesare pentru inserarea unui nod
având cheia asociată de valoare 3. Se adaugă elementul având valoarea cheii 3, pe ultima
poziţie a heap-ului. Deoarece valoarea cheii ultimului element 3 este mai mică decât valoarea
cheii părintelui său 8, se interschimbă valorile cheilor. Se compară din nou, valoarea cheii
nodului curent (cheia cu valoarea 3) cu valoarea cheii asociată părintelui său (nodul 1). Se
interschimbă din nou valorile cheilor. La final, heap-ul arată ca ı̂n ultima configuraţie din
figura 5.2.
5.1.2 Ştergerea elementului minim

Procedura DeleteMin (a se vedea algoritmul 37) va elimina nodul rădăcină din heap, ı̂ntorcând
valoarea acestuia prin intermediul variabilei minim, şi va reorganiza heap-ul.
105
Fig. 5.2: Inserarea valorii 3 ı̂ntr-un heap
În linia 6 se păstrează valoarea rădăcinii ı̂n variabila minim. Instrucţiunea următoare ia
ultimul element şi ı̂l aduce pe prima poziţie. În linia 8, se decrementează numărul de elemente
existente la momentul respectiv ı̂n heap. Apoi se păstrează ı̂n variabila j indicele elementului
ce conţine cea mai mică valoare a cheii, dintre cheile corespunzătoare descendenţilor nodului
curent (liniile 11-15).
În linia 17 se interschimbă poziţia părintelui cu poziţia celui mai mic dintre descendenţii
săi, dacă este necesar. Instrucţinea de ciclare while (liniile 10 - 22) se părăseşte atunci când
s-a ajuns la o frunză sau când nu se mai poate ı̂nainta ı̂n jos ı̂n arbore (linia 20).
Fig. 5.3: Ştergerea valorii minime dintr-un heap
În figura 5.3 pot fi urmăriţi paşii necesari pentru ştergerea nodului de valoare minimă din
heap-ul considerat drept exemplu.
106
Algoritm 37 Algoritm de ştergere a elementului minim dintr-un heap
1: procedure DeleteMin(A, last, N ; minim)
2: if (last = 0) then
3: Output {′ Heap vid!′ }
4: return
5: end if
6: minim ← a1
7: a1 ← alast
8: last ← last − 1
9: i←1
10: while (i ≤ ⌊ last
2 ⌋) do
11: if ((2 · i = last) ∨ (a2·i < a2·i+1 )) then
12: j ←2·i
13: else
14: j ←2·i+1
15: end if
16: if (ai > aj ) then
17: ai ↔ aj
18: i←j
19: else
20: return
21: end if
22: end while
23: end procedure
5.1.3 Crearea unui heap
Algoritm 38 Algoritm de creare a unui heap (prima variantă)

1: procedure NewHeap1(A, n)
2: for i ← 2, n do
3: call Insert(A, i − 1, n, ai )
4: end for
5: end procedure
Prima metodă de construire a unui heap binar se bazează pe următoarea tehnică: se pleacă
iniţial cu heap-ul format dintr-un singur element şi se inserează, pe rând, toate elementele ı̂n
heap-ul nou creat (a se vedea algoritmul 38).
Exemplul 5.3 Să construim o structură de heap pornind de la şirul de valori 10, 7, 9, 5, 7 . . ..
Se pleacă cu heap-ul format dintr-un singur nod, 10. Apoi, se inserează elementul cu valoarea
7 ı̂n heap. Deoarece 7 > 10, se interschimbă valorile ı̂ntre ele (a se vedea figura 5.4). Urmează
să se insereze nodul a cărui valoare asociată este 9. Acest nod va fi descendentul drept al
rădăcinii, după cum se poate observa din figura 5.4. La final, se adaugă nodul a cărui cheie
are valoarea 5, şi se restabileşte proprietatea de heap prin interschimbări succesive.
Analizând numărul de operaţii efectuate de subrutina Insert, se observă că o valoare

nou introdusă poate să ajungă până ı̂n rădăcina arborelui. Astfel, numărul de operaţii
(interschimbări) ı̂n cazul cel mai defavorabil va fi egal cu ı̂nălţimea arborelui, h. Deoarece
107
Fig. 5.4: Crearea unui heap prin inserări succesive
avem un arbore binar complet cu cel mult n noduri, ı̂nălţimea acestuia este cel mult [log n]
(h ≤ [log n]).
Complexitatea-timp ı̂n cazul cel mai defavorabil al subrutinei NewHeap1 este egală cu
suma timpilor necesari inserării tuturor celor n valori, ı̂n cazul cel mai defavorabil. Vom ţine
cont de faptul că, ı̂n cazul unui arbore binar complet, numărul nodurilor de pe un nivel i este
2i , cu excepţia ultimului nivel unde numărul de noduri este mai mic.
n [log n] [log n]
X X X
i
T (n) = TInsert (k) ≤ i · 2 ≤ log n 2i = O(n log n). (5.1)
k=1 i=1 i=1
Cea de-a doua metodă de creare a unui heap se bazează pe ideea de a construi un heap
prin combinări (reuniri) repetate de heap-uri, strategie cu o eficienţă superioară metodei
prezentate anterior. Iniţial, se porneşte cu o pădure de arbori, compuşi fiecare numai dintr-un
singur nod, rădăcina. La fiecare pas i, se construieşte un heap nou din ai şi două heap-uri
de dimensiuni apropiate: heap-ul având rădăcina 2 · i şi cel cu rădăcina 2 · i + 1 (a se vedea
algoritmul 39).
Algoritm 39 Algoritm de creare a unui heap (a doua variantă)

1: procedure NewHeap2(A, n)
2: for i ← ⌊ n2 ⌋, 1 ST EP − 1 do
3: call P ush(A, i, n)
4: end for
5: end procedure
Se observă faptul că subrutina Push (a se vedea algoritmul 40) este asemănătoare cu
subrutina DeleteMin. Scopul subrutinei Push este de a reorganiza un heap ı̂ntre limitele
f irst şi last ale tabloului A.
Exemplul 5.4 Să construim o structură de heap având drept date de intrare elementele
secvenţei:
108
Algoritm 40 Algoritm de reorganizare a unui heap
1: procedure Push(A, f irst, last)
2: i ← f irst
3: while (i ≤ ⌊ last
2 ⌋) do
4: if ((last = 2 · i) ∨ (a2·i < a2·i+1 )) then
5: j ←2·i
6: else
7: j ←2·i+1
8: end if
9: if (ai > aj ) then
10: ai ↔ aj
11: i←j
12: else
13: i ← last
14: end if
15: end while
16: end procedure
poz 1 2 3 4 5 6 7
A 10 7 9 5 7 8 6
După cum se poate observa din figura 5.5, pentru i = 3 se va construi heap-ul compus din
elementele de valori 9, 8 şi 6, pentru i = 2 se va construi heap-ul compus din elementele de
valori 7, 5 şi 7, iar pentru i = 1 se va construi heap-ul ce are drept rădăcină elementul de
valoare 10, descendentul stâng fiind heap-ul construit la pasul i = 2 iar descendentul drept
fiind heap-ul construit la pasul i = 3.
Fig. 5.5: Crearea unui heap prin reorganizări succesive
Fie x un nod aflat pe nivelul i (i = 0, h − 1, h = log n). Acest nod va suferi cel mult
h − i deplasări ı̂n cadrul structurii de heap, migrând către frunzele arborelui. Astfel numărul
de operaţii (deplasări) efectuate ı̂n cadrul algoritmului 39 (NewHeap2) pentru a construi o
109
structură de tip heap binar cu n elemente este:
h−1
X h
X h
X Xh
j=h−i j j
T (n) ≤ 2i (h − i) = j2h−j = 2h j
≤ n j
< 2n = O(n). (5.2)
i=0 j=1 j=1
2 j=1
2
5.1.4 Ordonare folosing heap-uri - HeapSort

Metoda de ordonare HeapSort [138] are la bază algoritmul general prezentat ı̂n subrutina
SortX (a se vedea algoritmul 41). Vom presupune că elementele şirului iniţial se află ı̂ntr-o
structură de date A de tip tablou, iar rezultatul va fi obţinut ı̂n structura de date S. Iniţial
S este vidă (nu conţine niciun element). Subrutina Insert(x, S) va adăuga elementul x
structurii de date S.
Algoritm 41 Algoritm de ordonare folosind heap-uri (prima variantă)

1: procedure SortX(A, n)
2: S←∅
3: for f iecare x ∈ A do
4: call Insert(x, S)
5: end for
7: call M in(S; y)
8: ouput {y}
9: call Delete(y, S)
10: end while
11: end procedure
Subrutina Min(S; y) ı̂ntoarce valoarea minimă a lui S ı̂n y, iar subrutina Delete(y, S)
şterge elementul y din S.
După câteva modificări ale subrutinei de ordonare SortX (algoritmul 41) se obţine sub-
rutina Heapsort (a se vedea algoritmul 42): instrucţiunile din liniile 2-4 au rolul de a forma
heap-ul printr-o construcţie incrementală; apoi pentru toate elementele, se elimină cel mai
mic element din faţa heap-ului şi se reface proprietatea de arbore parţial ordonat ı̂ntre limitele
1 şi i − 1 (liniile 6 şi 7).
Algoritm 42 Algoritm de ordonare folosind heap-uri (a doua variantă)

1: procedure HeapSort(A, n)
2: for i ← ⌊ n2 ⌋, 1 ST EP − 1 do
3: call P ush(A, i, n)
4: end for
5: for i ← n, 2 ST EP − 1 do
6: a1 ↔ ai
7: call P ush(A, 1, i − 1)
8: end for
9: end procedure
Implementarea ı̂n limbajul C a algoritmului de ordonare a unei secvenţe de numere

folosind heap-uri este următoarea:
110
Listing 5.1: sortheap.c
#include <stdio.h>
#define MAXN 100
/**
* Functie pentru citirea valorilor datelor de intrare.
*/
int readInput(int *a) {
int i, n;
printf("n="); scanf("%d", &n);

for (i = 1; i <= n; i++) {
printf("a[%d]=", i); scanf("%d", &a[i]);
}
return n;
}
/**
* Functie pentru afisarea rezultatelor.
*/
void list(int *a, int n) {
int i;
for (i = 1; i <= n; i++)

printf("%d, ", a[i]);
printf("\n");
}
/**
* Functia realizeaza reorganizarea unei movile.
* @param start - indicele primului element al secventei
* @param finish - indicelel ultimului element al secventei
* @param a - vectorul ce pastreaza valorile movilei
*/
void push(int start, int finish, int *a) {
int i, j, aux;
i = start;
while (i <= finish / 2) {
if (2 * i == finish || a[2 * i] < a[2 * i + 1])
j = 2 * i;
else
j = 2 * i + 1;
if (a[j] < a[i]) {
aux = a[i]; a[i] = a[j]; a[j] = aux;
i = j;
}
else
return;
}
}
111
void main(void) {
int a[MAXN];
int n = readInput(a);
int i, j, aux;
// organizarea unui heap

for (i = n / 2; i > 0; i--)
push(i, n, a);
// determinarea minimului si reorganizarea heap-ului

j = n;
while (j > 1) {
aux = a[1]; a[1] = a[j]; a[j] = aux;
j--;
push(1, j, a);
}
list(a, n);
}
5.2 Aplicatie - Coadă cu priorităţi

Definiţia 5.2 O coadă cu priorităţi este o structură de date abstractă formată din ele-
mente ce au asociată o valoare numită cheie sau prioritate şi care suportă următoarele opera-
ţii:
• Insert(Q, X) - inserează elementul x ı̂n coada cu priorităţi denumită Q;

• ExtractMax(Q) - extrage din coada cu priorităţi Q, elementul de valoare maximă.
Multitasking-ul este o metodă prin intermediul căreia mai multe procese utilizează ı̂n co-
mun resursele calculatorului (inclusiv procesorul). În situaţia unui calculator cu un singur
procesor, se spune că ı̂n orice moment rulează cel mult un proces, ceea ce ı̂nseamnă că proce-
sorul execută instrucţiunile unui singur proces la un moment dat. Sarcina alegerii procesului
care să se afle ı̂n execuţie la un moment dat este o problemă de planificare. Operaţia de a
opri un proces aflat ı̂n execuţie, pentru a-i aloca altui proces, aflat ı̂n aşteptare, un timp pro-
cesor se numeşte schimbare de context (eng. context switch). Realizarea frecventă a acestor
schimbări de context crează iluzia execuţiei ı̂n paralel a mai multor programe. În cazul unui
calculator cu mai multe procesoare, multitasking-ul permite execuţia unui număr de procese
mai mare decât numărul de procesoare.
Sistemul de operare este cel care se ocupă de planificarea proceselor, planificare ce se
ı̂ncadrează ı̂ntr-una din următoarele strategii:
• ı̂n cazul sistemelor cu multiprogramare, procesul curent se află ı̂n execuţie până ı̂n
momentul ı̂n care realizează o operaţie ce presupune aşteptarea după un eveniment
extern (o operaţie de I/O), sau până când planificatorul de procese forţează eliberarea
procesorului.
• ı̂ntr-un sistem de tip time-sharing, fiecare proces va elibera procesorul ı̂n mod voluntar,
după expirarea cuantei de timp alocate acestuia, sau ı̂n urma apariţiei unui eveniment
hardware cum ar fi o ı̂ntrerupere.
112
• ı̂n cadrul sistemelor real-time, unui proces aflat ı̂n stare de aşteptare i se garantează
accesul la procesor ı̂n cazul apariţiei unui eveniment extern. Astfel de sisteme sunt
proiectate pentru controlul unor dispozitive mecanice cum ar fi roboţii industriali.
Comutarea ı̂ntre procese consumă timp procesor pentru ca planificatorul de procese să
ı̂ngheţe starea unui proces şi să dezgheţe starea altui proces (schimbare de context). Dacă
mai multe procese concurente sunt executate pe acelaşi procesor şi toate efectuează diverse
calcule, atunci timpul total de execuţie va fi mai mare decât timpul de execuţie al unui
program secvenţial echivalent. Creşterea vitezei sistemului se poate realiza prin ı̂ntreţeserea
(intercalarea) diferitelor faze ale mai multor procese.
În cadrul unui proces se pot identifica două tipuri de faze din punct de vedere logic:
faza de calcul şi faza de I/O. Faza de calcul se realizează exclusiv la nivelul procesorului
utilizându-se la maxim funcţiunile acestuia. Faza de I/O (intrare/ieşire) presupune un aport
mai mare din partea perifericelor (imprimante, hard discuri, plăci de reţea etc), procesul
aşteptând ca un periferic să-şi termine sarcina. În timp ce un proces se află ı̂ntr-o fază de
I/O aşteptând după finalizarea unei operaţii de către un dispozitiv periferic, un proces aflat
ı̂n faza de calcul poate ocupa procesorul şi efectua calculele programate.
În cazul multitasking-ului preemtiv, planificatorul de procese alocă cuante de timp procesor
egale fiecărui proces, asigurându-le astfel un tratament echitabil. De asemenea, sistemul poate
răspunde rapid unui eveniment extern (cum ar fi sosirea unor date) ce presupune procesarea
de către procesul curent sau de către un altul. În cazul multitasking-ului non-preemtiv,
planificatorul ı̂i dă controlul unui proces până când acesta se termină, sau eliberează singur
procesorul.
Sistemele de operare bazate pe kernelul Windows NT 4.0 folosesc un planificator de
procese preemtiv cu priorităţi. În momentul ı̂n care trebuie să aleagă un proces pentru a-i da
controlul procesorului, planificatorul de procese va alege procesul ce are prioritatea cea mai
mare şi este gata de execuţie, utilizând o strategie de tip round rubin: dacă avem trei procese
având aceeaşi prioritate A, B şi C, şi un proces D de prioritate mai mică, planificatorul va
alege mai ı̂ntâi procesul A, apoi procesul B, urmat de procesul C, procesului D alocându-i
procesorul numai ı̂n situaţia ı̂n care celelalte trei procese nu sunt ı̂n starea gata de execuţie (de
exemplu sunt blocate ı̂n aşteptarea efectuării unei operaţii I/O). Pentru procesele de prioritate
mică, şi care nu au fost executate deloc ı̂n ultimele, să zicem, 3 secunde, planificatorul de
procese aplică următorul algoritm pentru a evita fenomenul de ı̂nfometare: le atribuie o
prioritate temporară foarte mare, ridicându-le la ı̂nceputul cozii de procese, şi le alocă o
cuantă de timp mai lungă decât ı̂n mod normal.
Sistemele de operare bazate pe un kernel de tip Unix folosesc un planificator bazat pe
mai multe cozi de priorităţi ce foloseşte aceaşi strategie de tip round rubin ı̂n cadrul fiecărei
cozi. Procesele noi sunt inserate ı̂ntr-o coadă corespunzătoare unor priorităţi mai mari, şi pe
măsură ce petrec un timp procesor mai ı̂ndelungat, sunt inserate ı̂ntr-o coadă corespunzătoare
unor priorităţi mai mici. Sistemele de operare de generaţie mai nouă, bazate pe un kernel
Unix, incrementează prioritatea unui proces aflat ı̂n stare de ı̂nfometare (starvation) până
când acesta este executat, după care prioritatea acestuia este resetată la valoarea pe care
procesul o avea ı̂nainte de a ı̂ncepe ı̂nfometarea.
Vom simula un planificator de procese bazat pe o coadă de priorităţi: la un moment
dat, planificatorul alege procesul de prioritate minimă, ı̂i dă controlul procesorului pentru o
perioadă de timp variabilă ı̂nsă limitată. După trecerea acelei perioade de timp, prioritatea
procesului este incrementată cu o valoare ce depinde direct proporţional de timpul procesor
petrecut de acesta, şi este inserat ı̂n coada de priorităţi pe poziţia corespunzătoare.
În cadrul fişierului task.h definim structura de date Process precum şi două funcţii ce
113
au legătură cu prelucrarea informaţiilor asociate unui proces:
• long p(Process a); - ı̂ntoarce prioritatea unui proces;
• void execute(int id); - simulează execuţia unui proces pentru o anumită perioadă
de timp.
Listing 5.2: task.h

#ifndef __TASK_
#define __TASK_
#include <stdio.h>
#include <stdlib.h>
#include <dos.h>
typedef struct process {

int id;
long priority;
}Process;
long p(Process a);

void execute(int id);
#endif
Implementarea funcţiilor declarate ı̂n fişierul header anterior se realizează ı̂n cadrul fişierului
task.c:
Listing 5.3: task.c
#include "task.h"
#define MAX_RUN 2000
/**
* Functia returneaza prioritatea unui task
*/
long p(Process a){
return a.priority;
}
/**
* Functia simuleaza executia unui task si ocuparea procesorului
* pentru o anumita perioada de timp.
*/
void execute(int id){
int time;
time = 1 + random(MAX_RUN);
printf("Procesul %d ruleaza %d milisecunde.\n", id, time);
delay(time);
}
În fişierul heap.h se defineşte o coadă de priorităţi (PriorityQueue) implementată sub

forma unui heap:
114
• Process* deleteMin(PriorityQueue*); - ı̂ntoarce procesul de prioritate minimă având
grijă să-l şteargă din coada de priorităţi;
• void makeNull(PriorityQueue*); - goleşte (videază) o coadă de priorităţi;
• void insertTask(PriorityQueue*, Process); - adaugă un nou proces ı̂n coada de

priorităţi.
Coada de priorităţi se comportă ca un container de obiecte.

Listing 5.4: heap.h
#ifndef __HEAP_
#define __HEAP_
#include <mem.h>
#include "task.h"
#define MAX_SIZE 100
/**
* Definitia structurii PriorityQueue
*/
typedef struct priorityqueue {
Process elements[MAX_SIZE+1];
int last;
} PriorityQueue;
Process* deleteMin(PriorityQueue*);
void makeNull(PriorityQueue*);
void insertTask(PriorityQueue*, Process);
#endif
Implementarea funcţiilor declarate ı̂n fişierul header heap.h, se realizează ı̂n cadrul fişierului
heap.c:
• Process* deleteMin(PriorityQueue*); - ı̂ntoarce procesul de prioritate minimă. Se mută

elementul de pe ultima poziţie pe prima poziţie şi se reorganizează structura de date
de tip heap (prin reorganizare ı̂nţelegem rearanjarea elementelor cu un număr minim
de operaţii astfel ı̂ncât să se păstreze proprietatea de heap).
• void makeNull(PriorityQueue*); - videază structura de date de tip heap.
• void insertTask(PriorityQueue*, Process); - adaugă un nou proces ı̂n heap la sfârşit, şi
caută poziţia corespunzătoare acestui proces nou astfel ı̂ncât proprietatea de heap să
fie păstrată.
Listing 5.5: heap.c

#include "heap.h"
Process* deleteMin(PriorityQueue* Queue) {

int i, j;
Process tmp;
115
Process *minimum;
if (!Queue->last)
printf("Coada vida! \n");
else{
minimum = (Process*)malloc(sizeof(Process));
*minimum = Queue->elements[1];
Queue->elements[1] = Queue->elements[Queue->last];
Queue->last --;
i = 1;
while (i <= Queue->last/2) {
if ((p(Queue->elements[2*i]) < p(Queue->elements[2*i+1]))
|| (2*i == Queue->last))
j = 2*i;
else
j = 2*i + 1;
if (p(Queue->elements[i]) > p(Queue->elements[j])) {
tmp = Queue->elements[i];
Queue->elements[i] = Queue->elements[j];
Queue->elements[j] = tmp;
i = j;
}
else
return minimum;
}
return minimum;
}
return NULL;
}
void makeNull(PriorityQueue* Queue) {

Queue->last = 0;
}
void insertTask(PriorityQueue* Queue, Process t) {

int i;
Process tmp;
if (Queue->last >= MAX_SIZE)

printf("Coada plina!\n");
else {
Queue->last++;
Queue->elements[Queue->last] = t;
i = Queue->last;
while ((i > 1) && (p(Queue->elements[i]) < p(Queue->elements[i/2]))) {
tmp = Queue->elements[i];
Queue->elements[i] = Queue->elements[i/2];
Queue->elements[i/2] = tmp;
i /= 2;
}
}
}
116
Fişierul manager.c conţine funcţii ce implementează comportamentul planificatorului de
procese.
void init(int p) - crează un proces cu identificatorul p şi prioritatea egală cu momentul
de timp ı̂n care a fost creat, pe care ı̂l inserează ı̂n coada de priorităţi.
void select(void) - la un moment dat, selectează procesul aflat ı̂n vârful cozii, ı̂i dă con-
trolul procesorului pentru o perioadă de timp, actualizează prioritatea acestuia şi-l inserează
ı̂n coada de priorităţi.
Dacă dorim ca managementul cozii de priorităţi să fie realizat prin intermediul unei liste
ı̂n locul structurii de tip heap, este suficient să ı̂nlocuim linia #include "heap.h" cu linia
#include "list.h".
Listing 5.6: manager.c
#include <conio.h>
#include "task.h"
#include "heap.h"
long* currenttime;
PriorityQueue waiting;
void init(int p) {
Process process;
process.id = p;
process.priority = -*currenttime;
insertTask(&waiting, process);
}
void select(void) {
long begintime, endtime;
Process* process;
process = deleteMin(&waiting);
begintime = *currenttime;
execute(process->id);
endtime = *currenttime;
process->priority += 100*(endtime - begintime);
insertTask(&waiting, *process);
free(process);
}
int main(void) {
int i,n;
currenttime = MK_FP(0x0, s0x46c);

printf("Numarul de procese: "); scanf("%d", &n);
makeNull(&waiting);
for (i = 0; i < n; i++)
init(i+1);
while (!kbhit())
select();
printf("Stop!\n");
117
return 0;
}
5.3 Exerciţii
1. Să se implementeze structura de date abstractă coadă cu priorităţi cu ajutorul:
a) unui vector ordonat,
b) unei liste simplu ı̂nlănţuită,
şi să se elaboreze algoritmii pentru operaţiile Insert şi Extract. Analizaţi ı̂n aceste
cazuri complexitatea operaţiilor.
2. Să se descrie algoritmi având complexitate logaritmică ce implementează următoarele

operaţii efectuate asupra unei cozi cu priorităţi.
• DecreaseKey(H, k, x) - valoarea elementului k din heap-ul H se micşorează

(hk ← min{hk , x}), operaţia fiind, eventual, urmată de restaurarea heap-ului.
• IncreaseKey(H, k, x) - valoarea elementului k din heap-ul H este mărită (hk ←

max {hk , x}), operaţia fiind urmată de restaurarea heap-ului.
Coada cu priorităţi este implementată cu ajutorul unui heap.
3. Implementare următoare a algoritmului Heapsort este foarte scurtă şi rapidă, având
avantajul că nu utilizează un vector suplimentar pentru ordonare2 :
Listing 5.7: heapsortv2.c
void heapsort(int arr[], unsigned int N) {
int t;
unsigned int n = N, parent = N/2, index, child;
for (;;) {
if (parent > 0) {
t = arr[--parent];
} else {
n--;
if (n == 0)
return;
t = arr[n];
arr[n] = arr[0];
}
index = parent;
child = index * 2 + 1;
while (child < n) {
if ((child + 1 < n) && (arr[child + 1] > arr[child])) {
child++;
2
http://en.wikibooks.org/wiki/Algorithm_Implementation/Sorting/Heapsort
118
}
if (arr[child] > t) {
arr[index] = arr[child];
index = child;
child = index * 2 + 1;
} else {
break;
}
}
arr[index] = t;
}
}
Ordonaţi crescător următoarea secvenţă de numere, pe baza funcţiei anterioare, utili-

zând numai o coală de hârtie şi un creion: 5, 100, 25, 20, 10, 5, 7, 80, 90, 1.
4. Să se elaboreze un algoritm de timp O(n · lg k) pentru a interclasa k liste ordonate,

unde n este numărul total de elemente din listele de intrare.
5. Se dă un şir de numere ı̂ntregi şi două numere x şi y (x, y ∈ N). Să se determine
subsecvenţa de sumă maximă a cărei lungime se află ı̂n intervalul [x, y].
6. K concurenţi participă la o ı̂ntrecere. Fiecare dintre ei trebuie să facă N tururi. Toţi
concurenţii pleacă ı̂n acelaşi timp de la linia de pornire. La ı̂nceput fiecare concurent
se simte normal, ı̂nsă când termină o tură el ı̂şi pierde din capacitatea de a conduce.
Astfel fiecare cursă este cu o milisecundă mai ı̂nceată decât cea dinainte. La ı̂nceput,
concurentul i face un tur ı̂n msi milisecunde (msi este un număr natural nenul). Reg-
ulile spun că fiecare concurent i are dreptul la fiecare pi (1 ≤ pi ≤ N) să primească
atunci când trece linia de sosire o băutură energizantă ce ı̂l readuce la forma normală.
Fiecare concurent va trece linia de sosire de N ori (vom număra ultima trecere, ı̂nsă nu
şi pe cea de la ı̂nceput)
Date de intrare
Pe prima linie din fişierul competitie.in se vor găsi două numere, K şi N. Pe
următoarele K linii se găsesc două numere msi şi pi .
Date de ieşire
Fişierul competitie.out va conţine numărul maxim de concurenţi ce trec linia de start
ı̂n acelaşi timp.
Restricţii: K ≤ 10000, N ≤ 1000, msi ≤ 1000000, 1 ≤ pi ≤ N.
Exemplu
competitie.in competitie.out
4 3
26 2
39 3 2
45 1
56 2
(Shumen 2010, Competitie)
119
7. Un magazin de antichităţi cumpără şi vinde obiecte. Proprietarul vânează mereu
chilipiruri şi adaugă obiecte ı̂n stoc. Pentru vânzare, magazinul foloseşte un site web
care listează numai cele mai ieftine K obiecte, ı̂n ordinea crescătoare a preţului. Dacă
magazinul are mai puţin de K obiecte ı̂n stoc, site-ul le arată pe toate. Uneori un client
vizitează site-ul şi cumpără un obiect. Şi la adăugarea ı̂n stoc, şi la vânzare, site-ul se
actualizează automat cu cele mai ieftine K obiecte disponibile.
Magazinul porneşte cu stocul gol. Dându-se o listă de N operaţii de adăugare şi vânzare,
ajutaţi-l pe proprietar să ı̂şi calculeze veniturile.
Date de intrare
Fişierul de intrare magazin.in va conţine pe prima linie două numere N K, separate
printr-un spaţiu. N este numărul de operaţii, iar K este numărul de obiecte vizibile pe
site. Urmează N linii ı̂ntr-una din formele:
• 1 x – proprietarul adaugă ı̂n stoc un obiect de valoare x (număr natural pozitiv).
• 2 q – pe site se vinde al q-lea cel mai ieftin obiect.
Date de ieşire
În fişierul de ieşire magazin.out se va tipări, pentru fiecare operaţie de vânzare, suma
ı̂ncasată de magazin.
Restricţii: 1 ≤ N ≤ 300.000, 1 ≤ K ≤ 100, 1 ≤ x ≤ 1.000.000.000 pentru toate
obiectele adăugate; 1 ≤ q ≤ K pentru toate obiectele vândute. Se garantează că există
q obiecte ı̂n stoc la momentul vânzării.
Exemplu
competitie.in competitie.out
10 3 5
1 5 4
1 8 10
1 3
2 2
1 10
1 4
1 12
2 2
1 15
2 3
(Magazin, Cătălin Frâncu)
120
Capitolul 6
Arbori oarecare
Reamintim definiţia unui arbore oarecare:
Definiţia 6.1 Fiind dată o mulţime M de elemente denumite noduri, vom numi arbore o
submulţime finită de noduri astfel ı̂ncât:
1. există un nod cu destinaţie specială, numit rădăcina arborelui;

2. celelalte noduri sunt repartizate ı̂n n mulţimi disjuncte două câte două, A1 , A2 , · · · , An ,
fiecare mulţime Ai constituind la rândul ei un arbore.
6.1 Moduri de reprezentare

Pentru reprezentarea arborilor oarecare pot fi utilizate următoarele metode:
• legături fiu-frate: acest mod de reprezentare utilizează două tablouri, denumite fiu şi
frate, unde f iuk reprezintă primul descendent al vârfului k, iar f ratek desemnează
un descendent al tatălui nodului k, ce urmează după k. Între descendenţii unui vârf
se presupune că definim o relaţie de ordine, astfel ı̂ncât, atunci când ı̂i vizităm, acest
lucru se face, ı̂ntr-o anumită ordine: de obicei, descendenţii unui nod sunt vizitaţi de
la cel mai mic (ca valoare a etichetei asociate nodului) la cel mai mare.
De exemplu, descendenţii nodului 4 din figura 6.1 sunt 7, 8, 9 şi 10.
Rădăcina arborelui din figura 6.1 este nodul 1 (Rad = 1).
2 3 4
5 6 7 8 9 10
Fig. 6.1: Exemplu de arbore oarecare
Dacă identificăm Fiu cu Stang şi Frate cu Drept, ı̂n cadrul reprezentării fiu-frate,
atunci unui arbore oarecare i se poate asocia un arbore binar.
121
Table 6.1: Reprezentarea cu legături fiu-frate a arborelui din figura 6.1.
Nod 1 2 3 4 5 6 7 8 9 10
Fiu 2 0 5 7 0 0 0 0 0 0
Frate 0 3 4 0 6 0 8 9 10 0
Pentru reprezentarea unui arbore oarecare, modelul de reprezentare fiu-frate ı̂n varianta
cu alocare statică poate fi uşor extins la o variantă cu alocare dinamică, ce utilizează
pointeri pentru legăturile către primul descendent respectiv pentru următorul frate.
Astfel, un nod al arborelui poate avea următoarea structură:
TipOarecare data;
struct nod* fiu;
struct nod* frate;
} Nod;
data - informaţia asociată unui nod oarecare.

fiu - adresa primului nod descendent al nodului curent.
frate - adresa primului nod frate ”din dreapta”, al nodului curent.
Asemănător cu modelul construit la arbori binari, rad (declarată Nod *rad;) este o
variabilă de tip pointer la Nod (variabila păstrează adresa unei zone de memorie), ce
desemnează adresa rădăcinii arborelui.
rad
1 NULL
2 3 4 NULL
NULL
5 6 NULL 7 8 9 10 NULL
NULL NULL NULL NULL NULL NULL
Fig. 6.2: Exemplu de arbore oarecare cu 10 noduri reprezentat prin legături fiu-frate
În figura 6.2 poate fi urmărită reprezentarea arborelui din figura 6.1 folosind legături
fiu-frate, varianta cu pointeri.
• lista descendenţilor. În cadrul acestui mod de reprezentare, fiecare vârf este descris prin
lista descendenţilor săi. Pentru memorare se va utiliza un vector C cu n componente:
(
0 , dacă vârful respectiv nu are descendenţi
Ck =
j , unde j indică adresa (coloana) unde ı̂ncepe lista descendenţilor vârfului k.
122
Listele de descendenţi se păstrează prin intermediul unei matrice L cu 2 linii şi N − 1
coloane (L ∈ M2×n (N)):
L1,k - un descendent al unui nod al arborelui a cărui listă conţine coloana k a matricei
date. (
0 , dacă descendentul respectiv este ultimul
L2,k =
j , unde j indică coloana unde se află următorul descendent, frate cu L1,k .
Table 6.2: Reprezentarea arborelui din figura 6.1 folosind liste cu descendenţi.
Nod 1 2 3 4 5 6 7 8 9 10
C 1 0 4 6 0 0 0 0 0 0

2 3 4 5 6 7 8 9 10
L=
2 3 0 5 0 7 8 9 0
Exploatând mai departe această idee, ı̂ntr-un nod al arborelui oarecare se poate păstra o
listă cu adresele descendenţilor săi, lista fiind reprezentată sub forma unui tablou alocat
static sau dinamic. Acest model se recomandă atunci când numărul descendenţilor unui
nod este limitat superior, sau când acesta este cunoscut/stabilit ı̂n momentul ı̂n care
se construieşte arborele. Modificările efectuate asupra arborelui, cum ar fi inserări
de noi descendenţi, atunci când intrările alocate pentru aceşti descendenţi sunt deja
ocupate nu poate conduce decât la realocarea spaţiului de memorie cu un cost reflectat
ı̂n complexitatea algoritmului. Pentru un număr limitat superior de descendenţi putem
defini tipul Nod astfel
#define NMAX 100
TipOarecare data;
struct nod* children[NMAX];
} Nod;
unde data constituie informaţia asociată unui nod, iar children este un tablou ce
păstrează adresele tuturor descendenţilor unui nod. Dacă childrenn = NULL atunci
nodul curent va avea n copii (descendenţi) de la children0 la childrenn−1 .
Altfel, putem defini tipul Nod
TipOarecare data;
int no_of_children;
struct nod** children;
} Nod;
atunci când numărul maxim de descendenţi nu poate fi cunoscut decât ı̂n momentul
construirii arborelui. Din acest motiv, se alocă spaţiu pentru un tablou de pointeri
către structura de tip Nod ı̂n acel moment prin instrucţiunea
children = (Nod**)malloc(sizeof(Nod*) * no of children).
În figura 6.3 este reprezentat arborele din figura 6.1 folosind reprezentarea cu liste cu
descendenţi.
• vectorul Tata - pentru fiecare nod k, tatak indică nodul său părinte.
123
rad
1 3
2 0 3 2 4 4
5 0 6 0 7 0 8 0 9 0 10 0
Fig. 6.3: Exemplu de arbore oarecare cu 10 noduri reprezentat prin liste cu descendenţi
Table 6.3: Reprezentarea arborelui din figura 6.1 folosind vectorul tata.
Nod 1 2 3 4 5 6 7 8 9 10
Tata 0 1 1 1 3 3 4 4 4 4
Acest mod de reprezentare are dezavantajul că nu păstrează ı̂n mod explicit ordinea
descendenţilor unui nod. Această ordine poate fi dedusă printr-o numerotare adecvată
a nodurilor, ı̂n anumite condiţii. De obicei, reprezentarea prin vectorul tata nu este
folosită singură ci ı̂mpreună cu alte moduri de reprezentare, ca o completare la acestea.
De exemplu, reprezentarea unui nod propusă la primul punct, poate fi modificată astfel
ı̂ncât să incorporeze şi informaţii despre nodul părinte:
TipOarecare data;
struct nod* fiu;
struct nod* tata;
struct nod* frate;
}Nod;
În figura 6.4, reprezentarea din figura 6.2 este ı̂mbunătăţită prin legătura tata.
6.2 Metode de parcurgere

Parcurgerea unui arbore oarecare se poate realiza folosind metodele generale de parcurgere
ale unui arbore binar aplicate asupra arborelui binar asociat. Arborele binar asociat unui
arbore oarecare se obţine ı̂n urma redenumirii ı̂n reprezentarea fiu-frate, a vectorului Fiu ı̂n
Stang şi a vectorului Frate ı̂n Drept, astfel ı̂ncât reprezentarea devine stang-drept
În plus faţă de acestea, avem două metode de parcurgere pe care putem să le numim
specifice unui arbore oarecare. Aceste metode se pot clasifica după momentul ı̂n care se
realizează vizitarea nodului părinte astfel:
• parcurgerea ı̂n A-preordine: se vizitează mai ı̂ntâi rădăcina, şi apoi, ı̂n ordine, subar-
borii săi [96], [131]. Metoda conduce la aceleaşi rezultate ca şi metoda de parcurgere ı̂n
preordine a arborelui binar ataşat: 1, 2, 3, 5, 6, 4, 7, 8, 9, 10 (a se vedea algoritmul 43).
124
rad
NULL
1 NULL
NULL
2 3 4 NULL
NULL
5 6 NULL 7 8 9 10 NULL
NULL NULL NULL NULL NULL NULL
Fig. 6.4: Exemplu de arbore oarecare cu 10 noduri reprezentat prin legături fiu-frate-tata
Parcurgerea ı̂n A-preordine este exemplificată pe arborele oarecare ilustrat ı̂n figura
6.1.
Algoritm 43 Algoritm de parcurgere ı̂n A-preordine

1: procedure APreordine(Rad, F iu, F rate)
2: k ← rad
3: q←0
4: S←∅ ⊲ iniţializare stivă vidă
5: while (q = 0) do
6: if (k 6= 0) then
7: call V izit(k)
8: S⇐k ⊲ S.push(k)
9: k ← f iuk
10: else
11: if (S = ∅) then ⊲ verificare dacă stiva este vidă
12: q←1
13: else
14: S⇒k ⊲ S.pop(k)
15: k ← f ratek
16: end if
17: end if
18: end while
19: return
20: end procedure
• parcurgerea ı̂n A-postordine: se vizitează, mai ı̂ntâi, toţi subarborii ce au drept rădăcini,
descendenţii rădăcinii arborelui şi apoi, rădăcina arborelui [96], [131]. În urma parcurg-
erii ı̂n A-postordine a arborelui din figura 6.1 se obţine 2, 5, 6, 3, 7, 8, 9, 10, 4, 1.
Exemplul 6.1 [31] În continuare se prezintă implementarea ı̂n limbajul de programare C
a variantelor recursive pentru fiecare dintre cele două metode de vizitare ale unui arbore
oarecare.
125
Listing 6.1: arboreoarecare.c
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
/**
* Definitii de tipuri necesare cozii
*/
int id;
float info;
struct nod *down, *next;
}NOD;
typedef NOD* TINFO;
/**
* Definitii de tipuri pentru reprezentarea arborelui
*/
typedef struct cnod {
TINFO info; //informatia memorata in nod
struct cnod *next; //adresa urmatorului element
}CNOD;
CNOD *prim = NULL, *ultim = NULL;
NOD* readListaDescendenti(NOD *up);
/**
* Functie ce testeaza daca coada e vida
* @return 1 daca coada e vida
* 0 altfel
*/
int isEmpty(void) {
if (prim == NULL)
return 1;
else
return 0;
}
/**
* Functia adauga un element la sfarsitul unei cozi, unde n reprezinta elementul
* ce se adauga.
*/
void enQueue(TINFO n) {
CNOD *curent;
curent = (CNOD *) malloc(sizeof(CNOD));

curent->info = n;
curent->next = NULL;
if (!prim) {
prim = ultim = curent;
126
} else {
ultim->next = curent;
ultim = curent;
}
}
/**
* Functia extrage un element din coada si returneaza elementul scos.
*/
TINFO deQueue(void) {
CNOD *curent;
TINFO n;
if (prim == ultim) {
n = prim->info;
free(ultim);
prim = ultim = NULL;
} else {
curent = prim;
n = prim->info;
prim = prim->next;
free(curent);
}
return n;
}
/**
* Functia realizeaza crearea unui arbore oarecare. Se introduce initial radacina
,
* apoi descendentii ei, dupa care se introduc descendentii nodurilor de pe
* nivelul 1, dupa care se introduc descendentii nodurilor de pe nivelul 2 s.a.m.d
.
*/
NOD* creare(void) {
NOD *p, *c;
p = (NOD *)malloc(sizeof(NOD));
p->next = NULL;
printf("Dati id:"); scanf("%d", &p->id);
enQueue(p);
while (!isEmpty()) {
c = deQueue();
c->down = readListaDescendenti(c);
}
return p;
}
/**
* Functia citeste informatia asociata unui nod.
* @return 1 daca citirea s-a facut corect
* 0 altfel
*/
127
int readInfo(NOD *pn) {
printf("Id:");
pn->next = NULL;
pn->down = NULL;
return (scanf("%d", &pn->id) == 1);
}
/**
* Functia realizeaza citirea listei de descendenti ai nodului up si
* returneaza adresa primului descendent din lista.
*/
NOD* readListaDescendenti(NOD *up) {
NOD *prim, *ultim, *p;
NOD n;
printf("\nLista de descendenti pt %d (CTRL+Z) daca nu are\n", up->id);

prim = ultim = NULL;
while (readInfo(&n)) {
p = (NOD *)malloc(sizeof(NOD));
*p = n;
if (prim == NULL)
prim = ultim = p;
else {
ultim->next = p;
ultim = p;
}
enQueue(p);
}
return prim;
}
/**
* Parcurgerea recursiva in A-preordine a arborelui cu radacina p.
*/
void APreordine(NOD *p) {
NOD *desc;
printf("%d ", p->id);

desc = p->down;
while (desc != NULL) {
APreordine(desc);
desc = desc->next;
}
}
/**
* Parcurgerea recursiva in A-postordine a arborelui cu radacina p.
*/
void APostordine(NOD *p) {
NOD *desc;
desc = p->down;
128
while (desc != NULL) {
APostordine(desc);
desc = desc->next;
}
printf("%d ", p->id);
}
void main(void) {
NOD *rad;
rad = creare();
printf("\n Parcurgerea in A-Preordine este:\n");
APreordine(rad);
printf("\n Parcurgerea in A-Postordine este:\n");
APostordine(rad);
}
6.3 Arbori de acoperire de cost minim

Fie G = (V, E) un graf neorientat şi fie c : E −→ R o funcţie de cost ce asociează o valoare
reală fiecărei muchii. Notăm cu TG mulţimea arborilor parţiali ai grafului G (un arbore
parţial este un graf parţial conex şi fără cicluri al grafului iniţial).
Cerinţa problemei este aceea de a determina un arbore T ′ ∈ TG având costul cel mai mic
dintre toţi arborii ce aparţin mulţimii TG :
c(T ′ ) = min{c(T )|T ∈ TG } (6.1)

P
unde costul unui arbore T se defineşte astfel: c(T ) = e∈ET c(e).
Arborele T ′ ce posedă această proprietate se numeşte arbore de acoperire de cost minim
(eng. minimum spanning tree - MST ). Se mai ı̂ntâlneşte şi sub denumirea de arbore parţial
de cost minim sau arbore parţial minim.
Altfel spus, se cere să se determine un graf parţial conex G1 = (V, E1 ), E1 ⊆ E, cu
proprietatea că suma costurilor tuturor muchiilor este minimă, graful parţial de cost minim
fiind chiar un arbore.
Determinarea arborelui de acoperire de cost minim are multe aplicaţii practice: de exem-
plu, dacă se dau n oraşe precum şi costul legăturilor ı̂ntre acestea, o cerinţă ar putea fi să
se determine o conectare a tuturor oraşelor astfel ı̂ncât oricare două oraşe să fie conectate
direct sau indirect, iar costul conectării să fie minim.
Lema 6.2 (Proprietatea tăieturii) Fie S o submulţime de noduri a lui V şi e muchia
ce are costul minim dintre toate muchiile ce au o singură extremitate ı̂n S. Atunci arborele
parţial de cost minim va conţine muchia e.
Demonstraţie: Fie T ′ un arbore parţial de cost minim. Presupunem prin reducere la

absurd că e ∈ / ET ′ . Dacă adăugăm muchia e la T ′ se obţine un ciclu C. În acest ciclu, există
o altă muchie f ce posedă exact o extremitate ı̂n mulţimea S.
Înlocuind muchia f cu muchia e ı̂n arborele T ′ , obţinem un alt arbore de acoperire T ′′
astfel ı̂ncât T ′′ = T ′ ∪ {e} \ {f }.
129
Deoarece c(e) < c(f ) vom avea că
c(T ′′ ) = c(T ′ ) + c(e) − c(f ) ⇒ c(T ′′ ) < c(T ′ ) (6.2)

| {z }
<0
adică am obţinut un arbore de acoperire T ′′ ce prezintă un cost mai mic decât T ′ , contradicţie
cu faptul că T ′ este un arbore de acoperire de cost minim.
Definiţia 6.2 Se numeşte tăietură a grafului G o partiţie de două submulţimi a mulţimii

nodurilor V , notată < S, T >, unde S ∪ T = V şi S ∩ T = ∅.
Lema 6.3 (Proprietatea ciclului) Fie C un ciclu şi f muchia ce are costul maxim dintre
toate muchiile ce aparţin lui C. Atunci arborele parţial de cost minim T ′ nu conţine muchia
f.
Demonstraţie: Fie T ′ un arbore parţial de cost minim. Presupunem prin reducere la

absurd că f ∈ ET ′ . Dacă ştergem muchia f din arborele T ′ , se obţine o tăietură < S, V \ S >,
corespunzătoare celor două componente conexe obţinute din T ′ prin eliminarea unei muchii.
Din ipoteză, avem că f ∈ C şi o extremitate a lui f aparţine lui S. Există atunci o altă
muchie e cu proprietatea că e ∈ C şi e are o extremitate ce aparţine lui S.
Înlocuind muchia f cu muchia e ı̂n arborele T ′ , obţinem un alt arbore de acoperire T ′′
unde T ′′ = T ′ ∪ {e} \ {f }.
Deoarece c(e) < c(f ) ⇒ c(T ′′ ) < c(T ′), adică am obţinut un arbore de acoperire T ′′ ce
are costul mai mic decât T ′ , contradicţie.
Majoritatea algoritmilor ce calculează arborele de acoperire de cost minim prezintă aceeaşi
tehnică generală de calcul. La ı̂nceput se porneşte cu o pădure de arbori, T 0 = {T10 , T20, . . . , Tn0 }
unde Ti0 = {xi }, i = 1, n, este un arbore format dintr-un singur nod. În general, la pasul k
vom avea mulţimea T k compusă din n − k arbori: T k = {T1k , T2k , . . . , Tn−k k
}.
k ′ ′
La fiecare pas, se alege un arbore Ti şi o muchie (u , v ) având costul minim dintre toate
muchiile (u, v) cu proprietatea că o extremitate aparţine mulţimii de noduri a arborelui Tik
(u′ ∈ Tik ) şi cealaltă extremitate aparţine mulţimii V \ VTik (v ′ ∈ V \ VTik ).
Mulţimea T k+1 se obţine din mulţimea T k prin reuniunea arborilor Tik şi Tjk (i 6= j) ca
urmare a adăugării muchiei (u′ , v ′ ), unde u′ ∈ Tik şi v ′ ∈ Tjk (T k+1 = T k \{Tik , Tjk }∪{Tik ∪Tjk }).
În final, la pasul n − 1, mulţimea T n−1 va fi compusă dintr-un singur element, T n−1 =
n−1
{T1 }, acesta fiind arborele de acoperire de cost minim. Algoritmii cei mai cunoscuţi pentru
determinarea arborilor de acoperire de cost minim sunt următorii:
1. Algoritmul lui Boruvka (a se vedea algoritmul 44);
2. Algoritmul lui Prim (a se vedea algoritmul 45);
130
Algoritm 44 Algoritmul lui Boruvka (varianta schematică)
1: procedure Boruvka1(G, C, n; L)
2: iniţializează pădurea de arbori P compusă din n arbori, fiecare arbore fiind compus dintr-un
singur nod
3: L←∅
4: while (|P| > 1) do
5: for T ∈ P do
6: alege e muchia de cost minim de la T la G \ T
7: L ⇐ e ⊲ adaugă muchia e la lista de muchii alese ce vor forma arborele de acoperire
de cost minim
8: end for
9: adaugă toate muchiile selectate ı̂n cadrul f or-ului anterior la P
10: end while
11: end procedure
Algoritm 45 Algoritmul lui Prim (varianta schematică)

1: procedure Prim1(n, C, u; L)
2: S ← {u}, L ← ∅
3: for i ← 1, n do
4: di ← cu,i
5: end for
6: for i ← 1, n − 1 do
7: k ← min {dk |k ∈ V \ S}
8: L ⇐ (tatak , k)
9: S ← S ∪ {k}
10: for each j ∈ V \ S do
11: dj ← min {dj , ck,j }
12: end for
13: end for
14: end procedure
3. Algoritmul lui Kruskal (a se vedea algoritmul 46).

Algoritmul lui Prim implementat simplu are o complexitate O(n2 )[30] şi atinge o com-
plexitate de O(m log n) dacă se folosesc heap-uri Fibonacci [55], sau pairing heaps [122].
În tabelul 6.4 sunt prezentaţi mai mulţi algoritmi elaboraţi de-a lungul timpului, pentru
determinarea arborelui de acoperire minimal şi complexităţile lor. Karger, Klein şi Tarjan [82]
pornind de la algoritmul lui Boruvka au realizat un algoritm randomizat pentru determinarea
arborelui de acoperire minimal, având o complexitate liniară, iar Chazelle [26] a dezvoltat
un algoritm având complexitatea O(n · α(m, n)) (unde α(m, n) este inversa funcţiei lui Ack-
erman). Pe de altă parte, Pettie şi Ramachandran [109] au propus un algoritm demonstrat
ca fiind optimal, având complexitatea cuprinsă ı̂ntre O(n + m) şi O(n · α(m, n)).
Fie G(V, E) un graf neorientat unde V = {1, 2, . . . , n} este mulţimea nodurilor şi E este
mulţimea muchiilor (E ⊆ V × V ). Pentru reprezentarea grafului se poate utiliza matricea
costurilor C (C ∈ Mn×n (R)):

0
 , dacă i = j
ci,j = ∞ , dacă (i, j) ∈
/E


d > 0 , dacă (i, j) ∈ E
131
Algoritm 46 Algoritmul lui Kruskal (varianta schematică)
1: procedure Kruskal1(G, C, n; L)
2: ordonează muchiile ı̂n ordine crescătoare după cost
3: L←∅
4: for each u ∈ V do
5: crează o mulţime compusă din {u}
6: end for
7: count ← 0
8: while (count < n − 1) do
9: alege muchia (u, v)
10: if (u şi v sunt ı̂n mulţimi diferite) then
11: L ⇐ (u, v)
12: reuneşte mulţimile ce conţin pe u şi v
13: count ← count + 1
14: end if
15: end while
16: end procedure
Table 6.4: Algoritmi pentru determinarea arborelui de acoperire minim
Anul Complexitate Autori

1975 E log log V Yao
1976 E log log V Cheriton-Tarjan
1984 E log∗ V, E + V log V Friedman-Tarjan
1986 E log log ∗ V Gabow-Galil-Spencer-Tarjan
1997 Eα(V ) log α(V ) Chazelle
2000 Eα(V ) Chazelle [26]
2002 optimal Pettie-Ramachandran [109]
6.3.1 Algoritmul lui Boruvka

Algoritmul lui Boruvka [80] a fost descoperit de către matematicianul ceh Otakar Boruvka
ı̂n 1926 [21], şi redescoperit apoi de către alţi cercetători. Dintre aceştia, Sollin (1961) este
cel care a mai dat numele algoritmului, acesta fiind cunoscut ı̂n literatura de specialitate şi
sub numele de algoritmul lui Sollin. Pentru ca acest algoritm să poată fi aplicat, trebuie ca
muchiile grafului să aibă costuri distincte (a se vedea algoritmul 47).
Exemplul 6.4 Să considerăm graful din figura 6.5:
G = (V, E), V = {1, 2, 3, 4, 5, 6, 7, 8}
Aplicând algoritmul lui Boruvka, la pasul ı̂ntâi vor fi selectate muchiile (1, 2), (3, 6), (4, 5),
(4, 7) şi (7, 8). În urma operaţiilor de reuniune a componentelor conexe pe baza muchiilor
selectate, vor mai rămâne trei componente conexe ı̂n mulţimea M.
La pasul al doilea sunt alese muchiile (2, 5) şi (1, 3) ce conduc, ı̂n urma operaţiilor de
reuniune, la o singură componentă conexă.
132
Algoritm 47 Algoritmul lui Boruvka
1: procedure Boruvka2(G, C, n; L)
2: for i ← 1, n do
3: Vi ← {i}
4: end for
5: L ← ∅, M ← {V1 , . . . , Vn }
6: while (|T | < n − 1) do
7: for U ∈ M do
8: fie (u, v) muchia pentru care se obţine valoarea minimă
min {c(u′ , v ′ )|(u′ , v ′ ) ∈ E, u′ ∈ U, v ′ ∈/ V \ U}
9: se determină componenta U ′ ce conţine pe v
10: L ⇐ (u, v)
11: end for
12: for U ∈ M do
13: reuneşte mulţimile ce conţin pe u şi v, U şi U ′
14: end for
15: end while
16: end procedure
Fig. 6.5: Exemplu de graf ponderat - aplicaţie algoritmul lui Boruvka
6.3.2 Algoritmul lui Prim

Algoritmul a fost descoperit mai ı̂ntâi de V. Jarnik (1930) [79], şi apoi independent de Prim
(1957) [110] şi Djikstra (1959) [38].
Se porneşte cu o mulţime S formată dintr-un singur nod iniţial v0 (S = {v0 }). La fiecare
pas, se alege muchia de cost minim ce are numai o extremitate ı̂n mulţimea S. Procesul se
ı̂ncheie după n − 1 paşi, rezultând un graf parţial aciclic. Din teorema 4.1 rezultă faptul că
acest graf parţial aciclic cu n − 1 muchii este un arbore (de acoperire).
Conform Proprietăţii tăieturii, toate muchiile alese aparţin arborelui parţial de cost minim
de unde rezultă că acest arbore de acoperire este un arbore parţial minim.
Vom utiliza trei vectori de dimensiune n, unde n reprezintă numărul de vârfuri al grafului
(a se vedea algoritmul 48):
133
• vizitat - vector caracteristic
(
1 , dacă nodul k ∈ S
vizitatk =
0 , dacă nodul k ∈ V \ S
• d - pentru un nod k ∈ / S, dk va conţine distanţa minimă de la k la un nod oarecare

u ∈ S. La ı̂nceput, dj = cv0 ,j , ∀j ∈ V \ S. Pentru un nod k ales la un moment dat să
fie adăugat mulţimii S, ∀j ∈ V \ S, dj se modifică numai dacă ck,j < dj astfel ı̂ncât să
primească o valoare mai mică, dj = ck,j .
• tata - conţine pentru fiecare nod k ∈
/ S nodul u ∈ S astfel ı̂ncât ck,u = min{ck,i|i ∈ S}.
La ı̂nceput, (
0 , dacă nodul k = v0
tatak =
v0 , dacă nodul k 6= v0
În momentul ı̂n care se modifică dj , se va modifica şi valoarea lui tataj astfel ı̂ncât
tataj = k.
Fig. 6.6: Exemplu de graf ponderat - aplicaţie algoritmul lui Prim
Exemplul 6.5 Considerăm graful din figura 6.6:

G = (V, E), V = {1, 2, 3, 4, 5, 6, 7, 8},
E = {(1, 2), (1, 3), (1, 5), (2, 4), (2, 5), (2, 6), (3, 6), (3, 8), (4, 5), (4, 7), (4, 8), (5, 6), (6, 7), (6, 8), (7, 8)}
Vom lua nodul iniţial v0 = 1. La ı̂nceput, după etapa de iniţializare avem următoarele valori
pentru tablourile d, tata şi vizitat:
1 2 3 4 5 6 7 8
D 14 6 ∞ 5 ∞ ∞ ∞
Tata 0 1 1 1 1 1 1 1
Vizitat 1 0 0 0 0 0 0 0
După primul pas al ciclului, vom selecta muchia (1, 5).
1 2 3 4 5 6 7 8
D 14 6 21 5 16 ∞ ∞
Tata 0 1 1 5 1 5 1 1
Vizitat 1 0 0 0 1 0 0 0
134
Algoritm 48 Algoritmul lui Prim (varianta detaliată)
1: function DistantaMinima(n, vizitat, d)
2: min ← ∞
3: for j ← 1, n do
4: if ((vizitatj 6= 1) ∧ (dj < min)) then
5: min ← dj
6: j0 ← j
7: end if
8: end for
9: if (min = ∞) then
10: return −1
11: else
12: return j0
13: end if
14: end function
15: procedure Prim2(n, C, v0 ; d, tata)

16: vizitatv0 ← 1
17: tatav0 ← 0
18: for i ← 1, n do
19: if (i 6= v0 ) then
20: vizitati ← 0
21: di ← cv0 ,i
22: tatai ← v0
23: end if
24: end for
25: for i ← 1, n − 1 do
26: k ← DistantaM inima(n, vizitat, d)
27: if (k < 0) then
28: Output ’Graful nu este conex!’
29: return
30: end if
31: vizitatk ← 1 ⊲ (k, tatak ) este o muchie ce aparţine arborelui parţial minim
32: for j ← 1, n do
33: if ((vizitatj 6= 1) ∧ (dj > ck,j )) then
34: tataj ← k
35: dj ← ck,j
36: end if
37: end for
38: end for
39: end procedure
La pasul al doilea se alege nodul 3 şi muchia (1, 3):

1 2 3 4 5 6 7 8
D 14 6 21 5 12 ∞ 12
Tata 0 1 1 5 1 3 1 3
Vizitat 1 0 1 0 1 0 0 0
La pasul al treilea, avem două noduri ale căror distanţe la noduri din mulţimea S sunt
egale, 6 şi 8. Alegem primul nod, cel cu valoarea 6 şi muchia (3, 6):
135
1 2 3 4 5 6 7 8
D 14 6 21 5 12 14 6
Tata 0 1 1 5 1 3 6 6
Vizitat 1 0 1 0 1 1 0 0
Al patrulea nod ales este 8:
1 2 3 4 5 6 7 8
D 14 6 10 5 12 10 6
Tata 0 1 1 8 1 3 8 6
Vizitat 1 0 1 0 1 1 0 1
La pasul cinci, nodul aflat la distanţă minimă este 7:
1 2 3 4 5 6 7 8
D 14 6 10 5 12 10 6
Tata 0 1 1 8 1 3 8 6
Vizitat 1 0 1 0 1 1 1 1
La pasul şase este ales nodul 4:
1 2 3 4 5 6 7 8
D 12 6 10 5 12 10 6
Tata 0 4 1 8 1 3 8 6
Vizitat 1 0 1 1 1 1 1 1
La final, ultimul nod ales este 2 ı̂mpreună cu muchia (4, 2).
Trebuie să remarcăm faptul că algoritmul lui Prim (a se vedea algoritmul 48) este aproape
identic cu algoritmul lui Dijkstra (a se vedea algoritmul 62).
După cum am subliniat, implementarea optimă se realizează folosind nişte structuri de
date avansate - heap-uri Fibonacci sau pairing heaps (a se vedea algoritmul 49).
Algoritm 49 Algoritmul lui Prim folosind structuri de date avansate

1: procedure Prim3(n, C, u)
2: for fiecare v ∈ V do
3: dv ← cu,v
4: end for
5: Q←∅ ⊲ iniţializează coada cu priorităţi Q cu mulţimea vidă
6: for fiecare v ∈ V do
7: Q⇐v
8: end for
9: S←∅ ⊲ iniţializează mulţimea S cu mulţimea vidă
10: while Q 6= ∅ do
11: u ← deleteM in(Q) ⊲ extrage nodul de prioritate minimă din Q
12: S ← S ∪ {u}
13: for fiecare muchie e = (u, v) ∈ E do
14: if (v ∈
/ S) ∧ (c(e) < dv ) then
15: actualizeaza prioritatea lui v: dv ← c(e)
16: end if
17: end for
18: end while
19: end procedure
136
6.3.3 Structuri de date pentru mulţimi disjuncte
O partiţie a unei mulţimi A este o secvenţă finită de mulţimi (submulţimi) A1 , . . . , Am
disjuncte
Sm două câte două, cu proprietatea că reuniunea acestora este chiar mulţimea A
(A = i=1 Ai şi Ai ∩ Aj = ∅, ∀i, j = 1, m, i 6= j).
Există mai multe probleme ai căror algoritmi de rezolvare depind de următoarele operaţii
efectuate asupra elementelor partiţiei: verificarea dacă două elemente fac parte din aceeaşi
submulţime şi operaţia de reuniune a două submulţimi.
O structură de date pentru mulţimi disjuncte memorează o colecţie de mulţimi disjuncte
dinamice. Fiecare mulţime este identificată printr-un reprezentant [30]. Operaţiile de bază
ale acestei structuri de date sunt următoarele [2]:
• init(x, B) - crează o mulţime B formată dintr-un singur element x;
• find(x) - ı̂ntoarce reprezentantul mulţimii căreia ı̂i aparţine x;
• merge(A, B) - reuneşte mulţimile distincte A şi B (A 6= B) ı̂ntr-o nouă mulţime ce

conţine elementele celor două mulţimi.
O astfel de structură de date pentru mulţimi disjuncte se mai numeşte şi structură de date
union-find (eng. union-find data structure).
Reprezentarea folosind vectori

Vom folosi un vector C de dimensiune n, unde n reprezintă numărul de elemente, iar ck = u
indică faptul că elementul k aparţine mulţimii u.
Algoritm 50 Algoritmi pentru operaţiile init, find, merge (prima variantă)

1: procedure Init(x, u)
2: cx ← u
3: end procedure
4: function Find(x)
5: return cx
6: end function
7: function Merge(x, y)
8: setx ← cx
9: sety ← cy
10: for k ← 1, n do
11: if (ck = sety) then
12: ck ← setx
13: end if
14: end for
15: return setx
16: end function
Init constă din iniţializarea elementului cx cu identificatorul mulţimii, u. Find ı̂ntoarce

valoarea lui cx (valoarea identificatorului mulţimii). În subrutina Merge se caută toate ele-
mentele ce fac parte din mulţimea de identificator cy şi se trec ı̂n mulţimea al cărui identifi-
cator este cx (a se vedea algoritmul 50).
Exemplul 6.6 Pentru a putea opera cu modul de reprezentare ales, cel cu vectori, trebuie
ca elementele mulţimii să ia valori naturale ı̂n intervalul [1,. . . ,n]. Dacă acest lucru nu este
137
posibil, atunci vom folosi un vector auxiliar A ce păstrează valorile elementelor, ı̂n cadrul
reprezentării utilizându-se indicele acestora. Să presupunem că avem mulţimea de elemente
A = {a, b, e, x, y, z, u, v} şi partiţia {a, x, y}, {b, z, v}, {e, u}. Atunci, conform modului de
reprezentare descris, vom avea:
1 2 3 4 5 6 7 8
A ’a’ ’b’ ’e’ ’x’ ’y’ ’z’ ’u’ ’v’
C 1 2 3 1 1 2 3 2
a2 =′ b′ are semnificaţia următoare: elementul de pe poziţia 2 are valoarea ’b’. c2 = 2 -
elementul de pe poziţia 2 face parte din mulţimea de identificator 2. Sau a4 =′ x′ - elementul
de pe poziţia 4 are valoarea ’x’, şi c4 = 1 - elementul de pe poziţia 4 face parte din mulţimea
de identificator 1.
Reprezentarea folosind liste ı̂nlănţuite

În cadrul acestei metode, fiecare mulţime este reprezentată printr-o listă simplu ı̂nlănţuită,
elementul reprezentant fiind elementul aflat ı̂n capul listei. Un nod al listei va avea un câmp
ce păstrează informaţia cu privire la un element al unei mulţimi, şi un câmp ce conţine
legătura către următorul nod al listei.
Vom folosi un vector de adrese (List), ce conţine adresa primului element din fiecare listă
corespunzătoare unei mulţimi de elemente (Listi ).
Algoritm 51 Algoritmi pentru operaţiile init, find, merge (a doua variantă)

1: procedure Init(x, k)
2: Listk ← new node ⊲ alocă spaţiu pentru un nod al listei
3: Listk .data ← x
4: Listk .next ← N U LL
5: end procedure
6: function Find(x)
7: for i ← 1, m do
8: reprezentant ← Listi , p ← reprezentant
9: while ((p 6= N U LL) ∧ (p.data 6= x)) do
10: p ← p.next
11: end while
13: return reprezentant
14: end if
15: end for
16: return N U LL
17: end function
19: capx ← F ind(x)
20: capy ← F ind(y)
21: p ← capx
22: while (p.next 6= N U LL) do
23: p ← p.next
24: end while
25: p.next ← capy
26: return capx
27: end function
138
Procedura Init alocă un nod şi iniţializează câmpurile acestuia. Adresa nodului alocat
este păstrată ı̂n Listk (a se vedea algoritmul 51).
Funcţia Find caută un element printre elementele păstrate de fiecare listă ı̂n parte. Se
parcurge vectorul List şi se obţine reprezentantul fiecărei submulţimi memorate. Se parcurge
lista folosind metoda de căutare liniară şi se ı̂ncearcă identificarea unui element având valoarea
x. Dacă elementul este găsit, atunci se ı̂ntoarce capul listei din care face parte. Dacă, până
la sfârşit, nu a fost identificat elementul x, atunci funcţia returnează valoarea NULL.
Funcţia Merge reuneşte două liste: practic se adaugă o listă la sfârşitul celeilalte. Pentru
a realiza această operaţie, pe lângă adresa primului element dintr-o listă, avem nevoie şi de
adresa ultimului element. Acest lucru se poate obţine, indirect, prin parcurgerea listei de la
primul la ultimul element, fie direct, dacă ı̂n momentul creării, păstrăm pentru fiecare listă
ı̂ncă o variabilă ce conţine adresa ultimului element (last).
Reprezentarea folosind o pădure de arbori

În cadrul acestei modalităţi de reprezentare fiecare mulţime este păstrată sub forma unui
arbore. Pentru fiecare nod, păstrăm informaţia despre părintele său, astfel ı̂ncât tatak mem-
orează indicele nodului părinte al nodului k.
Algoritm 52 Algoritmi pentru operaţiile init, find, merge (a treia variantă)

1: procedure Init(x)
2: tatax ← x
3: end procedure
4: function Find(x)
5: while (x 6= tatax ) do
6: x ← tatax
7: end while
8: return x
9: end function
11: radx ← F ind(x)
12: rady ← F ind(y)
13: tatarady ← radx
14: return radx
15: end function
Se poate observa foarte uşor (a se vedea algoritmul 52), faptul că arborele obţinut ı̂n urma
unor operaţii repetate de reuniune Merge poate deveni degenerat (o structură mai apropiată
de o listă liniară decât o structură de arbore). Pentru a putea să evităm asemenea situaţii,
reuniunea se poate realiza ţinând cont de una din următoarele euristici:
1. numărul de elemente (noduri) din fiecare arbore - rădăcina arborelui ce are mai puţine
noduri (notăm arborele cu TB ) va deveni descendentul direct al rădăcinii arborelui ce
posedă mai multe noduri (notat cu TA ). Astfel, toate nodurile din arborele TA vor
rămâne cu aceeaşi valoare a adâncimii ı̂n cadrul arborelui rezultat, pe când nodurile
din arborele TB vor avea valoarea adâncimii incrementată cu 1. De asemenea, arborele
rezultat ı̂n urma reuniunii celor doi arbori TA şi TB va avea cel puţin de două ori mai
multe noduri decât arborele TB .
În continuare sunt descrise subrutinele Init, Find şi Merge actualizate pentru a folosi
caracteristica numărului de elemente din fiecare arbore.
139
3: rady ← F ind(y)
1: procedure Init(x)
4: size ← |tataradx | + |tatarady |
2: tatax ← −1
5: if (|tataradx | > |tatarady |) then
3: end procedure
6: tatarady ← radx
4: function Find(x)
7: tataradx ← −size
5: while (tatax > 0) do
8: return radx
6: x ← tatax
9: else
7: end while
10: tataradx ← rady
8: return x
11: tatarady ← −size
9: end function
12: return rady
13: end if
14: end function
Prin această euristică simplă se urmăreşte o echilibrare a arborelui rezultat pentru a se
evita cazurile degenerate. Complexitatea timp a procedurii Find este O(log n).
2. ı̂nălţimea fiecărui arbore - rădăcina arborelui ce are ı̂nălţimea mai mică (notăm arborele
cu TB ) va deveni descendentul direct al rădăcinii arborelui cu ı̂nălţimea mai mare (notat
cu TA ). Dacă ı̂nălţimile lui TA şi TB sunt egale şi TA devine subarbore al lui TB , atunci
ı̂nălţimea lui TB creşte cu o unitate.
Înălţimea fiecărui subarbore de rădăcină u se păstrează ı̂ntr-o variabilă nouă hu . Pentru
a economisi cantitatea de memorie utilizată, se poate păstra ı̂nălţimea unui arbore ı̂n
vectorul tata: tatax = −valoarea ı̂nălţimii arborelui, atunci când x reprezintă nodul
rădăcină al unui arbore.
În continuare sunt descrise subrutinele Init, Find şi Merge actualizate pentru a folosi
caracteristica ı̂nălţimii unui arbore.
1: procedure Init(x) 3: rady ← F ind(y)
2: tatax ← x 4: if (hradx > hrady ) then
3: hx ← 0 5: tatarady ← radx
4: end procedure 6: return radx
5: function Find(x) 7: else
6: while (tatax 6= x) do 8: tataradx ← rady
7: x ← tatax 9: if (hradx = hrady ) then
8: end while 10: hrady ← hrady + 1
9: return x 11: end if
10: end function 12: return rady
13: end if
14: end function
Cea de-a doua tehnică utilizată pentru a reduce complexitatea timp a operaţiilor Find şi
Merge este reprezentată de comprimarea drumului. Aceasta constă ı̂n a apropia fiecare nod
de rădăcina arborelui căruia ı̂i aparţine. Astfel, ı̂n timpul operaţiei Find(x) se determină,
mai ı̂ntâi, rădăcina arborelui căruia ı̂i aparţine (rad) şi apoi se mai parcurge o dată drumul
de la nodul x la rădăcină, astfel tatay ← rad, ∀y ∈ lanţul de la x la rad:
140
1: function Find(x)
2: y←x
3: while (tatay 6= y) do
4: y ← tatay
5: end while
6: rad ← y
7: y←x
8: while (tatay =6 y) do
9: y ← tatay
10: tatax ← rad
11: x←y
12: end while
13: return rad
14: end function
6.3.4 Algoritmul lui Kruskal

Algoritmul lui Kruskal [91] este o ilustrare foarte bună a metodei generale de elaborarea a
algoritmilor Greedy (a se vedea algoritmul 53). La ı̂nceput, se pleacă cu o pădure de arbori,
fiecare arbore fiind alcătuit dintr-un singur nod. La fiecare pas, se alege o muchie: dacă cele
două extremităţi (noduri) fac parte din acelaşi arbore, atunci nu se va adăuga muchia curentă
la arborele parţial respectiv, deoarece ar conduce la un ciclu, ceea ce ar strica proprietatea
de graf aciclic. Altfel, dacă cele două noduri fac parte din arbori parţiali distincţi, se adaugă
muchia curentă la mulţimea de muchii alese anterior, iar cei doi arbori parţiali devin unul
singur printr-o operaţie de reuniune. La fiecare pas, numărul de arbori parţiali scade cu 1.
După n − 1 alegeri, pădurea iniţială formată din n arbori se restrânge la un singur arbore.
Algoritm 53 Algoritmul lui Kruskal

1: procedure Kruskal2(n, m, A; L, cost)
2: for i ← 1, n do
3: call Init(i)
4: end for
5: cost ← 0
6: j ← 1, L ← ∅
7: for i ← 1, n − 1 do
8: q←0
9: while (q = 0) do
10: r1 ← F ind(A1,j )
11: r2 ← F ind(A2,j )
12: if (r1 6= r2 ) then
13: cost ← cost + A3,j
14: call M erge(r1 , r2 )
15: L ← L ∪ {(A1,j , A2,j )}
16: q←1
17: end if
18: j ←j+1
19: end while
20: end for
21: end procedure
Pentru a păstra muchiile grafului, vom utiliza o matrice A cu 3 linii şi m coloane (A ∈
141
M3×m (R)): primele două linii conţin extremităţile muchiilor, iar linia a 3-a costul muchiei
respective.
A1,k - indicele nodului ce reprezintă prima extremitate a muchiei.
A2,k - indicele nodului ce reprezintă a doua extremitate a muchiei.
A3,k - lungimea muchiei respective.
Pentru a se aplica o strategie Greedy, datele de intrare, muchiile grafului, se vor ordona
crescător ı̂n funcţie de costul asociat. Deoarece graful parţial respectiv este un arbore cu n
noduri, rezultatul final va avea un număr de n − 1 muchii.
O verificare eficientă cu privire la apartenenţa la acelaşi arbore a celor două extremităţi
ale unei muchii se poate face dacă vom utiliza o structură de date pentru mulţimi disjuncte.
Ca implementare, am ales reprezentarea cu pădure de arbori. Vom folosi un vector Tata
care, pentru fiecare nod, va păstra tatăl acestuia ı̂n arborele parţial căruia ı̂i aparţine. L este
o structură de date de tip listă ce va păstra muchiile alese ı̂n timpul procesului de calcul,
muchii ce formează arborele parţial de cost minim.
Când sunt preluate ca date de intrare, muchiile vor fi prezentate ı̂n ordinea crescătoare
a extremităţilor lor, de forma u v cost, cu u < v, indicii nodurilor ce formează extremităţile
unei muchii.
Exemplul 6.7 Să considerăm graful din figura 6.6. Muchiile grafului şi costurile asociate
lor sunt următoarele:
A 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
linia 1 1 1 1 2 2 2 3 3 4 4 4 5 6 6 7
linia 2 2 3 5 4 5 6 6 8 5 7 8 6 7 8 8
linia 3 14 6 5 12 16 20 12 12 21 24 10 16 14 6 10
După aşezarea ı̂n ordine crescătoare a muchiilor după cost avem:
A 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
linia 1 1 1 6 4 7 2 3 3 1 6 2 5 2 4 4
linia 2 5 3 8 8 8 4 6 8 2 7 5 6 6 5 7
linia 3 5 6 6 10 10 12 12 12 14 14 16 16 20 21 24
În figura 6.7, sunt ilustraţi paşii algoritmului lui Kruskal aplicat pe graful considerat. La
ı̂nceput, se iniţializează pădurea de arbori, fiecare arbore fiind alcătuit dintr-un singur nod,
acesta fiind şi rădăcina arborelui. Apoi, la fiecare pas, se alege o muchie şi se verifică dacă
extremităţile acesteia fac parte din arbori diferiţi. Dacă răspunsul este afirmativ, atunci
muchia respectivă este selectată, altfel se trece la muchia următoare.
La pasul ı̂ntâi, evaluăm muchia (1, 5), şi, deoarece cele două extremităţi fac parte din
arbori distincţi, vom selecta această muchie (L = {(1, 5)}). Reunim arborii din care fac
parte cele două extremităţi (a se vedea figura 6.7 (1)).
La pasul al doilea, se ia ı̂n considerare muchia (1, 3) şi mulţimea muchilor selectate devine
L = {(1, 5), (1, 3)} (a se vedea figura 6.7 (2)).
La pasul al treilea, alegerea muchiei (6, 8) va conduce la reuniunea arborilor de rădăcini
6 şi 8, iar L = {(1, 5), (1, 3), (6, 8)} (figura 6.7 (3)).
La pasul al patrulea, ajungem la muchia (4, 8) ce are costul 10. Nodul 4 face parte din ar-
borele de rădăcină 4, iar nodul 8 face parte din arborele de rădăcină 6. Deoarece extremităţile
muchiei sunt amplasate ı̂n arbori distincţi selectăm muchia curentă pentru arborele parţial
de cost minim, iar L devine L = {(1, 5), (1, 3), (6, 8), (4, 8)}. În urma reuniunii arborilor
corespunzători celor două noduri, se obţine configuraţia din figura 6.7 (4).
142
Fig. 6.7: Algoritmului lui Kruskal exemplificat pe graful din figura 6.6
La paşii următori, cinci şi şase, sunt alese muchiile (7, 8) şi respectiv (2, 4): mulţimea L
este actualizată astfel L = {(1, 5), (1, 3), (6, 8), (4, 8), (7, 8), (2, 4)}.
La pasul al şaptelea, se evaluează muchia (3, 6). Nodurile 3 şi 6 fac parte din arbori diferiţi,
astfel ı̂ncât muchia curentă poate fi selectată pentru soluţia problemei, L = {(1, 5), (1, 3), (6, 8),
(4, 8), (7, 8), (2, 4), (3, 6)}.
Observaţia 6.8 Subliniem faptul că arborii reprezentaţi ı̂n figura 6.7 sunt diferiţi de arborii
ce conduc la obţinerea soluţiei problemei: arborii din figură constituie suportul necesar pentru
reprezentarea structurii de date pentru mulţimi disjuncte, structură ce este utilizată pentru
efectuarea eficientă a operaţiilor Find şi Merge. Acest lucru justifică faptul că, deşi la pasul
al patrulea selectăm muchia (4, 8) pentru arborele parţial de cost minim, ea nu se regăseşte ı̂n
143
configuraţia (4) (nodul 4 este unit direct cu nodul 6, a se vedea figura 6.7). Singura legătură
dintre un arbore suport pentru reprezentarea unei mulţimi şi un arbore folosit pentru obţinerea
arborelui parţial de cost minim, este mulţimea de noduri ce este comună.
6.4 Exerciţii
1. Să se realizeze o subrutină ce ı̂ntoarce numărul de noduri dintr-un arbore oarecare.
2. Fiind dat un arbore oarecare T , să se elaboreze un algoritm ce determină un nod cu

proprietatea că valoarea cheii asociate este cea mai mică dintre toate valorile cheilor
nodurilor arborelui.
3. Se dă un arbore oarecare T , reprezentat prin vectorul tata. Să se elaboreze un algoritm
pentru a determina ı̂nălţimea arborelui T .

proprietatea că valoarea cheii asociate este mai mare decât o valoare specificată a, şi
este cea mai mică dintre toate nodurile cu această proprietate.
5. Fiind dat un arbore oarecare T , să se elaboreze un algoritm ce determină toate nodurile
u cu proprietatea că numărul de copii ai nodului u este mai mare decât numărul de
copii ai părintelui său.

proprietatea că valoarea cheii asociate este a doua cea mai mare valoare dintre valorile
cheilor nodurilor arborelui.
7. Fiind dat un arbore oarecare T , să se elaboreze un algoritm ce determină diametrul

arborelui T . Diametrul unui arbore este dat de numărul de noduri corespunzător celui
mai lung lanţ elementar ı̂ntre oricare două noduri ale arborelui.
8. Fiind dat un arbore oarecare T , să se elaboreze un algoritm ce determină pentru fiecare
nod u ∈ T numărul descendenţilor din subarborele a cărui rădăcină este u.
9. Fiind dată o secvenţă de valori ce reprezintă rezultatul parcurgerii ı̂n A-preordine a

unui k-arbore strict T , să se elaboreze un algoritm ce determină arborele T , şi să se
parcurgă arborele T ı̂n A-postordine.
Un k-arbore strict T este un arbore ı̂n care fiecare nod are fie k descendenţi direcţi fie
nici unul.
10. Fiind dat un arbore oarecare T de rădăcină r şi un număr natural k, să se elaboreze
un algoritm ce determină toate nodurile aflate la distanţa k fatţ de rădăcină.
11. Se dă un arbore oarecare T cu n noduri. Să se elaboreze un algoritm eficient ce verifică
pentru o pereche de noduri (u, v) dacă nodul u este un straămoş al nodului v.
12. Se consideră procesul de proiectare a unei plăci electronice cu N componente (1 ≤ N ≤

100). Pentru fiecare componentă electronică C se cunoaşte numărul de interconexi-
uni. Se consideră graful determinat de mulţimea pinilor şi mulţimea interconectărilor
posibile ale tuturor componentelor, precum şi lungimile lor.
144
Să se elaboreze un algoritm care, dintre toate modalităţile de interconectare posibile,
să determine o interconectare corespunzătoare arborelui de acoperire de cost minim
(interconectarea pentru care suma tuturor circuitelor imprimate are lungimea minimă).
Datele de intrare sunt alcătuite din descrierile mai multor plăci electronice. Descrierea
fiecărei plăci conţine numărul N de componente şi numărul M de interconexiuni. O
conexiune se caracterizează prin trei valori: două vârfuri, u şi v, precum şi lungimea
acesteia l.
Datele de ieşire constau dintr-un răspuns pentru fiecare mulţime de date de test, compus
din numărul testului (se ı̂ncepe numerotarea cu 1), precum şi costul interconectării de
lungime minimă.
Exemplul 6.9 Pentru datele de intrare
5 7
1 2 40 2 3 35 1 5 27 1 4 37 4 5 30 2 4 58 3 4 60
0 0
vom obţine rezultatul
Cazul 1: [1 5] [4 5] [2 3] [1 2]
Interconectarea de cost minim are valoarea 132.
În figura 6.8 este reprezentat graful corespunzător datelor de intrare.
Fig. 6.8: Descrierea conexiunilor posibile dintre componentele unei plăci electronice
13. Se dă un graf neorientat conex ponderat G = (V, E). Să se elaboreze un algoritm ce
determină un arbore de acoperire al grafului G ı̂n care costul maxim al unei muchii este
minim dintre toţi arborii de acoperire ai lui G.
14. Se dă un graf neorientat conex ponderat G = (V, E). Să presupunem că se cunoaşte un
arbore parţial de cost minim T (arbore minim de acoperire) corespunzător lui G. Să se
elaboreze un algoritm eficient care actualizează arborele T dacă ı̂n graful G se adaugă
un vârf nou u şi muchii incidente cu acesta.
145
Capitolul 7
Grafuri orientate
7.1 Noţiuni de bază

Fie o mulţime finită V = {x1 , x2 , . . . , xn }. Fie E ⊆ V × V (unde V × V este produsul
cartezian al mulţimii V cu ea ı̂nsăşi).
În cazul unui graf orientat, noţiunea de muchie este ı̂nlocuită cu noţiunea de arc (o
pereche de noduri (x, y) devine ordonată, adică (x, y) 6= (y, x)). Pentru un arc (x, y) ∈ E,
vârful x reprezintă extremitatea iniţială a arcului, iar vârful y reprezintă extremitatea finală.
Vom spune că vârfurile x şi y sunt adiacente.
Definiţia 7.1 Un graf orientat este o pereche ordonată G = (V, E), unde V este o
mulţime de vârfuri sau noduri, iar E este o mulţime de arce.
Exemplul 7.1 Fie graful orientat G = (V, E), V = {1, 2, 3, 4, 5, 6, 7, 8},

E = {(1, 2), (1, 3), (1, 4), (2, 1), (3, 5), (4, 6), (5, 2), (5, 7), (6, 4), (6, 8), (7, 5), (7, 6)}. Acest graf
se poate reprezenta ca ı̂n figura 7.1.
Definiţia 7.2 Un graf parţial al unui graf orientat G = (V, E) este un graf orientat
G1 = (V, E1 ) unde E1 ⊂ E.
Exemplul 7.2 Pentru graful G din exemplul anterior (G = (V, E)), considerăm graful
parţial G1 = (V, E1 ), cu E1 = {(1, 3), (2, 1), (3, 5), (4, 6), (5, 2), (5, 7), (6, 4), (6, 8)}, şi V =
{1, 2, 3, 4, 5, 6, 7, 8}.
Definiţia 7.3 Un subgraf al unui graf orientat G = (V, E) este un graf orientat H =
(V1 , E1 ) unde V1 ⊂ V iar arcele din E1 sunt toate arcele din E ce au ambele extremităţi ı̂n
mulţimea V1 (E1 = E|V1 ×V1 ).
Exemplul 7.3 Fie subgrafurile H1 şi H2 ale grafului G din exemplul anterior: H1 = (V1 , E1 ),
unde V1 = {1, 2, 3, 5}, iar E1 = {(1, 2), (1, 3), (2, 1), (3, 5), (5, 2)}, şi H2 = (V2 , E2 ), unde
V = {4, 6, 7, 8} şi E2 = {(4, 6), (6, 4), (6, 8), (7, 6)}.
Definiţia 7.4 Gradul exterior al unui vârf d+ (x) este egal cu numărul arcelor ce au ca ex-
tremitate iniţială pe x (d+ (x) = |{(x, u)|(x, u) ∈ E, u ∈ V }|). Gradul interior al unui vârf
d− (x) este egal cu numărul arcelor ce au ca extremitate finală pe x (d− (x) = |{(u, x)|(u, x) ∈
E, u ∈ V }|).
146
Fig. 7.1: Un exemplu de graf orientat
Definiţia 7.5 Se numeşte lanţ o secvenţă de arce L = {l1 , . . . , lp } cu proprietatea că oricare
două arce consecutive ale secvenţei au o extremitate comună. (L = [v0 , v1 , . . . , vp ] unde
(vi , vi+1 ) ∈ E sau (vi+1 , vi ) ∈ E, ∀i = 0, p − 1).
Definiţia 7.6 Un drum D = [v0 , v1 , . . . , vp ] este o succesiune de vârfuri cu proprietatea că

oricare două vârfuri vecine sunt adiacente ((vi , vi+1 ) ∈ E, i = 0, p − 1).
Dacă vârfurile v0 , v1 , . . . , vp sunt distincte două câte două, drumul se numeşte elementar.
Exemplul 7.4 L1 = {(6, 8), (7, 6), (7, 5), (3, 5), (1, 3)} şi L2 = {(6, 8), (6, 4), (1, 4)} sunt lanţuri
de la vârful 8 la vârful 1, iar D1 = {(1, 3), (3, 5), (5, 7), (7, 6), (6, 8)} şi
D2 = {(1, 4), (4, 6), (6, 8)} sunt drumuri elementare de la vârful 1 la vârful 8.
Definiţia 7.7 Un drum D pentru care v0 = vp se numeşte circuit.
Definiţia 7.8 Se numeşte circuit hamiltonian un circuit elementar ce trece prin toate
vârfurile grafului. Un graf ce admite un circuit hamiltonian se numeşte graf hamiltonian
orientat.
Definiţia 7.9 Un drum D ce conţine fiecare arc exact o singură dată se numeşte drum eu-
lerian. Dacă v0 = vp şi drumul este eulerian atunci circuitul se numeşte circuit eulerian.
Un graf ce conţine un circuit eulerian se numeşte graf eulerian orientat.
Definiţia 7.10 Un graf se numeşte conex dacă pentru orice pereche de vârfuri x şi y există
un lanţ Lxy de la x la y.
Definiţia 7.11 Un graf orientat este complet dacă oricare două vârfuri sunt adiacente.
Metodele utilizate pentru reprezentarea unui graf neorientat se pot adapta ı̂n mod natural
pentru reprezentarea unui graf orientat, ı̂nlocuind noţiunea de muchie cu cea de arc.
147
Fig. 7.2: Arbore de acoperire ı̂n lăţime pentru graful orientat din figura 7.1
7.2 Parcurgerea grafurilor

În urma vizitării unui graf neorientat, de obicei nu rezultă numai un arbore de acoperire ci o
pădure de arbori de acoperire.
În urma unei parcurgeri ı̂n lăţime a unui graf orientat, se ı̂ntâlnesc următoarele tipuri de
arce:
• arc al arborelui de acoperire - arcul (u, v) este un arc al arborelui de acoperire ı̂n lăţime.
• arc de ı̂ntoarcere - arcul (u, v) se numeşte arc de ı̂ntoarcere dacă are sensul contrar unui
drum de la v la u ı̂n arborele de acoperire (v u) (se spune că u este un descendent
al lui v şi v este un strămoş al lui u).
• arc de traversare - arcul (u, v) este un arc de traversare dacă v nu este nici descendent
direct, nici strămoş al lui u.
În figura 7.2 este prezentat arborele de acoperire ı̂n lăţime corespunzător grafului din
figura 7.1 având rădăcina 1: arcele (2, 1), (7, 5), (6, 4) sunt arce de ı̂ntoarcere, (5, 2), (7, 6)
sunt arce de traversare, iar celelalte sunt arce ale arborelui de acoperire (de exemplu (1, 3),
(6, 8)).
Vom prezenta schiţa unui algoritm mai general pentru parcurgerea unui graf (a se vedea
algoritmul 54). Pentru aceasta se utilizează două mulţimi de noduri, V izitat şi Neexplorat,
unde V izitat reprezintă mulţimea nodurilor vizitate iar Neexplorat (Neexplorat ⊂ V izitat)
reprezintă mulţimea nodurilor vizitate dar neexplorate (noduri ce prezintă vecini ı̂ncă nevizitaţi).
În urma unei parcurgeri ı̂n adâncime a unui graf orientat, fiecare arc din mulţimea arcelor
poate fi ı̂ncadrat ı̂ntr-unul dintre tipurile următoare:
• arc al arborelui de acoperire - arcul (u, v) este un arc al arborelui de acoperire dacă
call
df s(u) apelează df s(v) (df s(u) df s(v)).
• arc de ı̂naintare - arcul (u, v) este un arc de ı̂naintare dacă este paralel cu un drum de
la u la v din arborele de acoperire (u v) (nu face parte din arborele de acoperire).
148
Algoritm 54 Algoritm de vizitare a unui graf (model general)
( ParcurgereGraf(u, G)
1: procedure
u - vârful de unde se porneşte vizitarea
Input:
G - graful
2: V izitat ← {u}
3: N eexplorat ← V izitat
4: while (N eexplorat 6= ∅) do
5: extrage un nod x din N eexplorat
6: determină y, următorul vecin al lui x ce nu a fost vizitat
7: if (y = N U LL) then
8: elimină x din N eexplorat
9: else
10: if (y ∈
/ V izitat) then
11: V izitat ← V izitat ∪ {y}
12: N eexplorat ← N eexplorat ∪ {y}
13: end if
14: end if
15: end while
16: end procedure
• arc de ı̂ntoarcere - arcul (u, v) se numeşte arc de ı̂ntoarcere dacă are sensul contrar unui
drum de la v la u din arborele de acoperire (v u).
• arc de traversare - arcul (u, v) este un arc de traversare dacă df s(v) a fost apelat şi s-a
terminat ı̂nainte de apelul lui df s(u).
Fig. 7.3: Arbore de acoperire ı̂n adâncime pentru graful orientat din figura 7.1
Pentru fiecare nod v al unui graf vom introduce două numere, prenumv şi postnumv ,
numere ce depind de ordinea ı̂n care sunt ı̂ntâlnite nodurile acestuia ı̂n timpul vizitării ı̂n
adâncime: prenumv marchează momentul când este ı̂ntâlnit nodul v pentru prima oară
149
iar postnumv momentul ı̂n care prelucrarea nodului v s-a ı̂ncheiat. Variabila counter este
iniţializată cu valoarea 1:
1: procedure Prenum(v)
2: prenumv ← counter
4: end procedure
şi
1: procedure Postnum(v)
2: postnumv ← counter
4: end procedure
Un arc (u, v) va avea următoarele proprietăţi, ı̂n funcţie de una din cele patru categorii
de arce introduse anterior ı̂n care se ı̂ncadrează:
1. arc al arborelui de acoperire: prenumu < prenumv şi postnumu > postnumv ;
2. arc de ı̂naintare: prenumu < prenumv şi postnumu > postnumv ;
3. arc de ı̂ntoarcere: prenumu > prenumv şi postnumu < postnumv ;
4. arc de traversare: prenumu > prenumv şi postnumu > postnumv .

Arborele de acoperire ı̂n adâncime corespunzător grafului din figura 7.1 ilustrează aceste
tipuri de arce: arc de ı̂naintare – (1, 4), arce de ı̂ntoarcere - (2, 1), (7, 5), (4, 6) arc de traver-
sare - (5, 2), arce ale arborelui de acoperire - (1, 2), (1, 3), (3, 5), (5, 7), (7, 6), (6, 8), (6, 4) (a
se vedea figura 7.3).
Algoritm 55 Algoritm de vizitare ı̂n adâncime pentru un graf orientat

1: procedure DFSNum(k, n, V ecin)

k
 - nodul curent vizitat


2: vizitatk ← 1 ⊲ marcarea nodului curent k ca fiind vizitat
3: call P renum(k)
4: call V izitare(k) ⊲ vizitarea nodului curent k
5: for i ← 1, n do
7: call DF SN um(i, n, V ecin) ⊲ apelul recursiv al subrutinei DF SN um pt nodul i
8: end if
9: end for
10: call P ostnum(k)
11: end procedure
Lema 7.5 Fiind dat un graf orientat G şi două noduri oarecare u, v ∈ G ce aparţin aceluiaşi
arbore de acoperire ı̂n adâncime rezultat ı̂n urma parcurgerii cu metoda DF S a grafului G
avem:
1. dacă (u, v) este un arc al arborelui de acoperire sau un arc de ı̂naintare sau un arc de traver-
sare ⇒ postnumu > postnumv ;
2. dacă (u, v) este un arc de ı̂ntoarcere ⇒ postnumu < postnumv .
150
Lema 7.6 Fiind dat un graf orientat G pentru oricare două noduri u, v ∈ G avem:
1. v este un descendent al lui u ı̂n pădurea de arbori de acoperire rezultaţi ı̂n urma vizitării ı̂n
adâncime a grafului G ⇔ intervalul [prenumv , postnumv ] este inclus ı̂n intervalul [prenumu ,
postnumu ];
2. nu există nici o legătură ı̂ntre u şi v ı̂n pădurea de arbori de acoperire rezultaţi ı̂n urma
vizitării ı̂n adâncime a grafului G ⇔ intervalele [prenumu , postnumu ] şi [prenumv , postnumv ]
sunt disjuncte;
3. situaţii prenumu < prenumv < postnumu < postnumv sau prenumv < prenumu < postnumv
< postnumu nu sunt posibile.
Lema 7.7 Fiind dat un graf neorientat G, dacă pentru două noduri oarecare u, v ∈ G avem
relaţia prenumu < prenumv < postnumu atunci:
• prenumu < prenumv < postnumv < postnumu ;
• există un drum de la u la v ı̂n G.
Exemplul 7.8 În urma apelării procedurii DFSNum(1, 8, Vecin) (a se vedea algoritmul
55), secvenţa de apeluri recursive ale procedurii DFSNum este ilustrată prin arborele de acoperire
ı̂n adâncime din figura 7.3.
Numerotarea nodurilor ı̂n preordine şi postordine, rezultată ı̂n urma vizitării este următoarea:
1 2 3 4 5 6 7 8
prenum 1 2 4 8 5 6 7 10
postnum 16 3 15 9 14 13 12 11
Pentru arcul (1, 4) avem prenum1 = 1, postnum1 = 16, prenum4 = 8 şi postnum4 = 9.
Deoarece relaţia prenumu < prenumv < postnumu este adevărată conform lemei 7.7 ar
trebui să avem prenumu < prenumv < postnumv < postnumu şi să existe un drum de la u
la v, lucruri care sunt adevărate (prenum1 < prenum4 < postnum4 < postnum1 şi există un
drum de la 1 la 4 ı̂n arborele de acoperire ı̂n adâncime).
7.3 Sortarea topologică
Fig. 7.4: Un graf orientat aciclic
Definiţia 7.12 Un graf orientat şi care nu posedă circuite se numeşte graf orientat aciclic
(directed acyclic graph - DAG).
151
Lema 7.9 Într-un graf orientat aciclic, dacă prenumu < prenumv şi există un drum de la
u la v ı̂n G, atunci prenumu < prenumv < postnumv < postnumu .
În practică, există mai multe situaţii ı̂n care o mulţime de activităţi sau sarcini, trebuie
organizate ı̂ntr-o anumită ordine, ı̂ntre acestea existând, de obicei, o mulţime de restricţii sau
dependenţe. În activitatea de construire a unei clădiri, anumite activităţi nu pot fi ı̂ncepute
decât după finalizarea altor activităţi: spre exemplu, nu se poate ı̂ncepe ridicarea pereţilor
unei construcţii decât după turnarea fundaţiei şi finalizarea structurii de rezistenţă, nu se
poate realiza instalaţia electrică dacă nu au fost ridicate zidurile, ş.a.m.d.
Sau dacă un student doreşte să ı̂şi alcătuiască un plan de studiu individual ce va conţine
pe lângă cursurile obligatorii, şi o serie de cursuri opţionale, va trebui să ţină cont de anul de
studiu ı̂n care se predă fiecare materie, precum şi de cerinţele obligatorii ale acestora: un curs
nu poate fi inclus ı̂n planul de studiu individual al unui student decât dacă acesta a parcurs
şi a obţinut creditele la toate materiile anterioare cerute explicit ı̂n programa cursului.
Algoritm 56 Algoritm de sortare topologică a unui graf orientat (algoritmul lui Kahn)
( SortTop1(n, V ecin; L)
1: procedure
Input:
V ecin - vector ce conţine listele cu vecini ai fiecărui nod
Output: L - lista nodurilor ordonate ı̂n urma sortării topologice
2: for k ← 1, n do
3: dminusk ← 0
4: end for
5: for ∀(u, v) ∈ E do
6: dminusv = dminusv + 1
7: end for
8: Q←∅ ⊲ se iniţializează coada
9: for k ← 1, n do
10: if (dminusk = 0) then
11: Q⇐k ⊲ se inserează ı̂ntr–o coadă nodurile cu gradul interior 0
12: end if
13: end for
14: while (Q 6= ∅) do
15: Q⇒k ⊲ se extrage din coadă un nod
16: L⇐k ⊲ se inserează nodul ı̂ntr-o listă
17: w ← V ecink ⊲ v ia valoarea capului listei de vecini a nodului k
18: while (w 6= N U LL) do
19: dminusw.nodeIndex ← dminusw.nodeIndex − 1
20: if (dminusw.nodeIndex = 0) then
21: Q ⇐ w.nodeIndex ⊲ se inserează ı̂n coadă nodul w.nodeIndex
22: end if
23: w ← w.next ⊲ se trece la următorul vecin
24: end while
25: end while
26: end procedure
Dependenţa dintre două activităţi A şi B o putem modela prin introducerea a două noduri
ı̂n graf xi şi xj , asociate celor două activităţi. Dacă activitatea A trebuie realizată ı̂naintea
activităţii B, atunci se adaugă arcul (xi , xj ).
152
Definiţia 7.13 Se numeşte sortare topologică pentru un graf orientat G = (V, E) o or-
donare {x1 , x2 , . . . , xn } a nodurilor grafului astfel ı̂ncât pentru orice arc (xi , xj ) să avem
i < j.
Prin urmare o sortare topologică presupune aranjarea liniară a vârfurilor unui graf astfel
ı̂ncât toate arcele sale să fie orientate de la stânga la dreapta.
Lema 7.10 Dacă un graf orientat G admite o sortare topologică atunci G este aciclic.
Lema 7.11 Dacă un graf orientat G este aciclic atunci el admite o sortare topologică.
Observaţia 7.12 Într-un graf orientat aciclic există cel puţin un nod al cărui grad interior
este 0 (graful nu posedă arce care să aibă nodul v drept extremitate finală).
Pornind de la această observaţie se schiţează următorul algoritm [81]: ı̂ntr-un graf G se
determină un nod v astfel ı̂ncât gradul său interior să fie zero (d− (v) = 0); se adaugă acest
nod la o listă ce va conţine ordonarea topologică, se şterge nodul din graf ı̂mpreună cu toate
arcele ce ı̂l au ca extremitate iniţială, şi se reia algoritmul pentru graful G′ = (V ′ , E ′ ), unde
V ′ = V \ {v}, E ′ = E|V ′ ×V ′ .
Algoritmul 56 se termină ı̂n cel mult n paşi (|V | = n). Dacă se termină mai devreme,
atunci graful G nu este aciclic (la un moment dat nu mai există nici un nod v astfel ı̂ncât
d− (v) = 0).
Fig. 7.5: Sortare topologică cu algoritmul 56 pentru graful orientat din figura 7.4
Exemplul 7.13 Fie graful orientat din figura 7.5. Vârful 3 are d− (v) = 0. Se adaugă acest
nod la lista finală ce va conţine nodurile ordonate, se şterge nodul ı̂mpreună cu arcele care ı̂l
au drept extremitate iniţială. În graful rezultat, vârful 1 are proprietatea că d− (v) = 0. Se
adaugă la lista de rezultate, şi se elimină din graf ı̂mpreună cu arcele ce pleacă din el. Se
continuă procedeul până când graful devine vid (ı̂ntregul proces poate fi urmărit ı̂n figura 7.5).
153
Algoritm 57 Algoritm de sortare topologică a unui graf orientat (a doua variantă)
1: procedure
Input:
2: for k ← 1, n do
3: prenumk ← 0, postnumk ← 0
4: vizitatk ← 0
5: end for
6: for k ← 1, n do
7: if (vizitatk = 0) then
8: call DF SN um(k, n, V ecin)
9: end if
10: end for
11: se ordonează descrescător nodurile după postnumk şi se păstrează astfel ordonate ı̂n lista L
12: end procedure
Lema 7.14 Un graf orientat G este aciclic dacă şi numai dacă ı̂n urma unei vizitări ı̂n
adâncime a acestuia nu este ı̂ntâlnit nici un arc de ı̂ntoarcere.
Ideea algoritmului 57 o reprezintă lema 7.14[125].
Exemplul 7.15 Să considerăm ca date de intrare pentru algoritmul 57 graful orientat din
figura 7.4. După etapa de iniţializare (liniile 2 - 5) avem:
1 2 3 4 5 6 7
prenum 0 0 0 0 0 0 0
postnum 0 0 0 0 0 0 0
vizitat 0 0 0 0 0 0 0
Se apelează mai ı̂ntâi DFSNum(1, 7, Vecin). Secvenţa rezultată de apeluri recursive este
următoarea: DFSNum(1, 7, Vecin) → DFSNum(2, 7, Vecin) → DFSNum(4, 7, Vecin)
→ DFSNum(5, 7, Vecin) → DFSNum(7, 7, Vecin) → DFSNum(6, 7, Vecin).
În urma acestei secvenţe valorile vectorilor prenum şi postnum sunt următoarele:
1 2 3 4 5 6 7
prenum 1 2 0 3 4 6 5
postnum 12 11 0 10 9 7 8
vizitat 1 1 0 1 1 1 1
Mai rămâne nevizitat un singur nod, 3, drept pentru care vom mai avea un apel
DFSNum(3, 7, Vecin) din procedura principală SortTop2():
1 2 3 4 5 6 7
prenum 1 2 13 3 4 6 5
postnum 12 11 14 10 9 7 8
vizitat 1 1 1 1 1 1 1
Ordonarea descrescătoare a nodurilor mulţimii V după valorile vectorului postnum, con-
duce la următoarea configuraţie:
154
postnum 14 12 11 10 9 8 7
3 1 2 4 5 7 6
Astfel, sortarea topologică a nodurilor grafului obţinută ı̂n urma aplicării algoritmului 57
este: 3, 1, 2, 4, 5, 7, 6.
Observaţia 7.16 O optimizare a algoritmului 57 se referă la adăugarea nodului v ı̂ntr-o

stivă atunci când se termină vizitarea acestui nod v şi se calculează postnumv . Această stivă
va conţine la final nodurile grafului ı̂n ordinea descrescătoare a valorilor postnumv .
Prin urmare, nu mai este nevoie să ordonăm descrescător valorile vectorului postnum
pentru a obţine o sortare topologică a nodurilor grafului G, iar complexitatea algoritmului 57
devine O(|V | + |E|).
7.4 Componente tare conexe
Fig. 7.6: Graf orientat. Componente tare conexe.
Fie G = (V, E) un graf orientat unde V = {1, 2, . . . , n} este mulţimea nodurilor şi E este
mulţimea arcelor (E ⊆ V × V ).
Definiţia 7.14 O componentă tare conexă a unui graf orientat G este o mulţime maxi-
mală de vârfuri U ⊆ V , astfel ı̂ncât, pentru fiecare pereche de vârfuri {u, v} (u, v ∈ U) există
atât un drum de la u la v cât şi un drum de la v la u. Prin urmare se spune că vârfurile u
şi v sunt accesibile unul din celălalt.
Un graf orientat ce are o singură componentă tare conexă astfel ı̂ncât U = V este un graf
tare conex. În cazul ı̂n care un graf orientat nu este tare conex atunci el se poate descompune
ı̂n mai multe componente tare conexe. O astfel de componentă este determinată de un subgraf
al grafului iniţial.
Definiţia 7.15 Graful orientat G se numeşte tare conex dacă pentru orice pereche de
vârfuri u 6= v, există un drum de la nodul u la nodul v şi un drum de la nodul v la nodul u.
Se poate arăta că relaţia de tare conexitate este o relaţie de echivalenţă. O relaţie (notată
cu ∼) este o relaţie de echivalenţă dacă prezintă proprietăţile de reflexivitate, simetrie şi
tranzitivitate:
155
• reflexivitate: a ∼ a;
• simetrie: a ∼ b ⇒ b ∼ a;
• tranzitivitate: a ∼ b, b ∼ c ⇒ a ∼ c.
O clasă de echivalenţă este mulţimea tuturor elementelor care se află ı̂n relaţia ∼ ([x]∼ =
{y|x ∼ y}). Relaţia de echivalenţă determină o partiţie ı̂n clase de echivalenţă a mulţimii
peste care a fost definită. Prin urmare relaţia de tare conexitate determină o partiţie a
mulţimii V . Clasele de echivalenţă determinate de relaţia de tare conexitate sunt componen-
tele tare conexe.
Definiţia 7.16 Se numeşte graf condensat Gcc al unui graf orientat G = (V, E) un graf
orientat ı̂n care fiecărui nod din Gcc ı̂i corespunde o componentă tare conexă din G, iar
(ucc, v cc ) este un arc din Gcc dacă ∃u1 ∈ CC1 şi v1 ∈ CC2 astfel ı̂ncât (u1 , v1 ) ∈ E (CC1 este
componenta conexă a lui G ce ı̂i corespunde nodului ucc, iar CC2 este componenta conexă a
lui G ce ı̂i corespunde nodului v cc ).
Teorema 7.17 Graful condensat Gcc al unui graf orientat G = (V, E) este un graf orientat
aciclic.
Pentru determinarea componentelor tare conexe există mai mulţi algoritmi, dintre care
amintim algoritmul lui Tarjan, algoritmul lui Kosaraju şi algoritmul lui Gabow.
7.4.1 Algoritmul lui Kosaraju

Algoritmul lui Kosaraju-Sharir a fost prezentat de Aho, Hopcroft şi Ullman ı̂n lucrarea lor [2],
fiind preluat dintr-un manuscris al lui S. Rao Kosaraju (M. Sharir l-a prezentat ı̂n lucrarea
[116]).
Algoritmul foloseşte graful transpus GT asociat grafului iniţial G ([11], [23], [30]), fiind
compus din următorii paşi:
Pas 1. Se realizează parcugerea grafului cu algoritmul de vizitare ı̂n adâncime, pornind de la
un nod arbitrar. În timpul vizitării, se realizează numerotarea ı̂n postordine a nodurilor
ı̂n cadrul vectorului postnum.
Pas 2. Se obţine un nou graf GT = (V, E T ) prin inversarea sensului arcelor grafului G (E T =
{(u, v)|(v, u) ∈ E, u, v ∈ V }).
Pas 3. Se caută nodul nevizitat din graful GT ce are cel mai mare număr atribuit ı̂n urma
parcurgerii de la Pasul 1. Din acest nod se iniţiază parcugerea grafului cu algoritmul
de vizitare ı̂n adâncime.
Pas 4. Dacă mai rămân noduri nevizitate atunci se reia Pasul 3, altfel algoritmul se termină.
Fiecare arbore rezultat ı̂n urma parcurgerii de la Pasul 3 constituie o componentă tare conexă
a grafului G.
În continuare se prezintă implementarea ı̂n limbajul C a algoritmului anterior:
Listing 7.1: kosaraju.c
#include <stdio.h>
#include <mem.h>
156
#define MAX 100
#define TRUE 1
#define FALSE 0
char vecin[MAX][MAX]; // Matricea de adiacenta

char vizitat[MAX]; // Vector ce pastreaza starea unui nod: vizitat sau
nevizitat
int nump;
int postnum[MAX]; // Numarul asociat fiecarui varf la vizitarea in postordine
.
void dfs(int k) {
int i;
vizitat[k] = TRUE;
for (i = 0; i < n; i++)
if ((vizitat[i] == FALSE) && (vecin[k][i] > 0))
dfs(i);
nump++;
postnum[k] = nump;
}
void dfsGT(int k) {
int i;
vizitat[k] = TRUE;
for (i = 0; i < n; i++)
if ((vizitat[i] == FALSE) && (vecin[k][i] > 0))
dfsGT(i);
printf("%d ", k);
}
int i, j;

do{
printf("nod1 nod2 : "); scanf("%d %d", &i, &j);
if (i >= 0)
vecin[i][j] = 1;
} while (i >= 0);
}
void main(void) {
int i, j, k, tmp;
int maxim;
int nod;
readInput();
// prima etapa
157
nump = 0;
for (i = 0; i < n; i++)
if (vizitat[i] == FALSE)
dfs(i);
// etapa a doua
for (i = 0; i < n; i++)
for (j = i; j < n; j++) {
tmp = vecin[i][j];
vecin[i][j] = vecin[j][i];
vecin[j][i] = tmp;
}
k = 0;
while (TRUE) {
maxim = 0;
for (i = 0; i < n; i++)
if ((vizitat[i] == FALSE) && (maxim < postnum[i])) {
maxim = postnum[i];
nod = i;
}
if (maxim == 0)
break;
k++;
printf("Componenta %d : ", k);
dfsGT(nod);
printf("\n");
}
}
Exemplul 7.18 După parcurgerea ı̂n adâncime a grafului 7.6, valorile vectorilor vizitat şi
postnum sunt următoarele:
1 2 3 4 5 6 7 8
postnum 8 7 5 6 1 2 3 4
vizitat 1 1 1 1 1 1 1 1
Fig. 7.7: Graful transpus GT corespunzător grafului din figura 7.6
Se construieşte graful transpus, GT (a se vedea figura 7.7). Se caută primul nod u ı̂ncă
158
nevizitat (vizitatu = 0), căruia ı̂i corespunde cea mai mare valoare postnumu . În acest mod,
se identifică componenta tare conexă compusă numai din nodul 1: {1}.
Următorul nod, ca valoarea a vectorului postnum ordonat descrescător, este 2. Din nodul
2 se parcurg nodurile 3 şi 4, rezultând o altă componentă tare conexă: {2, 3, 4}.
Următorul nod nevizitat u ce are valoarea prenumu maximă este nodul 8. Se identifică
mai ı̂ntâi componenta tare conexă {7, 8} şi apoi {5, 6}.
Observaţia 7.19 Se poate simplifica algoritmul, prin eliminarea numerotării ı̂n postordine
a nodurilor. Pentru aceasta se va utiliza o stivă S ce va memora nodurile ı̂n momentul ı̂n
care toţi descendenţii unui nod au fost vizitaţi. Această stivă are acelaşi rol ca şi ı̂n cadrul
celui de-al doilea algoritm pentru sortarea topologică. Algoritmul lui Kosaraju se modifică
astfel:
Pas 1. Se iniţializează o stivă S. Se realizează parcugerea grafului cu algoritmul de vizitare ı̂n

adâncime, pornind de la un nod arbitrar. În timpul vizitării unui nod u, ı̂nainte de părăsirea
acestuia (după ce toate nodurile adiacente cu nodul u au fost vizitate), nodul u se adaugă pe
stiva S. Practic, la implementarea recursivă, ı̂nainte de părăsirea subrutinei nodul curent se
adaugă pe stivă.
Pas 2. Se obţine un nou graf GT = (V, E T ) prin inversarea sensului arcelor grafului G (E T =
{(u, v)|(v, u) ∈ E, u, v ∈ V }).
Pas 3. Se caută primul nod nevizitat din graful GT aflat ı̂n stiva S. Din acest nod se iniţiază
parcugerea grafului cu algoritmul de vizitare ı̂n adâncime.
Pas 4. Dacă mai rămân noduri ale grafului GT nevizitate ı̂n stiva S atunci se reia Pasul 3, altfel
algoritmul se termină.
Analiza algoritmului
Algoritmul lui Kosaraju realizează două parcurgeri ale tuturor elementelor grafului G: prima
dată parcurge graful G şi a doua oară parcurge graful GT . Prin urmare, complexitatea
timp a algoritmului este Ω(|V | + |E|) ı̂n cazul ı̂n care graful este reprezentat prin liste de
adiacenţă şi este pătratică ı̂n |V |2 (O(|V |2 )) atunci când graful este reprezentat prin matricea
de adiacenţă.
7.4.2 Algoritmul lui Tarjan

Algoritmul lui Tarjan [75], [124] este considerat drept o ı̂mbunătăţire a algoritmului lui
Kosaraju prin aceea că nu mai este nevoie de parcurgerea grafului G de două ori.
Algoritmul lui Tarjan este menţionat de către Donald Knuth ı̂ntr-un interviu1 , ca fiind
unul dintre algoritmii săi preferaţi ce au fost implementaţi de acesta:
Those little essays have been packaged into The Stanford GraphBase (1994),
and I still enjoy using and modifying them. My favorite is the implementation
of Tarjan’s beautiful algorithm for strong components, which appears on pages
512-519 of that book.
Algoritmul iniţiază o parcurgere ı̂n adâncime a nodurilor grafului G pornind de la un nod

oarecare. O componentă tare conexă a grafului G, dacă există, constituie un subarbore al
1
http://www.informit.com/articles/article.aspx?p=2213858
159
arborelui de acoperire ı̂n adâncime, iar rădăcina acestui subarbore este reprezentantul clasei
de echivalenţă.
Prin urmare componentele tare conexe se obţin prin descompunerea arborelui/arborilor
de acoperire ı̂n adâncime dacă eliminăm anumite arce ale acestora. Un nod este capul unei
componente tare conexe (sau rădăcina), dacă acesta constituie rădăcina subarborelui cores-
punzător componentei. Arcul ce are nodul-cap drept extremitate finală este cel ce trebuie
eliminat. După ce determinăm toate nodurile-cap, subarborii arborelui/arborilor de acoperire
ı̂n adâncime ce ı̂i au drept rădăcini, sunt componentele tare conexe.
Algoritmul lui Tarjan are drept scop determinarea nodurilor-cap. Pentru a păstra o ordine
a vizitării acestora pe parcursul algoritmului, nodurile vor fi adăugate pe o stivă. Ele vor fi
extrase din stivă ı̂n momentul ı̂n care procedura de vizitare DFS a unui nod este ı̂ncheiată: se
determină dacă nodul curent este rădăcina unei componente tare conexe, şi, ı̂n caz afirmativ,
toate nodurile care au fost vizitate din nodul curent ı̂n cadrul parcurgerii ı̂n adâncime sunt
marcate ca fiind elemente ale componentei tare conexe.
Vom numerota toate nodurile grafului ı̂n preordine (altfel spus, acest număr indică pen-
tru nodul curent numărul de noduri vizitate ı̂naintea sa), valorile fiind păstrate ı̂n vectorul
prenum (cititorul este invitat să revadă şi secţiunea despre Muchie critică, cea de-a doua
soluţie). Pentru un nod u ∈ G definim lowu astfel:

prenumu

lowu = min prenumx , dacă [u, x] este arc de ı̂ntoarcere sau de traversare şi x ∈ S


Dacă dintr-un vârf u ∈ G există un arc de ı̂ntoarcere sau de traversare către un nod v ∈ G
ı̂n afara subarborelui de vizitare ı̂n adâncime determinat de u, atunci acest nod v trebuie să
fi fost vizitat ı̂naintea lui u (prenumu > prenumv ). Dacă un astfel de nod nu există atunci
lowu = prenumu . Stiva S păstrează nodurile grafului, pe măsură ce sunt vizitate, ele fiind
adăugate la S. Dacă u este un nod-cap (lowu = prenumu ) se extrag din stivă toate nodurile
dintre vârful stivei şi u inclusiv: acestea formează o componentă tare conexă.
Se observă că algoritmul lui Tarjan (algoritmul 58) seamănă foarte mult cu algoritmul 22
de determinare a muchiei critice (varianta a II-a).
Exemplul 7.20 La ı̂nceput, valorile vectorilor vizitat şi prenum sunt următoarele:
1 2 3 4 5 6 7 8
prenum 0 0 0 0 0 0 0 0
vizitat 0 0 0 0 0 0 0 0
Primul element nevizitat este nodul 1 (linia 9), prin urmare se apelează DFSTarjan(1,
8, Vecin). Rezultă o secvenţă de apeluri recursive:
DFSNum(1, 8, Vecin) → DFSNum(2, 8, Vecin) → DFSNum(3, 8, Vecin)
→ DFSNum(6, 8, Vecin) → DFSNum(5, 8, Vecin).
1 2 3 4 5 6 7 8
prenum 1 2 3 0 5 4 0 0
vizitat 1 1 1 0 1 1 0 0
low 1 2 0 0 4 4 0 0
Stiva conţine următoarele elemente (vârful stivei fiind ı̂n dreapta): {1, 2, 3, 6, 5}.
low5 = min{prenum6 , low5 } = min{4, 5} = 4 (deoarece deşi vizitat6 = 1, avem 6 ∈ S,
adică nodul 6 se află pe stivă). Astfel ı̂n momentul terminării apelului DFSTarjan(5, 8,
Vecin), low5 = 4.
160
Algoritm 58 Algoritmul lui Tarjan pentru determinarea componentelor tare conexe
( Tarjan(n, V ecin)
1: procedure
Input:
2: for i ← 1, n do
3: vizitati ← 0
4: end for
5: counter ← 0
6: S←∅
7: for i ← 1, n do
9: call DF ST arjan(i, n, V ecin) ⊲ vizitarea ı̂n adâncime a grafului
10: end if
11: end for
12: end procedure
13: procedure DFSTarjan(k, n, V ecin)
14: S⇐k
15: vizitatk ← 1
17: prenumk ← counter, lowk ← counter
18: for i ← 1, n do
21: call DF ST arjan(i, n, V ecin)
23: else
24: if (i ∈ S) then
26: end if
27: end if
28: end if
29: end for
30: if (lowk = prenumk ) then
31: repeat
32: S⇒u
33: Output ”u”
34: until (u = k)
35: end if
36: end procedure
Acum la nivelul lui DFSTarjan(6, 8, Vecin), ı̂n urma revenirii din DFSTarjan(5, 8,
Vecin), se calculează low6 = min{low6 , low5 } = min{4, 4} = 4 (linia 22).
Nodul 6 este un nod-cap (low6 = prenum6 ) (vezi linia 30), şi prin urmare se extrag de pe
stivă toate elementele dintre vârful stivei şi elementul 6 inclusiv, rezultând prima componentă
tare conexă: {5, 6}. Stiva rămâne cu elementele (vârful stivei fiind ı̂n dreapta) {1, 2, 3}.
Din nodul 3 se continuă cu vizitarea nodului 8, ı̂ncă nevizitat:
DFSNum(3, 8, Vecin) → DFSNum(8, 8, Vecin) → DFSNum(7, 8, Vecin).
Conţinutul stivei este {1, 2, 3, 8, 7}.
La nivelul apelului DFSNum(7, 8, Vecin) nu se ia ı̂n considerare la calculului valorii lui
161
low7 nodul 6: deşi există arcul (7, 6), nodul 6 a fost vizitat (vizitati 6= 0) şi nu se mai află
pe stivă (i ∈
/ S). Astfel low7 = min{low7 , prenum8 } = min{7, 6} = 6.
La nivelul lui DFSNum(8, 8, Vecin), low8 = min{low8 , low7 } = min{6, 6} = 6 (linia
22). Avem că (low8 = prenum8 ) (linia 30) şi prin urmare 8 este un nod-cap. Se extrag de pe
stivă toate elementele dintre vârful stivei şi elementul 8 inclusiv, rezultând a doua componentă
tare conexă: {7, 8}.
Stiva rămâne cu elementele (vârful stivei fiind ı̂n dreapta) {1, 2, 3}.
1 2 3 4 5 6 7 8
prenum 1 2 3 0 5 4 7 6
vizitat 1 1 1 0 1 1 1 1
low 1 2 0 0 4 4 6 6
În momentul terminării apelului DFSTarjan(3, 8, Vecin), low3 = 2.
Revenind la nivelul apelului DFSTarjan(2, 8, Vecin), se calculează low2 = min{low2 , low3 } =
min{2, 2} = 2, şi se continuă cu următorul nod ı̂ncă nevizitat, 4: DFSNum(2, 8, Vecin) →
DFSNum(4, 8, Vecin).
Se adaugă nodul 4 pe stivă (stiva devine {1, 2, 3, 4}), low4 = prenum4 = 8.
low4 se calculează din low4 = min{low4 , prenum3 } = min{8, 3} = 3 (există arcul (4, 3),
nodul 3 a fost vizitat - vizitat3 = 1 şi 3 ∈ S - nodul 3 se află pe stivă).
1 2 3 4 5 6 7 8
prenum 1 2 3 8 5 4 7 6
vizitat 1 1 1 1 1 1 1 1
low 1 2 2 3 4 4 6 6
Ne ı̂ntoarcem la nivelul apelului DFSTarjan(2, 8, Vecin), low2 = min{low2 , low4 } =
min{2, 3} = 2. Arcul (2, 5) nu este luat ı̂n considerare la calculul lui low2 deoarece nodul 5 a
fost vizitat (vizitat5 = 1) şi 5 nu se regăseşte pe stivă. Astfel low2 rămâne cu valoarea 2.
Deoarece low2 = prenum2 , extragem de pe stivă elementele ce determină cea de-a treia
componentă tare conexă: {4, 3, 2}. Pe stivă mai rămâne un singur element, {1}, ce va
determina ultima componentă tare conexă.
În final, valorile elementelor vectorilor low şi prenum sunt următoarele:
1 2 3 4 5 6 7 8
prenum 1 2 3 8 5 4 7 6
vizitat 1 1 1 1 1 1 1 1
low 1 2 2 3 4 4 6 6
7.5 Exerciţii
1. Se dă un graf orientat G = (V, E) şi două noduri u şi v, u, v ∈ V . Să se elaboreze un
algoritm ce determină dacă există un drum de la u la v.
2. Se dă un graf orientat G = (V, E). Să se elaboreze un algoritm ce verifică dacă graful
G este aciclic.
3. Se dă un graf orientat G = (V, E) şi două noduri u şi v, u, v ∈ V . Să se elaboreze un
algoritm ce determină toate drumurile de la u la v ı̂n graful G.
4. Se dă un graf orientat G = (V, E). Să se elaboreze un algoritm ce determină un circuit
eulerian ı̂n graful G.
162
5. Se dă un graf orientat G = (V, E). Să se elaboreze un algoritm ce determină dacă graful
G este unic conex (singly connected ).
Un graf orientat este unic conex dacă pentru orice pereche de noduri u, v ∈ V , u 6= v,
există cel mult un drum simplu de la u la v.
6. Să se elaboreze un algoritm ce determină dacă un graf orientat G = (V, E) este semi-
conex (semiconnected ).
Un graf orientat G este semiconex dacă pentru orice pereche de noduri u, v ∈ V , u 6= v,
există fie un drum simplu de la u la v, fie un drum simplu de la v la u.
7. (Compilator ) În trecut compilatoarele erau foarte simple. În acele vremuri oamenii
preferau să includă tot programul ı̂ntr-un singur fişier. Dacă cineva făcea o modificare ı̂n
program, trebuia recompilat tot codul sursă. Creşterea lungimii programelor conducea
la timpi de compilare tot mai mari, ceea ce constituia o piedică ı̂n ceea ce priveşte
creşterea complexităţii algoritmilor implementaţi.
De aceea programatorii au dezvoltat o tehnică pentru eliminarea compilărilor redun-
dante. Ei au ı̂nceput prin a sparge programele ı̂n mai multe module mici pe care le
compilau separat. Astfel, pentru orice modificare care se opera ı̂ntr-un anumit modul,
se compila numai acesta, şi nu ı̂ntreaga aplicaţie. Fiecare modul conţine la ı̂nceput lista
celorlaltor module pe care le foloseşte.
Modulul A trebuie recompilat numai dacă a fost modificat sau are ı̂n lista sa un modul
B care a fost recompilat la rândul său. În celelalte cazuri nu este necesară recompilarea
modulului A.
Problema cere să se realizeze un algoritm şi pe baza acestuia un program, care să decidă
ce module trebuie recompilate şi care nu. Pentru a avea un timp de recompilare minim,
va trebui să căutam compilarea unui număr cât mai mic de linii.
Prima linie a datelor de intrare conţine numărul de module N (1 ≤ N ≤ 100). Urmează
descrierea modulelor. Prima linie a descrierii conţine numele modulului. A doua linie
conţine numărul liniilor din codul sursă. A treia linie conţine numărul M (0 ≤ M < N)
de module de care depinde modulul actual. Linia următoare conţine numele acestor
module, separate printr–un spaţiu. Numele unui modul nu depăşeşte 20 de caractere.
Descrierea modulelor este urmată de mai multe blocuri, câte unul pentru fiecare versiune
a programului. Prima linie a fiecărui bloc conţine numărul k (1 ≤ k ≤ N) de module
ce au suferit modificări de la recompilarea versiunii precedente.
Linia următoare conţine numele modulelor, separate prin spaţiu, ı̂n care au survenit
modificări. După ultimul bloc există o singură linie ce conţine doar numărul 0.
Pentru fiecare versiune a programului se scrie o linie ce conţine numărul liniilor codului
sursă care au trebuit să fie recompilate.
163
Intrare Ieşire
3 127
MATH
20
0
MAIN
100
2
MATH IO
IO
7
0
3
MATH IO MAIN
0
(Propusa la CEOI 1997)
8. Se dă un număr de k (k < 1000) reguli, numerotate de la 1 la k. O regulă are forma

x → y unde x şi y sunt propoziţii cu următoarea semnificaţie: dacă propoziţia x este
adevarată, atunci proproziţia y este adevărată.
Să considerăm pentru k = 5 următoarele reguli:
(1) 1 → 2 (2) 1 → 3 (3) 3 → 4 (4) 4 → 5 (5) 1 → 5
Profesorul cere să se demonstreze regula 1 → 5. Demonstraţia optimă constă ı̂n apli-
carea directă a regulii (5).
(2) (1) (3) (4)
Un elev demonstrează regula (5) astfel: 2 1 3 4 (1 → 3, 1 → 2, 3 → 4, 4 → 5). Aceasta
(1)
este o demonstraţie corectă, ce conţine ı̂n plus regula 1 → 2. Profesorul ar fi fost
(2) (3) (4)
mulţumit cu demonstraţia 2 3 4 (1 → 3, 3 → 4, 4 → 5).
Să se realizeze un algoritm ce utilizează drept date de intrare k, x (propoziţia care se
consideră adevărată), y (propoziţia ce trebuie demonstrată), şirul celor k reguli cât şi
şirul numerelor de ordine ale regulilor ce constituie demonstraţia elevului.
Algoritmul verifică dacă şirul numerelor de ordine ale regulilor constituie o demonstraţie.
În caz negativ va afişa ’NU’, iar ı̂n caz afirmativ va afişa ’DA’, pe linia următoare fiind
descrisă demonstraţia elevului din care au fost eliminate afirmaţiile inutile. Se consideră
că un şir de reguli fără reguli ı̂n plus constituie o demonstraţie corectă a propoziţiei y
pornind de la propozitia x, dacă renunţarea la orice regulă ar conduce la o secvenţă
prin care y nu se mai poate deduce din x.
(Marele premiu PACO, 1997)
9. Distribuirea cărţilor cerute de către cititorii de la sala de lectură a unei biblioteci este
făcută de către un robot ce are posibilitatea să ajungă la orice carte ce poate fi solicitată.
Din păcate, rafturile unde sunt depozitate cărţile sunt dispuse astfel ı̂ncât robotul nu
poate lua cărţile ı̂ntr–un singur drum. După recepţionarea comenzilor de la mai mulţi
cititori, robotul cunoaşte poziţia cărţilor ı̂n rafturi şi drumurile către acestea. Din
păcate, de la poziţia unei cărţi, robotul nu se poate deplasa decât spre anumite cărţi.
Acesta porneşte şi culege cărţile ce sunt accesibile ı̂ntr–un drum, apoi porneşte de la
o altă pozitie de carte şi culege acele cărţi ce sunt accesibile din acel punct şi aşa mai
departe.
164
Datele de intrare constau din numărul de cărţi n precum şi numărul m de legături
dintre poziţiile acestora (1 ≤ n ≤ 100, 11 ≤ m ≤ 10000), urmate de m perechi de
numere naturale, ce semnifică legăturile directe ı̂ntre poziţiile cărţilor.
Datele de ieşire constau din drumurile pe care le face robotul pentru a culege cărţile
cerute.
Fig. 7.8: Poziţiile cărţilor ı̂ntr-o bibliotecă precum şi posibilităţile de deplasare ale robotului
10. Să se elaboreze un algoritm eficient ce determină dacă un graf orientat G = (V, E)
posedă un nod cu proprietatea că gradul interior are valoarea |V | − 1 iar gradul exterior
are valoarea 0.
11. Subrutina SortTop2 (a se vedea algoritmul 57) se poate rescrie astfel ı̂ncât să se renunţe
la ordonarea realizată la sfârşitul subrutinei. Acest lucru se poate obţine prin utilizarea
unei stive ce va păstra fiecare nod al grafului ı̂n timpul parcurgerii ı̂n A-postordine,
parcugere a arborelui de vizitare ı̂n adâncime asociat grafului.
Să se realizeze un program ce implementează algoritmul descris.
Indicaţie
O variantă de implementare este cea propusă de procedura SortTop3 (a se vedea algo-
ritmul 59).
165
Algoritm 59 Algoritm de sortare topologică a unui graf orientat
1: procedure
Input:
2: for k ← 1, n do
3: vizitatk ← 0
4: end for
5: S ← ∅, L ← ∅
6: for k ← 1, n do
7: if (vizitatk = 0) then
8: call DF ST op(k, n, V ecin; S)
9: end if
10: end for
11: while (S 6= ∅) do
12: S⇒u
13: L⇐u
14: end while
15: end procedure
16: procedure DFSTop(k, n, V ecin; S)

k
 - nodul curent vizitat


Output: S - stiva ce păstrează nodurile vizitate ı̂n postordine
17: vizitatk ← 1
18: for i ← 1, n do
20: call DF ST op(i, n, V ecin; S)
21: end if
22: end for
23: S⇐k
24: end procedure
166
Capitolul 8
Distanţe ı̂n grafuri
Reţeaua de drumuri europene, naţionale şi judeţene dintr-o ţară, reţeaua feroviară reprezentând
infrastructura căilor ferate absolut necesară pentru realizarea transportului de mărfuri şi
călători cu trenul, reţeaua de fibră optică folosită pentru traficul de date ı̂n Internet, reţeaua
de transport a energiei electrice folosită pentru alimentarea cu energie electrică a consumato-
rilor casnici şi a celor industriali, reţeaua de canalizare dintr-un oraş folosită pentru evacuarea
deşeurilor, reţeaua CAT V a unui operator de televiziune prin cablu, reţeaua de linii de auto-
buz ce face parte din sistemul public de transport al unui oraş sunt exemple tipice de grafuri
cu care interacţionăm ı̂n viaţa de zi cu zi.
Putem spune că reţelele de transport şi cele de comunicaţii de date ne influenţează ı̂n
mod direct modul de viaţă, devenind elemente indispensabile ale omului modern, şi astfel,
problemele referitoare la studiul căilor de comunicaţie, drumurilor, conexiunilor, capătă un
interes special.
De obicei suntem interesaţi de aspecte precum drumul cel mai scurt sau cel mai lung,
drumul cel mai ieftin sau drumul care se poate parcurge cel mai repede, drumul cel mai
sigur. Teoria grafurilor ne pune la dispoziţie mijloacele pentru aflarea răspunsului la multe
astfel de ı̂ntrebări.
Definiţiile pentru drum, lanţ, ciclu, circuit au fost prezentate ı̂n capitolele anterioare,
ı̂mpreună cu multe alte concepte teoretice. Lungimea unui lanţ este determinată de numărul
muchiilor sale. În mod analog, lungimea unui drum este egală cu numărul arcelor sale.
Într-un graf G se introduce o funcţie de cost ce asociează o valoare reală fiecărei muchii
sau arc, după caz:
c : E −→ R sau c : V × V −→ R
Notăm costul unui drum ca fiind suma costurilor arcelor componente. Astfel pentru
un drum D = [x0 , x1 , . . . , xm ], xi ∈ V , de lungime m, costul acestuia va fi dat de către
următoarea formulă:
m−1
X
c(D) = c([xi , xi+1 ]). (8.1)
i=0
Notăm cu Ms,t mulţimea drumurilor dintre nodul sursă xs şi nodul destinaţie xt , xs , xt ∈
V . Pentru două noduri oarecare xs şi xt , se doreşte să se determine un drum δs,t de la xs la
xt a cărui valoare să fie optimă (minimă sau maximă):
opt
c(δs,t )= min c(δs,t ). (8.2)
δs,t ∈Ms,t
167
8.1 Drumul minim de la un vârf la celelalte vârfuri
8.1.1 Algoritmul lui Moore
Fie G = (V, E) un graf orientat unde V = {x1 , x2 , . . . , xn } este mulţimea nodurilor şi E este
mulţimea arcelor (E ⊆ V × V ). Pentru reprezentarea grafului vom utiliza, ca metodă de
reprezentare, listele de adiacenţă (liste de vecini).
Fie u un vârf al grafului numit sursă. Dorim să determinăm pentru fiecare vârf w ∈
V, w 6= u, dacă există, un drum de lungime minimă de la u la w. Lungimea unui drum se
defineşte ca fiind numărul arcelor ce ı̂l compun.
Algoritmul lui Moore (a se vedea algoritmul 60) se bazează pe structura algoritmului de
parcurgere ı̂n lăţime al unui graf (Breadth First Search - a se vedea algoritmul 16). În lucrarea
[?], Moore ı̂şi prezintă algoritmul astfel:
Write 0 on the source. Then look at all the neighbors of the source and write
1 on them. Then look at all the neighbors of nodes with 1 on them and write 2
on them. And so on.
Vom utiliza un vector de distanţe D, unde dk reprezintă lungimea drumului minim de la vârful
u la vârful xk , iar tatak păstrează vârful anterior lui xk , pe drumul de lungime minimă de la
nodul u la nodul xk .
Algoritm 60 Algoritmul lui Moore (prima versiune)

1: procedure Moore1(k, n, V ecin; D, T ata)

k
 - nodul sursă


V ecin - vector ce conţine capetele listelor de vecini

D
 - vectorul distanţelor de la nodul sursă la celelalte noduri
Output: T ata - vector ce conţine pentru fiecare nod k, predecesorul acestuia pe drumul


de lungime minimă de la nodul sursă la nodul k
2: for i ← 1, n do
3: di ← +∞
4: end for
5: dk ← 0 ⊲ distanţa de la un nod la el ı̂nsuşi este 0
6: Q⇐k ⊲ inserarea nodului curent k ı̂n coadă
7: while (Q 6= ∅) do ⊲ cât timp coada nu este vidă
8: Q⇒k ⊲ extrage nodul curent din coadă
9: v ← vecink ⊲ se pleacă cu primul vecin din lista de vecini
10: while (v 6= N U LL) do
11: if (dv.nodeIndex = +∞) then ⊲ v.nodeIndex este indicele nodului vecin
12: dv.nodeIndex ← dk + 1, tatav.nodeIndex ← k
13: Q ⇐ v.nodeIndex ⊲ inserarea nodului v.nodeIndex ı̂n coadă
14: end if
15: v ← v.next ⊲ se trece la următorul vecin
16: end while
17: end while
18: end procedure
168
Exemplul 8.1 Fie un graf orientat reprezentat prin intermediul următoarelor liste cu vecini:
1: (2, 4) 7: (8)
2: (3, 6) 8: (6, 7)
3: (2) 9: ()
4: (1, 5) 10: (11)
5: (4, 6, 9) 11: (10)
6: (7, 8)
În urma aplicării algoritmului lui Moore pentru acest graf şi pentru nodul 1 drept sursă,
se obţin următoarele valori pentru vectorii D şi Tata:
1 2 3 4 5 6 7 8 9 10 11
D 0 1 2 1 2 2 3 3 3 ∞ ∞
Tata 1 2 1 4 2 6 6 5
Urmărind valorile calculate, putem trage concluzia că drumul de lungime minimă de la
nodul 1 la nodul 9, are lungimea 3 şi este compus din nodurile [1, 4, 5, 9].
8.1.2 Algoritmul lui Dijkstra

Să considerăm G = (V, E) un graf orientat unde V = {1, 2, . . . , n} este mulţimea nodurilor
iar E este mulţimea arcelor (E ⊆ V × V ). Pentru reprezentarea grafului vom utiliza matricea
costurilor C: 
0
 , dacă i = j
ci,j = ∞ , dacă (i, j) ∈
/ E, i 6= j


d > 0 , dacă (i, j) ∈ E
Fie u un vârf al grafului numit sursă. Dorim să determinăm pentru fiecare vârf w ∈
V, w 6= u, dacă există, un drum de lungime minimă de la u la w. Lungimea unui drum se
defineşte ca fiind suma costurilor asociate arcelor ce ı̂l compun.
Fie p = [x1 , x2 , . . . , xk ] un drum elementar. Se numeşte vârf intermediar orice vârf u ∈
{x2 , . . . , xk−1 } unde u 6= x1 , u 6= xk (vârful intermediar este diferit de extremităţile drumului
p).
Algoritmul lui Dijkstra [38] utilizează metoda generală de elaborare a algoritmilor Greedy,
drumurile de cost minim fiind generate ı̂n ordinea crescătoare a valorilor acestor costuri. Vom
nota cu S mulţimea nodurilor grafului G pentru care se cunoaşte (s-a calculat) drumul de
cost minim de la sursă la un astfel de nod. La ı̂nceput, mulţimea S este compusă doar din
nodul sursă. La fiecare pas, se adaugă la mulţimea S un nod xk ∈ V \ S astfel ı̂ncât drumul
de la sursă la acest nod xk , este cel mai scurt dintre toate drumurile posibile de la sursă la
noduri din mulţimea V \ S, drumuri ce au drept noduri intermediare numai elemente din
mulţimea S. Vom utiliza un tablou D, ce va păstra pentru fiecare nod xk , costul drumului cel
mai scurt de la sursă ce trece numai prin noduri din mulţimea S (a se vedea algoritmul 61).
După ce am identificat un astfel de nod xk , mulţimea S se modifică prin adăugarea nodului
xk : S = S ∪ {xk }. Este posibil ca lungimea unui drum de la sursă la un nod xj ∈ V \ S,
ce are drept noduri intermediare noduri din mulţimea S, să se modifice datorită faptului că,
anterior, nodul xk nu fusese luat ı̂n considerare ca vârf intermediar, deoarece nu aparţinea
mulţimii S. Se poate astfel ca, un drum de la sursă la nodul xj ∈ V \ S, ce trece şi prin nodul
xk , să fie mai mic decât drumul anterior de la sursă la nodul xj , ce nu avea printre nodurile
sale intermediare vârful xk :
dk + ck,j < dj . (8.3)
169
Algoritm 61 Algoritmul lui Dijkstra (schema generală)
1: procedure Dijkstra1(u, n, C)
2: S ← {u}
3: for i ← 1, n do
4: di ← cu,i
5: end for
6: for i ← 1, n − 1 do
7: k ← min{dk |xk ∈ V \ S}
8: S ← S ∪ {xk }
9: for each xj ∈ V \ S do
10: dj ← min{dj , dk + ck,j }
11: end for
12: end for
13: end procedure
În cadrul algoritmului 62 vom utiliza trei vectori cu următoarele semnificaţii:
• Vizitat - vector caracteristic pentru mulţimea S, unde:

(
1 , dacă nodul xj ∈ S
vizitatj =
0 , dacă nodul xj ∈ V \ S
• D - vectorul distanţelor de la nodul u la celelalte noduri ale grafului. Aşa cum am

precizat anterior, dj păstrează costul drumului minim de la nodul sursă u la nodul xj ,
drum ce are drept noduri intermediare numai elemente din mulţimea S.
În momentul iniţial vom avea dj = cu,j .
Notăm cu xk nodul ales la un moment dat. Atunci costul drumului minim dj de la
nodul sursă u la un nod xj , se modifică numai dacă dk + ck,j < dj , fiind actualizat
astfel: dj = dk + ck,j .
• tataj - păstrează pentru fiecare nod xj , nodul anterior xk (xk ∈ S) pe drumul de cost
minim de la u la xj . La ı̂nceput,
(
0 , dacă nodul j = u sau cu,j = ∞
tataj =
u , ı̂n rest (j 6= u şi cu,j 6= ∞).
Un element al acestui vector se poate modifica atunci când se modifică valoarea ele-
mentului dj astfel ı̂ncât dj = dk + ck,j , caz ı̂n care tataj = k.
Observaţia 8.2 Algoritmul lui Dijkstra prezintă asemănări cu algoritmul de căutare ı̂n
lăţime, vectorul T ata păstrând la sfârşitul procesului de calcul al distanţelor un arbore al
drumurilor minime ce are drept rădăcină nodul sursă.
Demonstrarea corectitudinii algoritmului

În momentul ı̂n care alegem nodul xk ∈ V \ S având proprietatea că drumul de la sursă la
acel nod xk are costul cel mai mic dintre toate drumurile posibile de la sursă la noduri din
mulţimea V \ S, ce trec numai prin noduri din mulţimea S, acel drum este cel mai scurt
170
Algoritm 62 Algoritmul lui Dijkstra
1: function DistantaMinima(n, V izitat, D)
2: min ← ∞
3: for j ← 1, n do
4: if ((vizitatj = 0) ∧ (dj < min)) then
5: min ← dj
6: j0 ← j
7: end if
8: end for
9: if (min = ∞) then
10: return −1
11: else
12: return j0
13: end if
14: end function

16: vizitatu ← 1
17: du ← 0, tatau ← 0
18: for i ← 1, n do
19: if (i 6= u) then
20: vizitati ← 0
21: di ← cu,i , tatai ← u
22: end if
23: end for
24: while (true) do
25: k ← DistantaM inima(n, vizitat, d)
26: if (k < 0) then
27: break ⊲ forteaza iesirea dintr-o instructiune de ciclare
28: else
29: vizitatk ← 1
30: for i ← 1, n do
31: if ((vizitati = 0) ∧ (dk + ck,i < di )) then
32: tatai ← k
33: di ← dk + ck,i
34: end if
35: end for
36: end if
37: end while
38: end procedure
drum de la sursă la xk dintre toate drumurile posibile. Denumim drum special un drum de
la sursă la un nod xk ce are drept noduri intermediare numai elemente din mulţimea S.
Să presupunem, prin reducere la absurd, că există un drum având costul mai mic de la
nodul sursă la nodul xk , ce nu are toate nodurile intermediare din mulţimea S. Fie xj ∈ V \S,
primul nod intermediar pe drumul de cost minim de la nodul sursă la nodul xk , ce nu aparţine
mulţimii S. Atunci, drumul de la nodul sursă u la nodul xk se compune dintr-un drum de la
u la xj , şi un drum de la xj la xk . Datorită modului de alegere al lui xj , drumul de la u la xj
are drept noduri intermediare numai elemente din mulţimea S (xj este primul nod pe drumul
de la nodul sursă la nodul xk , ce nu aparţine mulţimii S), deci este un drum special ce are
171
Fig. 8.1: O cale specială mai scurtă
un cost mai mic decât drumul special de la sursă la nodul xk . Prin urmare, am identificat
drum special distinct având un cost mai mic, ceea ce contrazice modul de alegere al nodului
xk .
Trebuie să demonstrăm că, ı̂n orice moment, dk păstrează costul celui mai scurt drum
special de la nodul sursă u la nodul xk ∈ V \ S. În momentul ı̂n care nodul xk este adăugat
mulţimii S, avem grijă să verificăm dacă nu există un drum special de la nodul u la un nod
xj ∈ V \ S care să aibă un cost mai mic. Să presupunem că, pentru un nod xj fixat, există
un nod w ∈ S astfel ı̂ncât drumul special u xk ∪ xk w ∪ (w, xj ) să aibă un cost mai
mic (a se vedea figura 8.1). Deoarece nodul w a fost adăugat mulţimii S ı̂naintea nodului xk ,
avem dw ≤ dk .
Prin urmare
dw + cw,j ≤ dk + cw,j < dk + costxk w + cw,j , (8.4)
adică drumul special de la sursă la nodul xj ce trece prin nodul w are costul mai mică decât
drumul special compus din drumul de la nodul sursă la nodul xk , drumul de la nodul xk la
nodul w şi arcul (w, xj ).
Fig. 8.2: Un exemplu de graf orientat ponderat
Exemplul 8.3 Să presupunem că nodul sursă este nodul 1 pentru graful din figura 8.2. După
etapa de iniţializare, vom avea următoarele valori:
172
1 2 3 4 5
D 1 ∞ 21 ∞
Tata 0 1 1 1 1
Vizitat 1 0 0 0 0
În cadrul primei iteraţii, după selectarea nodului 2, se evaluează următoarele distanţe:
d2 + c2,3 < d3 ⇔ 1 + 8 < +∞

d2 + c2,4 < d4 ⇔ 1 + ∞ < 21
d2 + c2,5 < d5 ⇔ 1 + 4 < +∞
1 2 3 4 5
D 1 9 21 5
Tata 0 1 2 1 2
Vizitat 1 1 0 0 0
În timpul celei de-a doua iteraţii se evaluează următoarele condiţii:
d5 + c5,3 < d3 ⇔ 5 + 3 < 9

d5 + c5,4 < d4 ⇔ 5 + ∞ < 21
1 2 3 4 5
D 1 8 21 5
Tata 0 1 5 1 2
Vizitat 1 1 0 0 1
După pasul al treilea, vom actualiza costul unui singur drum:
d3 + c3,4 < d4 ⇔ 8 + 12 < 21
1 2 3 4 5
D 1 8 20 5
Tata 0 1 5 3 2
Vizitat 1 1 1 0 1
La sfâşitul ultimei iteraţii valorile vectorilor D, Tata, Vizitat sunt următoarele:
1 2 3 4 5
D 1 8 20 5
Tata 0 1 5 3 2
Vizitat 1 1 1 1 1

Listing 8.1: dijkstra.c
#include <stdio.h>
#include <values.h>
#define MAXN 100

#define TRUE 1
#define FALSE 0
#define MAXINT 30000
173
/**
* Citirea datelor de intrare - +infinit = -1
*/
void readInput(int* n, int c[][MAXN], int* u) {
int i, j;
printf("n = "); scanf("%d", n);

for (i = 0; i < *n; i++)
for (j = 0; j < *n; j++) {
scanf("%d", &c[i][j]);
if (c[i][j] < 0)
c[i][j] = MAXINT;
}
printf("Nodul initial : "); scanf("%d", u);
}
int minim(int n, int d[], char vizitat[]) {

int j, j0;
int min;
min = MAXINT;
for (j = 0; j < n; j++)
if (!vizitat[j] && d[j] < min) {
min = d[j];
j0 = j;
}
if (min == MAXINT)
return -1;
else
return j0;
}
/**
* Functia verifica daca a > b + c.
*/
return (a > b+c) ? 1 : 0;
}
void dijkstra(int u, int n, int c[][MAXN], int d[], int tata[]) {

/* vector ce pastreaza starea unui nod: vizitat sau nevizitat */
char vizitat[MAXN];
int i, j, k;
//initializari
vizitat[u] = TRUE;
tata[u] = -1;
for (i = 0; i < n; i++)
if (i != u) {
vizitat[i] = FALSE;
d[i] = c[u][i];
174
tata[i] = u;
}
//partea principala
for(i = 1; i < n; i++) {
k = minim(n, d, vizitat);
if (k < 0)
break;
vizitat[k] = TRUE;
//actualizare
for (j = 0; j < n; j++)
if (!vizitat[j] && mai_mare(d[j],d[k],c[k][j])) {
tata[j] = k;
d[j] = d[k] + c[k][j];
}
}
}
void printDrum(int k, int tata[]) {

if (tata[k] >= 0)
printDrum(tata[k], tata);
else
printf("[");
printf("%d ", k);
}
void printSolution(int u, int n, int d[], int tata[]) {

int i;
for (i = 0; i < n; i++)

if (i != u)
if (d[i] == MAXINT)
printf("Nu exista drum de la varful %d la varful %d.\n", u, i);
else {
printf("Distanta de la varful %d la varful %d este %d:", u, i, d[i]);
printDrum(i, tata);
printf("]\n");
}
}
void main(void) {
/* numarul de noduri din graf */
int n;
/* matricea costurilor */
int c[MAXN][MAXN];
/* nodul fata de care se calculeaza drumurile de lungime minima */
int u;
/* tata[k] - parintele varfului k in arborele rezultat */
int tata[MAXN];
/* distanta de la u la fiecare nod */
int d[MAXN];
readInput(&n, c, &u);
175
dijkstra(u, n, c, d, tata);
printSolution(u, n, d, tata);
}
Utilizarea structurii coadă cu priorităţi ı̂n algoritmul lui Dijkstra

Complexitatea-timp a algoritmului lui Dijkstra poate fi ı̂mbunătăţită prin utilizarea structurii
de date coadă cu priorităţi (a se vedea algoritmul 63).
Algoritm 63 Algoritmul lui Dijkstra (varianta ce foloseşte o coadă cu priorităţi)

2: for i ← 1, n do
3: di ← ∞
4: tatai ← N U LL
5: call Insert(Q, i, di ) ⊲ inserează ı̂n coadă elementul xi cu prioritatea di
6: end for
7: du ← 0
8: call DecreaseKey(Q, u, du ) ⊲ actualizează prioritatea vârfului u la du
9: S←∅
10: while (Q 6= ∅) do
11: k ← DeleteM in(Q) ⊲ şterge elementul de prioritate minimă din coadă
12: S ← S ∪ {xk }
13: for each xj ∈ V \ S, astfel ı̂ncât (xk , xj ) ∈ E do
14: if (dj > dk + ck,j ) then
15: dj ← dk + ck,j
16: tataj ← k
17: call DecreaseKey(Q, j, dj ) ⊲ actualizează prioritatea vârfului xj la dj
18: end if
19: end for
20: end while
21: end procedure
Analizând algoritmul 63, obţinem că timpul de lucru al acestuia depinde de formula:
T (n, m) = O(n · TInsert + n · TDeleteM in + m · TDecreaseKey ) (8.5)
unde n reprezintă numărul de noduri ale grafului G iar m reprezintă numărul de muchii ale
aceluiaşi graf. Cele trei operaţii ı̂ntâlnite ı̂n cadrul algoritmlui sunt (a se vedea şi capitolul
5):
1. DeleteMin(Q) - şterge nodul ce conţine cheia de valoare minimă şi reorganizează struc-
tura prin refacerea proprietăţii de coadă cu priorităţi.
2. Insert(Q,p,x) - inserează nodul p ı̂n coada cu priorităţi Q, unde x reprezintă priori-

tatea nodului p.
3. DecreaseKey(Q,p,v) - modifică valoarea priorităţii nodului p din coada cu priorităţi

Q, atribuindu-i valoarea v şi reorganizează această structură.
Astfel, complexitatea algoritmului pentru diferite implementări ale cozii cu priorităţi Q

va fi [30]:
176
1. Listă liniară dublu ı̂nlănţuită neordonată:
T (n, m) = O(n · 1 + n · n + m · 1) = O(n2 ) (8.6)
2. Arbore 2 − 3:
T (n, m) = O(n · log n + n · log n + m · log n) = O((n + m) · log n) (8.7)
3. Heap-uri Fibonacci:
T (n, m) = O(n · 1 + n · log n + m · 1) = O(m + n · log n). (8.8)
8.1.3 Distanţe ı̂ntr-un graf orientat şi fără circuite

Într-un graf orientat aciclic, ce poate avea şi arce de cost negativ, putem calcula drumurile
de cost minim de la un nod la toate celelalte printr-un algoritm bazat pe metoda programării
dinamice (a se vedea algoritmul 64).
Datorită faptului că ı̂n graful orientat G = (V, E) nu există circuite, nodurile grafului
pot fi organizate ı̂n ordine topologică, organizare ce determină ordinea ı̂n care acestea vor fi
prelucrate pentru calculul drumurilor de cost minim.
Algoritm 64 Algoritmul de calcul a distanţelor ı̂ntr-un graf orientat aciclic

1: procedure DAGDist(k, n, C; D, T ata)

k - nodul sursă



C - matricea costurilor
2: call T opSort(n, V ecin; L)
3: for i ← 1, n do
4: di ← +∞, tatai ← 0
5: end for
6: dk ← 0
7: for i ← 1, n do
8: u ← Li ⊲ nodul aflat pe poziţia i ı̂n ordinea topologică
9: for each e = (u, v) ∈ E do
10: if (dv > du + cu,v ) then
11: dv ← du + cu,v
12: tatav ← u
13: end if
14: end for
15: end for
16: end procedure
Complexitatea timp a algoritmului 64 este O(|E| + |V |).
Exemplul 8.4 În figura 8.3 avem un graf orientat aciclic. Rezultatul sortării topologice a
nodurilor acestui graf este 1, 2, 5, 4, 7, 6, 3, după cum se poate vedea şi ı̂n figură.
La pasul 1, nodul curent este nodul 1 (a se vedea figura 8.4 (a)):
d2 > d1 + c1,2 ⇔ ∞ > 0 + 7 ⇒ d3 = 0 + 7 = 7

d3 > d1 + c1,3 ⇔ ∞ > 0 + 25 ⇒ d3 = 0 + 25 = 25
177
Fig. 8.3: Un exemplu de graf orientat aciclic.
Fig. 8.4: Determinarea drumurilor de cost minim de la nodul 1 la toate celelalte noduri ale grafului orientat
aciclic din figura 8.3
d4 > d1 + c1,4 ⇔ ∞ > 0 + 20 ⇒ d3 = 0 + 20 = 20.
La pasul al doilea, nodul curent este nodul 2 (a se vedea figura 8.4 (b)):
d4 > d2 + c2,4 ⇔ 20 > 7 + 10 ⇒ d3 = 7 + 10 = 17

d5 > d2 + c2,5 ⇔ ∞ > 7 + 4 ⇒ d3 = 7 + 4 = 11.
La pasul al treilea, nodul curent este nodul 5 (a se vedea figura 8.4 (c)):
d4 > d5 + c5,4 ⇔ 17 > 11 + 2 ⇒ d3 = 11 + 2 = 13

d7 > d5 + c5,7 ⇔ ∞ > 11 + 9 ⇒ d3 = 11 + 9 = 20.
178
La pasul al patrulea, nodul curent este nodul 4 (a se vedea figura 8.4 (d)):
d3 > d4 + c4,3 ⇔ 25 > 13 + 4 ⇒ d3 = 13 + 4 = 17

d6 > d4 + c4,6 ⇔ ∞ > 13 + 4 ⇒ d3 = 13 + 4 = 17
d7 > d4 + c4,7 ⇔ 20 > 13 + 5 ⇒ d3 = 13 + 5 = 18.
La al cincilea pas, nodul curent este nodul 7 (a se vedea figura 8.4 (e)):
d6 > d7 + c7,6 ⇔ 17 > 18 + 1.
La al şaselea pas, nodul curent este nodul 6 (a se vedea figura 8.4 (f )):
d3 > d6 + c6,3 ⇔ 17 > 17 + 3.
La ultimul pas, nodul curent este nodul 3, din care nu pleacă niciun arc.
Observaţia 8.5 Deşi ı̂n exemplul prezentat, primul nod al listei obţinute ı̂n urma sortării
topologice este identic cu nodul sursă (cel de la care se doreşte să se calculeze drumul de cost
minim la fiecare nod al grafului), ı̂n general, algoritmul ı̂ntoarce rezultate corecte şi atunci
când cele două noduri sunt distincte.
Pornind de la algoritmul 64 se pot determina cele mai lungi drumuri de la nodul sursă la
toate celelalte noduri ale grafului G, dacă se efectuează una dintre următoarele modificări:
• fie toate elementele din matricea costurilor se ı̂nmulţesc cu valoarea −1,
• fie relaţia dv > du + cu,v devine dv < du + cu,v şi di ← −∞, ∀i = 1, n.
De asemenea, tot prin intermediul acestui algoritm se poate determina un drum critic
maximal ı̂ntr-un graf.
8.1.4 Algoritmul Bellman-Ford-Moore

Algoritmul lui Dijkstra determină drumurile de cost minim de la un nod la toate nodurile
unui graf orientat, ı̂n situaţia ı̂n care costurile acestor arce sunt pozitive.
Dacă avem arce al căror cost este negativ, atunci algoritmul lui Dijkstra nu mai calculează
corect drumurile de cost minim, existând alţi algoritmi ce pot determina drumurile de cost
minim de la un nod la toate celelalte noduri ale unui graf orientat.
179
Algoritm 65 Algoritmul Bellman-Ford-Moore
1: function BellmanFord1(k, n, C; D, T ata)

k - nodul sursă



C - matricea costurilor
2: for i ← 1, n do
3: di ← +∞, tatai ← 0
4: end for
6: for i ← 1, n − 1 do
9: dv ← du + cu,v
10: tatav ← u
11: end if
12: end for
13: end for
16: return f alse ⊲ Există un ciclu de cost negativ!
17: end if
18: end for
19: return true
20: end function
Însă nici aceşti algoritmi nu pot calcula rezultatul corect dacă ı̂n cadrul grafului orientat
este semnalată prezenţa unor circuite având costul negativ.
Cel mai cunoscut algoritm este algoritmul Bellman-Ford-Moore, numele acestuia consti-
tuind o recunoaştere a muncii depuse de către cercetătorii R. E. Bellman [13], L. R. Ford Jr.
[47] şi E. F. Moore [101], care au publicat independent algoritmi foarte apropiaţi (a se vedea
algoritmul 65).
Algoritmul 66 este o variantă a algoritmului 65 ı̂n care arcele nu mai sunt tratate ı̂ntr-o
ordine apriori, ele fiind abordate ı̂n ordinea dată de nodul sursă.
180
Algoritm 66 Algoritmul Bellman-Ford-Moore (a doua variantă)
 BellmanFord2(k, n, C, V ecin; D, T ata)

1: function

 k - nodul sursă


n - numărul de noduri din graf
Input:

 C - matricea costurilor


V ecin - liste de adiacenţă
2: for i ← 1, n do
3: di ← +∞, tatai ← 0
4: end for
6: for i ← 1, n − 1 do
7: for j ← 1, n do
8: p ← V ecinj
9: while (p 6= N U LL) do
10: w ← p.nodeIndex
11: if (dw > dj + cj,w ) then
12: dw ← dj + cj,w
13: tataw ← j
14: end if
15: p ← p.next
16: end while
17: end for
18: end for
19: for i ← 1, n do
20: p ← V ecini
23: if (dw > di + ci,w ) then
25: end if
26: p ← p.next
27: end while
28: end for
29: return true
30: end function
În lucrarea [114] este prezentată o variantă a algoritmului Bellman-Ford-Moore ce uti-

lizează o coadă ı̂n care, ı̂n cadrul fiecărei etape, sunt introduse nodurile w pentru care se
obţine o ı̂mbunătăţire a lungimii drumului minim de la nodul de start la nodul w. În algo-
ritmul 67, se foloseşte un vector inQueue ce va păstra pentru un nod u dacă se află ı̂n coada
Q sau nu: inQueueu = true dacă nodul u se află ı̂n coadă şi false ı̂n caz contrar. Vectorul
count contorizează pentru fiecare nod u numărul de ori când acesta s-a aflat ı̂n coada Q.
Se cuvine să menţionăm faptul că aceşti algoritmi sunt folosiţi la rutarea pachetelor de
date ı̂n cadrul reţelei globale Internet:
• protocolul OSPF (Open Shortest Path First - OSPF1 , OSPFv22 ) utilizează algoritmul
lui Dijkstra;
1
RFC 1131 - http://tools.ietf.org/html/rfc1131
2
RFC 2328 - http://tools.ietf.org/html/rfc2328
181
• protocolul RIP (Routing Information Protocol - RIP3 , RIPv24 ) utilizează algoritmul
lui Bellman-Ford-Moore.
Algoritm 67 Algoritmul Bellman-Ford-Moore (a treia variantă)

1: function BellmanFord3(k, n, C, V ecin; D, T ata)
2: for i ← 1, n do
3: di ← +∞, tatai ← 0, inQueuei ← 0, counti ← 0
4: end for
5: Q ← ∅, dk ← 0 ⊲ distanţa de la un nod la el ı̂nsuşi este 0
6: Q ⇐ k, inQueuek ← 1
7: while (Q =6 ∅) do
8: Q ⇒ u, inQueueu ← 0
9: p ← V ecinu
12: if (dw > du + cu,w ) then
13: dw ← du + cu,w , tataw ← u
14: if (inQueuew = 0) then
15: if (countw > n) then
17: else
18: Q ⇐ w, inQueuew ← 1, countw ← countw + 1
19: end if
20: end if
21: end if
22: p ← p.next
23: end while
24: end while
25: return true
26: end function
8.2 Drumuri minime ı̂ntre toate perechile de vârfuri

Fie G = (V, E) un graf orientat, unde V = {x1 , x2 , . . . , xn } reprezintă mulţimea nodurilor
şi E reprezintă mulţimea arcelor (E ⊆ V × V ). Fiecărui arc din E i se asociază o valoare
pozitivă ci,j (ci,j ≥ 0) ce reprezintă lungimea arcului. Se doreşte calcularea drumului de cost
minim pentru oricare pereche de noduri xi , xj .
Pentru a determina drumurile de cost minim ı̂ntre toate perechile de vârfuri, putem alege
un algoritm ce determină drumurile minime de sursă unică (drumurile de cost minim de la
un vârf la toate celelalte), şi pe care să-l aplicăm pentru fiecare vârf al grafului.
Un astfel de algoritm este algoritmul lui Dijkstra, algoritm ce a cunoscut multiple ı̂mbunătă-
ţiri faţă de varianta orginală, ce se bazează pe utilizarea unor structuri de date avansate (de
exemplu heap-uri Fibonacci ), menite să-i optimizeze timpul de execuţie. Astfel, complexitatea-
timp ı̂n cazul cel mai defavorabil pentru calculul celor mai scurte drumuri, pornind dintr-un
vârf al unui graf cu n noduri şi m arce, este O(m + n log n). Dacă aplicăm acest algoritm
pentru toate cele n vârfuri vom obţine un timp de lucru de O(mn + n2 log n).
3
RFC 1058 - https://tools.ietf.org/html/rfc1058
4
RFC 2453 - https://tools.ietf.org/html/rfc2453
182
Algoritm 68 Algoritmul lui Dijkstra pentru toate perechile de vârfuri
1: procedure DijkstraAll(n, C; D)
2: for i ← 1, n do
3: for j ← 1, n do
4: if ((i, j) ∈ E) then ⊲ sau (ci,j > 0) ∧ (ci,j < ∞)
5: di,j ← ci,j
6: else
7: di,j ← ∞
8: end if
9: C ⇐ (i, j) cu prioritatea di,j
10: end for
11: end for
12: while (C = 6 ∅) do
13: C ⇒ (i, j)
14: for k ← 1, n do
15: if (di,j + cj,k < di,k ) then
16: di,k ← di,j + cj,k
17: actualizează prioritatea perechii (i, k) din C la di,k
18: end if
19: end for
20: for k ← 1, n do
21: if (ck,i + di,j < dk,j ) then
22: dk,j ← ck,i + di,j
23: actualizează prioritatea perechii (k, j) din C la dk,j
24: end if
25: end for
26: end while
27: end procedure
Algoritmul 68 prezintă o variantă a algoritmului lui Dijkstra ı̂n care drumurile de cost
minim ı̂ntre oricare două vârfuri sunt calculate incremental şi intercalat [35]. Matricea D
va păstra pentru fiecare pereche [xi , xj ] costul di,j al drumului minim dintre cele explorate
până la momentul curent. Coada de priorităţi C va conţine toate perechile de noduri (i, j),
ordonate crescător ı̂n funcţie de prioritatea di,j a fiecăreia. La fiecare pas, se extrage din
coadă perechea de noduri (i, j) având prioritatea cea mai mică şi se ı̂ncearcă extinderea
drumului [xi , xj ] cu exact un arc la fiecare extremitate a drumului. Tehnica utilizată este cea
a relaxării, ı̂ntâlnită ı̂n cadrul algoritmilor prezentaţi anterior (de exemplu algoritmului lui
Bellman-Ford-Moore), cu scopul de a micşora costul drumului de la xi la xj , prin parcurgerea
tuturor arcelor ce părăsesc vârful xj şi a celor ce sosesc ı̂n vârful xi .
8.2.1 Algoritmul lui Roy-Floyd-Warshall

Fie p = [x1 , x2 , . . . , xk ] un drum elementar. Definim drept vârf intermediar orice vârf u ∈
{x2 , . . . , xk−1 }, u 6= x1 , u 6= xk (vârful intermediar este diferit de extremităţile drumului p).
Fie U = {x1 , x2 , . . . , xk } o mulţime de noduri. Notăm cu MUi,j mulţimea drumurilor de la
xi la xj ce au drept noduri intermediare numai elemente din mulţimea U. Fie p drumul de
cost minim de la xi la xj (p ∈ MUi,j ). Un astfel de drum este elementar deoarece am presupus
că nu există cicluri al căror cost să fie negativ.
(k)
Notăm di,j costul drumului minim de la xi la xj ce are noduri intermediare numai din
183
mulţimea {x1 , x2 , . . . , xk }. Dacă xk ∈
/ p (xk nu aparţine drumului p) atunci drumul de
cost minim de la xi la xj având toate nodurile intermediare din mulţimea {x1 , x2 , . . . , xk−1 }
va fi şi drum de cost minim de la xi la xj cu toate nodurile intermediare din mulţimea
{x1 , x2 , . . . , xk }:
(k) (k−1)
di,j = di,j (8.9)
Dacă xk este un vârf intermediar al drumului p, fie p1 şi p2 subdrumuri ale lui p, p = p1 ⊕ p2
(p1 drumul de la xi la xk având nodurile intermediare din mulţimea {x1 , x2 , . . . , xk } şi p2
drumul de la xk la xj având nodurile intermediare din mulţimea {x1 , x2 , . . . , xk }). Deoarece
p1 şi p2 sunt drumuri de cost minim şi xk ∈
/ {x1 , x2 , . . . , xk−1 } vom avea:
(k−1) (k)
di,k = di,k ,
(k−1) (k)
dk,j = dk,j .
Prin urmare
(k) (k−1) (k−1)
c(p) = c(p1 ) + c(p2 ) ⇒ di,j = di,k + dk,j (8.10)
Algoritmul Roy-Floyd-Warshall va construi un şir de matrici D (0) , D (1) , . . . , D (k) , . . . , D (n) .
(k)
Pentru fiecare k, 1 ≤ k ≤ n, di,j va conţine costul drumului minim de la nodul xi la nodul
xj ce are drept noduri intermediare numai noduri din mulţimea {x1 , x2 , . . . , xk }.
Matricea D (0) se va iniţializa astfel:

0
 , dacă i = j
(0)
di,j = +∞ , dacă (xi , xj ) ∈
/ E, i 6= j (8.11)


d > 0 , dacă (xi , xj ) ∈ E
(un drum ce nu are nici un vârf intermediar este determinat de costul legăturii directe dintre
xi şi xj ).
Drumul de cost minim de la xi la xj ce trece numai prin nodurile {x1 , x2 , . . . , xk } fie nu
(k) (k−1) (k)
conţine nodul xk , caz ı̂n care di,j = di,j , fie ı̂l conţine, şi atunci are loc relaţia di,j =
(k−1) (k−1) (k)
di,k + dk,j . Prin urmare, valoarea elementului di,j se poate calcula astfel:
(k) (k−1) (k−1) (k−1)
di,j = min{di,j , di,k + dk,j } (8.12)
Deşi această ultimă relaţie sugerează un algoritm recursiv, o abordare iterativă este mai
eficientă atât ı̂n ceea ce priveşte complexitatea timp, cât şi din punctul de vedere al necesaru-
lui de memorie. Se observă că, matricea D (k) este necesară pentru calculul matricei D (k+1) ,
după aceea ea nemaifiind folosită.
Rezultatul final este păstrat ı̂n matricea D (n) :
(n) (n)
D (n) = (di,j ), di,j = δi,j , ∀xi , xj ∈ V, (8.13)
(n)
unde di,j = costul drumului minim de la nodul xi la nodul xj , drum ce are noduri intermediare
numai elemente din mulţimea {x1 , x2 , . . . , xn }.
Algoritmul 69 prezintă modul de calcul al elementelor din matricea D (n) .
În algoritmul 69 se poate renunţa la indicii superiori, obţinându-se astfel o economie de
spaţiu de la Θ(n3 ) la Θ(n2 ) (a se vedea algoritmul 70).
Algoritmul 70 ne permite să calculăm distanţa minimă ı̂ntre oricare pereche de noduri
apaţinând unui graf G. Se pune problema de a determina şi componenţa drumului minim
(mulţimea vârfurilor intermediare) dintre două noduri, nu numai valoarea distanţei minime.
184
Algoritm 69 Algoritmul Floyd-Warshall
1: procedure FloydWarshall1(n, C; D (n))
2: for i ← 1, n do
3: for j ← 1, n do
(0)
4: di,j ← ci,j
5: end for
6: end for
7: for k ← 1, n do
8: for i ← 1, n do
9: for j ← 1, n do
(k) (k−1) (k−1) (k−1)
10: di,j ← min {di,j , di,k + dk,j }
11: end for
12: end for
13: end for
14: end procedure
Algoritm 70 Algoritmul Floyd-Warshall (varianta optimizată)

1: procedure FloydWarshall2(n, C; D)
2: for i ← 1, n do
3: for j ← 1, n do
4: di,j ← ci,j
5: end for
6: end for
7: for k ← 1, n do
8: for i ← 1, n do
9: for j ← 1, n do
10: di,j ← min {di,j , di,k + dk,j }
11: end for
12: end for
13: end for
14: end procedure
Acest lucru se poate realiza prin intermediul unei alte matrici P (k) asociată matricii D (k) .
(k)
Un element Pi,j va păstra nodul intermediar k ce conduce la cea mai mică valoare pentru
(k) (k)
di,j conform formulei 8.12. Daca pi,j = 0, atunci cel mai scurt drum dintre nodurile xi şi xj
este cel direct.
(0)
Elementele matricii iniţiale P (0) vor fi toate nule (pi,j = 0).
(k)
Valoarea unui element pi,j al matricii P (k) se va calcula conform formulei următoare,
ţinându-se cont de relaţia 8.12:
(
(k−1) (k−1) (k−1) (k−1)
(k) pi,j , dacă di,j ≤ di,k + dk,j
pi,j = (k−1) (k−1) (k−1) (8.14)
k , dacă di,j > di,k + dk,j .
Împreună cu secvenţa de matrici D (0) , D (1) , . . ., D (n) , se vor calcula şi elementele secvenţei
de matrici P (0) , P (1) , . . ., P (n) . La final vom avea: P = P (n) , D = D (n) .
Printr-un raţionament analog, se poate demonstra că nu este nevoie să construim efectiv
şirul de matrici P (0) , P (1) , . . ., P (n) . Algoritmul 71 prezintă varianta extinsă a algoritmului
185
70, ı̂n cadrul acestuia fiind adăugat şi suportul pentru determinarea drumului de cost minim
dintre oricare pereche de noduri a grafului.
Algoritm 71 Algoritmul Floyd-Warshall (reconstruirea drumului optim)

1: procedure FloydWarshall3(n, C; D, P )
2: for i ← 1, n do
3: for j ← 1, n do
4: di,j ← ci,j
5: pi,j ← 0
6: end for
7: end for
8: for k ← 1, n do
9: for i ← 1, n do
10: for j ← 1, n do
11: if (di,j > di,k + dk,j ) then
12: di,j ← di,k + dk,j
13: pi,j ← k
14: end if
15: end for
16: end for
17: end for
18: end procedure
19: procedure PrintDrum(i, j, P )
20: if (pi,j = 0) then
21: Output {(i,j)}
22: else
23: call P rintDrum(i, pi,j , P )
24: call P rintDrum(pi,j , j, P )
25: end if
26: end procedure
Exemplul 8.6 Fie graful din figura 8.2. Matricea costurilor asociată acestui graf este următoarea:
 
0 1 +∞ 21 +∞
+∞ 0 8 +∞ 4 
 
C=  3 +∞ 0 12 +∞ 

+∞ +∞ 9 0 +∞
+∞ +∞ 3 +∞ 0
Şirul de matrice D (k) , rezultat al aplicării algoritmului Roy-Floyd-Warshall pentru acest
graf, este ilustrat ı̂n continuare:
186
   
0 1 ∞ 21 ∞ 0 1 ∞ 21 ∞
 ∞ 0 8 ∞ 4   ∞ 0 8 ∞ 4 
   
D(0) =
 3 ∞ 0 12 ∞ 
 D(1) =
 3 4 0 12 ∞ 

 ∞ ∞ 9 0 ∞   ∞ ∞ 9 0 ∞ 
∞ ∞ 3 ∞ 0 ∞ ∞ 3 ∞ 0
   
0 1 9 21 5 0 1 9 21 5
 ∞ 0 8 ∞ 4   11 0 8 20 4 
   
D(2) =
 3 4 0 12 8 
 D(3) =
 3 4 0 12 8 

 ∞ ∞ 9 0 ∞   12 13 9 0 17 
∞ ∞ 3 ∞ 0 6 7 3 15 0
   
0 1 9 21 5 0 1 8 20 5
 11 0 8 20 4   10 0 7 19 4 
   
D(4) =
 3 4 0 12 8 
 D(5) =
 3 4 0 12 8 .

 12 13 9 0 17   12 13 9 0 17 
6 7 3 15 0 6 7 3 15 0
Închiderea tranzitivă
Definiţia 8.1 Fie G = (V, E) un graf orientat, simplu, finit, şi V = {x1 , x2 , . . . , xn }.
Închiderea tranzitivă a grafului G este un graf G+ = (V, E + ), unde E + se defineşte astfel:
E + = {(xi , xj )| ∃ un drum de la xi la xj ı̂n G}.
Definiţia 8.2 O relaţie binară ρ peste o mulţime A = {1, 2, . . . , n} se defineşte ca fiind o
submulţime a produsului cartezian A × A (ρ ⊆ A × A). (a, b) ∈ ρ se mai poate scrie aρb.
Definiţia 8.3 Închiderea tranzitivă a relaţiei binare ρ este o relaţie binară ρ∗ cu proprietatea
că ∀i, j ∈ {1, . . . , n}, (i, j) ∈ ρ∗ ⇔ ∃i1 , . . . , im ∈ {1, 2, . . . , n} astfel ı̂ncât (i1 , i2 ) ∈ ρ, (i2 , i3 ) ∈
ρ, . . ., (im−1 , im ) ∈ ρ şi i = i1 , j = im .
Notăm ρn = ρ ◦ ρ ◦ . . . ρ, unde ρn reprezintă compunerea relaţiei ρ cu ea ı̂nsăşi de n ori.
| {z }
n ori
Atunci ρ∗ se poate defini ı̂n modul următor:
[
ρ∗ = ρn = ρ ∪ (ρ ◦ ρ) ∪ . . . ∪ (ρ ◦ ρ ◦ . . . ◦ ρ) ∪ . . . (8.15)
n∈N
O relaţie binară ρ peste mulţimea {1, 2, . . . , n} se poate reprezenta cu ajutorul unei ma-
trice R, ale cărei elemente sunt definite astfel:
(
1 , dacă (i, j) ∈ ρ
ri,j = (8.16)
0 , dacă (i, j) ∈ / ρ.
Pentru relaţia ρ2 = ρ ◦ ρ ı̂i corespunde matricea R × R, pentru relaţia ρ3 = ρ ◦ ρ ◦ ρ ı̂i

corespunde matricea R × R × R etc.
Dacă notăm cu R(k) matricea corespunzătoare relaţiei ρk , atunci avem R(k) = Rk =
. . × R}. Conform formulei 8.15, pentru determinarea ρ∗ este nevoie de calculul unei
| × .{z
R
k ori
(k)
serii de matrici R0 , R1 , . . . , Rn , unde un element ri,j ∈ Rk se calculează după formula:
(
(k−1) (k−1) (k−1)
(k) 1 , dacă ri,j = 1 sau (ri,k = 1 ∧ rk,j = 1)
ri,j = (8.17)
0 , ı̂n caz contrar.
187
Închiderea tranzitivă a unei relaţii binare prezintă multiple aplicaţii, ca subproblemă ı̂n
cadrul unor probleme computaţionale, cum ar fi: construirea unui automat de parsare utilizat
la realizarea unui compilator, evaluarea interogărilor recursive efectuate asupra unei baze de
date sau analiza elementelor accesibile ı̂ntr-o reţea de tranziţie asociată unui sistem paralel
sau distribuit.
Prima variantă de calcul pentru a determina ı̂nchiderea tranzitivă presupune atribuirea
unui cost unitar (= 1) arcelor mulţimii E, urmată de aplicarea algoritmului Roy-Floyd-
Warshall. Vom obţine o matrice, ı̂n care di,j = +∞ dacă nu există un drum de la xi la xj ,
sau di,j = c < n dacă există.
În cadrul celei de-a doua variante de calcul (a se vedea algoritmul 72), se ı̂nlocuiesc ı̂n
algoritmul 69 operaţiile ’min’ cu ’∨’ (sau logic) şi respectiv ’+’ cu ’∧’ (şi logic).
Algoritm 72 Algoritm de calcul a ı̂nchiderii tranzitive

1: procedure InchidereTranzitiva(n, C; D)
2: for i ← 1, n do
3: for j ← 1, n do
4: if ((i = j) ∨ (ci,j 6= +∞)) then
(0)
5: di,j ← 1
6: else
(0)
7: di,j ← 0
8: end if
9: end for
10: end for
11: for k ← 1, n do
12: for i ← 1, n do
13: for j ← 1, n do
(k) (k−1) (k−1) (k−1)
14: di,j ← di,j ∨ (di,k ∧ dk,j )
15: end for
16: end for
17: end for
18: end procedure
(k)
Semnificaţia valorii unui element al matricii D (k) este următoarea: di,j = 1 dacă există un
drum de la xi la xj ı̂n graful G având vârfurile intermediare numai din mulţimea {x1 , . . . , xk }.
Elementele matricii D (0) se iniţializează astfel:
(
(0) 1 , dacă i = j sau (xi , xj ) ∈ E
di,j = (8.18)
0 , dacă i 6= j şi (xi , xj ) ∈
/ E.
Există astfel un drum de la xi la xj ı̂n graful G având vârfurile intermediare numai

(k)
din mulţimea {x1 , . . . , xk } (di,j = 1) dacă există un drum de la xi la xj având vârfurile
intermediare numai din mulţimea {x1 , . . . , xk−1 } sau dacă există un drum de la xi la xk
având vârfurile intermediare numai din mulţimea {x1 , . . . , xk−1 } şi dacă există un drum de
la xk la xj având vârfurile intermediare numai din mulţimea {x1 , . . . , xk−1 }:
(k) (k−1) (k−1) (k−1)
di,j = di,j ∨ (di,k ∧ dk,j ). (8.19)
Exemplul 8.7 Fie graful din figura 8.2, din care am eliminat arcul (1, 2). Matricea cos-
turilor asociată acestui graf modificat este următoarea:
188
Algoritm 73 Algoritm de calcul a ı̂nchiderii tranzitive (variantă)
1: procedure InchidereTranzitiva(n, C; D)
2: for i ← 1, n do
3: for j ← 1, n do
4: if ((i = j) ∨ (ci,j 6= +∞)) then
5: di,j ← 1
6: else
7: di,j ← 0
8: end if
9: end for
10: end for
11: for k ← 1, n do
12: for i ← 1, n do
13: if (di,k = 1) then
14: for j ← 1, n do
15: di,j ← di,j ∨ dk,j
16: end for
17: end if
18: end for
19: end for
20: end procedure
 
0 ∞ ∞ 21 ∞
 ∞ 0 8 ∞ 4 
 
C=
 3 ∞ 0 12 ∞ 

 ∞ ∞ 9 0 ∞ 
∞ ∞ 3 ∞ 0
   
1 0 0 1 0 1 0 0 1 0
 0 1 1 0 1   0 1 1 0 1 
   
D0 =
 1 0 1 1 0 
 D1 =
 1 0 1 1 0 

 0 0 1 1 0   0 0 1 1 0 
0 0 1 0 1 0 0 1 0 1
   
1 0 0 1 0 1 0 0 1 0
 0 1 1 0 1   1 1 1 1 1 
   
D2 =
 1 0 1 1 0 
 D3 =
 1 0 1 1 0 

 0 0 1 1 0   1 0 1 1 0 
0 0 1 0 1 1 0 1 1 1
   
1 0 1 1 0 1 0 1 1 0
 1 1 1 1 1   1 1 1 1 1 
   
D4 =
 1 0 1 1 0 
 D5 =
 1 0 1 1 0 

 1 0 1 1 0   1 0 1 1 0 
1 0 1 1 1 1 0 1 1 1
8.3 Diametrul unui graf

Definiţia 8.4 Diametrul unui graf G = (V, E) este dat de lungimea celui mai mare drum
dintre toate drumurile de lungime minimă ı̂ntre oricare două noduri u şi v ale grafului.
189
diam(G) = max{c(δu,v )| u, v ∈ V }. (8.20)
Un caz particular ı̂l reprezintă diametrul unui arbore binar, unde distanţa dintre două
noduri este dată de numărul muchiilor lanţului ce le uneşte. Pentru a determina diametrul
unui arbore binar este suficient să determinăm perechea de noduri ce se află la distanţă
maximă ı̂n acel arbore. Putem avea următoarele situaţii:
1. calea cea mai lungă (lanţul cel mai lung) se găseşte ı̂n ı̂ntregime ı̂n subarborele stâng
al rădăcinii;
2. lanţul cel mai lung se găseşte ı̂n ı̂ntregime ı̂n subarborele drept al rădăcinii;
3. lanţul cel mai lung trece prin rădăcină. Lanţul cel mai lung ce trece prin rădăcină
se poate calcula ca suma dintre ı̂nălţimea subarborelui stâng + ı̂nălţimea subarborelui
drept + 1.
Dacă notăm cu R rădăcina arborelui, TL subarborele stâng, TR subarborele drept şi h(T )
ı̂nălţimea unui arbore, atunci pentru arborele T = (R, TL , TR ) vom pune ı̂n evidenţă relaţia:
diam(T ) = max {h(TL ) + h(TR ) + 1, max{diam(TL ), diam(TR )}}. (8.21)
Pe baza acestei formule avem algoritmul 74.
Algoritm 74 Algoritm pentru determinarea diametrului unui arbore binar

1: procedure DiametruArboreBinar(T = (R, TL , TR ); d, h)

R - rădăcina arborelui T

Input: TL - subarborele stâng


T - subarborele drept
(R
d - diametrul arborelui T
Output:
h - ı̂nălţimea arborelui T
2: if (R = N U LL) then
3: d ← 0, h ← 0
4: else
5: call DiametruArboreBinar(TL ; dl, hl)
6: call DiametruArboreBinar(TR ; dr, hr)
7: h ← max{hl, hr} + 1
8: d ← max{hl + hr + 1, max{dl, dr}}
9: end if
10: end procedure
Dacă graful G este un arbore fără rădăcină (graf neorientat aciclic conex), iar lungimea
distanţei dintre două noduri este dată de numărul de muchii al lanţului cel mai scurt, atunci
diametrul grafului G, diam(G), se poate calcula cu ajutorul următorului algoritm:
Pas 1. Se alege un nod oarecare s ∈ V şi se parcurge graful G folosind metoda de parcurgere
ı̂n lăţime BF S(s). Fie u ultimul nod vizitat ı̂n cadrul acestei parcurgeri.
Pas 2. Se parcurge ı̂n lăţime graful G plecând din nodul u. Fie v ultimul nod la care se ajunge
ı̂n cadrul acestei parcurgeri.
Pas 3. u, v reprezintă extremităţile unui lanţ de lungime maximă ı̂n graful G.
190
8.4 Graf pe mai multe niveluri
Fig. 8.5: Graf pe mai multe niveluri
Definiţia 8.5 Se numeşte graf pe mai multe niveluri un graf orientat G = (V, E) ı̂n
care:
• vârfurile sunt aşezate pe n niveluri numerotate de la 1 la n; fie Vi mulţimea vârfurilor de pe

nivelul i;
• pentru orice arc (xi , xj ), există k ∈ {1, 2, . . . , n − 1} astfel ı̂ncât xi ∈ Vk şi xj ∈ Vk+1 ;
• există un singur vârf pe nivelul 1 (notat cu xs ) şi un singur vârf pe nivelul n (notat cu xt );
• fiecărui arc (xi , xj ) i se ataşează un cost ci,j .
Într-un astfel de graf, se cere să de identifice un drum de cost minim de la vârful iniţial
xs la vârful final xt .
Dacă d este un drum optim (de cost minim) de la nodul xs la nodul xt , atunci pentru
orice xi vârf intermediar, drumurile de la xs la xi şi cel de la xi la xt sunt optime.
Fie xj ∈ Vi , i ∈ {1, 2, . . . , n − 1}. Notăm cu dij costul drumului minim de la xj la xt
(considerăm că vom avea dij = +∞ dacă nu există vreun drum de la xj la xt ).
dij = min {cj,k + di+1 n

k } cu dt = 0 (8.22)
xk ∈Vi+1 ;(xj ,xk )∈E
Aceste relaţii presupun utilizarea metodei programării dinamice, mai exact metoda ı̂nainte
(a se vedea algoritmul 75).
Exemplul 8.8 Fie graful pe mai multe niveluri din figura 8.5. Numărul de vârfuri este
n = 12.
În urma aplicării algoritmului prezentat pentru acest graf şi având vârfurile 1 drept sursă,
respectiv 12 destinaţie, se obţin următoarele valori pentru vectorii D şi Next:
191
Algoritm 75 Algoritm de calcul al drumului minim ı̂ntr-un graf pe nivele
1: procedure GrafPeNivele(n, C)
2: dn ← 0, nextn ← 0
3: for i ← n − 1, 1 ST EP − 1 do
4: di ← ∞, nexti ← 0
5: for j ← i + 1, n do
6: if ((cij < ∞) ∧ (di > cij + dj )) then
7: di ← cij + dj
8: nexti ← j
9: end if
10: end for
11: end for
12: if (d1 = ∞) then
13: Output {’Nu exista drum’}
14: else
15: k←1
16: while (k 6= 0) do
17: Output {k}
18: k ← nextk
19: end while
20: end if
21: end procedure
1 2 3 4 5 6 7 8 9 10 11 12
D 11 10 8 9 8 2 ∞ 7 1 ∞ 2 0
Next 4 5 6 6 9 9 0 12 12 0 12 0
i = 11 : j = 12 d11 > c11,12 + d12 ⇔ ∞>∞+0

i = 10 : j = 11 d10 > c10,11 + d11 ⇔ ∞>∞+2
j = 12 d10 > c10,12 + d12 ⇔ ∞>∞+0
i = 9 : j = 10 d9 > c9,10 + d10 ⇔ ∞>∞+∞
j = 11 d9 > c9,11 + d11 ⇔ ∞>∞+2
j = 12 d9 > c9,12 + d12 ⇔ ∞ > 1 + 0 ⇒ d9 = 1
i=8: j=9 d8 > c8,9 + d9 ⇔ ∞ > ∞ + 1

j = 10 d8 > c8,10 + d10 ⇔ ∞ > ∞ + ∞
j = 11 d8 > c8,11 + d11 ⇔ ∞ > ∞ + 2
j = 12 d8 > c8,12 + d12 ⇔ ∞ > 7 + 0 ⇒ d8 = 7
...
Prin urmare, drumul de lungime minimă de la 1 la 12 are costul 11 şi trece prin nodurile
[1, 4, 6, 9, 12].
Complexitatea timp a algoritmului prezentat (algoritmul 75) este O(n2 ), ea devenind
O(n + m) dacă se utilizează reprezentarea grafului prin liste de adiacenţă.
192
8.5 Exerciţii
1. (Cutii n-dimensionale) Să considerăm o cutie n-dimensională, dată prin lungimea
fiecărei laturi (o cutie bidimensională este un dreptunghi, o cutie tridimensională este
un paralelipiped etc.).
Problema cere analizarea unui grup de k cutii n-dimensionale: să se elaboreze un algo-
ritm ce determină o secvenţă de cutii de lungime maximă (b1 , b2 , . . .) din grupul de k
cutii, astfel ı̂ncât fiecare cutie bi să poată fi introdusă ı̂n cutia bi+1 .
O cutie D = (d1 , d2 , . . . , dn ) poate fi inclusă ı̂ntr-o cutie E = (e1 , e2 , . . . , en ) numai dacă
există o permutare a mulţimii valorilor laturilor cutiei D astfel ı̂ncât lungimea fiecărei
laturi a cutiei D, după reorganizare, să nu depăşească lungimea laturii corespunzătoare
din cutia E.
De exemplu cutia (2, 6) poate fi introdusă ı̂n cutia (7, 3) ((6, 2) ⊂ (7, 3)), iar cutia
(1, 6, 13) poate fi introdusă ı̂n cutia (11, 15, 3) ((6, 13, 1) ⊂ (11, 15, 3)).
Cutiile egale pot fi introduse una ı̂ntr-alta. Măsurile laturilor sunt numere reale mai
mici sau egale cu 1000. Numărul de cutii nu depăşeste 100, iar numărul de dimensiuni
nu depăşeşte 20.
(Tuymaada, 1997)
2. Se dă reţeaua hidrografică a unei ţări constituită din mulţimea râurilor şi afluenţii lor.
Cele N râuri (2 ≤ n ≤ 1000) sunt numerotate de la 1 la N. Legătura dintre un râu v
şi un afluent al său u este specificată prin perechea (u, v).
Pentru a se putea face estimări cu privire la potenţialul risc de inundaţie pe cursul unui
râu trebuie să se calculeze debitul fiecărui râu ı̂n parte.
Debitul unui izvor se defineşte ca fiind cantitatea de apă ce trece prin secţiunea izvorului
ı̂n unitatea de timp. Debitul râului u la vărsare va fi egal cu debitul izvorului râului u
plus suma debitelor afluenţilor la vărsare ı̂n râul u.
Se cere să se realizeze un algoritm care să calculeze debitul la vărsare al fiecărui râu.
3. Să se determine drumul de lungime minimă necesar deplasării unui cal pe o tablă de şah
(având dimensiunile 8×8), de la un punct de plecare la unui de sosire, ştiind că pe tablă
există şi căsuţe-capcană. Calul ı̂n drumul său nu poate trece printr-o căsuţă-capcană.
(ACM, Eastern Europe, 1994)
4. Un traducător găseşte o carte scrisă cu litere latine, ı̂n care ı̂nsă ordinea literelor din
alfabet este schimbată. La sfârşitul cărţii, se află un index de cuvinte complet şi necon-
tradictoriu.
Se cere să se elaboreze un algoritm ce determină ordinea literelor din noul alfabet.
(ONI, 1991)
193
Capitolul 9
Fluxuri ı̂n reţele de transport
Studierea fluxului ı̂n reţele de transport ı̂şi are originea ı̂n analiza unor probleme de transport
[113]. Un graf orientat poate constitui o structură ce intervine ı̂n modelarea procesul de
transport dintre un producător şi un consumator prin intermediul unei reţele de transport,
iar ceea ce se trimite pe un drum nu poate depăşi capacitatea sa de transport. La destinaţie
nu poate să ajungă o cantitate mai mare decât cea care a fost realizată de către producător.
În jurul nostru există foarte multe reţele cum ar fi reţeaua electrică, reţeaua de apă,
reţeaua de drumuri, reţeaua de legături telefonice, ce au devenit elemente indispensabile ale
modului de viaţă actual. O astfel de reţea de transport poate asigura curgerea unui lichid
printr-o reţea de conducte, deplasarea curentului prin reţele electrice, transportul de mărfuri
de-a lungul unei reţele de drumuri etc.
Fig. 9.1: Diagrama schematica a reţelei de căi ferate din vestul Uniunii Sovietice şi a ţărilor din estul Europei.
Fluxul maxim este de 163.000 de tone de material din Rusia către Europa de Est. [71]
194
Două dintre lucrările considerate a avea un caracter de pionierat ı̂n acest domeniu ([128]
şi [71]) ı̂şi bazează studiul de caz pe reţeaua feroviară existentă ı̂n fosta U.R.S.S. (cf. [113]).
Aşa cum observă şi autorii lucrării [64], o abordare a acestei probleme folosea algoritmi având
la bază programarea liniară, mai exact metoda simplex [33], ı̂nsă algoritmii dezvoltaţi inde-
pendent de această metodă au condus la rezultate mai bune ı̂n ceea ce priveşte complexitatea
timp.
Prima formulare a problemei determinării fluxului maxim ı̂ntr-o reţea de transport a fost
făcută de T. E. Harris ı̂n lucrarea [71]:
Consider a rail network connecting two cities by way of a number of intermediate

cities, where each link of the network has a number assigned to it representing its
capacity. Assuming a steady state condition, find a maximal flow from one given
city to the other. 1
Există două probleme celebre pentru care s-a demonstrat matematic că sunt duale una
celeilalte: problema fluxului maxim ı̂ntr-o reţea de transport şi problema determinării tăieturii
de capacitate minimă.
În concluzie, putem asimila o reţea de transport cu un graf orientat ı̂n cadrul căruia arcele
facilitează fluxul de materiale ı̂ntre noduri, flux limitat de capacitatea maximă a fiecărui arc.
Procesul presupune stabilirea unui flux de resurse de la un producător (nodul sursă) către
un consumator (nodul destinaţie). Prin flux aici ı̂nţelegem debitul de deplasare (transport)
a resurselor.
Problema fluxului maxim ı̂ntr-o reţea de transport se reduce la a calcula debitul maxim al
unui flux de resurse de la producător la consumator, cu respectarea restricţiilor impuse de
capacitatea maximă de transport a fiecărui arc.
9.1 Reţea de transport. Flux. Tăietură

Definiţia 9.1 Se numeşte reţea de transport un tuplu < G, c, s, t > astfel ı̂ncât:
1. G = (V, E) este un graf orientat, unde fiecărui arc (u, v) ∈ E ı̂i este asociată o valoare
pozitivă denumită capacitate, c(u, v) ≥ 0;
2. există două noduri speciale, s, t ∈ V , s - sursă, t - destinaţie;
3. ∀u ∈ V \ {s, t}, nodul u se găseşte pe cel puţin un drum de la sursă la destinaţie.
Observaţia 9.1 1. Dacă nu există un arc de la u la v ((u, v) ∈

/ E) vom considera că valoarea
capacităţii corespunzătoare perechii (u, v) este 0 (c(u, v) = 0).
2. Graful G considerat este conex şi |E| ≥ |V | − 1.
Definiţia 9.2 Definim fluxul asociat reţelei de transport < G, c, s, t > drept o funcţie
f : V × V → R ce satisface următoarele condiţii:
1. ∀u, v ∈ V , avem f (u, v) ≤ c(u, v) (restricţie de capacitate);

2. ∀u, v ∈ V , avem f (u, v) = −f (v, u) (antisimetrie);
1
Luaţi ı̂n considerare o reţea de cale ferată ce leagă două oraşe prin intermediul unui număr de oraşe
intermediare, unde fiecare legătură are atribuit un număr ce reprezintă capacitatea acesteia. Presupunând
că sistemul se află ı̂ntr-o stare de echilibru, se cere să se determine un flux maxim de la un oraş specificat la
altul.
195
P
3. ∀u ∈ V \ {s, t} avem v∈V f (u, v) = 0 (conservarea fluxului).
f (u, v) se numeşte fluxul net de la nodul u la nodul v.
Definiţia 9.3 Se spune că arcul (u, v) este saturat dacă f (u, v) = c(u, v).
Dacă f (u, v) > 0 se spune că fluxul părăseşte nodul u, iar dacă, pentru arcul (u, v) avem
f (u, v) < 0 (echivalent cu f (v, u) > 0) spunem că fluxul intră ı̂n nodul u.
Definiţia 9.4 Definim valoarea fluxului f ca fiind valoarea fluxului total ı̂n nodul sursă:
X
|f | = f (s, v). (9.1)
v∈V
Fluxul pozitiv de reţea ce intră ı̂ntr-un nod v este:

X
f (u, v). (9.2)
u∈V,f (u,v)>0
Fluxul pozitiv de reţea ce pleacă dintr-un nod v este:

X
f (v, u). (9.3)
u∈V,f (v,u)>0
Drept urmare, valoarea fluxului ı̂n exces ce părăseşte nodul sursă s este:
X X
|f | = f (s, v) − f (u, s). (9.4)
v∈V,f (s,v)>0 u∈V,f (u,s)>0
Definiţia 9.5 Problema fluxului maxim presupune determinarea unui flux de valoare
maximă de la s la t pentru reţeaua de transport < G, c, s, t > [48], [49].
Se poate demonstra faptul că

X X
|f | = f (u, t) − f (t, v), (9.5)
u∈V,f (u,t)>0 v∈V,f (t,v)>0
adică valoarea fluxului f este egală cu diferenţa dintre suma fluxurilor ce intră ı̂n destinaţie
minus suma fluxurilor ce părăsesc destinaţia.
Din regula de conservare a fluxului rezultă că:
X X
f (u, v) = f (v, u), ∀u ∈ V \ {s, t} (9.6)
v∈V,f (u,v)>0 v∈V,f (v,u)>0
Cu alte cuvinte, suma fluxurilor ce intră ı̂ntr-un nod u este egală cu suma fluxurilor ce
părăsesc acelaşi nod u.
Într-o reţea de transport avem următoarea relaţie:
X X X
( f (u, v) − f (w, u)) = 0. (9.7)
u∈V v∈V,f (u,v)>0 w∈V,f (w,u)>0
196
Pe de altă parte avem
X X X X X
( f (u, v) − f (w, u)) = ( f (s, v) − f (u, s))+
u∈V v∈V,f (u,v)>0 w∈V,f (w,u)>0 v∈V,f (s,v)>0 u∈V,f (u,s)>0
X X
( f (t, v) − f (u, t))
v∈V,f (t,v)>0 u∈V,f (u,t)>0
X X
= |f | + ( f (t, v) − f (u, t))
v∈V,f (t,v)>0 u∈V,f (u,t)>0
(9.8)
Din relaţiile 9.7 şi 9.8 rezultă că:

X X
|f | = f (u, t) − f (t, v). (9.9)
u∈V,f (u,t)>0 v∈V,f (t,v)>0
Observaţia 9.2 f (u, u) = 0, ∀u ∈ V .
Observaţia 9.3 Pentru două mulţimi oarecare A, B (A, B ⊆ V ), f (A, B) se defineşte astfel:
XX
f (A, B) = f (u, v). (9.10)
u∈A v∈B
Atunci f (u, B) se poate descrie prin următoarea relaţie:

X
f (u, B) = f (u, v). (9.11)
v∈B
Condiţia de conservare a fluxului ı̂ntr-un nod devine: f (u, V ) = 0.
Propoziţia 9.4 Fluxul asociat unei reţele de transport < G, c, s, t > are următoarele proprie-
tăţi:
1. ∀A ⊆ V , f (A, A) = 0;
2. ∀A, B, C ⊆ V avem:
f (A ∪ B, C) = f (A, C) + f (B, C) − f (A ∩ B, C)
f (A, B ∪ C) = f (A, B) + f (A, C) − f (A, B ∩ C); (9.12)
3. ∀A, B, C ∈ V , unde B este o submulţime proprie a lui A (B ⊂ A):
f (A \ B, C) = f (A, C) − f (B, C)
f (C, A \ B) = f (C, A) − f (C, B); (9.13)
4. ∀A, B ⊆ V , avem f (A, B) = −f (B, A);

5. ∀A ⊆ V , f (A, ∅) = f (∅, A) = 0.
Definiţia 9.6 Fie f1 , f2 două fluxuri ı̂ntr-o reţea de transport < G, c, s, t > şi α ∈ R. Atunci
definim următoarele operaţii cu fluxuri:
1. Funcţia f1 + f2 : V × V → R reprezintă suma fluxurilor f1 şi f2 :

(f1 + f2 )(u, v) = f1 (u, v) + f2 (u, v), ∀u, v ∈ V .
197
Fig. 9.2: Un exemplu de reţea de transport
2. Funcţia αf1 : V × V → R reprezintă produsul scalar dintre scalarul α şi fluxul f1 :

(αf1 )(u, v) = αf1 (u, v), ∀u, v ∈ V .
Observaţia 9.5 1. În figura 9.2 poate fi vizualizat un exemplu de reţea de transport. În cadrul
acesteia sunt indicate doar fluxurile pozitive. Astfel dacă pentru arcul (u, v) avem f (u, v) > 0,
aceasta va fi etichetată ”f(u,v)/c(u,v)”. Dacă f (u, v) ≤ 0, atunci arcul va fi etichetat doar
cu valoarea capacităţii ”c(u,v)”.
2. Dacă avem f1 = f (u, v) ≥ 0 şi f2 = f (v, u) ≥ 0, f1 ≥ f2 > 0 (a se vedea figura 9.3 (a)),
atunci putem aplica următoarea transformare (figura 9.3 (b)): arcul (u, v) este etichetat cu
”(f1 − f2 )/c1 ”, iar arcul (v, u) este etichetat cu ”c2 ” (regula de anulare).
În urma aplicării acestei tranformări, se elimină fluxurile negative din reţea ı̂n acelaşi timp
fiind ı̂ndeplinite restricţiile din definiţia unei reţele de transport.
Fig. 9.3: Regula de anulare
Exemplul 9.6 În figura 9.2 este prezentat un exemplu de reţea de transport şi un flux f .
Ca o ilustrare a celor discutate vom calcula suma fluxurilor pentru nodul 1:
X
f (1, v) = f (1, s) + f (1, 2) + f (1, 3) + f (1, 4) + f (1, t)
v∈V (9.14)
= −f (s, 1) + (−1) + 12 + 0 + 0 = −11 − 1 + 12 = 0
f (1, 2) = 0 − 1 = −1
Sau
X
f (4, v) = f (4, s) + f (4, 1) + f (4, 2) + f (4, 3) + f (4, t)
v∈V (9.15)
= 0 + 0 + (−f (2, 4)) + 7 + 4 = −11 + 7 + 4 = 0
198
Tăietură. Fluxul de-a lungul unei tăieturi
Definiţia 9.7 O < s, t > - tăietură este o partiţie (A, B) a lui V (A ∩ B = ∅, A ∪ B = V ,
A, B ⊆ V ) cu proprietatea că s ∈ A şi t ∈ B.
Definiţia 9.8 Capacitatea unei < s, t > - tăieturi (A, B) este suma capacităţilor arcelor
ce au o extremitate ı̂n mulţimea A şi cealaltă extremitate ı̂n mulţimea B:
X
c(A, B) = c(u, v). (9.16)
u∈A,v∈B
Se defineşte fluxul net de-a lungul tăieturii (A, B) astfel:

XX
f (A, B) = f (u, v). (9.17)
u∈A v∈B
not
X
|f | = f ({s}, V \ {s}) = f (s, v) (fluxul net ce părăseşte nodul sursă). (9.18)
v∈V
Lema 9.7 Pentru < G, c, s, t > reţea de transport, (A, B) o < s, t >-tăietură şi f un flux ı̂n
reţeaua de transport, avem
|f | = f (A, B) . (9.19)
(valoarea fluxului ı̂n reţeaua de transport este egală cu valoarea fluxului de-a lungul tăieturii).
Demonstraţie: Să ne reamintim că dacă (A, B) este o < s, t >-tăietură, avem A ∩ B = ∅,
A ∪ B = V . Atunci din propoziţia 9.4 obţinem
f (A, V ) = f (A, A ∪ B) = f (A, A) + f (A, B) − f (A, A ∩ B) = f (A, B) (9.20)
deoarece f (A, A) = 0 şi f (A, A ∩ B) = f (A, ∅) = 0.
Astfel pentru o < s, t >-tăietură avem f (A, B) = f (A, V ). Aplicând identitatea A =
(A \ {s}) ∪ {s} ı̂n relaţia 9.20, obţinem:
f (A, V ) = f (A \ {s}, V ) + f ({s}, V ) − f (∅, V ) = f (A \ {s}, V ) + f ({s}, V ) (9.21)
Pe de altă parte avem identitatea:
f (A \ {s}, V ) = 0. (9.22)
Din ultimele trei relaţii, 9.20, 9.21 şi 9.22, concluzionăm faptul că:
9.20 9.21 9.22
f (A, B) = f (A, V ) = f ({s}, V ) + f (A \ {s}, V ) = f ({s}, V ) = |f |. (9.23)

Corolarul 9.8 Următoarea inegalitate este adevărată pentru un flux oarecare f ı̂n reţeaua
de transport < G, c, s, t > şi (A, B) o < s, t >-tăietură:
|f | ≤ c(A, B) . (9.24)
Demonstraţie: Din Lema 9.7 avem:
L9.7 def
XX def X X def
|f | = f (A, B) = f (u, v) ≤ c(u, v) = c(A, B). (9.25)
u∈A v∈B u∈A v∈B

Tăietura minimă reprezintă modalitatea cea mai eficientă / simplă de a ı̂ntrerupe fluxul
(curgerea) de la s la t.
Problema tăieturii minime se referă la a determina o < s, t > - tăietură a cărei capacitate
să fie minimă.
199
9.2 Graf rezidual. Drum de ameliorare. Flux maxim–
tăietură minimă
Definiţia 9.9 Definim capacitatea reziduală a unui arc (u, v) aparţinând grafului G ast-
fel:
cR (u, v) = c(u, v) − f (u, v) . (9.26)
Definiţia 9.10 Graful rezidual [48] corespunzător grafului G = (V, E), capacităţii c şi
fluxului f este graful GR = (V, ER ) având funcţia de capacitate cR , unde ER se defineşte
astfel:
ER = {(u, v) ∈ V × V |cR (u, v) > 0}. (9.27)
Observaţia 9.9 Între două noduri u şi v din graful G vom avea cel mult două arce ı̂n graful
rezidual GR :
1. dacă (u, v) ∈ E şi f (u, v) < c(u, v) atunci există arcul (u, v) ı̂n graful rezidual ((u, v) ∈ ER )
şi cR (u, v) = c(u, v) − f (u, v) (cR (u, v) > 0);
2. dacă (u, v) ∈ E şi f (u, v) > 0 atunci există arcul (v, u) ı̂n graful rezidual ((v, u) ∈ ER ) şi
cR (v, u) = f (u, v).
Altfel spus, ı̂n graful rezidual GR pot să apară arce noi, care nu existau ı̂n graful iniţial
G. Un alt element ce merită subliniat se referă la faptul că dacă, ı̂ntre două noduri nu există
nici un arc ı̂n graful iniţial G, atunci nu va exista nici un arc ı̂ntre cele două noduri nici ı̂n
graful rezidual GR . Prin urmare, numărul total de arce din graful rezidual GR este cel mult
de două ori mai mare decât numărul arcelor din graful G.
Lema 9.10 Fie < G, c, s, t > o reţea de transport şi f un flux ı̂n această reţea de transport.
Dacă fR este un flux ı̂n reţeaua de transport < GR , cR , s, t > (GR este graful rezidual asociat
grafului G), atunci f + fR este un flux ı̂n < G, c, s, t >, iar |f + fR | = |f | + |fR |.
Demonstraţie: Pentru a arăta că f + fR este un flux ı̂n reţeaua de transport < G, c, s, t >
trebuie să verificăm dacă condiţiile din definiţia 9.2 sunt ı̂ndeplinite:
1. restricţie de capacitate
Avem fR (u, v) ≤ cR (u, v), ∀u, v ∈ V .
(f + fR )(u, v) = f (u, v) + fR (u, v) ≤ f (u, v) + cR (u, v)

= f (u, v) + (c(u, v) − f (u, v)) = c(u, v)(9.28)
2. antisimetrie
(f + fR )(u, v) = f (u, v) + fR (u, v) = −f (v, u) − fR (v, u)

= −(f (v, u) + fR (v, u)) = −(f + fR )(v, u) (9.29)
3. conservarea fluxului
X X
(f + fR )(u, v) = (f (u, v) + fR (u, v))
v∈V v∈V
X X
= f (u, v) + fR (u, v) = 0 + 0 = 0 (9.30)
v∈V v∈V
200
Să demonstrăm că |f + fR | = |f | + |fR |:
X X
|f + fR | = (f + fR )(s, v) = (f (s, v) + fR (s, v))
v∈V v∈V
X X
= f (s, v) + fR (s, v) = |f | + |fR |. (9.31)
v∈V v∈V

not
Corolarul 9.11 Dacă f ′ = f +fR , unde fR este un flux ı̂n reţeaua de transport < GR , cR , s, t >
a grafului rezidual, atunci f ′ este un flux ı̂n < G, c, s, t > şi |f ′| = |f | + |fR | > |f |.
Demonstraţia acestui corolar rezultă imediat din lema 9.10.
Lema 9.12 Fie f un flux ı̂n reţeaua de transport < G, c, s, t > şi GR graful rezidual asociat
cu G. Atunci avem:
1. funcţia fR este un flux maxim ı̂n reţeaua de transport < GR , cR , s, t > dacă f + fR este un
flux maxim ı̂n reţeaua de transport < G, c, s, t >;
2. valoarea funcţiei este aditivă: |f + fR | = |f | + |fR |, |f − fR | = |f | − |fR |;
3. dacă f este un flux oarecare şi f ∗ este fluxul maxim ı̂n reţeaua de transport < G, c, s, t >,
atunci valoarea fluxului maxim ı̂n reţeaua de transport < GR , cR , s, t > este |f ∗ | − |f |.
Definiţia 9.11 Fiind dată o reţea de transport < G, c, s, t > şi un flux f ı̂n această reţea,
atunci o cale de creştere d (drum de ameliorare, drum de augmentare) este un drum de la
s la t ı̂n graful rezidual GR .
Numim capacitate reziduală a unui drum de creştere d, cantitatea maximă a fluxului
ce poate fi transportat de-a lungul acestui drum de ameliorare d:
cR (d) = min{cR (u, v)|(u, v) arc pe drumul d}. (9.32)
Observaţia 9.13 Unui drum de ameliorare ı̂n graful rezidual GR ı̂i corespunde un lanţ ı̂n
graful G.
Definiţia 9.12 Un arc (u, v) se numeşte arc critic dacă face parte dintr-un drum de ame-
liorare d şi dacă capacitatea sa reziduală este egală cu capacitatea reziduală a drumului de
ameliorare (c(u, v) = cR (d)).
Lema 9.14 Fie o reţea de transport < G, c, s, t >, f un flux ı̂n această reţea, şi d o cale
de creştere (drum) ı̂n GR , graful rezidual asociat reţelei de transport şi fluxului f . Atunci
funcţia fR : V × V → R descrisă prin

cR (d)
 , dacă (u, v) ∈ d
fR (u, v) = −cR (d) , dacă (v, u) ∈ d


0 , altfel
este un flux pentru reţeaua de transport < GR , cR , s, t >, iar |fR | = cR (d).
Teorema 9.15 (flux maxim - tăietură minimă) [47], [49], [50]. Fie o reţea de transport
< G, c, s, t > şi f un flux ı̂n această reţea. Următoarele afirmaţii sunt echivalente:
201
1. f este un flux maxim ı̂n reţeaua de transport;
2. nu există nici o cale de creştere (drum de ameliorare) ı̂n reţeaua de transport < G, c, s, t >;
3. există o < s, t >-tăietură a lui G pentru care |f | = c(A, B) (există o < s, t >-tăietură pentru
care valoarea fluxului maxim este egală cu capacitatea tăieturii).
Demonstraţie: Vom demonstra această teoremă abordând următoarea serie de implicaţii:
1) ⇒ 2) ⇒ 3) ⇒ 1).
1) ⇒ 2)
Să presupunem prin reducere la absurd că există un drum de ameliorare ı̂n reţeaua de trans-
port < G, c, s, t > pentru un flux maxim |f |.
Dacă există un drum de ameliorare atunci există un flux nenul fp ı̂n reţeaua < GR , cR , s, t >.
Fie f ′ fluxul construit astfel: f ′ = f + fp . Din corolarul 9.11 obţinem că f ′ este un flux
ı̂n reţeaua de transport < G, c, s, t > şi |f ′| > |f |.
Am determinat astfel un flux f ′ ı̂n < G, c, s, t > a cărui valoare este mai mare decât
cea a fluxului f . Contradicţie cu faptul că f este un flux maximal ı̂n reţeaua de transport
< G, c, s, t >.
2) ⇒ 3)
Dacă nu există nici un drum de ameliorare ı̂n < G, c, s, t > atunci nu există nici un drum de
la s la t ı̂n graful rezidual GR (GR = (V, ER )).
Să notăm S = {v ∈ V |∃ un drum de la s la v ı̂n GR } şi T = V \ S.
Deoarece nu există nici un drum de la s la t ı̂n GR ⇒ t ∈ T . De asemenea avem că s ∈ S,
S ∩ T = ∅, S ∪ T = V . Prin urmare S, T este o < s, t >-tăietură.
Din cauza faptului că nu există nici nici un drum de la s la t ı̂n GR ⇒ nu există arce
ı̂n GR care să aibă o extremitate ı̂n S şi cealaltă extremitate ı̂n T ⇒ ∀u ∈ S, v ∈ T , dacă
∃(u, v) ∈ E atunci f (u, v) = c(u, v).
Aplicând Lema 9.7 obţinem că |f | = f (S, T ) = c(S, T ).
3) ⇒ 1)
Din Corolarul 9.8 avem |f | ≤ c(A, B), ∀(A, B) < s, t >-tăietură a lui G.
Deoarece |f | = c(A, B) rezultă că f este fluxul maxim ce se poate obţine ı̂n reţeaua de
transport < G, c, s, t >.
În concluzie, valoarea maximă a unui flux ı̂ntr–o reţea de transport < G, c, s, t > este
egală cu valoarea capacităţii tăieturii minime pentru aceeaşi reţea de transport.
Corolarul 9.16 Fie f un flux ı̂ntr-o reţea de transport < G, c, s, t >. Notăm cu Af mulţimea
nodurilor ce aparţin unui drum de ameliorare. Fie Bf = V \ Af . Atunci f este un flux
maximal dacă şi numai dacă t ∈ Bf .
Mai mult, Af , Bf reprezintă o < s, t >-tăietură minimă (de cost minim): |f | = c(Af , Bf ) .
9.3 Metoda Ford-Fulkerson

Pe baza rezultatelor anterioare a fost elaborat un algoritm cunoscut sub numele de algorit-
mul lui Ford şi Fulkerson (vezi algoritmul 76) [47], [49], [50].
Exemplul 9.17 Pentru reţeaua de transport din figura 9.2 construim reţeaua reziduală din
figura 9.4:
cR (s, 1) = c(s, 1) − f (s, 1) = 16 − 11 = 5
cR (1, s) = c(1, s) − f (1, s) = 0 − (−11) = 11
202
Algoritm 76 Algoritmul Ford–Fulkerson (varianta simplificată)
1: se iniţializează fluxul cu valoarea 0
2: while (∃ un drum de ameliorare d ı̂n GR ) do
3: măreşte fluxul f de-a lungul drumului de ameliorare d
4: end while
5: return |f |
Fig. 9.4: Reţeaua reziduală corespunzătoare reţelei de transport din figura 9.2
cR (1, 3) = c(1, 3) − f (1, 3) = 12 − 12 = 0

cR (3, 1) = c(3, 1) − f (3, 1) = 0 − (−f (1, 3)) = 12
cR (4, 3) = c(4, 3) − f (4, 3) = 7 − 7 = 0
cR (3, 4) = c(3, 4) − f (3, 4) = 0 − (−f (4, 3)) = f (4, 3) = 7
cR (2, 3) = c(2, 3) − f (2, 3) = 0 − (−f (3, 2)) = f (3, 2) = 4
cR (3, 2) = c(3, 2) − f (3, 2) = 9 − 4 = 5
cR (2, 1) = c(2, 1) − f (2, 1) = 4 − 1 = 3
cR (1, 2) = c(1, 2) − f (1, 2) = 10 − (0 − 1) = 11
| {z }
f luxul net
Fie d = (s, 2, 3, t) o cale de creştere (drum de ameriorare) ı̂n graful din figura 9.4. Capacitatea
reziduală a acestui drum este:
cR (d) = min{5, 4, 5} = 4
Vom creşte valoarea fluxul f pentru arcele din graful G ı̂ntâlnite pe parcursul drumului
de ameliorare d. Arcele ı̂ntâlnite ı̂n cadrul căii de creştere d se clasifică astfel:
• arc ı̂nainte - arc al cărui sens corespunde cu sensul parcurgerii de la s la t; pentru un

astfel de arc, (u, v) ∈ E, f (u, v) = f (u, v) + cR (d);
• arc ı̂napoi - arcul are sensul contrar sensului de parcurgere de la s la t: (u, v) ∈ E,

f (u, v) = f (u, v) − cR (d).
Noul flux corespunzător grafului din figura 9.2 şi drumului de augmentare d = (s, 2, 3, t)
poate fi urmărit ı̂n figura 9.5.
Vom prezenta o variantă mai elaborată a algoritmului Ford-Fulkerson (a se vedea algo-
ritmul 77).
203
Fig. 9.5: Flux ı̂ntr-o reţea de transport după o creştere pe baza unui drum de ameliorare
Algoritm 77 Algoritmul Ford–Fulkerson (varianta detaliată a algoritmului 76)

1: for (fiecare arc (u, v) ∈ E) do
2: f (u, v) ← 0, f (v, u) ← 0
3: end for
4: while (∃ un drum d de la s la t ı̂n reţeaua reziduală < GR , cR , s, t >) do
5: cR (d) ← min{cR (u, v)|(u, v) arc pe drumul d}
6: for fiecare arc (u, v) ∈ E corespunzător lanţului d do
7: f (u, v) ← f (u, v) + cR (d)
8: f (v, u) ← −f (u, v)
9: end for
10: end while
11: return |f |
Observaţia 9.18 Determinarea fluxului maxim ı̂ntr-o reţea de transport având capacităţile
arcelor numere raţionale, precum şi valorile fluxului tot numere raţionale, se reduce la de-
terminarea unui flux maxim având componentele fluxului cât şi capacităţile arcelor numere
naturale (această reducere este posibilă deoarece valorile raţionale pot fi amplificate cu o valoa-
re pozitivă, cel mai mic multiplu comun al numitorilor acestor numere).
Complexitatea algoritmului
În tabelul 9.1 [135] sunt prezentaţi principalii algoritmi pentru determinarea fluxului maxim
ı̂ntr-o reţea de transport, anul ı̂n care au apărut, precum şi complexitatea lor. Astfel aceşti
algoritmi se pot compara din punct de vedere al complexităţii teoretice şi se poate alege
varianta potrivită rezolvării unor probleme concrete.
204
Table 9.1: Principalii algoritmi pentru determinarea fluxului maxim ı̂ntr-o reţea de transport
Autor(i) Anul apariţiei Complexitate

Ford & Fulkerson 1956 [49] O(V EU)
Dinic 1970 [39] O(V 2 E)
Edmonds & Karp 1972 [42] O(V E 2 )
Karzanov 1974 [83] O(V√3 )
Cherkassky 1976 [29] O(V 2 E)
Malhotra, Kumar şi Maheswari 1978 [97] O(V 3 )
5 2
Galil 1980 [59] O(V 3 E 3 )
Galil & Naamad 1980 [60] O(EV (log V )2 )
Sleator 1980 [120] O(EV log V )
Shiloach & Vishkin 1982 [117] O(V 2 log V )
Sleator & Tarjan 1983 [121] O(EV log V )
Tarjan 1984 [127] O(V 3 )
Goldberg 1985 [62] O(V 3 )
2
Goldberg & Tarjan 1986 [63] O(EV log ( V ) E )
Ahuja & Orlin 1989 [4] O(V E + V 2 log U)
9.4 Algoritmul Edmonds-Karp

Algoritmul lui Edmonds-Karp [42] are la bază algoritmul lui Ford-Fulkerson ı̂n care s-a efec-
tuat o singură modificare: la fiecare pas se alege drumul de ameliorare cel mai scurt dintre
toate drumurile de ameliorare existente. Complexitatea acestui algoritm este de O(V · E 2 )
spre deosebire de varianta clasică a algoritmului lui Ford-Fulkerson ce prezintă o complexitate
O(Eφ) unde φ reprezintă valoarea fluxului maxim din reţeaua de transport.
Algoritmul lui Edmonds-Karp (publicat ı̂n 1972 de către Jack Edmonds şi Richard Karp
[42]) a plecat de la următoarea ipoteză euristică: alegerea la fiecare pas a drumului de ame-
liorare cel mai scurt ne conduce la determinarea fluxului maxim ı̂ntr-un timp mai mic. Prin
lungimea unui drum se ı̂nţelege aici numărul de arce din care este format.
Prezentăm o variantă a algoritmului Edmonds-Karp, destul de simplu de implementat2 .
Pentru determinarea drumurilor de ameliorare având lungimea cea mai mică se utilizează
algoritmul lui Moore (vezi algoritmul 60) bazat şi el, la rândul său, pe algoritmul de vizitare
ı̂n lăţime a unui graf. În algoritmul 78, procedura FindAugmentingPath, se primesc ca date
de intrare nodul sursă s, nodul destinaţie t, un vector V izitat ce păstrează dacă un nod
al grafului a fost vizitat sau nu, şi respectiv o matrice ce conţine capacităţile reziduale ale
arcelor din graful rezidual GR denuită Cost.
Capacitatea reziduală a drumului de ameliorare se calculează ı̂n cadrul funcţiei GetMaxCapacity
(a se vedea algoritmul 79). Se porneşte procesul de calcul de la nodul destinaţie t şi se merge
ı̂napoi atâta timp cât mai există un nod anterior nodului curent (tatau > 0), pe drumul de
la s la t ı̂n graful rezidual. Capacitatea reziduală se calculează după formula din relaţia 9.32.
După ce s-a calculat valoarea capacităţii reziduale a drumului de ameliorare determinat ı̂n
urma apelului procedurii FindAugmentingPath, se actualizează ı̂n procedura UpdateResidualGraph
valorile capacităţii reziduale ale arcelor aflate pe drumul de ameliorare (a se vedea algoritmul
79).
2
http://community.topcoder.com/tc?module=Static&d1=tutorials&d2=maxFlow
205
Algoritm 78 Algoritm pentru determinarea unui drum de ameliorare
1: procedure FindAugmentingPath(s, t, Cost, Vizitat; Tata)
2: Q⇐s
3: vizitats ← 1
4: while (Q 6= ∅) do
5: Q⇒u
6: for (fiecare k ∈ lista de vecini a lui u) do
7: if ((vizitatk = 0) ∧ (costu,k > 0)) then
8: Q⇐k
9: vizitatk ← 1
10: tatak ← u
11: if (k = t) then
12: return
13: end if
14: end if
15: end for
16: end while
17: end procedure
Algoritm 79 Algoritmi pentru determinarea capacităţii reziduale şi actualizarea grafului

rezidual
1: function GetMaxCapacity(s, t, Cost, Tata)
2: u ← t, capacity ← ∞
3: while (tatau > 0) do
4: prev ← tatau
5: capacity ← min{capacity, costprev,u }
6: u ← prev
7: end while
8: return capacity
9: end function
10: function UpdateResidualGraph(s, t, capacity, Tata; Cost)
11: u←t
12: while (tatau > 0) do
13: prev ← tatau
14: costprev,u ← costprev,u − capacity
15: costu,prev ← costu,prev + capacity
16: u ← prev
17: end while
18: end function
Algoritmul lui Edmonds-Karp se găseşte implementat ı̂n algoritmul 80.

În figura 9.6 este ilustrat algoritmul lui Edmonds-Karp (algoritmul 80) pentru reţeaua de
transport din figura 9.2. Sunt puse ı̂n evidenţă cele patru iteraţii ce conduc la determinarea
fluxului maxim ı̂n acest caz.
206
Algoritm 80 Algoritmul Edmonds-Karp
 Edmondskarp(n, s, t, C; F )
1: procedure

 n - numărul de vârfuri ale grafului


s - nodul sursă
Input:

 t - nodul destinaţie


C - matricea capacităţilor reţelei de transport
Output: F - matricea ce conţine fluxul pe fiecare din arcele grafului
2: for (fiecare (u, v) ∈ E) do
3: costu,v ← cu,v
4: end for
5: repeat
6: for (fiecare u ∈ V ) do
7: vizitatu ← 0, tatau ← −1
8: end for
9: call FindAugmentingPath(s, t, Cost, Vizitat; Tata)
10: capacity ← GetM axCapacity(s, t, Cost, T ata)
11: call UpdateResidualGraph(s, t, capacity, Tata; Cost)
12: until (capacity = 0)
13: for (fiecare (u, v) ∈ E) do
14: if (cu,v > 0) then
15: f (u, v) ← cu,v − costu,v
16: end if
17: end for
18: end procedure
Implementarea ı̂n limbajul C + + a acestui algoritm este următoarea:

Listing 9.1: edmondskarp.cpp
#include <vector>
#include <queue>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <conio.h>
using namespace std;
#define INPUT_FILE "retea7.txt"

#define INFINIT 1000000

typedef vector<bool> BoolVector;

typedef vector<int> IntVector;
/**
* Se citesc numarul de noduri, numarul de arce, nodul sursa, nodul destinatie
* precum si matricea cu capacitatile arcelor.
*/
207
Fig. 9.6: Algoritmul Edmonds-Karp pentru reţeaua de transport din figura 9.2
void readInput(int &n, int &m, int &s, int &t, Matrice& c) {
int i, u, v;
ifstream fin(INPUT_FILE);
fin >> n >> m >> s >> t;

c = Matrice(n, Linie(n, 0));
for (i = 0; i < m; i++) {
fin >> u >> v;
fin >> c[u][v];
}
208
fin.close();
}
/**
* Functie ce afiseaza valorile elementelor unei matrice patratice.
* @param n - numarul de linii/coloane
* @param cost - matricea ce contine capacitatile reziduale ale arcelor
* din graful rezidual
*/
void afisare(int n, Matrice& cost) {
int i, j;
for (i = 0; i < n; i++) {

for (j = 0; j < n; j++)
cout << setw(3) << cost[i][j];
cout << endl;
}
}
/**
* Functie pentru determinarea unui drum de ameliorare.
* @param n - numarul de noduri al grafului
* @param s - nodul sursa
* @param t - nodul destinatie
* @param cost - matricea ce contine capacitatile reziduale ale arcelor
* @param vizitat - vector ce pastreaza starea (vizitat/nevizitat) nodurilor
* grafului
* @param tata - nodul anterior nodului curent pe drumul de la sursa catre nodul
* curent
*/
void FindAugmentingPath(int n, int s, int t, Matrice& cost,
BoolVector& vizitat, IntVector& tata) {
int u, k;
queue<int> Q;
Q.push(s);
vizitat[s] = true;
while (!Q.empty()) {
u = Q.front();
Q.pop();
for (k = 0; k < n; k++)
if ((!vizitat[k]) && (cost[u][k] > 0)) {
Q.push(k);
vizitat[k] = true;
tata[k] = u;
if (k == t)
return;
}
}
}
/**
209
* Functia calculeaza minimul dintre doua numere intregi.
*/
int min(int a, int b) {
if (a < b)
return a;
else
return b;
}
/**
* Determina capacitatea reziduala a unui drum de ameliorare.
*/
int GetMaxCapacity(int s, int t, Matrice& cost, IntVector& tata) {
int u, prev;
int capacity = INFINIT;
u = t;
while (tata[u] != -1) {
prev = tata[u];
capacity = min(capacity, cost[prev][u]);
u = prev;
}
if (capacity < INFINIT)

return capacity;
else
return 0;
}
/**
* Actualizeaza fluxul in reteaua de transport si respectiv capacitatile reziduale
* ale arcelor din graful rezidual.
*/
void UpdateResidualGraph(int s, int t, int capacity,
IntVector& tata, Matrice& cost) {
int u, prev;
u = t;
while (tata[u] != -1) {
prev = tata[u];
cost[prev][u] = cost[prev][u] - capacity;
cost[u][prev] = cost[u][prev] + capacity;
u = prev;
}
}
/**
* Implementarea algoritmului Edmonds-Karp.
*/
void EdmondsKarp(int n, int s, int t, Matrice& c) {
Matrice cost;
Matrice f;
210
int i, j;
int capacity;
BoolVector vizitat;
IntVector tata;
cost = Matrice(n, Linie(n, 0));

f = Matrice(n, Linie(n, 0));
vizitat = vector<bool>(n, false);
tata = vector<int>(n, -1);
for (i = 0; i < n; i++)

for (j = 0; j < n; j++) {
cost[i][j] = c[i][j];
}
do{
for (i = 0; i < n; i++) {
vizitat[i] = false; tata[i] = -1;
}
FindAugmentingPath(n, s, t, cost, vizitat, tata);
capacity = GetMaxCapacity(s, t, cost, tata);
UpdateResidualGraph(s, t, capacity, tata, cost);
}while (capacity != 0);
for (i = 0; i < n; i++)

for (j = 0; j < n; j++)
if (c[i][j] > 0) {
f[i][j] = c[i][j] - cost[i][j];
}
afisare(n, f);
}
void main(void) {
Matrice c;
int n, m, s, t;
readInput(n, m, s, t, c);
EdmondsKarp(n, s, t, c);
}
Datele de intrare se citesc dintr-un fişier, formatul acestuia fiind următorul:
nr_de_noduri nr_de_arce nodul_sursa nodul_destinatie
varf1 varf2 capacitate1
varf3 varf4 capacitate2
....
Fişierul retea1.txt are următoarea componenţă corespunzătoare reţelei de transport din
figura 9.2:
6 10 0 5
211
0 1 16
0 2 13
1 2 10
1 3 12
2 1 4
2 4 14
3 2 9
3 5 20
4 3 7
4 5 4
(numărul de noduri este 6, numărul de arce este 10, nodul sursă este 0 iar nodul destinaţie
este 5).
9.5 Algoritmul lui Dinic

Algoritmul lui Dinic a fost publicat ı̂n anul 1970 de către cercetătorul rus, la acea dată, Yefim
Dinitz [39], ulterior angajat al Universităţii Ben-Gurion din Israel3 [40].
Într-o lucrare publicată mult mai târziu [40], Y. Dinitz povesteşte faptul că algoritmul
lui Dinic aşa cum a fost prezentat ı̂n multe cărţi era, de fapt, o adaptare realizată de către
cercetătorii Shimon Even şi Alon Itai a algoritmului său original publicat ı̂n anul 1970 [39]
şi a algoritmului lui Alexander Karzanov [83].
Definiţia 9.13 Se numeşte flux de saturare un flux f cu proprietatea că orice drum de
la s la t conţine un arc saturat.
Algoritmul lui Dinic ı̂şi propune să determine un flux de saturare f ′ , urmat de actualizarea
fluxului f (f = f + f ′ ) şi apoi algoritmul se reia.
9.5.1 Varianta originală

Vom prezenta ı̂n continuare algoritmul original al lui Dinitz [39] ı̂ncercând să păstrăm notaţiile
originale ale autorului [40].
Fie graful G = (V, E). Notăm cu Vk mulţimea nodurilor din stratul k - nodurile v pentru
care distanţa de la s la v este k, dv = k (Vk = {v ∈ V |dv = k}, V0 = {0}). Notăm dv = ds,v
distanţa minimă de la nodul s la nodul v (prin lungimea drumului de la u la v ı̂nţelegem
numărul de arce al drumului).
Fie Ek mulţimea arcelor ce au o extremitate ı̂n Vk−1 şi cealaltă extremitate ı̂n Vk (Ek =
{(u, v) ∈ E|u ∈ Vk−1S ,v ∈ V
Sk }).
Atunci L(s) = ( Vi , Ei ) este un subgraf al grafului G. L(s) mai este denumit graf
stratificat sau reţea stratificată (eng. layered network ) unde fiecare nivel/strat/layer este
alcătuit din mulţimea nodurilor Vk . L(s) conţine numai arce ce fac legătura ı̂ntre un nod al
unui strat (u ∈ Vk ) şi un alt nod aflat pe stratul imediat următor (v ∈ Vk+1 ), arce de alte
tipuri ale grafului GR , cum ar fi arce de ı̂ntoarcere sau arce de traversare, identificate ı̂n urma
unei vizitări ı̂n lăţime, nefiind luate ı̂n considerare.
Construim L(s, b t), subgraful obţinut din L(s) prin restricţia acestuia doar la drumurile
de lungime minimă de la s la t. Din punct de vedere computaţional, L(s, b t) se poate obţine
astfel: mai ı̂ntâi se aplică algoritmul de vizitare ı̂n lăţime (BFS) pentru nodul de pornire s
3
http://www.cs.bgu.ac.il/~dinitz/
212
Algoritm 81 Algoritmul lui Dinic (varianta originală)
1: procedure Dinitz(s, t, Cost)
2: f inish ⇐ f alse
3: repeat
4: b t) folosind o variantă de BFS
construieşte L(s,
5: b
if (L(s, t) = ∅) then
6: f inish ← true
7: else
8: b ← L(s,
L b t)
9: while (L b=6 ∅) do
10: P ← P athF inding(L) b
11: Sat ← F lowChange(P )
12: Qr ← Sat, Ql ← Sat
13: call RightP ass(Qr )
14: call Lef tP ass(Ql )
15: end while
16: end if
17: until (f inish)
18: end procedure
având drept rezultat L(s) şi apoi se aplică din nou algoritmul de vizitare ı̂n lăţime (BFS)
pornind din nodul t, de data aceasta mergând pe arcele inverse din graful L(s).
Subrutina PathFinding determină un drum minim de la nodul sursă s la nodul destinaţie
b t). Pentru determinarea unui drum de ameliorare P se porneşte de la nodul s
t ı̂n graful L(s,
şi, folosind numai arborele de parcurgere (ı̂n lăţime) construit ı̂n urma aplicării algoritmului
de vizitare ı̂n lăţime, se ajunge, după un număr minim de paşi, la nodul t.
În procedura FlowChange se actualizează valoarea fluxului de-a lungul arcelor ce aparţin
drumului P . Se şterg din L b toate arcele de devin saturate. Notăm cu Sat mulţimea tuturor
arcelor ce devin saturate la pasul curent şi care sunt eliminate din L. b
r l
Se iniţializează două mulţimi Q şi Q cu mulţimea Sat.
În procedura RightPass se ia fiecare element din Qr şi, dacă pentru e = (u, v) ∈ Qr nu
mai există alte arce care să-l aibă ca extremitate finală pe v (d− (v) = 0), atunci se şterge v
din L b şi se adaugă la Qr toate arcele e′ = (v, w) ce ı̂l au pe v drept extremitate iniţială.
Subrutina LeftPass presupune realizarea unor operaţii simetrice; pentru fiecare element
din Ql , e = (u, v) ∈ Ql , dacă nu există arce care să aibă nodul u drept extremitate iniţială
(d+ (u) = 0), atunci se şterge u din L b ı̂mpreună cu arcele ce ı̂l au pe u drept extremitate
l
finală, arce ce se adaugă la Q .
9.6 Aplicaţii
Problema determinării fluxului maxim ı̂ntr-o reţea de transport are foarte multe aplicaţii
ı̂n domenii variate precum data mining, segmentarea de imagini, determinarea cuplajului
maxim ı̂ntr-un graf bipartit, selectarea proiectelor, programarea zborurilor, calcul distribuit,
identificarea ı̂ncercărilor de intruziune ı̂ntr-o reţea de calculatoare, fiabilitatea unei reţele.
Pentru o reţea de transport cu surse multiple {s1 , s2 , . . . , sn } şi destinaţii multiple {t1 , t2 ,
. . ., tm } se procedează astfel:
1. se adaugă o sursă s0 şi arce de la s0 către si , i = 1, n unde cs0 ,si = ∞ şi f (s0 , si ) = |f (si)|;
213
2. se adaugă o destinaţie t0 şi arce de la ti , i = 1, m către t0 unde c(ti , t0 ) = ∞ şi f (ti , f0 ) =
|f (ti)|;
Se poate aplica apoi unul dintre algoritmii pentru determinarea fluxului maxim ı̂n reţeaua
de transport.
Fie o reţea de transport < G, c, s, t >. În această reţea, fiecărui arc i se alocă un cost
unitar, ϕ(u, v) ≥ 0, reprezentând costul plătit pentru fiecare unitate de flux ce trece prin
arcul (u, v). Problema determinării P
fluxului maxim de cost minim se referă la identificarea
unui flux maxim cu proprietatea că (u,v)∈G f (u, v) · ϕ(u, v) este minimă.
9.7 Exerciţii
1. Aplicându-se algoritmii Ford-Fulkerson, Edmonds-Karp şi Dinic să se determine fluxul
maxim ı̂n reţelele de transport din figura 9.2. Nodul 0 este nodul sursă iar nodul 5
respectiv nodul 6 este nodul destinaţie.
1 4 3
1 4 3 5 3
10 10
8 1
0 2 5 0 5
8 6 2
10 9 9
10
2 9 4 2 3 4
a) b)
1 9 4
1 1 4
10 10 1
15 15
4 3 4
2 6
0 5 2 8 5 10 5
0 2 2
3
9
4 6 15 1
15 10
3 5
3 6
3 30 4
c) d)
Fig. 9.7: Alte exemple de reţele de transport
2. Se dă un graf G = (V, E) orientat, conex şi două noduri u şi v.
• Să se realizeze un algoritm ce determină tăietura minimală a grafului sub forma

unei mulţimi de muchii de cardinal minim, muchii ce trebuie eliminate pentru a
deconecta u şi v.
• Să se determine numărul maxim de drumuri disjuncte ı̂ntre u şi v, cât şi componenţa
acestora. Două drumuri sunt considerate disjuncte dacă nu au nici un arc ı̂n co-
mun.
214
Fig. 9.8: Un exemplu de graf orientat conex
3. Se dau 4 centre de distribuţie A1 , A2 , A3 , A4 , ı̂n care, la un moment dat, se găsesc

următoarele cantităţi de marfă: A1 = 240t, A2 = A3 = A4 = 200t. Aceste cantităţi
urmează să fie transportate la 4 beneficiari B1 , B2 , B3 şi B4 , ce au capacităţile maxime
B1 = 200t, B2 = 160t, B3 = 180t, B4 = 300t.
Posibilităţile de transport limitate de capacitatea mijloacelor de transport sunt date ı̂n
tabelul 9.2.
Să se determine cantitatea maximă de mărfuri (fluxul maxim de mărfuri) ce poate fi
transportată de la centrele de distribuţie la beneficiari (făcându-se abstracţie de costuri).
Table 9.2: Capacităţile mijloacelor de transport
B1 B2 B3 B4
A1 140 60 40 -
A2 100 80 20 -
A3 - 40 80 160
A4 - 40 80 160
4. Algorel are ı̂n pivniţă o reţea subterană prin care mişună şobolani. Reţeaua constă din
N adăposturi numerotate de la 1 la N şi M tunele ı̂ntre acestea. Adăposturile 1 şi N
comunică cu suprafaţa fiind singurele locuri din reţea cu această proprietate (nici un
alt adăpost sau tunel nu mai are ieşire la suprafaţă).
Algorel vrea să trimită un număr maxim de pisici ı̂n reţea. Pisicile intră prin adăpostul
1 şi ies prin adăpostul N. Nici o pisică nu poate rămâne ı̂n reţea. Pentru fiecare tunel
se ştie rezistenţa lui, adică numărul maxim de pisici ce pot trece prin el fără ca să se
dărâme. Dacă printr-un tunel cu rezistenţa nenulă a trecut o pisică, atunci rezistenţa
acestuia scade cu o unitate.
215
Algorel a observat existenţa unor anumite tunele cu proprietatea că, dacă rezistenţa lor
creşte, ı̂n timp ce rezistenţa celorlalte tunele rămâne la fel, atunci va creşte şi numărul
maxim de pisici pe care le poate trimite prin reţea. El a denumit tunelele cu această
proprietate tunele critice.
Fiind dată reţeaua din pivniţa lui Algorel determinaţi tunelele critice.
Date de intrare
Pe prima linie a fişierului critice.in se găsesc numerele naturale N şi M (1 ≤ N ≤
1000, 1 ≤ M ≤ 10000) reprezentând numărul de adăposturi şi numărul de tunele din
reţeaua subterană. Urmează M linii conţinând trei numere naturale separate prin
spaţii, A B C, având următoarea semnificaţie: ı̂ntre adăposturile A şi B (A 6= B)
există un tunel cu rezistenţa C.
Date de ieşire
Prima linie a fişierului de ieşire critice.out conţine un număr natural K reprezentând
numărul de tunele critice din reţeaua lui Algorel. Următoarele K linii conţin câte un
număr natural reprezentând indicii muchiilor critice. Indicii vor fi ordonaţi crescător.
Muchiile sunt numerotate de la 1 la M după ordinea din fişierul de intrare.
Rezistenţele sunt numere naturale mai mici sau egale cu 10000. Între oricare două
noduri există cel mult un tunel. Orice tunel poate fi parcurs ı̂n ambele sensuri.
Exemplu
critice.in critice.out
5 6 2
2 1 2 1
2 3 3 4
3 5 4
1 4 7
4 3 2
4 5 6
(PreONI, 2005, Critice)
5. Se dă un graf orientat fără circuite cu n noduri (numerotate de la 1 la n) şi m arce. Un

drum ı̂n graf este o succesiune de unul sau mai multe vârfuri D = (x1 , x2 , . . . , xk ) astfel
ı̂ncât pentru orice i din {1, 2, . . . , k − 1}, există arcul (xi , xi+1 ). Numim acoperire a gra-
fului o mulţime de drumuri din graf, cu proprietatea că fiecare vârf al grafului aparţine
cel puţin unui drum din mulţime. Nu este necesar ca drumurile dintr-o acoperire să fie
disjuncte (nici relativ la vârfuri, nici relativ la arce).
Să se realizeze un algoritm ce determină numărul minim de drumuri cu care se poate
acoperi un graf dat.
Datele de intrare se citesc din fişierul drumuri2.in: pe prima linie se află numerele
naturale n şi m, separate printr-un spaţiu (1 ≤ n ≤ 100, 1 ≤ m ≤ 5000). Pe fiecare
dintre următoarele m linii se găseşte câte o pereche de numere naturale i, j (1 ≤ i, j ≤ n)
separate printr-un spaţiu, cu semnificaţia că există arc de la vârful i la vârful j.
Rezultatul va fi afişat ı̂n fişierul de ieşire drumuri2.out. Acesta va conţine o singură
linie reprezentând numărul minim de drumuri cu care se poate acoperi graful din fişierul
de intrare.
Exemplu
216
drumuri2.in drumuri2.out
7 7 2
1 2
7 2
2 3
2 4
3 5
4 5
4 6
(Lot 2005, Drumuri)
6. După ce au ı̂mpărţit ţară ı̂n judeţe maimuţele au o altă problemă, trebuie să oprească
traficul de banane. Ţara maimuţelor are n oraşe numerotate de la 1 la n legate ı̂ntre ele
prin m şosele bidirecţionale. Între oricare două oraşe există maxim o şosea, dar există
drum - direct sau prin oraşe intermediare. Oraşele 1 şi n sunt capitale.
În ultima vreme ı̂ntre cele două capitale s-a intensificat traficul cu banane. Pentru a
combate traficul preşedintele are la dispoziţie G soldaţi pe care poate să-i aşeze oriunde
pe o şosea, oricât de aproape de un oraş, ı̂nsă nu ı̂n oras. În cazul unui atac asupra
uneia dintre capitale, toţi soldaţii trebuie să ajungă ı̂n acea capitală. Soldaţii se mişcă cu
aceeaşi viteză constantă. Timpul necesar unei astfel ce mobilizări este egal cu maximul
distanţelor de la soldaţi la una dintre capitale.
Să se realize o aplicaţie care să determine o aşezare a soldaţilor astfel ı̂ncât orice rută
de la o capitală la alta să treacă printr-o şosea cu cel puţin un soldat şi timpul de
mobilizare ı̂n cel mai rău caz să fie minim.
Date de intrare se citesc din fişierul trafic.in. Pe prima linie a acestuia sunt scrise
trei numere NMG separate prin câte un singur spaţiu (3 ≤ n ≤ 154, 3 ≤ m ≤ 5054,
3 ≤ G ≤ 4095). Pe următoarele m linii sunt scrise câte trei numere separate prin spaţii
abc cu semnificaţia ”există şosea bidirecţională de la oraşul a la oraşul b de lungime c”
(1 ≤ lungimea unei şosele ≤ 1023).
Date de ieşire se vor afişa ı̂n fişierul trafic.out. Prima linie a fişierului va conţine
timpul minim de mobilizare cu o zecimală exactă. Dacă nu există soluţie se va scrie
−1.
Exemplu
trafic.in trafic.out
6 6 2 2.5
1 2 1
2 3 2
3 6 1
1 4 1
4 5 3
5 6 1
(.campion 2005, Trafic)
217
Bibliografie
[1] A. Aho, J. Hopcroft, J. Ullman, On finding lowest common ancestors in trees, Proc. 5th
ACM Symp. Theory of Computing (STOC), pp. 253-265, 1973.
[2] A. V. Aho, J. E. Hopcroft, J. D. Ulmann, Data Structures and algorithms, Addison-
Wesley, 1983.
[3] A. V. Aho, J. D. Ulmann, Foundation of Computer Science, Computer Science Press,
1992.
[4] R. K. Ahuja, J. B. Orlin, A Fast and Simple Algorithm for the Maximum Flow Problem,
Operations Research, vol. 37(5), pp. 748–759, 1989.
[5] R. Ahuja, T. Magnanti, J. Orlin, Network Flows, Prentice Hall, 1993.
[6] R. Andonie, I. Gârbacea, Algoritmi fundamentali, o perspectivă C++, Editura Libris,
1995.
[7] C. Aragon, R. Seidel, Randomized Search Trees, in Proc. of 30th IEEE Symposium on
Foundations of Computer Science, pp. 540–546, 1989.
[8] A. Atanasiu, Concursuri de informatică. Probleme propuse (1994), Editura Petrion,
Bucureşti, 1995.
[9] M.D. Atkinson, J.-R. Sack, N. Santoro, T. Strothotte, Min-max heaps and generalized
priority queues, Programming techniques and Data structures. Comm. ACM, vol. 29(10),
pp. 996-1000, 1986.
[10] M. Augenstein, A. Tenenbaum, Program efficiency and data structures, Proceedings of
the eighth SIGCSE technical symposium on Computer science education, pp. 21–27,
1977.
[11] S. Baase, Computer algorithms. Introduction to Design and Analysis, Addison-Wesley,
1992.
[12] P. Băzăvan, Elemente de Teoria Algoritmilor, Editura Sitech, Craiova, 2007.
[13] R. Bellman, On a routing problem, Quarterly Applied Mathematics, XVI(1), pp. 87-90,
1958.
[14] M. A. Bender, M. Farach-Colton, The LCA problem revisited, Proceedings of the 4th
Latin American Symposium on Theoretical Informatics, LNCS, vol. 1776, Springer-
Verlag, pp. 88-94, 2000.
[15] J. Bentley, R. Sedgewick, Fast Algorithms for Sorting and Searching Strings, Proceedings
of the 8th Annual ACM-SIAM Symposium on Discrete Algorithms, 1997.
218
[16] J. Bentley, R. Sedgewick, Ternary Search Trees, Dr. Dobb’s Journal, 1998.
[17] C. Bereanu, Algoritmica Grafurilor, Editura Sitech, Craiova, 2006.
[18] C. Berge, Graphes et hypergraphes, Dunod, Paris 1970.
[19] O. Berkman, D. Breslauer, Z. Galil, B. Schieber, şi U. Vishkin, Highly parallelizable

problems, in Proceedings of the 21st Annual ACM Symposium on Theory of Computing,
pp. 309-319, 1989.
[20] O. Berkman, U. Vishkin, Recursive Star-Tree Parallel Data Structure, SIAM Journal on
Computing, vol.22(2), pp.221-242, 1993.
[21] O. Boruvka, O jistém problému minimálnı́m (About a certain minimal problem), Acta
Societ. Scient. Natur. Moravicae, 3, pp. 37-58, 1926.
[22] R. P. Brent, An improved Monte Carlo factorization algorithm, BIT Numerical Mathe-
matics, Springer, vol. 20(2), pp. 176–184, 1980.
[23] D. D. Burdescu, Analiza complexităţii algoritmilor, Editura Albastră, Cluj–Napoca,

1998.
[24] D. D. Burdescu, M. Brezovan, M. Coşulschi, Structuri de date arborescente cu aplicaţii

ı̂n Pascal şi C, Reprografia Universităţii din Craiova, 2000.
[25] D. D. Burdescu, Liste, arbori, grafuri, Editura Sitech, Craiova, 2005.
[26] B. Chazelle, A minimum spanning tree algorithm with inverse-Ackerman type complexity,
J. ACM, 47, pp. 1028-1047, 2000.
[27] D. Cherition, R. E. Tarjan, Finding minimum spanning trees, SIAM Journal on Com-
puting, vol. 5, pp. 724-741, 1976.
[28] J. Cheriyan, K. Mehlhorn, Algorithms for dense graphs and networks on the random
access computer, Algorithmica, vol. 15, pp. 521-549, 1996.
[29] B. V. Cherkassky,
√ Algorithm for construction of maximal flows in networks with com-
plexity of O(V 2 E), Mathematical Methods of Solution of Economical Problems, vol.
7, pp. 112–125, 1977.
[30] T. H. Cormen, C. E. Leiserson, R. L. Rivest, Introducere ı̂n Algoritmi, Computer Libris

Agora, Cluj–Napoca, 1999.
[31] M. Coşulschi, M. Gabroveanu, Algoritmi o abordare pragmatică, Editia a 2-a, Universi-

taria, Craiova, 2004.
[32] C. Croitoru, Tehnici de bază ı̂n optimizarea combinatorie, Editura Univ. Al. I. Cuza Iaşi,
Iaşi, 1992.
[33] G. B. Dantzig, Linear programming and extensions, University Press, Princeton, 1962.
[34] S. Dasgupta, C. H. Papadimitriou, U. V. Vazirani, Algorithms, McGraw–Hill, 2006.
[35] C. Demetrescu, G. F. Italiano, Engineering Shortest Path Algorithms, WEA, Springer,

LNCS 3059, pp. 191–198, 2004.
219
[36] R. B. Dial, Algorithm 360: shortest-path forest with topological ordering [H], Communi-
cations of the ACM, vol. 12:11, pp. 632–633, 1969.
[37] Dicţionarul explicativ al limbii române, Academia Română, Institutul de Lingvistică

Iorgu Iordan, Editura Univers Enciclopedic, 1998.
[38] E. W. Dijkstra, A note on two problems in connections with graphs, Numerische Math-
ematik, 1, pp. 269-271, 1959.
[39] Y. Dinitz, Algorithm for solution of a problem of maximum flow in a network with power
estimation, Doklady Akademii nauk SSSR, vol. 11, pp. 1277-1280, 1970.
[40] Y. Dinitz, Dinitz’ Algorithm: The Original Version and Even’s Version, in Oded Goldre-
ich, Arnold L. Rosenberg, and Alan L. Selman, Theoretical Computer Science: Essays
in Memory of Shimon Even, Springer, pp. 218-240, 2006.
[41] J. Edmonds, Paths, Trees and Flowers, Canadian J. Math, vol. 17, pp. 449-467, 1965.
[42] J. Edmonds, R. M. Karp, Theoretical improvements in algorithmic efficiency for network

flow problems, Journal of the ACM, vol. 19(2), pp. 248-264, 1972.
[43] J. Egerváry, Matrixok kombinatorius tulajdonságairól, (in Hungarian), Matematikai és

Fizikai Lapok, vol. 38 pp. 16-28, 1931.
[44] J. Farey, On a Curious Property of Vulgar Fractions, London, Edinburgh and Dublin
Phil. Mag. 47, 385, 1816.
[45] J. Feng, G. Li, J. Wang, L. Zhou, Finding and ranking compact connected trees for
effective keyword proximity search in XML documents, Information Systems, vol. 35(2),
pp. 186–203, 2010.
[46] M. Fleury, Deux problmes de Gomtrie de situation, Journal de mathmatiques lmentaires,

2nd ser. (in French), 2, pp. 257–261, 1883.
[47] L. R. Ford, Network flow theory, Technical Report P-923, RAND, Santa Monica, CA,
1956.
[48] L. R. Ford, Jr., D. R. Fulkerson, Maximal Flow Through a Network, Research Memo-
randum RM-1400, The RAND Corporation, Santa Monica, California, 1954 [published
in Canadian Journal of Mathematics, 8, pp. 399–404, 1956].
[49] L. R. Ford, Jr., D. R. Fulkerson, A Simple Algorithm for Finding Maximal Network
Flows and an Application to the Hitchcock Problem, Research Memorandum RM-1604,
The RAND Corporation, Santa Monica, California, 1955 [published in Canadian Journal
of Mathematics, 9, pp. 210–218, 1957].
[50] L. R. Ford, Jr., D. R. Fulkerson, Flows in Networks, Princeton University Press, Prince-
ton, 1962.
[51] C. L. Foster, The Design and Analysis of Algorithms, Springer Verlag, 1992.
[52] J.-C. Fournier, Graph Theory and Applications, Wiley-Blackwell, 2009.
[53] E. Fredkin, Trie Memory, Communications of the ACM, 3:(9), pp. 490, 1960.
220
[54] M. Fredman, R. Sedgewick, R. Sleator, R. Tarjan, The pairing heap: A new form of
self-adjusting heap, Algorithmica, 1, pp. 111–129, 1986.
[55] M.L. Fredman, R.E. Tarjan, Fibonacci heaps and their use in improved network opti-
mization algorithms, Journal of the ACM, vol. 34, pp. 596-615, 1987.
[56] H. N. Gabow, R. E. Tarjan, A linear-time algorithm for a special case of disjoint set
union, Proceedings of the 15th ACM Symposium on Theory of Computing (STOC), pp.
246-251, 1983.
[57] H. N. Gabow, Path-based depth-first search for strong and biconnected components, In-
formation Processing Letters, pp. 107-114, 2000.
[58] D. Gale, L. S. Shapley, College Admissions and the Stability of Marriage, American
Mathematical Monthly, vol. 69, pp. 9–14, 1962.
5
[59] Z. Galil, An O(V 3 E f rac23 ) algorithm for the maximal flow problem, Acta Informatica,
vol. 14, pp. 221–242, 1980.
[60] Z. Galil, A. Naamad, An O(EV (log V )2 ) algorithm for the maximal flow problem, Jour-
nal of Computer and System Sciences, vol. 21(2), pp. 203–217, 1980.
[61] C. Giumale, Introducere ı̂n analiza algoritmilor, Editura Polirom, Iaşi, 2004.
[62] A. V. Goldberg, A new max-flow algorithm, Technical Report MIT/LCS/TM-291, Lab-

oratory for Computer Science, MIT, 1985.
[63] A. V. Goldberg, R. E. Tarjan, A new approach to the maximum flow problem, in Pro-
ceedings of the 18th ACM Symposium on Theory of Computing, ACM, pp. 136–146,
1986.
[64] A. V. Goldberg, É. Tardos, R. E. Tarjan, Network flow algorithms, Algorithms and
Combinatorics, vol. 9. in B. Korte, L. Lovsz, H. J. Prmel, A. Schrijver, Editors, Paths,
Flows, and VLSI-Layout, Springer-Verlag, Berlin, pp.101-164, 1990.
[65] R. L. Graham, D. E. Knuth, O. Patashnik, Concrete Mathematics: A Foundation for

Computer Science, 2nd Edition, Addison-Wesley, 1994.
[66] D. Gries, The Science of Programming, Springer Verlag, Heidelberg, New–York, 1981.
[67] L. Guo, F. Shao, C. Botev, J. Shanmugasundaram, XRANK: ranked keyword search over
XML documents, in Proceedings of the 2003 ACM SIGMOD International Conference
on Management of Data, pp. 16–27, 2003.
[68] D. Gusfield, Algorithms on Strings, Trees, and Sequences, Cambridge University Press,
1997.
[69] G. H. Hardy, E. M. Wright, An Introduction to the Theory of Numbers, 5th Edition,

Oxford University Press, 1979.
[70] D. Harel, R. E. Tarjan, Fast algorithms for finding nearest common ancestors, SIAM
Journal on Computing, vol. 13(2), pp. 338-355, 1984.
221
[71] T. E. Harris, F. S. Ross, Fundamentals of a Method for Evaluating Rail Net Capacities,
Research Memorandum RM-1573, The RAND Corporation, Santa Monica, California,
1955.
[72] I. N. Herstein, I. Kaplansky, Matters mathematical, 2nd Edition, Chelsea Publishing

Company, 1978.
[73] C. Hierholzer, C. Wiener, Ueber die Möglichkeit, einen Linienzug ohne Wiederholung
und ohne Unterbrechung zu umfahren, Mathematische Annalen, vol. 6(1), pp. 30–32,
1873.
5
[74] J. E. Hopcroft, R. Karp, An n 2 algorithm for maximum matchings in bipartite graphs,
SIAM Journal on Computing, vol. 2(4), pp.225-231, 1973.
[75] J. Hopcroft, R. Tarjan, Algorithm 447: efficient algorithms for graph manipulation,
Communications of the ACM, vol 16(6), pp. 372–378, 1973.
[76] V. Hristidis , N. Koudas , Y. Papakonstantinou, D. Srivastava, Keyword Proximity

Search in XML Trees, IEEE Transactions on Knowledge and Data Engineering, vol.
18(4), pp. 525–539, 2006.
[77] D. A. Huffman, A Method for the Construction of Minimum-Redundancy Codes, Pro-

ceedings of the I.R.E., 1952, pp. 1098-1102.
[78] C. Ionescu, I. Zsako, Structuri arborescente, Editura Tehnică, Bucureşti, 1990.

[79] V. Jarnı́k, O jistém problému minimálnı́m (About a certain minimal problem), Práce
Moravské Prı́rodovedecké Spolecnosti, 6, pp. 57–63, 1930.
[80] D. Jungnickel, Graphs, Networks and Algorithms, Algorithms and Computation in Math-
ematics, vol. 5, 3rd Edition, Springer, 2008.
[81] A. B. Kahn, Topological sorting of large networks, Communications of the ACM, vol.
5(11), pp. 558-562, 1962.
[82] D. Karger, P. Klein, R. Tarjan, A randomized linear-time algorithm to find minimum

spanning trees, Journal of ACM, 42, pp. 321328, 1995.
[83] A. V. Karzanov, Determining the maximum flow in the network by the method of pre-
flows, Doklady Akademii nauk SSSR 15, pp. 434-437, 1974.
[84] B. W. Kernigham, D. M. Ritchie, The C Programming Language, 2nd Edition, Prentice

Hall, 1988.
[85] D. C. Kozen, The Design and Analysis of Algorithms. Texts and Monographs in Com-
puter Science, Springer, 1993.
[86] D. Kőnig, Theorie der endlichen und unendlichen Graphen, Leipzig: Akademische Ver-
lagsgesellschaft, 1936. Translated from German by Richard McCoart, Theory of finite
and infinite graphs, Birkhäuser, 1990.
[87] J. Kleinberg, E. Tardos, Algorithm Design, Addison-Wesley, 2005.
[88] D. E. Knuth, Arta programării calculatoarelor, vol. 1 Algoritmi fundamentali, Teora,

Bucureşti, 1999.
222
[89] D. E. Knuth, Arta programării calculatoarelor, vol. 2 Algoritmi seminumerici, Teora,
Bucureşti, 2000.
[90] D. E. Knuth, Arta programării calculatoarelor, vol. 3 Sortare şi Căutare, Teora, Bu-
cureşti, 2001.
[91] J. B. Kruskal, On the shortest spanning subtree of a graph and the traveling salesman
problem, Proc. of the American Mathematical Society, 7, pp. 48-50, 1956.
[92] H. W. Kuhn, On combinatorial properties of matrices, Logistics Papers (George Wash-

ington University), vol. 11, pp. 1-11, 1955.
[93] H. W. Kuhn, The Hungarian Method for the assignment problem, Naval Research Lo-
gistics Quarterly, vol. 2, pp. 83-97, 1955.
[94] H. W. Kuhn, Variants of the Hungarian method for assignment problems, Naval Research
Logistics Quarterly, vol. 3, pp. 253-258, 1956.
[95] Y. Li , C. Yu , H. V. Jagadish, Schema-free XQuery, in Proceedings of the Thirtieth

International Conference on Very Large Databases (VLDB), pp. 72–83, 2004.
[96] L. Livovschi, H. Georgescu, Analiza şi sinteza algoritmilor, Ed. Ştiinţifică şi Enciclope-
dică, Bucureşti, 1986.
[97] V. M. Malhotra, M. P. Kumar, S. N. Maheshwari, An O(|V |3 ) algorithm for finding

maximum flows in networks, Information Processing Letters, 7(6), pp.277–278, 1978.
[98] K. Mehlhorn, Data Structures and Algorithms: Graph Algorithms and NP-Completeness,
Springer Verlag, 1984.
p
[99] S. Micali, V. V. Vazirani, An O( |V | · |E|) algorithm for finding maximum matching
in general graphs, Proc. 21st IEEE Symp. Foundations of Computer Science, pp. 17-27,
1980.
[100] V. Mitrana, Provocarea algoritmilor, Editura Agni, Bucureşti, 1994.
[101] E. F. Moore, The shortest path through a maze, in Proceedings of International Sym-
posium on the Theory of Switching, Part II, pp. 285-292, 1959. (prezentat la simpozion
la Universitatea Harvard in aprilie 1957)
[102] R. Motwani, Average-case analysis of algorithms for matchings and related problems,
Journal of the ACM, vol. 41(6), pp. 1329-1356, 1994.
[103] J. Munkres, Algorithms for the Assignment and Transportation Problems, Journal of
the Society for Industrial and Applied Mathematics, vol. 5(1), pp. 32-38, 1957.
[104] G. Nivasch, Cycle detection using a stack, Information Processing Letters, vol. 90(3),
pp. 135–140, 2004.
[105] E. Nuutila, E. Soisalon-Soininen, On finding the strongly connected components in a

directed graph, Information Processing Letters, vol 49(1), pp. 9–14, 1993.
[106] I. Odăgescu, F. Furtună, Metode şi tehnici de programare, Computer Libris Agora,
Cluj–Napoca, 1998.
223
[107] S. Pettie, A faster all-pairs shortest path algorithm for real-weighted sparse graphs, in
Proceedings of 29th International Colloquium on Automata, Languages, and Program-
ming (ICALP02), LNCS Vol. 2380, pp. 85-97, 2002.
[108] S. Pettie, V. Ramachandran, Computing shortest paths with comparisons and additions,
in Proceedings of the 13th Annual ACM-SIAM Symposium on Discrete Algorithms
(SODA02), SIAM, pp. 267-276, 2002.
[109] S. Pettie, V. Ramachandran, An optimal minimum spanning tree algorithm, Journal of

ACM, 49:1634, 2002.
[110] R. C. Prim, Shortest connection networks and some generalizations, Bell System Tech-
nical Journal, 36, pp. 1389-1401, 1957.
[111] B. Schieber, U. Vishkin, On finding lowest common ancestors: Simplification and par-
allelization, SIAM J. Comput., vol. 17, pp. 1253-1262, 1988.
[112] L. Schmitz, An improved transitive closure algorithm, Computing, vol 30(4), pp. 359-
371, 1983.
[113] A. Schrijver, On the history of the transportation and maximum flow problems, Math-
ematical Programming, vol. 91, issue 3, pp. 437-445, 2002.
[114] R. Sedgewick, K. Wayne, Algoritms, 4th Edition, Addison-Wesley Professional, 2011.
[115] R. Seidel, C. Aragon, Randomized Search Trees, Algorithmica, vol. 16, pp. 464–497,
1996.
[116] M. Sharir, A strong-connectivity algorithm and its applications in data flow analysis,
Computers and Mathematics with Applications, vol. 7(1), pp. 67–72, 1981.
[117] Y. Shiloach, U. Vishkin, An O(n2 log n) parallel max-flow algorithm, Journal of Algo-
rithms, vol. 3(2), pp. 128-146, 1982.
[118] K. Simon, An improved algorithm for transitive closure on acyclic digraphs, Theoretical
Computer Science, vol 58(13), pp. 325–346, 1988.
[119] S. Skiena, The Algorithm Design Manual, 2nd Edition, Springer, 2008.
[120] D. D. Sleator, An O(EV log V ) algorithm for maximum network flow, Technical Report,
STAN-CS-80-831, 1980.
[121] D. D. Sleator, R. E. Tarjan, A data structure for dynamic trees, Journal of Computer
Sciences, vol. 26, pp. 362–391, 1983.
[122] J. Stasko, J. Vitter, Pairing heaps: Experiments and analysis, Communications of the
ACM, vol. 30(3), pp. 234-249, 1987.
[123] T. Takaoka, Theory of 2-3 heaps, Discrete Applied Mathematics, Vol. 126(1), 5th An-
nual International Computing and Combinatories Conference (COCOON’99), pp. 115–
128, 2003.
[124] R. E. Tarjan, Depth–first search and linear graph algorithms, SIAM Journal on Com-
puting, vol. 1(2), pp. 146–160, 1972.
224
[125] R. E. Tarjan, Edge-disjoint spanning trees and depth-first search, Algorithmica, vol.
6(2), pp. 171-185, 1976.
[126] R. E. Tarjan, Applications of path compression on balanced trees, Journal of the ACM,
vol. 26(4), pp. 690-715, 1979.
[127] R. E. Tarjan, A simple version of Karzanov’s blocking flow algorithm, Operation Re-
search Letters, vol. 2, pp.265–268, 1984.
[128] A. N. Tolstoi, Methods of Finding Minimum Total Kilometrage in Cargo-Transportation

Planning in Space, Transportation Planning, vol. 1, TransPress of the National Com-
missariat of Transportation, Moscow,pp. 23–55, 1930.
[129] I. Tomescu, Grafuri şi programare liniară, Ed. Didactică şi Pedagogică, Bucureşti, 1975.
[130] I. Tomescu, Probleme de combinatorică şi teoria grafurilor, Ed. Didactică şi Pedagogică,
Bucureşti, 1981.
[131] I. Tutunea, Algoritmi, logică şi programare, Reprografia Universităţii din Craiova, 1993.
[132] I. Tutunea, S. Pescăruş, Algoritmi şi programe Pascal. (Culegere de probleme), Repro-
grafia Universităţii din Craiova, 1994.
[133] J. Vuillemin, A data structure for manipulating priority queues, Communications of

the ACM, vol. 21:4, pp. 309–315, 1978.
[134] J. Vuillemin, A unifying look at data structures, Communications of the ACM, vol.
23:4, pp. 229-239, 1980.
[135] G. A. Waissi, A new Karzanov-type O(n3 ) max-flow algorithm, Mathematical and Com-
puter Modelling, vol. 16(2), pp.65–72, 1992.
[136] J. Westbrook, R. E. Tarjan, Maintaining bridge-connected and biconnected components

on-line, Algorithmica, vol 7, pp. 433–464, 1992.
[137] H. S. Wilf, Algorithms and Complexity, Internet edition, 1996.
[138] J. W. J. Williams, Algorithm 232 - Heapsort, Communications of the ACM, vol. 7(6),
pp. 347-348, 1964.
[139] Y. Xu, Y. Papakonstantinou, Efficient keyword search for smallest LCAs in XML
databases, in Proceedings of the 2005 ACM SIGMOD International Conference on Man-
agement of Data, pp. 527–538, 2005.
[140] D. Zaharie, Introducere ı̂n proiectarea şi analiza algoritmilor, Eubeea, Timişoara, 2008.
225

CursuriAG2017 1 14

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

CursuriAG2017 1 14

Încărcat de

Drepturi de autor:

Formate disponibile

Cuprins

1 Introducere ı̂n algoritmi 3

2 Grafuri. Grafuri neorientate 28

3 Grafuri euleriene şi hamiltoniene 57

4 Arbori. Arbori binari 81

6 Arbori oarecare 121

7 Grafuri orientate 146

8 Distanţe ı̂n grafuri 167

9 Fluxuri ı̂n reţele de transport 194

Introducere ı̂n algoritmi

Un algoritm trebuie să posede următoarele trăsături caracteristice:

2. corectitudine - rezultatele trebuie să fie corecte;

• exprimare - implementarea unui algoritm intr-un limbaj de programare se poate face

• validare - verificarea corectitudinii algoritmului prin metode formale;

• o adresă - desemnează o locaţie de memorie;

1.1 Limbajul pseudocod

Algoritm 1 Algoritm pentru rezolvarea ecuaţiei de gradul I

• Expresie1 > Expresie2: <instructiune> nu se execută niciodată;

• Expresie1 = Expresie2: <instructiune> se execută exact o dată;

• Expresie1 < Expresie2: <instructiune> se execută de Expresie2 − Expresie1 + 1 ori.

Algoritm 3 Algoritm pentru calculul elementului de valoare minimă dintr-un şir

Structura repetitivă condiţionată posterior repeat . . . until prezintă următoarea sin-

Atâta timp cât <expresie-booleana> este falsă, se execută <instructiune>. Se observă

Observaţia 1.5 1. Algoritmul 4 utilizează enunţul repetitiv cu test final, repeat . . .

2. Enunţurile S ← 0 şi i ← 1 au rolul de a atribui valori iniţiale variabilelor S şi i.

3. Atribuirile i = i + 1 şi S = S + i (liniile 5 şi 6) sunt lipsite de sens din punct de

unde a se numeşte deı̂mpărţitul, b ı̂mpărţitorul, q câtul iar r restul.

1. d|a, d|b (d este un divizor comun al lui a şi b);

Observaţia 1.8 1. cmmdc(a, 0) = a.

Algoritm 6 Algoritmul lui Euclid pentru calculul cmmdc a două numere

Algoritm 7 Algoritm pentru verificarea dacă un număr este prim

Algoritm 9 Algoritm pentru verificarea simetriei unui vector

• liniile 6, 7 - se iniţializează variabila de ciclare j cu l şi valoarea maximă cu 0; Deoarece

• linia 11 - se actualizează poziţia valorii maxime.

1.3 Elemente de analiza algoritmilor

Definiţia 1.6 Fiind dată o funcţie g : N −→ R vom nota cu O(g(n)) mulţimea:

Observaţia 1.13 Vom prezenta câteva proprietăţi ale lui O(·):

• O(f (n) + g(n)) = O(max {f (n), g(n)}).

• O(loga n) = O(logb n);

• f (n) = O(f (n)) (reflexivitate);

• f (n) = O(g(n)) şi g(n) = O(h(n)) atunci f (n) = O(h(n)) (tranzitivitate).

Definiţia 1.7 Fiind dată o funcţie g : N −→ R vom nota cu Θ(g(n)) mulţimea:

Spunem că g(n) este o margine asimptotic tare pentru f (n).

Definiţia 1.8 Fiind dată o funcţie g : N −→ R vom nota cu Ω(g(n)) mulţimea:

La fel cum O furnizează o delimitare asimptotică superioară pentru o funcţie, Ω furnizează

Definiţia 1.9 Fiind dată o funcţie g : N −→ R vom nota cu o(g(n)) mulţimea:

Definiţia 1.10 f (n) ∈ ω(g(n)) ⇐⇒ g(n) ∈ o(f (n))

Observaţia 1.16 1. f (n) = Θ(g(n)), g(n) = Θ(h(n)) =⇒ f (n) = Θ(h(n)) (tranzitivi-

2. f (n) = Θ(f (n)) (reflexivitate);

3. f (n) = Θ(g(n)) ⇐⇒ g(n) = Θ(f (n)) (simetrie).

Exemplul 1.18 • Pentru x ∈ R∗+ avem xn ∈ o(n!).

• Pentru a, b > 1, a, b ∈ R∗ avem loga n ∈ Θ(logb n).

Calcularea cu exactitate a timpului de execuţie al unui program oarecare se poate dovedi

O(1) ⊆ O(log n) ⊆ O(n) ⊆ O(n log n) ⊆ O(n2 ) ⊆ O(n3) ⊆ O(2n )

• timpul de execuţie al unei secvenţe de instrucţiuni este proporţional cu timpul instrucţiunii

Dacă instrucţiunii compuse A(i) ı̂i corespunde un timp de execuţie constant t, ce nu

În cazul general, timpul de execuţie al instrucţiunii compuse A(i) depinde

nu se poate preciza de câte ori se va ajunge la realizarea instrucţiunii de incrementare

Exemplul 1.19 De exemplu

are timpul de execuţie O(n).

T (n) = O(n2 ) + O(n) + O(1) = O(n2 ). (1.6)

T (n) = O(1)(linia 1) + O(n)(liniile 2–4) + O(1)(linia 6) = O(n) (1.7)

1.3.1 Metoda substituţiei