2.

1 Parcurgere genericaMANGHIUC PATRONU’

PROGRAM PG;

U = N − {s} U = multimea nodurilor nevizitate devine multimea nodurilor fara nodul de start
V = {s} V = multimea nodurilor vizitate si neanalizate se initializeaza cu nodul de start
W = Ø W = multimea nodurilor vizitate si analizate se initializeaza cu multimea vida

FOR toti y ∈ N DO pentru toate nodurile ‘y’ din multimea de noduri ‘N’, predecesorul va fi 0
p(y) = 0
END

k = 1 k = contor
o(s) = 1 se noteaza in tabloul ‘ordine’ ca nodul de start ‘s’ are numarul de ordine 1

FOR toti y ∈ U DO pentru toate nodurile ‘y’ din multimea nodurilor nevizitate ‘U’ in tabloul ‘ordine’ se initializeaza cu ∞
o(y) = ∞
END

WHILE V ≠ Ø DO cat timp nu am analizat toate nodurile din ‘V’

se selecteaza un nod x din V se ia cate un nod
IF exista arc(x, y) ∈ A si y ∈ U THEN daca exista arc intre ‘x’ si ‘y’ si ‘y’ este in multimea nodurilor nevizitate ‘U’ atunci
U = U − {y} din multimea nodurilor nevizitate se elimina ‘y’
V = V ∪ {y} ‘y’ este adaugat in multimea nodurilor vizitate si neanalizate
p(y) = x predecesorul lui ‘y’ devine ‘x’
k = k + 1 crestem contorul
o(y) = k ordinea lui ‘y’ este egala cu valoarea contorului
ELSE
V = V − {x} din multimea nodurilor vizitate si neanalizate ‘V’ se scoate ‘x’
W = W ∪ {x} se adauga ‘x’ in multimea nodurilor vizitate si analizate ‘W’
END

END.

T2.1. Determina multimea tuturor nodurilor care sunt accesibile din nodul sursa ‘s’ in digraful G = (N,A)
DEM T2.1. Toate nodurile introduse in V sunt eliminate dupa ce sunt analizate. Dupa un numar finit de operatii se obtine V = Ø si executia algoritmului se opreste.
La terminarea executiei, algoritmul determina multimea tuturor nodurilor care sunt accesibile din nodul sursa s in digraful G = (N, A) daca multimea W este:
W = { y | y ∈ N si exista drum de la s la y }.
In V sunt introduse numai noduri y care sunt accesibile din s, iar dupa ce un nod y a fost analizat este scos din V si introdus in W.
Algoritmul se opreste cand se obtine V = Ø deci W contine toate nodurile y ∈ N care sunt accesibile din s si sunt introduse in V.
Prin reducere la absurd daca presupunem ca exista un drum D = (y1, y2, .., yk-1, yk) cu y1 = s si yk = y in G si y ∉ W rezulta ca yk ∉ V.
Deoarece yk ∉ V si (yk-1, yk) ∈ A deducem ca yk-1 ∉ V, altfel yk ar fi fost introdus in V. Repetand procedeul vom concluziona in final ca s = y1 ∉ V.
Aceasta concluzie contrazice faptul ca V se initializeaza cu {s} si deci rezulta ca y ∈ V, deci y ∈ W si teorema este demonstrata.

T2.2. Complexitate: O(m)

DEM T2.2. Fiecare nod al digrafului G este introdus si eliminat din V cel mult o data.
Executia algoritmului se temina cand V = Ø deci algoritmul executa cel mult 2×n iteratii.
Fiecare arc (x,y) ∈ A este explorat cel mult o data pentru identificarea arcelor admisibile.
Rezulta deci ca algoritmul are complexitatea O(m+n) deci O(m).

Ø
∈
∩
∪
∞
′
∉
≠
∃
2.1 Parcurgere total generica

PROGRAM PTG;

U = N − {s} U = multimea nodurilor nevizitate devine multimea nodurilor fara nodul de start
V = {s} V = multimea nodurilor vizitate si neanalizate se initializeaza cu nodul de start
W = Ø W = multimea nodurilor vizitate si analizate se initializeaza cu multimea vida

FOR toti y ∈ N DO pentru toate nodurile ‘y’ din multimea de noduri ‘N’, predecesorul va fi 0
p(y) = 0
END

k = 1 k = contor
o(s) = 1 se noteaza in tabloul ‘ordine’ ca nodul de start ‘s’ are numarul de ordine 1

FOR toti y ∈ U DO pentru toate nodurile ‘y’ din multimea nodurilor nevizitate ‘U’ in tabloul ‘ordine’ se initializeaza cu ∞
o(y) = ∞
END

WHILE W ≠ N DO cat timp nu am parcurs intreaga lista de noduri ‘N’

WHILE V ≠ Ø DO cat timp nu am analizat toate nodurile din ‘V’
se selecteaza un nod x din V se ia cate un nod
IF exista arc(x, y) ∈ A si y ∈ U THEN daca exista arc intre ‘x’ si ‘y’ si ‘y’ este in multimea nodurilor nevizitate ‘U’ atunci
U = U − {y} din multimea nodurilor nevizitate se elimina ‘y’
V = V ∪ {y} ‘y’ este adaugat in multimea nodurilor vizitate si neanalizate
p(y) = x predecesorul lui ‘y’ devine ‘x’
k = k + 1 crestem contorul
o(y) = k ordinea lui ‘y’ este egala cu valoarea contorului
ELSE
V = V − {x} din multimea nodurilor vizitate si neanalizate ‘V’ se scoate ‘x’
W = W ∪ {x} se adauga ‘x’ in multimea nodurilor vizitate si analizate ‘W’
END
END se ia alt nod de start ‘s’ din multimea nodurilor nevizitate
se selecteaza s ∈ U U = multimea nodurilor nevizitate devine multimea nodurilor fara nodul de start
U = U – {s} V = multimea nodurilor vizitate si neanalizate se initializeaza cu nodul de start
V = {s} crestem contorul
k = k + 1 ordinea nodului de start ‘s’ va fi egala cu valoarea contorului
o(s) = k
END

END.

OBS 2.1. Determina multimea tuturor nodurilor care sunt accesibile din nodul sursa, ‘s’, dar ‘W’ nu mai este o submultime a lui ‘N’ ci multimea ‘N’ va fi parcursa in intregime

OBS 2.1. Complexitate: O(m), aceeasi ca a parcurgerii generice (PG)

DEM OBS 2.1. Fiecare nod al digrafului G este introdus si eliminat din V cel mult o data.
Executia algoritmului se temina cand V = Ø deci algoritmul executa cel mult 2×n iteratii.
Fiecare arc (x,y) ∈ A este explorat cel mult o data pentru identificarea arcelor admisibile.
Rezulta deci ca algoritmul are complexitatea O(m+n) deci O(m).
2.1 Drum unic

PROCEDURA DRUM;

se tipareste y
WHILE p(y) ≠ 0 DO cat timp in vectorul ‘predecesor’ nu gasim 0
x = p(y) ‘x’ devine parintele lui ‘y’
se tipareste x se tipareste ‘x’
y = x ‘y’ devine ‘x’
END

END.

OBS 2.4. Determina drumul unic de la nodul sursa ‘s’ la nodul ‘y’

-ESTE EXEMPLU LA P/33 [DONE]

2.2 Parcurgerea in latime (BF)

PROGRAM PBF;

U = N − {s} U = multimea nodurilor nevizitate devine multimea nodurilor fara nodul de start
V = {s} V = multimea nodurilor vizitate si neanalizate se initializeaza cu nodul de start
W = Ø W = multimea nodurilor vizitate si analizate se initializeaza cu multimea vida

FOR toti y ∈ N DO pentru toate nodurile ‘y’ din multimea de noduri ‘N’, predecesorul va fi 0
p(y) = 0
END

l(s) = 0 se noteaza in tabloul ‘lungime’ ca drumul are lungimea 0

FOR toti y ∈ U DO pentru toate nodurile ‘y’ din multimea nodurilor nevizitate ‘U’ in tabloul ‘lungime’ se initializeaza cu ∞
l(y) = ∞
END

WHILE V ≠ Ø DO cat timp nu am analizat toate nodurile din ‘V’

se selecteaza cel mai vechi nod x din V se ia cate un nod din coada
FOR toti arc(x,y) ∈ A se iau toate arcele din multimea de arce ‘A’
IF y ∈ U THEN daca ‘y’ este un nod nevizitat din ‘U’ atunci
U = U − {y} din multimea nodurilor nevizitate se elimina ‘y’
V = V ∪ {y} ‘y’ este adaugat in multimea nodurilor vizitate si neanalizate ‘V’
p(y) = x predecesorul lui ‘y’ devine ‘x’
l(y) = l(x) + 1 se actualizeaza lungimea drumului spre ‘y’ ca fiind lungimea pana la ‘x’ deja calculata + 1
END
V = V – {x} se scoate ‘x’ din multimea nodurilor vizitate si neanalizate
W = W ∪ {x} se adauga ‘x’ in multimea nodurilor vizitate si analizate ‘W’
END

END.

T2.5 (T2.1). Determina multimea tuturor nodurilor care sunt accesibile din nodul sursa ‘s’ in digraful G = (N,A)
T2.5 (T2.1). Determina prin tabloul ‘lungime’ distanta pana la nodul ‘y’
DEM T2.5 (T2.1). Toate nodurile introduse in V sunt eliminate dupa ce sunt analizate. Dupa un numar finit de operatii se obtine V = Ø si executia algoritmului se opreste.
La terminarea executiei, algoritmul determina multimea tuturor nodurilor care sunt accesibile din nodul sursa s in digraful G = (N, A) daca multimea W este:
W = { y | y ∈ N si exista drum de la s la y }.
In V sunt introduse numai noduri y care sunt accesibile din s, iar dupa ce un nod y a fost analizat este scos din V si introdus in W.
Algoritmul se opreste cand se obtine V = Ø deci W contine toate nodurile y ∈ N care sunt accesibile din s si sunt introduse in V.
Prin reducere la absurd daca presupunem ca exista un drum D = (y1, y2, .., yk-1, yk) cu y1 = s si yk = y in G si y ∉ W rezulta ca yk ∉ V.
Deoarece yk ∉ V si (yk-1, yk) ∈ A deducem ca yk-1 ∉ V, altfel yk ar fi fost introdus in V. Repetand procedeul vom concluziona in final ca s = y1 ∉ V.
Aceasta concluzie contrazice faptul ca V se initializeaza cu {s} si deci rezulta ca y ∈ V, deci y ∈ W si teorema este demonstrata.

-pentru ‘V’ se foloseste o coada

T2.6 (T2.2). Complexitate: O(m), aceeasi ca parcurgerea generica (PG)

DEM T2.6 (T2.2). Fiecare nod al digrafului G este introdus si eliminat din V cel mult o data.
Executia algoritmului se temina cand V = Ø deci algoritmul executa cel mult 2×n iteratii.
Fiecare arc (x,y) ∈ A este explorat cel mult o data pentru identificarea areclor admisibile.
Rezulta deci ca algoritmul are complexitatea O(m+n) deci O(m).

OBS 2.9. Se poate folosi 2.1 Drum unic pentru a determina un cel mai scurt drum de la ‘s’ la ‘y’

-ESTE EXEMPLU LA P/32 [DONE]

2.3 Parcurgerea in adancime (DF)

PROGRAM PDF;

U = N − {s} U = multimea nodurilor nevizitate devine multimea nodurilor fara nodul de start
V = {s} V = multimea nodurilor vizitate si neanalizate se initializeaza cu nodul de start
W = Ø W = multimea nodurilor vizitate si analizate se initializeaza cu multimea vida

FOR toti y ∈ N DO pentru toate nodurile ‘y’ din multimea de noduri ‘N’,
p(y) = 0 predecesorul va fi 0
END

t = 1 contor pentru timp

t1(s) = 1 pentru nodul de start ‘s’ se noteaza in tabloul ‘timp’ t1 = 1, timpul la care a fost vizitat si neanalizat
t2(s) = ∞ pentru nodul de start ‘s’ se noteaza in tabloul ‘timp’ t2 = infinit, timpul la care va fi vizitat si analizat

FOR toti y ∈ U DO toate nodurile ‘y’ nevizitate se initializeaza in tablourile ‘timp’ cu infinit
t1(y) = ∞
t2(y) = ∞
END
cat timp nu am analizat toate nodurile din ‘V’
WHILE V ≠ Ø DO
se selecteaza cel mai nou nod x din V se ia cate un nod din stiva
IF exista arc(x, y) ∈ A si y ∈ U THEN daca exista arc intre ‘x’ si ‘y’ si ‘y’ este un nod nevizitat atunci
U = U − {y} se scoate ‘y’ din multimea nodurilor nevizitate
V = V ∪ {y} se adauga ‘y’ in stiva
p(y) = x predecesorul lui ‘y’ devine ‘x’
t = t + 1
se actualizeaza timpul
t1(y) = t
t1(y) = momentul in care ‘y’ devine nod vizitat si neanalizat
ELSE

V = V – {x} din multimea nodurilor vizitate si neanalizate se scoate ‘x’

W = W ∪ {x} se adauga ‘x’ in multimea de noduri vizitate si analizate ‘W’
t = t + 1 se actualizeaza timpul
t2(x) = t t2(x) = momentul in care ‘x’ devine nod vizitat si analizat
END
END

END.

T2.1 (T2.1). Determina multimea nodurilor accesibile din nodul sursa ‘s’, dar ‘W’ nu va mai fi o submultime de noduri a lui ‘N’ ci multimea ‘N’ va fi parcursa in intregime, iar ‘s’ ∈ S
DEM T2.1 (T2.1). Toate nodurile introduse in V sunt eliminate dupa ce sunt analizate. Dupa un numar finit de operatii se obtine V = Ø si executia algoritmului se opreste.
La terminarea executiei, algoritmul determina multimea tuturor nodurilor care sunt accesibile din nodul sursa s in digraful G = (N, A) daca multimea W este:
W = { y | y ∈ N si exista drum de la s la y }.
In V sunt introduse numai noduri y care sunt accesibile din s, iar dupa ce un nod y a fost analizat este scos din V si introdus in W.
Algoritmul se opreste cand se obtine V = Ø deci W contine toate nodurile y ∈ N care sunt accesibile din s si sunt introduse in V.
Prin reducere la absurd daca presupunem ca exista un drum D = (y1, y2, .., yk-1, yk) cu y1 = s si yk = y in G si y ∉ W rezulta ca yk ∉ V.
Deoarece yk ∉ V si (yk-1, yk) ∈ A deducem ca yk-1 ∉ V, altfel yk ar fi fost introdus in V. Repetand procedeul vom concluziona in final ca s = y1 ∉ V.
Aceasta concluzie contrazice faptul ca V se initializeaza cu {s} si deci rezulta ca y ∈ V, deci y ∈ W si teorema este demonstrata.

-pentru ‘V’ se foloseste o stiva

-S = { s | s ∈ N, s selectat la initializare si apoi in ciclul WHILE pentru a parcurge in intregime lista de noduri N }

T2.2 (T2.2). Complexitate: O(m), aceeasi ca parcurgerea generica (PG)

DEM T2.2 (T2.2). Fiecare nod al digrafului G este introdus si eliminat din V cel mult o data.
Executia algoritmului se temina cand V = Ø deci algoritmul executa cel mult 2×n iteratii.
Fiecare arc (x,y) ∈ A este explorat cel mult o data pentru identificarea areclor admisibile.
Rezulta deci ca algoritmul are complexitatea O(m+n) deci O(m).
2.3 Parcurgerea totala in adancime (TDF)

PROGRAM PTDF;

U = N − {s} U = multimea nodurilor nevizitate devine multimea nodurilor fara nodul de start
V = {s} V = multimea nodurilor vizitate si neanalizate se initializeaza cu nodul de start
W = Ø W = multimea nodurilor vizitate si analizate se initializeaza cu multimea vida

FOR toti y ∈ N DO pentru toate nodurile ‘y’ din multimea de noduri ‘N’,
p(y) = 0 predecesorul va fi 0
END

t = 1 contor pentru timp

t1(s) = 1 pentru nodul de start ‘s’ se noteaza in tabloul ‘timp’ t1 = 1, timpul la care a fost vizitat si neanalizat
t2(s) = ∞ pentru nodul de start ‘s’ se noteaza in tabloul ‘timp’ t2 = infinit, timpul la care va fi vizitat si analizat

FOR toti y ∈ U DO toate nodurile ‘y’ nevizitate se initializeaza in tablourile ‘timp’ cu infinit
t1(y) = ∞
t2(y) = ∞
END
cat timp nu am parcurs intreaga lista de noduri ‘N’
WHILE W ≠ N DO
WHILE V ≠ Ø DO cat timp nu am analizat toate nodurile din ‘V’
se selecteaza cel mai nou nod x din V se ia cate un nod din stiva
IF exista arc(x, y) ∈ A si y ∈ U THEN daca exista arc intre ‘x’ si ‘y’ si ‘y’ este un nod nevizitat atunci
U = U − {y} se scoate ‘y’ din multimea nodurilor nevizitate
V = V ∪ {y} se adauga ‘y’ in stiva
p(y) = x predecesorul lui ‘y’ devine ‘x’
t = t + 1 se actualizeaza timpul
t1(y) = t t1(y) = momentul in care ‘y’ devine nod vizitat si neanalizat
ELSE
din multimea nodurilor vizitate si neanalizate se scoate ‘x’
V = V – {x}
W = W ∪ {x} se adauga ‘x’ in multimea de noduri vizitate si analizate ‘W’
t = t + 1 se actualizeaza timpul
t2(x) = t t2(x) = momentul in care ‘x’ devine nod vizitat si analizat
END
END
este selectat un nou nod de start ‘s’
se selecteaza s ∈ U
U = U – {s} nodul de start ‘s’ este scos din multimea nodurilor nevizitate
V = {s} in capul stivei ‘V’ este pus noul nod de start ‘s’
t = t + 1 se actualizeaza timpul
t1(s) = t t1(s) = momentul in care nodul de start ‘s’ devine vizitat si neanalizat
END

END.

T2.8 (T2.1). Determina multimea nodurilor accesibile din nodul sursa ‘s’, dar ‘W’ nu va mai fi o submultime de noduri a lui ‘N’ ci multimea ‘N’ va fi parcursa in intregime, iar ‘s’ ∈ S
DEM T2.8 (T2.1). Toate nodurile introduse in V sunt eliminate dupa ce sunt analizate. Dupa un numar finit de operatii se obtine V = Ø si executia algoritmului se opreste.
La terminarea executiei, algoritmul determina multimea tuturor nodurilor care sunt accesibile din nodul sursa s in digraful G = (N, A) daca multimea W este:
W = { y | y ∈ N si exista drum de la s la y }.
In V sunt introduse numai noduri y care sunt accesibile din s, iar dupa ce un nod y a fost analizat este scos din V si introdus in W.
Algoritmul se opreste cand se obtine V = Ø deci W contine toate nodurile y ∈ N care sunt accesibile din s si sunt introduse in V.
Prin reducere la absurd daca presupunem ca exista un drum D = (y1, y2, .., yk-1, yk) cu y1 = s si yk = y in G si y ∉ W rezulta ca yk ∉ V.
Deoarece yk ∉ V si (yk-1, yk) ∈ A deducem ca yk-1 ∉ V, altfel yk ar fi fost introdus in V. Repetand procedeul vom concluziona in final ca s = y1 ∉ V.
Aceasta concluzie contrazice faptul ca V se initializeaza cu {s} si deci rezulta ca y ∈ V, deci y ∈ W si teorema este demonstrata.

-pentru ‘V’ se foloseste o stiva

-S = { s | s ∈ N, s selectat la initializare si apoi in ciclul WHILE pentru a parcurge in intregime lista de noduri N }

T2.9 (T2.2). Complexitate: O(m), aceeasi ca parcurgerea totala generica (PTG)

DEM T2.9 (T2.2). Fiecare nod al digrafului G este introdus si eliminat din V cel mult o data.
Executia algoritmului se temina cand V = Ø deci algoritmul executa cel mult 2×n iteratii.
Fiecare arc (x,y) ∈ A este explorat cel mult o data pentru identificarea areclor admisibile.
Rezulta deci ca algoritmul are complexitatea O(m+n) deci O(m).

-ESTE EXEMPLU LA P/36

2.4.2 Componentele conexe

PROGRAM CC;

U = N − {s} U = multimea nodurilor nevizitate devine multimea nodurilor fara nodul de start
V = {s} V = multimea nodurilor vizitate si neanalizate se initializeaza cu nodul de start
W = Ø W = multimea nodurilor vizitate si analizate se initializeaza cu multimea vida
p = 1 p = numarul de componente conexe
N′ = {s} N′ = multimea de noduri care compun fiecare componenta conexa

WHILE W ≠ N DO cat timp nu au fost vizitate toate nodurile din multimea de noduri ‘N’ initiala
WHILE V ≠ Ø DO cat timp mai sunt noduri de analizat
se selecteaza cel mai nou nod x din V se ia cate un nod
IF exista muchie [x,y] ∈ A si y ∈ U THEN daca exista muchie intre ‘x’ si ‘y’ si ‘y’ este un nod din multimea nodurilor nevizitate ‘U’ atunci
U = U − {y} se scoate ‘y’ din multimea nodurilor nevizitate ‘U’
V = V ∪ {y} se adauga ‘y’ in multimea nodurilor vizitate si neanalizate ‘V’
N′ = N′ ∪ {y} se adauga ‘y’ in multimea de noduri care compune componenta conexa
ELSE
V = V − {x} din multimea nodurilor vizitate si neanalizate ‘V’ se scoate ‘x’
W = W ∪ {x} se adauga ‘x’ in multimea nodurilor vizitate si analizate ‘W’
END
se tiparesc p si N′ se printeaza numarul de componente conexe si nodurile care compun componenta conexa
se selecteaza s ∈ U se selecteaza un nou nod de start ‘s’
U = U – {s} se marcheaza ‘s’ ca fiind vizitat
V = {s} se adauga ‘s’ in multimea de noduri vizitate si neanalizate ‘V’
p = p + 1 se incrementeaza numarul componentelor conexe din graf
N′ = {s} se adauga nodul de start ‘s’ in multimea de noduri ‘ N′ ’
END

END.

-determina numarul de componente conexe ‘p’ si multimea nodurilor care compun componentele conexe ‘ N′ ’

T2.14. Determina componentele conexe ale unui graf orientat G = (N, A)

DEM T2.14. La terminarea executiei ciclului WHILE se construieste multimea nodurilor N′.
N′ contine toate nodurile accesibile printr-un lant cu extremitatea lantului in nodul s.
Multimea N′ genereaza o componenta conexa G′ = (N′, A′).
La terminarea algoritmului W = N rezulta ca sunt determinate toate componentele conexe ale grafului G = (N, A).

-graful este conex daca exista o singura componenta conexa tot graful intrand in compunearea componentei conexe
-se aplica grafurilor neorientate deoarece nu este important sensul arcelor

T2.15 (T2.2). Complexitate: O(m), aceeasi ca PTDF.

DEM T2.15 (T2.2). Fiecare nod al digrafului G este introdus si eliminat din V cel mult o data.
Executia algoritmului se temina cand V = Ø deci algoritmul executa cel mult 2×n iteratii.
Fiecare arc (x,y) ∈ A este explorat cel mult o data pentru identificarea areclor admisibile.
Rezulta deci ca algoritmul are complexitatea O(m+n) deci O(m).

-ESTE EXEMPLU LA P/40

2.4.3 Componentele tare conexe

PROGRAM CTC;

PROCEDURA PTDF(G):
U = N − {s} U = multimea nodurilor nevizitate devine multimea nodurilor fara nodul de start
V = {s} V = multimea nodurilor vizitate si neanalizate se initializeaza cu nodul de start
W = Ø W = multimea nodurilor vizitate si analizate se initializeaza cu multimea vida

FOR toti y ∈ N DO pentru toate nodurile ‘y’ din multimea de noduri ‘N’,
p(y) = 0 predecesorul va fi 0
END

t = 1 contor pentru timp

t1(s) = 1 pentru nodul de start ‘s’ se noteaza in tabloul ‘timp’ t1 = 1, timpul la care a fost vizitat si neanalizat
t2(s) = ∞ pentru nodul de start ‘s’ se noteaza in tabloul ‘timp’ t2 = infinit, timpul la care va fi vizitat si analizat

FOR toti y ∈ U DO toate nodurile ‘y’ nevizitate se initializeaza in tablourile ‘timp’ cu infinit
t1(y) = ∞
t2(y) = ∞
END
cat timp nu am parcurs intreaga lista de noduri ‘N’
WHILE W ≠ N DO
WHILE V ≠ Ø DO cat timp nu am analizat toate nodurile din ‘V’
se selecteaza cel mai nou nod x din V se ia cate un nod din stiva
IF exista arc(x, y) ∈ A si y ∈ U THEN daca exista arc intre ‘x’ si ‘y’ si ‘y’ este un nod nevizitat atunci
U = U − {y} se scoate ‘y’ din multimea nodurilor nevizitate
V = V ∪ {y} se adauga ‘y’ in stiva
p(y) = x predecesorul lui ‘y’ devine ‘x’
t = t + 1 se actualizeaza timpul
t1(y) = t t1(y) = momentul in care ‘y’ devine nod vizitat si neanalizat
ELSE
din multimea nodurilor vizitate si neanalizate se scoate ‘x’
V = V – {x}
W = W ∪ {x} se adauga ‘x’ in multimea de noduri vizitate si analizate ‘W’
t = t + 1 se actualizeaza timpul
t2(x) = t t2(x) = momentul in care ‘x’ devine nod vizitat si analizat
END
END
este selectat un nou nod de start ‘s’
se selecteaza s ∈ U
U = U – {s} nodul de start ‘s’ este scos din multimea nodurilor nevizitate
V = {s} in capul stivei ‘V’ este pus noul nod de start ‘s’
t = t + 1 se actualizeaza timpul
t1(s) = t t1(s) = momentul in care nodul de start ‘s’ devine vizitat si neanalizat
END
END
PROCEDURA INVERSARE(G) determina inversul grafului initial unde arcele vor fi inversate
PROCEDURA PTDF(G-1) se aplica PTDF pe graful inversat astfel incat t2(s) > t2(x), x ∈ U-1 – {s}
PROCEDURA SEPARARE(G-1) separa componentele conexe
END.

T2.17. Determina componentele tare conexe ale unui graf G = (N, A)

DEM T2.17. Toate nodurile din aceeasi componenta tare conexa apartin la aceeasi arborescenta a padurii parcurgere DF (in adancime).
Pentru orice nod x ∈ N, ascendentul radacina r(x) este un ascendent al lui x in padurea parcurgere DF (in adancime).
Nodurile x, r(x) se gasesc in aceeasi componenta tare conexa.

-graful este conex daca exista o singura componenta conexa tot graful intrand in compunearea componentei conexe
-se aplica numai grafurilor orientate

T2.18. Complexitate: O(m), acceasi cu parcurgerea totala in adancime (PTDF)

DEM T2.18 (T2.2). Fiecare nod al digrafului G este introdus si eliminat din V cel mult o data.
Executia algoritmului se temina cand V = Ø deci algoritmul executa cel mult 2×n iteratii.
Fiecare arc (x,y) ∈ A este explorat cel mult o data pentru identificarea areclor admisibile.
Rezulta deci ca algoritmul are complexitatea O(m+n) deci O(m).

-ESTE EXEMPLU LA P/42

3.2.2 Algoritmul generic

PROGRAM GENERIC;

FOR i = 1 TO n DO se vor parcurge toate nodurile arborelui

Ni = {i} se construieste un arbore partial plecand de la fiecare nod al arborelui in parte
A′i = Ø Ai′ = multimea muchiilor care compun arborele partial
END

FOR k = 1 TO n - 1 DO facem maxim n – 1 iteratii

se selecteaza Ni cu Ni ≠ Ø se selecteaza oricare set de noduri dintre cele care au fost initializate mai sus, ex. ‘N1‘

se selecteaza [y, y� ] pentru un nod din setul selectat se ia muchia minima care are cealalta extremitate in alt set,
cu b[y, y� ] = min{ [x, x�] | x ∈ Ni, x� ∉ Ni } nodurile deci trebuie sa faca parte din seturi diferite;

se determina indicele j pentru care y� ∈ Nj se determina din care set face parte acea extremitate

N i = Ni ∪ Nj se reunesc setul selectat cu setul care contine extremitatea;

Nj = Ø setul care contine extremitatea este golit;
A′i = A′i ∪ A′j ∪ { [y, y� ] } multimea de muchii initiale pentru setul selectat se reuneste cu multimea de muchii ale
setului care contine extremitatea si cu acea muchie minima determinata mai sus;

A′j = Ø setul care contine muchiile legate de extremitate este golit

IF k = n – 1 THEN daca am ajuns la n – 1 iteratii, ‘Ni‘ = ‘N’ adica multimea tuturor nodurilor din graf;
A′ = A′i cardinalitatea multimii muchiilor ‘ A′i ‘ este egala cu n – 1;
END
END

END.

T3.6. Conditiile de optimalitate ale taieturii:

Fie G = (N, A) un graf neorientat si conex.
Un arbore partial G′ = (N, A′) al grafului G este minim daca si numai daca pentru fiecare muchie arbore a = [x, x�] ∈ A′ avem:
b[x, x�] ≤ b[y, y� ] pentru toate muchiile [y, y� ] ∈ b[X, �
X]a

T3.7. Conditiile de optimalitate ale lantului:

Fie G = (N, A) un graf neorientat si conex.
�′ avem:
Un arbore partial G′ = (N, A′) al grafului G este minim daca si numai daca pentru fiecare muchie non-arbore [y, y� ] ∈ A
b[x, x�] ≤ b[y, y� ] pentru toate muchiile [x, x�] ∈ Lyy�

T3.8. Determina un arbore partial minim G′ = (N, A′) al grafului G = (N, A)

DEM T3.8. Prin inductie dupa k, numarul de iteratii ale ciclului FOR se arata ca Gi′ = (Ni, Ai′) este continut intr-un arbore partial minim al lui G′.
Pentru k = 0 (inainte de prima iteratie a ciclului) avem Gi′ = ({i}, Ø) si afirmatia de mai sus este adevarata.
Presupunem ca afirmatia este adevarata pentru executia a k – 1 iteratii ale ciclului FOR.
Aceasta inseamna ca Gi′ = (Ni, Ai′) determinat dupa executia a k – 1 iteratii ale ciclului FOR este continut intr-un arbore partial minim G′ = (N, A′) al lui G.
Dupa executia a k iteratii ale ciclului FOR referitor la muchia de cost minim [y, y� ] selectata pot exista cazurile: [y, y� ] ∈ A′ sau [y, y� ] ∉ A′.

OBS 3.3. Complexitate: nu se poate preciza cu exactitate deoarece depinde de modul de selectare a multimii Ni
3.2.3 Algoritmul Prim

PROGRAM PRIM;

v(1) = 0
N1 = Ø se va selecta mereu ‘N1’
A′ = Ø A′ = multimea de muchii care compun arborele partial
� 1 = N - N1
N � 1 = multimea de noduri care compun arborele partial
N

FOR i = 2 TO n DO
v(i) = ∞
END

cat timp nu am parcurs toate nodurile

WHILE N1 ≠ N DO

�1 }
v(y) = min{ v(x�) | x� ∈ N se alege muchia de cost minim legata la nodul selectat

N1 = N1 ∪ {y} se adauga vertexul in multimea nodurilor care compun arborele partial ‘N1’
�1 = N
N � 1 – {y} � 1’
se elimina vertexul din multimea nodurilor nu compun arborele partial ‘N

IF y ≠ 1 daca vertexul selectat este diferit de vertexul de la care am pornit construirea arborelui atunci
THEN A′ = A′ ∪ {e(y)} in multimea muchiilor includem muchia de cost minim determinata mai sus

� 1 ] DO
FOR [y, y� ] ∈ E(y) ∩ [N1, N pentru toate muchiile din lista de incidenta ‘E’ a lui ‘y’, toate nodurile catre care ‘y’ are arc
reunite cu cele care nu au fost vizitate;

IF v(y� ) > b[y, y� ] THEN daca vertexul curent are costul mai mare decat costul muchiei atunci;
v(y� ) = b[y, y� ] se actualizeaza costul muchiei
e(y� ) = [y, y� ] se pune muchia prin care s-a ajuns la nodul nevizitat ‘ y� ’
END
END

END

END.

T3.9 (T3.8). Determina un arbore partial minim G′ = (N, A′) al grafului G = (N, A)
DEM T3.9 (T3.8). Spre deosebire de algoritmul generic:
Este selectat mereu ‘N1’, iar functiile v si e ajuta la selectarea muchiei de cost minim.

Prin inductie dupa k, numarul de iteratii ale ciclului FOR se arata ca Gi′ = (Ni, Ai′) este continut intr-un arbore partial minim al lui G′.
Pentru k = 0 (inainte de prima iteratie a ciclului) avem Gi′ = ({i}, Ø) si afirmatia de mai sus este adevarata.
Presupunem ca afirmatia este adevarata pentru executia a k – 1 iteratii ale ciclului FOR.
Aceasta inseamna ca Gi′ = (Ni, Ai′) determinat dupa executia a k – 1 iteratii ale ciclului FOR este continut intr-un arbore partial minim G′ = (N, A′) al lui G.
Dupa executia a k iteratii ale ciclului FOR referitor la muchia de cost minim [y, y� ] selectata pot exista cazurile: [y, y� ] ∈ A′ sau [y, y� ] ∉ A′.

-‘v’ reprezinta tabloul vertex, contine nodurile catre care avem muchie pornind de la nodul selectat si au atasate un cost
-‘e’ reprezinta tabloul edges, contine muchiile care pleaca din nodul selectat si au atasate un cost

T3.10. Complexitate: O(n2)

DEM T3.10. Ciclul WHILE se executa de n ori.
� 1| si 1 ≤ n� 1 ≤ n.
In fiecare iteratie se executa n� 1 comparatii cu n� 1 = | N
Ciclul FOR se executa de cel mult n – 1 ori. Rezulta ca algoritmul are complexitatea O(n2).

-ESTE EXEMPLU LA P/52

3.2.4 Algoritmul Kruskal

PROGRAM KRUSKAL;

PROCEDURA SORTARE(G):
se sorteaza muchiile din A astfel incat se ordoneaza toate muchiile in functie de valoare (cost)
A = { a1, .., am } cu b(a1) ≤ .. ≤ b(am)
END;

A′ = Ø se initializeaza multimea muchiilor care compun arborele partial ‘A′’ cu multimea vida

FOR i = 1 TO m DO m = numarul de muchii

IF ai nu formeaza ciclu cu A′ daca muchia arbore ‘ai’ nu formeaza ciclu atunci
THEN A′ = A′ ∪ {ai} se adauga muchia arbore ‘ai’ in multimea muchiilor care compun arborele partial ‘A′’
END
END

END.

T3.11 (T3.8). Determina un arbore partial minim G′ = (N, A′) al grafului G = (N, A)
DEM T3.11 (T3.8). Spre deosebire de algoritmul generic:
Se foloseste procedura SORTARE si conditia de a nu forma un ciclu.

Prin inductie dupa k, numarul de iteratii ale ciclului FOR se arata ca Gi′ = (Ni, Ai′) este continut intr-un arbore partial minim al lui G′.
Pentru k = 0 (inainte de prima iteratie a ciclului) avem Gi′ = ({i}, Ø) si afirmatia de mai sus este adevarata.
Presupunem ca afirmatia este adevarata pentru executia a k – 1 iteratii ale ciclului FOR.
Aceasta inseamna ca Gi′ = (Ni, Ai′) determinat dupa executia a k – 1 iteratii ale ciclului FOR este continut intr-un arbore partial minim G′ = (N, A′) al lui G.
Dupa executia a k iteratii ale ciclului FOR referitor la muchia de cost minim [y, y� ] selectata pot exista cazurile: [y, y� ] ∈ A′ sau [y, y� ] ∉ A′.

OBS 3.4. Complexitate: depinde in functie de implementarea procedurii SORTARE si a implementarii testarii formarii ciclui si deci poate fi O(max(m×log(n),n2)), O(m×log(n)), etc.

-ESTE EXEMPLU LA P/53

3.2.5 Algoritmul Boruvka

PROGRAM BORUVKA;

FOR i = 1 TO n DO se vor parcurge toate nodurile arborelui

Ni = {i} se construieste un arbore partial plecand de la fiecare nod al arborelui in parte
END

A′ = Ø A′ = multimea muchiilor care compun arborele partial

‘M’ contine toate seturile de noduri, un set pentru fiecare nod (de la initializare)
M = { N1, N2, .., Nn }
trebuie sa gasim maxim n – 1 muchii, altfel arborele nu ar mai fi partial
WHILE |A′| < n – 1 DO

se selecteaza pe rand fiecare set de noduri ‘Ni’ dintre cele care au fost initializate mai sus din ‘M’
FOR Ni ∈ M DO

se selecteaza [y, y� ] pentru un nod din setul ‘Ni’ se ia muchia minima care are cealalta extremitate in alt set,
cu b[y, y� ] = min{ [x, x�] | x ∈ Ni, x� ∉ Ni } nodurile deci trebuie sa faca parte din seturi diferite;

se determina indicele j pentru care y� ∈ Nj se determina setul din care face parte acea extremitate;
A′ = A′ ∪ { [y, y� ] } se reunesc multimea muchiilor care compun arborele partial ‘A′’
cu muchia de cost minim gasita [y, y� ];
END

FOR Ni ∈ M DO aici se lucreaza cu seturile ‘Nj’ obtinute in FOR-ul de mai sus;

Ni = Ni ∪ Nj se reunesc setul care contine nodul selectat ‘Ni’ si setul care contine
extremitatea catre care are cel mai mic cost ‘Nj’

N j = Ni seturile ‘Nj’ primesc aceleasi valori ca seturile ‘Ni’

END

M := {.., Ni, .., Nj, ..| Ni ∩ Nj = ∅, ∪ Ni = N } pentru fiecare set se determina o multime unica intersectand multimile care au noduri comune si
se alege un set reprezentat daca este cazul;

END
END.

T3.12 (T3.8). Determina un arbore partial minim G′ = (N, A′) al grafului G = (N, A)
DEM T3.12 (T3.8). Spre deosebire de algoritmul generic:
Ipoteza ca functia valoare ‘b’ contine doar valori diferite pentru costul muchiilor asigura ca nu se creeaza cicluri in timpul executiei instructiunii WHILE.

Prin inductie dupa k, numarul de iteratii ale ciclului FOR se arata ca Gi′ = (Ni, Ai′) este continut intr-un arbore partial minim al lui G′.
Pentru k = 0 (inainte de prima iteratie a ciclului) avem Gi′ = ({i}, Ø) si afirmatia de mai sus este adevarata.
Presupunem ca afirmatia este adevarata pentru executia a k – 1 iteratii ale ciclului FOR.
Aceasta inseamna ca Gi′ = (Ni, Ai′) determinat dupa executia a k – 1 iteratii ale ciclului FOR este continut intr-un arbore partial minim G′ = (N, A′) al lui G.
Dupa executia a k iteratii ale ciclului FOR referitor la muchia de cost minim [y, y� ] selectata pot exista cazurile: [y, y� ] ∈ A′ sau [y, y� ] ∉ A′.

T3.13. Complexitate: O(m×log(n))

DEM T3.13. Deoarece numarul componentelor Ni ∈ M conexe este injumatatit la fiecare iteratie, ciclul WHILE este executat de cel mult log(n) ori.
Operatiile de selectare a muchiei de cost minim si determinarea setului care contine extremitatea muchiei de cost minim au complexitatea O(m).
Rezulta ca algoritmul are complexitatea O(m×log(n)).

-ESTE EXEMPLU LA P/54

4.3.1 Dijkstra

PROGRAM DIJKSTRA;

W = N W = multimea nodurilor vizitate si analizate se initializeaza cu multimea tuturor nodurilor ‘N’

d(s) = 0 tabloul ‘distance’ = retine distanta catre

p(s) = 0 tabloul ‘predecesor’ = va ajuta la reconstruirea drumului minim

FOR toti y ∈ N – {s} DO pentru toate nodurile ‘y’ fara nodul de start ‘s’;
d(y) = ∞ distanta catre toate nodurile ‘y’ este infinita
p(y) = 0 predecesorii tuturor nodurilor ‘y’ sunt 0 (nu se poate ajunge la ei)
END

WHILE W ≠ Ø DO cat timp multimea nodurilor vizitate

se selecteaza un nod x din W folosind coada de prioritati se ia vecinul cel mai apropiat de ‘x’ ca distanta
astfel incat d(x) sa fie minima
W = W – {x} nodul ‘x’ este scos din coada dupa ce a fost analizat

FOR y ∈ W ∩ V+(x) DO ‘y’ este in coada si face parte din vecinii lui ‘x’ (‘x’ are arc spre ‘y’)
IF d(x) + b(x,y) < d(y) THEN daca valoarea distantei + costul catre ‘y’ prin ‘x’ este mai mica decat valoarea directa catre ‘y’ atunci;

d(y) = d(x) + b(x,y) se actualizeaza distanta luand in calcul drumul prin ‘x’
p(y) = x parintele lui ‘y’ devine ‘x’
END
END

END

END.

T4.3. Determina distantele si drumurile minime catre toate nodurile ‘y’ in raport cu nodul sursa ‘s’
DEM T4.3. In algoritm, valoarea d(y) este calculata si reprezinta valoarea unui drum de la nodul de start s la nodul destinatie y din reteaua G.
Calculand aceasta valoare rezulta relatia d(s,y) ≤ d(y) pentru fiecare nod y ∈ N, dar trebuie sa aratam ca rezulta si relatia d(s,y) = d(y) pentru fiecare y ∈ N.
Prin inductie dupa ordinea in care nodurile sunt eliminate din W se demonstreaza ca d(y) ≤ d(s,y) pentru fiecare y ∈ N si se arata a doua relatie rezultata.
Primul nod eliminat este s si deci d(s) = 0 = d(s,s). Presupunem ca d(y) ≤ d(s,y) pentru toate nodurile y eliminate din W inaintea nodului z.
Fie Dszp = (x0, x1, .., xk-1, xk) un drum minim de la x0 = s si xk = z. Pentru h = 1, 2, .., k avem d(s, xh) = suma tuturor distantelor intre s si h incluzand toate nodurile intermediare:
h
d(s, xh ) = �i=1 b(xi−1, xi ).
Fie j indicele maxim pentru care xj a fost eliminat din W inaintea lui z. Deoarece xj+1 este inca in W (xj+1 ∈ W) si xj+1 face parte din vecinii catre care xj are arc (xj+1 ∈ V+( xj ) ),
rezulta ca dupa eliminarea lui xj avem: d(xj+1) ≤ d(xj) + b(xj, xj+1). Inegalitatea se pastreaza si daca este eliminat nodul z (nodul z este dupa xj), deoarece d(xj) ramane
nemodificata pentru ca xj nu mai este in W si d(xj+1) poate doar sa descreasca. De asemenea din ipoteza inductiei avem d(xj) = d(s, xj) si rezulta ultima inegalitate:
d(xj+1) ≤ d(xj) + b(xj, xj+1) ≤ d (s, z)
d(xj+1) ≤ d(s, xj) + b(xj, xj+1) ≤ d (s, z)
d(xj+1) ≤ d(s, xj+1) ≤ d (s, z)
Daca j = k – 1 atunci xj+1 = xk-1+1 = xk = z. Din ultima inegalitate rezulta ca d(z) ≤ d (s, z).
Daca j < k – 1 atunci xj+1 ≠ xk = z. Daca d(s, z) < d(z) din ultima inegalitate rezulta ca d(xj+1) < d(z). Din algoritm se poate deduce ca xj+1 este eliminat inaintea lui z din W insa
acestu lucru contrazice modul de alegere al indicelui j, astfel ca si in acest caz avem d(z) ≤ d (s, z).
Am demonstrat ca d(y) = d(s,y) pentru fiecare y ∈ N si y ≠ s.

Orice drum minim Dsyp de la s la y se determina cu tabloul predecesor.

-‘W’ este o coada de prioritati
-conduce la rezultate eronate daca avem arce de cost negativ

T4.4. Complexitate: O(n2)

DEM T4.4. Pentru selectarea nodului x ∈ W astfel incat d(x) sa fie minima sunt necesare cel mult n – 1 comparatii.
Ciclul FOR se executa de cel mult n – 1 ori. Ciclul WHILE se executa de n ori. Deci algoritmul are complexitatea O(n2).

-ESTE EXEMPLU LA P/63 [DONE]

4.3.2 Bellman-Ford

PROGRAM BELLMAN-FORD;

d(s) = 0 tabloul ‘distance’ = retine distanta catre

p(s) = 0 tabloul ‘predecesor’ = va ajuta la reconstruirea drumului minim

FOR toti y ∈ N – {s} DO pentru toate nodurile ‘y’ fara nodul de start ‘s’;
d(y) = ∞ distanta catre toate nodurile ‘y’ este infinita
p(y) = 0 predecesorii tuturor nodurilor ‘y’ sunt 0 (nu se poate ajunge la ei)
END

REPEAT repeta pentru toate nodurile ‘y’ din multimea de noduri ‘N’

FOR y ∈ N DO pentru toti ‘y’ din multimea nodurilor

d′(y) = d(y) distanta′ catre ‘y’ este distanta calculata la fiecare pas printr-un nod ‘x’
END
pentru toti ‘y’ din multimea nodurilor
FOR y ∈ N DO

IF V-(y) ≠ Ø THEN daca exista noduri care intra in ‘y’

se selecteaza ‘x’ care are arc catre ‘y’ si pentru care distanta′ prin ‘x’ catre ‘y’ este minima
se selecteaza x ∈ V-(y) aî
d′(x) + b(x,y) sa fie minima

IF d′(x) + b(x,y) < d′(y) THEN daca valoarea distantei′ + costul catre ‘y’ prin ‘x’ este mai mica decat valoarea directa catre ‘y’ atunci;
d(y) = d′(x) + b(x,y) se actualizeaza distanta luand in calcul drumul prin ‘x’
p(y) = x parintele lui ‘y’ devine ‘x’
END

END
END

UNTIL d(y) = d′(y) pentru toate nodurile y ∈ N pana cand distantele nu se mai actualizeaza

END.

T4.5. Determina distantele si drumurile minime catre toate nodurile ‘y’ in raport cu nodul sursa ‘s’ iar graful G nu contine circuite negative, dar poate contine arce negative
o o
DEM T4.5. Daca G nu contine circuite negative (D cu valoarea b(D ) < 0) atunci un drum minim de la s la y poate sa contina cel mult n – 1 arce.
Conditia de iesire din ciclul REPEAT este satisfacuta dupa cel mult n iteratii si d(y) = d(s, y) pentru toti y ∈ N si y ≠ s.
Un drum minim Dsyp de la s la y se determina cu tabloul predecesor.

-daca un drum minim contine mai mult decat n – 1 arce indica prezenta unui nod care se repeta, adica prezenta unui circuit
-deoarece graful nu poate contine circuite negative, se pot scoate arcele aditionale pentru a ajunge la drumul minim cautat
-de aceea algoritmul cicleaza de doar n – 1 ori

T4.6. Complexitate: O(m×n)

DEM T4.6. Ciclul REPEAT se executa de cel mult n ori. O iteratie a ciclului REPEAT are complexitatea O(m).
Deci algortimul are complexitatea O(m×n).

-ESTE EXEMPLU LA P/66

4.3.3 Floyd-Warshall

PROGRAM FLOYD-WARSHALL;

FOR i = 1 TO n DO se initializeaza matricea ‘distanta’

FOR j = 1 TO n DO se initializeaza matricea ‘predecesor’
dij = bij se iau valorile arcelor din graful initial si se folosesc ca distanta implicita;
ignoram diagonala principala;
IF i ≠ j AND dij < ∞ THEN
initial parintele unui nod va fi exact el insusi
pij = i
ELSE
pij = 0 sunt ignorate nodurile la care nu se poate ajunge;
END
END
END

FOR k = 1 TO n DO se calculeaza pentru fiecare nod daca exista un drum mai scurt trecand printr-un alt nod
FOR i = 1 TO n DO
FOR j = 1 TO n DO
IF dik + dkj < dij THEN daca distanta printr-un nod intermediar este mai mica atunci;
dij = dik + dkj se actualizeaza distanta prin nodurile de la indicii [i, k] si [k, j]
pij = pkj se actualizeaza predecesorul trecand prin nodul de la indicii [k, j]
END
END
END
END

END.

T4.7. Determina matricea distantelor ‘D’ si matricea predecesor ‘P’ ale tuturor nodurilor, iar graful G nu contine circuite negative, dar poate contine arce negative
DEM T4.7. Fie B matricea valoare adiacenta care contine informatii legate de graful initial (noduri si arce).
Fie D0, P0 matricile distanta si predecesor initiale si Dk, Pk matricile calculate la iteratia k.
Prin inductie dupa k, aratam ca Dk = (dkij ) este matricea distantelor minime intre i si j cu nodurile interioare din {1, 2, .. k}.
Pentru k = 0, avem afirmatia D0 = B care este adevarata.
Presupunem afirmatia adevarata pentru k – 1.
La iteratia k se determina dkij = min{ dk−1 k−1 k−1
ij , dik , dkj } adica se determina daca exista o distanta mai mica intre i si j trecand prin nodul k.
Din presupunerea inductiva si principiul optimalitatii lui Bellman rezulta ca Dk = (dkij ) este matricea distantelor minime intre i si j cu nodurile interioare din {1, 2, .. k}.
o o
Deoarece G nu contine circuite cu valoarea negativa (D cu valoarea b(D ) < 0) rezulta ca Dn este matricea distantelor.
Din modul in care se determina pij rezulta ca Pn este matricea predecesorilor cu care se poate reconstrui drumurile minime Dijp.

T4.8. Complexitate: O(n3)

DEM T4.8. Fiecare dintre ciclurile FOR se executa de n ori. Deci complexitatea algoritmului este O(n3).

-ESTE EXEMPLU LA P/68 [DONE]

4.3.3 Drum minim

PROGRAM DRUM(D,i,j):

k = n
xk = j

WHILE xk ≠ i DO
xk-1 = pixk
k = k – 1
END

END.

-determina un drum minim de la nodul ‘i’ la nodul ‘j’

-ESTE EXEMPLU LA P/69

5.4.1 Flux maxim generic

PROGRAM FLUX MAXIM GENERIC;

f = f0 se identifica fluxul initial f0;

se construieste reteaua reziduala G � (f) se sare peste aceasta etapa daca ni se specifica reteaua reziduala;
WHILE G� (f) contine un drum de marire a fluxului
se identifica un drum de marire a fluxului D �; se cauta un DMF in graful initial,
dar valorile arcelor le luam din graful obtinut la fiecare iteratie;
� ) = min{ r(x,y) | (x,y) ∈ D
r(D � }; � ) = capacitatea reziduala;
r(D
se executa marirea de flux prin se executa marirea de flux mai intai pe graful initial,
scaderea r(D� ) din capacitatea reziduala a arcelor directe apoi pe graful obtinut la fiecare iteratie;
adunarea r(D� ) la capacitatea reziduala a arcelor inverse;
se actualizeaza G � (f);
END

END.

-
5.4.1 Flux de cost minim

PROGRAM CIRCLE CANCELLING;

f = f0 se identifica reteaua initiala

v(f) = v(f0) = v
� (f)
se construieste reteaua reziduala G

o � (f) DO
WHILE ∃ C de cost negativ in G
o � (f);
determina C de cost negativ in G
r(Co) = min{ r(x,y) | (x,y) ∈ Co }; o
se cauta un circuit care are b(C ) < 0 in functie de b(toate arcele care il compun)
o
se mareste fluxul f pe circuitul C cu r prin se calculeaza capacitatea reziduala
scaderea r(D� ) din capacitatea reziduala a arcelor directe
adunarea r(D� ) la capacitatea reziduala a arcelor inverse;
se actualizeaza G � (f);
END

END.