You are on page 1of 129

Mihai TALMACIU

Algoritmica grafurilor

Editura ALMA MATER

Conf. univ. dr. MIHAI TALMACIU

Recenzori:
Prof. univ. dr. habilitat Dumitru Todoroi
Conf. univ. dr. Elena Nechita
Prof. univ. dr. Victor Blnu

Descrierea CIP a Bibliotecii Naionale a Romniei


Talmaciu, Mihai
Algoritmica grafurilor, Mihai Talmaciu Bacu
ALMA MATER, 2008
Bibliogr.
ISBN

978 973 1833 76 7

I, Talmaciu M.
Tehnoredactare computerizat: prep. univ. IOANA ALEXANDRA PANDELE
asist. univ. drd. ALINA-MIHAELA PATRICIU

ISBN

978 973 1833 76 7

CUPRINS

Capitolul 1 Introducere
1.1. Definiia unui graf
1. 2. Grade
1.3.
Subgrafuri
1.4.
Operaii cu grafuri
1.5.
Clase de grafuri
1.6.
Drumuri i circuite
1.7.
Mulimi separatoare, transversale i mulimi omogene
1.8.
Algoritmi i complexitate de calcul

1
1
3
3
3
4
5
6
7

Capitolul 2 Metode de cutare i programare


2.1.
Cutarea n lime
2.1.1. Algoritmul
2.1.2. Implementarea C++
2.1.3. Complexitate i optimalitate
2.1.4 Aplicaii ale BFS
2.2.
Cutarea n adncime
2.3.
Metoda Greedy
2.4.
Metoda backtracking
2.5.
Metoda divide et impera
2.6.
Metoda branch and bound

9
9
9
9
10
11
11
13
14
16
17

Capitolul 3 Structuri de date


3.1.
Liste
3.1.1. Liste simplu nlnuite
3.1.2. Parcurgerea unei liste simplu nlnuite
3.1.3. Liste dublu nlnuite
3.1.4. Parcurgerea unei liste dublu nlnuite
3.2.
Arbori
3.2.1. Arbori liberi
3.2.2. Arbori cu rdcin
3.2.3. Arbori binari
3.2.4. Parcurgerea arborilor binari

21
21
21
22
22
23
24
24
24
25
25

Capitolul 4 Parcurgeri de grafuri


4.1. Parcurgerea BF a grafurilor
4.2. Parcurgerea DF a grafurilor
4.3.
Aplicaii
4.3.1. Sortarea topologic
4.3.2. Componentele conexe ale unui graf

29
29
35
38
38
39

Capitolul 5 Probleme de drum n (di)grafuri


5.1.
Problema celui mai scurt drum
5.1.1. Arborele Steiner
5.1.2. Algoritmul lui Dijkstra
5.1.3. Probleme similare i algoritmi
5.1.4. Probleme legate de drum
5.1.5. Algoritmul Bellman-Ford

43
43
45
46
49
50
50
54

5.1.6.
5.1.7.
5.1.8.
5.2.
5.3.
5.4.
5.5.
5.6.
5.7.
5.8.

Algoritmul de cutare A
Algoritmul Floyd-Warshall
Algoritmul lui Johnson
Probleme de conexiune. Teorema lui Menger i aplicaii
Structura grafurilor p-conexe
Problema drumului Hamiltonian
Problema ciclului Hamiltonian
Arborele parial de cost minim
Algoritmul lui Prim
Algoritmul lui Kruskal

57
60
61
62
63
64
69
71
77

Capitolul 6 Probleme de fluxuri n reele


6.1.
Problema fluxului maxim
6.2.
Fluxuri de cost minim
6.3.
Algoritmul Ford-Fulkerson

83
83
89
92

Capitolul 7 Numrul de stabilitate i densitatea unui graf


7.1.
Mulimi stabile i clici
7.2.
Problema mulimii independente
7.3.
Problema clicii
7.4.
Determinarea mulimilor stabile maximale

95
95
96
98
100

Capitolul 8 Probleme de descompuneri n grafuri


8.1.
Tipuri de descompuneri n grafuri
8.1.1. Descompunerea de tip 2
8.1.2. Descompunerea de tip 3
8.1.3. Descompunerea n funcie de compoziie
8.1.4. G-descompunerea
8.1.5. Descompunerea substituie i partiionarea vrfurilor
8.2.
Descompunerea slab a grafurilor
8.2.1. Introducere
8.2.2. Descompunerea slab a unui graf
8.3. Teorema celor patru culori
8.3.1. Colorarea grafurilor
8.3.2. Colorarea vrfurilor
8.3.3. Numrul cromatic
8.3.4. Aspecte algoritmice
8.3.5. Algoritmul Welsh Powell
8.3.6. Polinomul cromatic

103
103
103
104
105
106
107
111
111
111
115
117
117
118
118
119
119

Bibliografie

121

Capitolul 1
INTRODUCERE

Pentru noiunile din acest paragraf am consultat Behzad, Chartrand,


Foster, Croitoru, Olaru, Tomescu. Alte completri bibliografice sunt
precizate n momentul utilizrii.

1.1.

Definiia unui graf

Un graf este o pereche G = (V,E), unde V este o mulime finit


nevid, iar E este o mulime de submulimi cu dou elemente distincte ale lui
V. V se numete mulimea vrfurilor i numrul su de elemente, |V| este
ordinul grafului G. E este mulimea muchiilor grafului G i |E| este
dimensiunea grafului G. Cnd facem referire la mulimea de vrfuri i
muchii ale grafului G folosim V(G) i E(G), respectiv.
Un digraf (graf orientat) este o pereche D = (V(D), A(D)) unde
V(D) este o mulime finit nevid (mulimea vrfurilor digrafului D), iar
A(D) V(D) V(D) este mulimea arcelor digrafului D.
Dac e = {x,y} este o muchie a grafului G, vom nota, pe scurt,
{x,y} = xy (yx) i vom spune c: muchia e este incident cu vrfuri1e x i y;
vrfurile x i y sunt adiacente n G; vrfurile x i y sunt vecine n G; vrfurile
x i y sunt extremitile muchiei e.
Dac v V(G) , atunci mulimea
NG (v) = {w | w V(G) {v}, vw E(G)} ,

se numete vecintatea vrfului v n G.


NG (v) = {w | w V(G) {v}, vw E(G)}
se numete mulimea nevecinilor vrfului v n G.
Dac A, B V(G), A B = 0/ atunci :
A ~ B (A este total adiacent cu B) dac i numai dac:
a A, b B : ab E(G) ;
A ~/ B (A este total neadiacent cu B) dac i numai dac:
a A, b B : ab E(G) ;
A ~ p B (A este parial adiacent cu B) dac i numai dac:
a A, b B : ab E(G) ;
a ~ B (vrful a este B universal, adic a vede toate vrfurile din B)
dac i numai dac {a} ~ B .
a ~/ B (vrful a este B nul) dac i numai dac {a} ~/ B .

Dac S V(G) atunci:


S este mulime stabil (sau independent) a lui G dac i numai dac
x, y V(G), x y : xy E(G) .
O stabil S este maximal dac nici o stabil a lui G nu conine
propriu S;
S(G) = {S | S este stabil maximal n G} ;
(G) = max{S | S S(G)} este numrul de stabilitate a lui G.
S (G) = {S | S S(G),| S | = (G)} ;
S este o mulime - stabil dac i numai dac S S (G) .
Complementarul, G , al unui graf G este graful a crui mulime de
vrfuri este V(G), iar dou vrfuri sunt adiacente n G dac i numai dac
ele nu sunt adiacente n G.
Dac Q V(G) atunci:
Q este clic (su mulime complet) a lui G dac i numai dac Q este
mulime stabil n G ; o clic Q este maximal dac nici o clic a lui G nu
conine propriu Q;
C(G) = {Q | Q este clic maximal n G}; ,
(G) = max{|Q| | Q C(G) } este numrul clic a lui G;
C (G) ={Q | Q C(G) i |Q| = (G)}; Q este o - clic dac i

numai dac Q C (G) .


Dac p N , se numete p colorare a vrfurilor lui G o aplicaie
c : V(G) {1,..., p}
cu proprietatea c c1 (i) este o mulime stabil n G.
(G) este numrul cromatic a lui G, adic cel mai mic numr de
culori necesare pentru a colora vrfurile de felul c dou vrfuri adiacente
distincte nu pot fi de aceeai culoare.
(G) = (G) este numrul de acoperire cu clici a lui G.
Dou grafuri, G = (V(G),E(G)) i H = (V(H),E(H)) se numesc
izomorfe, i notm aceasta prin G H (sau G H ) dac exist o bijecie
: V(G) V(H)
cu proprietatea c aplicaia
: E(G) E(H) ,
definit pentru orice uv E(G) prin
(uv) = (u)(v)
este o bijecie.

1. 2. Grade
Gradul unui vrf v dintr-un graf G este numrul de muchii ale lui G
incidente cu v, care se noteaz cu d G (v) . Un vrf de grad zero se numete
izolat. Un vrf de grad unu se numete pendant .

1.3.

Subgrafuri

Fie G un graf. Un graf H este un subgraf al lui G dac V(H) V(G) i


E(H) E(G). Dac A este o submulime nevid a lui V(G) atunci subgraful
lui G indus de A este graful avnd mulimea vrfurilor A, iar mulimea
muchiilor const din acele muchii ale lui G incidente cu dou elemente din
A. Dac A V(G), v V, U E(G),e E(G) atunci notm: G A sau G(A) sau
[A]G sau [A] subgraful lui G indus de A; G A = G(V(G) A);
G v = G {v} ; G U = (V(G),E(G) U); G e = G {e}.

1.4.

Operaii cu grafuri

Pe parcursul acestei cri vom folosi unele operaii cu grafuri, pe care


le reamintim mai jos.
1)
Dac G1 i G 2 sunt dou grafuri cu V( G1 ) V( G 2 ) = 0/ atunci
reuniunea disjunct a grafurilor G1 i G 2 nseamn graful G = G1 G 2 cu
V(G) = V( G1 ) V( G 2 ) i E(G) = E( G1 ) E( G 2 ).

2)
Se numete graf adiacen (X - adiacen) (Sabidussi, Olaru, Antohe)
a unei familii de grafuri (G x ) xV(X) , indexat de mulimea de vrfuri a
grafului X, graful notat U X
xX G x , unde:

(
)
E (UX
xX G x ) = U xV(X) E(G x )
V UX
xX G x = U xX V(X) {x};

{[(a, x), (b, x ')] | x x ',[x, x '] E(X), a V(G x ), b V(G x ' )}.

3)

Produsul lexicografic (compoziia) (Harary) a dou grafuri G1 i G 2


este graful notat G = G1 [ G 2 ], unde V(G) = V( G1 ) V( G 2 ) i dou vrfuri

(u1 , u 2 ) i (v1 , v 2 ) ale lui G sunt adiacente dac i numai dac


u1v1 E(G1 ) sau ( u1 = v1 i u 2 v2 E(G 2 ) ).
4)
Suma a dou grafuri. Dac luam X = K 2 , K 2 - adiacena grafurilor
oarecare G1 i G 2 se mai numete suma celor dou grafuri i se noteaz cu
G1 + G 2 .

1.5.

Clase de grafuri

Se numete graf complet de ordin n, graful notat, K n , unde


| V(K n ) | = n i E(K n ) = P2 (V(K n )) , iar P2 (X) este mulimea prilor cu
dou elemente ale lui X.
Se numete graf nul de ordin n, graful N n = K n .
Se numete ciclu de lungime n ( n 3 ) graful notat, Cn , unde
V(Cn ) = {1, 2,..., n} i E(Cn ) = {12, 23,..., n 1n, n1} . Deoarece vrfurile sunt

distincte, ciclul este elementar. Peste tot n carte vom folosi ciclu elementar.
De asemenea l vom numi i circuit
Se numete lan de ordin n, graful Pn = Cn e (e E(Cn )) . l vom
numi i drum. Dac a = i, b = i + l, pentru orice i = l, ..., n l i e = ab atunci
spunem c avem un a b drum (sau ab drum).
Un circuit (drum) al unui graf G este un subgraf indus al lui G care
este el nsui circuit (drum) n G. (Observm c un circuit (drum) al unui graf
nu are corzi. O coard ntr-un circuit (drum) al unui graf este o muchie cu
extremitile vrfuri neconsecutive pe circuit (drum)).
Un graf G = (V,E) se numete n partit, n 1 , dac V se
partiioneaz n n submulimi V1 , V2 ,..., Vn nevide astfel nct
[Vi ]G = (Vi , 0)
/ , i = 1, n (adic, orice muchie din E este incident cu un
vrf din Vi i un vrf din Vj , unde i j ). Pentru n = 2, un astfel de graf se
numete bipartit. Un graf n partit G se numete n partit complet dac
mulimile partiiei V1 , V2 ,..., Vn au proprietatea c pentru orice u din Vi i
orice v din Vj , i j , uv este muchie a lui G. Un graf bipartit complet cu
mulimile partiiei V1 i V2 , unde | V1 | = m i | V2 | = n este notat K(m,n)
( K m,n ). Graful K(l,n) (sau K1,n ) se numete graf stea (star).
Un graf se numete perfect (Berge) dac numrul cromatic i
numrul clic sunt egale pentru orice subgraf indus al su.
Un graf G este minimal imperfect dac i numai dac G nu este
perfect i orice subgraf G v (v din V(G)) este perfect.
O muchie e a lui G se numete critic (Olaru) dac
(G e) = (G) + 1. Notm mulimea muchiilor critice ale lui G prin
E c i numim G c = (V, E c ) scheletul critic a lui G. Dac E c = E, graful
se numete - critic.

Un graf G se numete ( , ) partiionabil (a se vedea Golumbic,


Olaru) dac pentru fiecare v V(G), G v admite o partiie de clici i
o partiie de mulimi stabile.
Un graf G = (V,E) se numete partiionabil ( decompozabil)
(Olaru) dac exist o partiie Z = {V1 ,..., Vm } a lui V, cu m > 1 astfel nct

im=1 (G i ) = (G) , unde G i = G(Vi ), i = 1, m .


Z se numete partiie a lui G, iar G i sunt componente.
Un graf G se numete - partiionabil dac G este partiionabil.
Dac graful G are o partiie astfel nct componentele sunt
clici atunci G este perfect partiionabil ( decompozabil).
G este partiionabil dac este partiionabil i partiionabil.
Un graf G se numete tare stabil (Olaru, Antohe) dac
(G Q) = (G) ,
pentru orice clic proprie Q a lui G.
Un graf G se numete tare stabil (Olaru) dac i numai dac
v V(G) i orice clic Q a lui G, (G v) = (G) = (G Q) .
Cografurile sau grafurile P4 libere (sau P4 free), descoperite de
mai muli autori, printre care Lerchs sunt grafuri care nu conin P4 indus.
Un graf G se numete gem free dac pentru fiecare vrf v, [NG(v)]
este graf P4 free.
Un graf se numete paw dac este izomorf cu
({a,b,c,d},{ab,bc,cd,db}).
Un graf izomorf cu P5 se numete house.
Un graf se numete bull dac este izomorf cu
({a,b,c,d,e},{ab,bc,ca,bd,ce}).
Chvatal a introdus clasa grafurilor ordonabile perfect, care sunt
caracterizate prin existena unei ordini lineare < pe mulimea vrfurilor astfel
nct nici un P4: abcd nu are a < b i d < c.
Fie F o familie de mulimi nevide. Graful intersecie al lui F este
obinut reprezentnd fiecare mulime din F printr-un vrf i dou astfel de
vrfuri determin o muchie dac i numai dac mulimile lor corespunztoare
se intersecteaz.

1.6.

Drumuri i circuite

Fie G un graf si a, b dou vrfuri ale sale. Distana dintre a i b,


notat d(a,b) nseamn minimum lungimilor a b drumurilor din G. Pentru
A V(G) i x V(G) A, distana de la x la A nseamn
d(x, A) = min aA d(x, a) .
5

Un graf este conex dac exist un drum ntre orice dou vrfuri ale
sale. Un graf care nu este conex se numete neconex. Orice graf poate fi
exprimat unic ca o reuniune disjunct de subgrafuri induse conexe i
maximale cu aceast proprietate. Aceste subgrafuri se numesc componente
conexe ale grafului.
Un arbore este un graf conex i fr circuite.

1.7.

Mulimi separatoare, transversale i mulimi omogene

Fie G = (V,E) un graf conex. O submulime S V se numete vrf


separator (a se vedea Golumbic) pentru vrfurile a i b (sau a b - separator)
dac n G S, a i b vor aparine la componente conexe diferite. Dac nici o
submulime proprie a lui S nu este a b separator atunci S este vrf
separator minimal pentru a i b.
Fie G = (V,E) un graf conex. O submulime A V se numete
mulime separatoare (cutset) dac G A este neconex. O mulime
separatoare A se numete minimal dac nici o submulime proprie a sa nu
este mulime separatoare.
Fie G = (V,E) un graf. O mulime nevid T de vrfuri se numete
star cutset (Chvatal) dac G T este neconex i exist un vrf v din T care
este adiacent la toate vrfurile rmase din T. Vrful v se numete centrul lui
T.
Fie M o mulime i F = {Mi }iI o familie de submulimi a lui M i

T M.

Mulimea T este o transversal a lui F dac


T Mi 0,
/ i I .
Transversala T este perfect dac
| T Mi | = 1, i I .
Fie G = (V,E) un graf. Se numete cuplaj (Berge) o mulime F E
astfel nct muchiile din F sunt neadiacente. Un cuplaj se numete perfect
dac orice vrf din V este extremitate a unei muchii din F. Un cuplaj se
numete maximal dac are cardinal maxim ntre toate cuplajele grafului G.
O submulime nevid A, a lui V(G), se numete modul dac
x V(G) A , ori x ~ A ori x ~/ A . Dac A este submulime proprie a lui
V(G) cu cel puin dou elemente, atunci A se numete mulime omogen
(Babel, Olariu, Olaru). Summer numete mulimea A, partitiv.
Fie A o mulime omogen n G. G / A este graful obinut din G,
nlocuind A cu un nou vrf a i conectnd a prin muchii cu toate vrfurile
xV(G) A dac i numai dac x ~ A.

1.8.

Algoritmi i complexitate de calcul

Vom nelege prin problem algoritmic (Croitoru) o funcie total


definit P : I F , unde I este mulimea informaiilor iniiale (intrrilor
problemei), iar F este mulimea informaiilor finale. Vom presupune c I i F
sunt cel mult numrabile. Dac i I este precizat, atunci determinarea lui
P(i) se numete instan a problemei P. Vom folosi pentru o instan notaia
p i prin abuz de notaie vom scrie p P .
Pentru fiecare instan p P se poate asocia un numr natural g(p)
numit dimensiunea problemei.
Un algoritm care rezolv problema P va porni de la o codificare a
unei instane oarecare a problemei P si va oferi o codificare a rezultatului.
Vom nota cu TA (p) timpul necesar algoritmului A pentru rezolvarea
instanei p a problemei P.
Comportarea n cazul cel mai nefavorabil a algoritmului A pe o
intrare de dimensiune n este
TA (n) = sup{TA (p) | p P i g(p) = n} .
Acest tip de analiz a algoritmilor ne asigur c, oricare ar fi o intrare
de dimensiune n, timpul de lucru este mrginit de TA (n) . De aceea, o
abordare natural este s se studieze comportarea n medie a unui algoritm,
care presupune:
precizarea unei distribuii de probabilitate pe mulimea instanelor
pP;
determinarea mediei variabilei aleatoare TA (p) :
TAmed (n) = M({TA (p) | p P i g(p) = n}) .

Fie f : N N . Atunci
O(f ) = {g | g : N N, c R, c > 0, n 0 N : g(n) cf (n), n n 0 } .
Un algoritm A cu proprietatea c TA(n) = O(p(n)), unde p este un
polinom n n se numete polinomial. Un algoritm care nu este polinomial se
numete exponenial. O problema pentru care nu se cunosc algoritmi
polinomiali se numete intractabil.

Capitolul 2
METODE DE CUTARE I PROGRAMARE

2.1.

Cutarea n lime

n teoria grafurilor, breadth-first search (BFS) este un algoritm de


cutare n grafuri, care ncepe cu vrful rdcin i exploreaz toate nodurile
vecine. Apoi, pentru fiecare dintre aceste noduri se exploreaz nodurile
vecine nc necercetate, .a.m.d.., pn cnd scopul a fost atins.
BFS este o metod de cutare, care intete extinderea i examinarea
tuturor nodurilor unui graf, cu scopul de a gsi soluia.
Din punct de vedere al algoritmului, toate nodurile fii obinute prin
expansiunea unui nod sunt adugate ntr-o coad de tipul FIFO (First In
First Out). n implementrile tipice, nodurile care nu au fost nc examinate
de ctre vecinii corespunztori sunt plasate ntr-un recipient (asemntor
unei cozi sau unei liste de legtur), numit deschis, iar odat examinai
sunt plasai n recipientul nchis.

2.1.1. Algoritmul
1. Introducerea nodului rdcin n coad.
2. Extragerea unui nod din captul listei i examinarea acestuia.
Dac elementul cutat se identific cu acest nod, se renun la
cutare i se returneaz rezultatul.
Altfel, se plaseaz toi succesorii (nodurile fii) (neexaminai
nc) acestui nod la sfritul cozii (acesta n cazul n care
exist)
3. Dac coada este goal, fiecare nod al grafului a fost examinat se renun la cutare i se ntoarce la not found.
4. Repet ncepnd cu Pasul 2.

2.1.2. Implementarea C++


n continuare este implementarea algoritmului de mai sus, unde
neexaminaii pn n momentul de fa sunt gestionai de ctre tabloul
printe.
Fie structura struct i structura de noduri
struct Vertex {
...
std::vector<int> out;
...
};

std::vector<Vertex> graph(vertices);
bool BFS(const std::vector<Vertex>& graph, int start, int end) {
std::queue<int> next;
std::vector<int> parent(graph.size(), 0);
parent[start] = -1;
next.push(start);
while (!next.empty()) {
int u = next.front();
next.pop();
if (u == end) return true;
for (std::vector<int>::const_iteratorj=graph[u].out.begin();
j != graph[u].out.end(); ++j)
{
// Look through neighbors.
int v = *j;
if (parent[v] == 0) {
// If v is unvisited.
parent[v] = u;
next.push(v);
}
}
}
return false;
}

Sunt stocai prinii fiecrui nod, de unde se poate deduce drumul.

2.1.3. Complexitate i optimalitate


Complexitate n spaiu. Avnd n vedere faptul c toate nodurile
descoperite pn la momentul de fa trebuiesc salvate, complexitatea n
spaiu a breadth-first search este O(V + E ) , unde V reprezint numrul
nodurilor, iar E numrul muchiilor grafului. Alt modalitate de a consemna

( )

acest lucru: complexitate O B M , unde B reprezint cea mai lunga ramur,


iar M lungimea maxim a drumului arborelui. Aceast cerere imens de
spaiu este motivul pentru care breadth-first search nu este practic n cazul
problemelor mai ample.
Complexitatea n timp. Odat ce, n cel mai ru caz breadth-first
search trebuie s ia n considerare toate drumurile ctre toate nodurile,
complexitatea n timp a acestui tip de cutare este de O(| V | + | E |) . Cel mai
bun caz n aceast cutare este conferit de complexitatea O(1) . Are loc
atunci cnd nodul este gsit la prima parcurgere.
Completitudine. Metoda breadth-first search este complet. Aceast
nseamn c dac exist o soluie , metoda breadth-first search o va gsi,
indiferent de tipul grafului. Cu toate acestea, dac graful este infinit i nu
exist nici o soluie, breadth-first search va eua.

10

Optimalitate. Pentru costul unitar pe muchii, bread-first search este


o metod optim. n general, breadth-first search nu este o metod optim, i
aceasta deoarece returneaz ntotdeauna rezultatul cu cele mai puine muchii
ntre nodul de start i nodul vizat. Dac graful este un graf ponderat, i drept
urmare are costuri asociate fiecrei etape, aceast problem se rezolv
mbuntind metoda breadth-first search astfel nct s se uniformizeze
costurile de cutare, identificate cu: costurile drumului. Totui, dac graful
nu este ponderat, i prin urmare toate costurile etapelor sunt egale,
breadth-first search va identifica cea mai apropiat i optim soluie.

2.1.4 Aplicaii ale BFS


Breadth-first search poate fi folosit pentru rezolvarea unei game
variate de probleme de teoria grafurilor, printre care:
Gsirea tuturor componentelor conexe dintr-un graf.
Identificarea tuturor nodurilor ntr-o component conex.
Gsirea celui mai scurt drum ntre nodurile u i v (ntr-un graf
neponderat).
Testarea bipartiiei unui graf.
Gsirea Componentelor Conexe
Mulimea vrfurilor accesate prin metode BFS reprezint cea mai
mare component conex care conine vrful de start.
Testarea bipartiiei
BFS poate fi folosit pentru testarea bipartiiei, ncepnd cutarea cu
orice vrf i atribuind etichete alternative vrfurilor vizitate n timpul
cutrii. Astfel, se atribuie eticheta 0 vrfului de start, 1 tuturor vecinilor si,
0 vecinilor acelor vecini, i aa mai departe. Dac ntr-un anumit moment al
procesului un vrf are vecini vizitai cu aceeai etichet, atunci graful nu este
bipartit. Dac parcurgerea se sfrete fr a se produce o astfel de situaie,
atunci graful este bipartit.

2.2.

Cutarea n adncime

Depth-first search (DFS) este un algoritm cutare a arborelui,


structurii arborelui, sau a grafului. Formal, DFS reprezint o cutare care
evolueaz prin expansiunea la primul vrf fiu a arborelui ce ia natere pe
msur ce se coboar n adncime, pn n momentul n care vrful int
este descoperit sau pn cnd se ntlnete un vrf care nu are fii. La pasul
urmtor, cutarea se reia (backtracking), revenind la nodul cel mai recent
vizitat, ns pentru care explorarea nu este ncheiat. ntr-o implementare nerecursiv, toate vrfurile recent vizitate sunt adugate ntr-o stiv de tipul
LIFO (Last In First Out), n scopul explorrii acestora. Complexitatea n
spaiu a DFS este cu mult mai mic dect cea a BFS (Breadth-First Search).
De asemenea se preteaz mult mai bine metodelor euristice de alegere a
11

ramurilor asemntoare. Complexitatea n timp a ambilor algoritmi este


proporional cu numrul vrfurilor plus numrul muchiilor grafului
corespunztor (O(V + E )) .
Cutarea n adncime se poate folosi i la ordonarea liniar a
vrfurilor grafului (sau arborelui). Exist trei astfel de posibiliti:
O preordine reprezint o listare a vrfurilor n ordinea n care au
fost vizitai prin intermediul algoritmului cutrii n adncime. Aceasta este
o modalitate natural i compact de descriere a progresului cutrii. O
preordine a unei expresii arbore este ceea ce numim expresie n notaia
Polonez.
O postordine reprezint o listare n care cel din urm vrf vizitat
este primul
element al listei. O postordine a unui expresii arbore este de
fapt expresia n oglind a expresiei n notaie Polonez.
O postordine inversat (n oglind) este, de fapt, reversul
postordinii, i.e. o listare a vrfurilor n ordinea invers a celei mai recente
vizite a vrfurilor in cauz. n cutarea unui arbore, postordinea inversat
coincide cu preordinea, ns, n general, difer atunci cnd se caut un graf.
Spre exemplu cnd se caut graful:

ncepnd cu vrful A, preordinile posibile sunt A B D C, respectiv A C D B


(n funcie de alegerea algoritmului de a vizita mai nti vrful B sau vrful
C), n timp ce postordinile inversate (n oglind) sunt: A B C D i A C B D.
Postordinea inversat produce o sortare topologic a oricrui graf orientat
aciclic. Aceast ordonare este folositore i n analiza fluxului de control,
reprezentnd adesea o liniarizare natural a fluxului de control. Graful mai
sus amintit poate reprezenta fluxul de control ntr-un fragment de cod ca cel
de mai jos:
if (A) then {
B
} else {
C
}
D

i este natural s considerm c acest cod urmeaz ordinea A B C D sau A C


B D, ns nu este normal s urmeze ordinea A B D C sau A C D B.
12

PSEUDOCOD (recursiv)
dfs(v)
process(v)
mark v as visited
for all vertices i adjacent to v not visited
dfs(i)

O alt variant
dfs(graph G)
{
list L = empty
tree T = empty
choose a starting vertex x
search(x)
while(L is not empty)
{
remove edge (v, w) from beginning of L
if w not yet visited
{
add (v, w) to T
search(w)
}
}
}
search(vertex v)
{
visit v
for each edge (v, w)
add edge (v, w) to the beginning of L
}

Aplicaii
Iat civa algoritmi n care se folosete DFS:

Gsirea componentelor conexe.

Sortarea topologic.

Gsirea componentelor tare conexe.

2.3.

Metoda Greedy
Descrierea metodei Greedy
Metoda Greedy (greedy = lacom) este aplicabil problemelor de

optim.
Considerm mulimea finit
A = {a1 ,..., a n }
i o proprietate p definit pe mulimea submulimilor lui A:
/ =1
p(0)
p : P(A) {0,1} cu
p(X) = 1 p(Y) = 1, Y X
O submulime S A se numete soluie dac p(S) = 1.

13

Dintre soluii va fi aleas una care optimizeaz o funcie de cost


p : P(A) R
dat.
Metoda urmrete evitarea cutrii tuturor submulimilor (ceea ce ar
necesita un timp de calcul exponenial), mergndu-se "direct" spre soluia
optim. Nu este ns garantat obinerea unei soluii optime; de aceea
aplicarea metodei Greedy trebuie nsoit neaprat de o demonstraie.
Distingem doua variante generale de aplicare a metodei Greedy:
Prima variant alege n mod repetat cte un element oarecare al
mulimii A i l adaug soluiei curente S numai dac n acest mod se obine
tot o soluie. n a doua variant procedura prel realizeaz o permutare a
elementelor lui A, dup care elementele lui A sunt analizate n ordine i
adugate soluiei curente S numai dac n acest mod se obine tot o soluie.
Exemplu.
Se consider mulimea de valori reale A = {a1 ,..., a n } .
Se caut submulimea a crei sum a elementelor este maxim.
Vom parcurge mulimea i vom selecta numai elementele pozitive,
care vor fi plasate n vectorul soluie s.
k0
for
i = 1,n
if ai > 0
then k k + 1; sk ai
write(s)

2.4.

Metoda backtracking

Un algoritm este considerat "acceptabil" numai dac timpul su de


executare este polinomial, adic de ordinul O(nk) pentru un anumit k; n
reprezint numrul datelor de intrare.
Pentru a ne convinge de acest lucru, vom considera un calculator
capabil s efectueze un milion de operaii pe secund. n tabelul urmtor apar
timpii necesari pentru a efectua n3, 2n i 3n operaii, pentru diferite valori
mici ale lui n:
n = 20
n3 2n 1 sec
3n 58 min

n = 40
12,7 zile
3855 secole

n = 60
0,2 sec
366 secole
1013 secole

Tabelul de mai sus arat c algoritmii exponeniali nu sunt


acceptabili.

14

Descrierea metodei Backtracking


Fie produsul cartezian X = X1 ... X n . Cutam x X cu (x) = 1 ,

unde : X {0,1} este o proprietate definit pe X.


Din cele de mai sus rezult c generarea tuturor elementelor
produsului cartezian X nu este acceptabil.
Metoda backtracking ncearc micorarea timpului de calcul. X este
numit spaiul soluiilor posibile, iar sintetizeaz condiiile interne.
Vectorul X este construit progresiv, ncepnd cu prima component.
Nu se trece la atribuirea unei valori lui x, dect dac am stabilit valori pentru
x1 ,..., x k 1 i k 1 (x1 ,..., x k 1 ) = 1 . Funciile k : X1 ... X n {0,1} se

numesc condiii de continuare i sunt de obicei restriciile lui la primele k


variabile. Condiiile de continuare sunt strict necesare, ideal fiind s fie i
suficiente.
Distingem urmtoarele cazuri posibile la alegerea lui xk:
1)
"Atribuie i avanseaz": mai sunt valori neanalizate din Xk i
valoarea xk aleas satisface k=> se mrete k.
2)
"ncercare euat": mai sunt valori neconsumate din Xk i
valoarea xk aleas dintre acestea nu satisface k=> se va relua,
ncercndu-se alegerea unei noi valori pentru xk.
3)
"Revenire": nu mai exist valori neconsumate din Xk (Xk
epuizat) ntreaga Xk devine disponibil i k <- k-1.
"Revenire dup determinarea unei soluii": este reinut soluia.
4)
Reinerea unei soluii const n apelarea unei proceduri retsol care
prelucreaz soluia i fie oprete procesul (dac se dorete o singur soluie),
fie prevede k k-1 (dac dorim s determinm toate soluiile).
Notm prin Ck X k mulimea valorilor consumate din Xk.
Algoritmul este urmtorul:

Ci<- 0, i;
k<-l;
while k > 0
if k = n+1
then retsol (x); k<- k-1;
else if C X
k
k
then alege v X \ C ; C C {v} ;
k
k
k
k
if (x ,..., x
k 1
k 1 , v) = 1
then x v ; k<- k+l;
k
else
/ ; k<- k-l;
else Ck<- 0

15

Pentru cazul particular

X1 = ... = X n = {1,...,s} , algoritmul se

simplific
k<-l;

x i <-0,

i = 1, , n;

while k > 0
if k = n+1
then retsol (x); k<-k-l;
else if x < s
k
then x x + 1 ;
k
k
if (x ,..., x ) = 1
k 1
k
then k<- k+l;
else
else x <-0; k<-k-l;
k

2.5.

Metoda divide et impera

Metoda Divide et Impera ("desparte i stpnete") consta n


mprirea repetat a unei probleme de dimensiuni mari n mai multe
subprobleme de acelai tip, urmat de rezolvarea acestora i combinarea
rezultatelor obinute pentru a determina rezultatul corespunztor problemei
iniiale. Pentru fiecare subproblem procedm n acelai mod, cu excepia
cazului n care dimensiunea ei este suficient de mic pentru a fi rezolvat
direct. Este evident caracterul recursiv al acestei metode.
Schema general
Descriem schema general pentru cazul n care aplicm metoda
pentru o prelucrare oarecare asupra elementelor unui vector. Funcia DivImp,
care ntoarce rezultatul prelucrrii asupra unei subsecvene a p ,..., a u , va fi
apelat prin DivImp (1,n).
function DivImp(p,u)
if u-p <
then r <- Prel (p, u)
else
m <- Interm (p,u);
r1 <- DivImp (p,m);
r2 <- DivImp (m+1,u);
r <- Combin (r1,r2)
return r
end;

unde:

p + u
- funcia Interm ntoarce un indice n intervalul p..u; de obicei m =
;
2
- funcia Prel ntoarce rezultatul subsecvenei p .. u, dac aceasta este
suficient de mic;
- funcia Combin ntoarce rezultatul asamblrii rezultatelor pariale r1 i r2.
16

2.6.

Metoda Branch and Bound

Prezentare general
Metoda Branch and Bound se aplic problemelor care pot fi
reprezentate pe un arbore: se ncepe prin a lua una dintre mai multe decizii
posibile, dup care suntem pui n situaia de a alege din nou dintre mai
multe decizii; vom alege una dintre ele etc. Vrfurile arborelui corespund
strilor posibile n dezvoltarea soluiei.
Deosebim dou tipuri de probleme:
1) Se caut un anumit vrf, numit vrf rezultat, care nu are descendeni.
2) Exist mai multe vrfuri finale, care reprezint soluii posibile, dintre care
cutm de exemplu pe cel care minimizeaz o anumit funcie.
Dei metoda este aplicabil pe arbori. Exist multe deosebiri, dintre
care menionm:
- ordinea de parcurgere a arborelui;
- modul n care sunt eliminai subarborii care nu pot conduce la o
soluie;
- faptul ca arborele poate fi infinit (prin natura sa sau prin faptul c
mai multe vrfuri pot corespunde la o aceeai stare).
n general arborele de stri este construit dinamic.
Este folosit o list L de vrfuri active, adic de stri care sunt
susceptibile de a fi dezvoltate pentru a ajunge la soluie / soluii. Iniial, lista
L conine rdcina arborelui, care este vrful curent. La fiecare pas, din L
alegem un vrf (care nu este neaprat un fiu al vrfului curent!), care devine
noul vrf curent.
Cnd un vrf activ devine vrf curent, sunt generai toi fiii si, care
devin vrfuri active (sunt inclui n L). Apoi din nou este selectat un vrf
curent.
Legat de modul prin care alegem un vrf activ drept vrf curent, deci
implicit legat de modul de parcurgere a arborelui, facem urmtoarele
remarci:
- cutarea n adncime nu este adecvat, deoarece pe de o parte
arborele poate fi infinit, iar pe de alt parte soluia cutat poate fi
de exemplu un fiu al rdcinii diferit de primul fiu i cutarea n
adncime ar fi ineficient: se parcurg inutil stri, n loc de a avansa
direct spre soluie;
- cutarea pe lime conduce totdeauna la soluie (dac aceasta
exist), dar poate fi ineficient dac vrfurile au muli fii.
Metoda Branch and Bound ncearc un "compromis" ntre cele dou
cutri menionate mai sus, atand vrfurilor active cate un cost pozitiv, ce
intenioneaz sa fie o msur a gradului de "apropiere" a vrfului de o
soluie. Alegerea acestui cost este decisiv pentru a obine un timp de
executare ct mai bun i depinde de problema concret, dar i de abilitatea
17

programatorului.
Costul unui vrf va fi totdeauna mai mic dect cel al descendenilor
(fiilor) si.
De fiecare dat drept vrf curent este ales cel de cost minim (cel
considerat ca fiind cel mai "aproape" de soluie).
Din analiza teoretic a problemei deducem o valoare lim care este o
aproximaie prin adaos a minimului cutat: atunci cnd costul unui vrf
depaseste lim, vrful curent este ignorat: nu este luat n considerare i deci
este eliminat ntregul subarbore pentru care este rdcin. Dac nu
cunoatem o astfel de valoare lim, o iniializm cu + .
Se poate defini o funcie de cost ideal, pentru care c(x) este dat de:
nivelul pe care se afl vrful x dac x este vrf rezultat;
+ dac x este vrf final, diferit de vrf rezultat;
min {c(y) | y fiu al lui x} dac x nu este vrf final.
Aceast funcie este ideal din dou puncte de vedere:
nu poate fi calculat dac arborele este infinit; n plus,
chiar dac arborele este finit, el trebuie parcurs n ntregime, ceea
ce este exact ce dorim s evitm;
dac totui am cunoate aceast funcie, soluia poate
fi determinat imediat: plecm din rdcin i coborm mereu spre
un vrf cu acelai cost, pn ajungem n vrful rezultat.
Neputnd lucra cu funcia ideal de mai sus, vom alege o
aproximaie d a lui c, care trebuie s satisfac condiiile:
1)
n continuare, dac y este fiu al lui x avem
d(x) < d(y);
2)
d(x) s poat fi calculat doar pe baza informailor din
drumul de la rdcin la x;
3)
este indicat ca d c pentru a ne asigura c dac
d(x ) > lim, atunci i c(x) > lim, deci x nu va mai fi
dezvoltat.
O prim modalitate de a asigura compromisul ntre cutrile n
adncime i pe lime este de a alege funcia d astfel nct, pentru o valoare
natural k, s fie ndeplinit condiia: pentru orice vrf x situat pe un nivel
nx i orice vrf situat pe un nivel ny nx + k, s avem d(x) > d(y),
indiferent dac y este sau nu descendent al lui x.
Condiia de mai sus spune c niciodat nu poate deveni activ un vrf
aflat pe un nivel ny nx + k dac n L apare un vrf situat pe nivelul nx,
adic nu putem merge "prea mult" n adncime. Dac aceasta condiie este
ndeplinit, este valabil urmtoarea propoziie:
Propoziie.
n ipoteza c este ndeplinit condiia de mai sus i dac exist
soluie, ea va fi atins ntr-un timp finit, chiar dac arborele este infinit.
18

Algoritmul Branch & Bound pentru probleme de optim


S presupunem c dorim s determinm vrful final de cost minim i
drumul de la rdcin la el. Fie lim aproximarea prin adaos considerat mai
sus.
Algoritmul este urmtorul (rad este rdcina arborelui, iar ifinal este
vrful rezultat):
i<-rad; L<={i}; min<-lim;
calculm d(rad); tata(i)<-0
while L
i <= L {este scos vrful i cu d(i) minim din min-ansamblul L}
for toi j fii ai lui i
calculm d(j); calcule locale asupra lui j; tata(j)<-i
if j este vrf final
then if d(j)< min
then min<-d(j); ifinal<-j
elimin din L vrfurile k cu d(k) min (*)
else if d(j)<min
then j => L
if min =lim then write {'Nu exist soluie')
else writeln (min); i<-ifinal
while i 0
write{i); i<-tata{i)

La (*) am inut cont de faptul c dac j este descendent al lui i, atunci


d(i ) < d(j).

19

20

Capitolul 3
STRUCTURI DE DATE

3.1.

Liste

Pentru a mbunti utilizarea memoriei sunt folosite structuri de date


nlnuite. Acestea poart numele de liste, fiind compuse dintr-o mulime de
noduri ntre care sunt definite anumite legturi. Se ntlnesc liste simplu
nlnuite, liste dublu nlnuite, liste circulare, structuri de liste i liste
speciale care sunt formate din atomi i din alte liste. n continuare se prezint
listele simplu nlnuite i dublu nlnuite.

3.1.1. Liste simplu nlnuite


Lista simplu nlnuit este o structur liniar de date, n care fiecare
nod este format dintr-o parte de informaie ce reine diverse valori
caracteristice elementului respectiv i o parte de legtur ce reine adresa
urmtorului element al listei. Exist valoarea NIL ce semnific adresa ctre
nicieri folosit n marcarea legturii ultimului element al listei. Pentru a crea
un nou nod, folosim o procedur predefinit new iar pentru a elibera spaiul
de memorie n momentul n care nu mai este necesar reinerea unui anumit
nod, exist procedura predefinit dispose.
Declararea unei liste simplu nlnuite se realizeaz astfel:
lista=Anod;
nod=record
inf:integer;
leg:lista;
end;
L:lista;

n pseudocod, crearea unei liste simplu nlnuite poate fi realizat


astfel:
algoritm creare (L:lista);
{
L:=NIL;
read (A);
while (A<>0) do
{
new(Pl);
P->inf:=A;
P->leg:=L;
L:=P;
readln (A);
}
}

Procesul se ncheie la citirea numrului 0. Prezentam n continuare o


21

variant recursiv de creare a listei:


algoritm creare:lista;
{
read (A);
if (A=O) then creare:=NIL;
else
{
new(P);
P->inf:=A;
P->leg:=creare;
creare:=P;
}
}

3.1.2. Parcurgerea unei liste simplu nlnuite


Dup ce a fost creat, se dorete n cele mai multe cazuri prelucrarea
listei i afiarea rezultatelor. Deoarece exist numai legtura ctre urmtorul
element al listei, toate prelucrrile vor fi fcute ncepnd cu primul element
pn la ultimul, n ordinea dat de legturi. Cel mai simplu exemplu de
prelucrare l constituie afiarea irului valorilor memorate n list. Parcurgem
pas cu pas elementele listei i afim informaia elementului curent:
algoritm listare(L:lista);
{
P:=L;
while (P<>NIL) do
{
write (P->inf, );
P:=P->leg;
}
)

3.1.3. Liste dublu nlnuite


ntr-o list dublu nlnuit fiecare nod are o parte de informaie i
dou legturi: legtura succ ctre urmtorul element i legtura pred ctre
elementul precedent. Putem memora poziia primului element L al listei. De
cele mai multe ori se vor memora doua poziii n list: poziia P a primului
element i poziia U a ultimului element.
Declararea listei dublu nlnuite se realizeaz n felul urmtor:
lista=^nod;
nod=record
inf:integer;
succ,pred:lista;
end;
L:lista;

Inserarea unui nou nod n interiorul unei liste dublu nlnuite se


execut prin introducerea informaiei ataate i refacerea a patru legturi,
astfel:

22

new (Q);
Q^.inf:=A;
Q^.succ:=P^.succ;
Q^.pred:=P;
Q^.succ^.pred:=Q;
P^.succ:=Q;

Pentru eliminarea nodului desemnat de pointerul P, se vor executa


instruciunile:
Q:=P;
P^.succ^.pred:=Q^.pred;
P^.pred^.succ:=Q^.succ;
dispose (Q) ;

3.1.4. Parcurgerea unei liste dublu nlnuite


Fie o list dublu nlnuit, avnd referinele la capete P, respectiv Q.
S se parcurg lista de la stnga la dreapta i de la dreapta la

a)
stnga.
b)
S se calculeze referina elementului aflat aproximativ la mijlocul
acestei liste.
Prezentam rezolvrile n pseudocod:
algoritm listare1(P,Q:lista);
{
AUX:=P;
while (AUX<>NIL) do
{
write (AUX->inf, );
AUX:=AUX->succ;
}
}
algoritm listare2(P,Q:lista);
{
AUX:=Q;
while (AUX<>NIL) do
{
write (AUX->inf, ) ;
AUX:=AUX->pred;
}
}
algoritm cautare(P,Q:lista):lista;
{
AUXl:=P;
AUX2:=Q;
while (AUXl<>AUX2) do
{
AUXl:=AUXl->succ;
if (AUXl=AUX2) then return (AUXl);
AUX2:=AUX2->pred;
if (AUXl=AUX2) then return (AUXl);
}
}

23

3.2.

Arbori

3.2.1. Arbori liberi


Definiie. Fie o mulime V de noduri i o mulime E de muchii,
fiecare muchie legnd dou noduri distincte.
Se numete lan un ir X1, X2, , XL de noduri pentru care oricare
dou noduri consecutive sunt legate printr-o muchie. Dac nodurile sunt
distincte, lanul se numete elementar.
Se numete ciclu elementar un lan X1, X2, , XL, X1 pentru care
lanul X1, X2, , XL este lan elementar.
Se numete arbore liber o pereche A = (V,E) cu proprietile:
l.
Oricare dou noduri distincte sunt legate printr-un lan.
2.
Nu conine cicluri elementare.
Propoziie. Un arbore liber cu |V| = n noduri are exact n l muchii.
Se poate demonstra prin inducie dup numrul n de noduri.
Propoziie. Urmtoarele afirmaii sunt echivalente:
l.
A = (V, E) este arbore liber.
2.
A = (V,E) cu |V| = n are exact n 1 muchii i nu conine cicluri
elementare.
3.
A = (V,E) cu |V| = n are exact n 1 muchii i oricare dou noduri
sunt legate printr-un lan.

3.2.2. Arbori cu rdcin


Definiie. Se numete arbore cu rdcin o mulime de noduri i
muchii n care: exist un nod special numit rdcin, iar celelalte noduri sunt
repartizate n k mulimi disjuncte A1, A2, , Ak care sunt la rndul lor
arbori cu rdcin.
Observaie.
1.
Prin alegerea unui nod drept rdcin, un arbore liber se poate
transforma n arbore cu rdcin. Totodat, fiecrui nod al arborelui i va fi
asociat un nivel. Nivelul rdcinii se consider a fi nivelul 1, iar un nod de pe
nivelul i are descendenii direci pe nivelul i + 1.
2.
Pentru fiecare nod, se consider o ordine a mulimilor A1, A2, , Ak.
Spunem atunci c arborele cu rdcin este ordonat.
Definiie. Numim adncimea unui arbore cu rdcin nivelul maxim
pe care l are un nod al acestui arbore.
Modaliti statice de memorare
1.
Putem memora arborele ca o expresie cu paranteze, n care prima
poziie este eticheta rdcinii, urmat, ntre paranteze, de lista subarborilor
respectivi.
2.
Putem memora un vector de tai. Vectorul are lungimea egal cu
numrul de noduri al arborelui, fiecare poziie i memornd ascendentul direct
al nodului i, iar ascendentul rdcinii (care nu exist) se consider a fi 0.
24

3.2.3. Arbori binari


Definiie. Un arbore binar este un arbore cu rdcin, n care orice
nod are cel mult doi descendeni direci i se face distincia ntre
descendentul stng i descendentul drept.
Definiie. Un arbore binar se numete arbore binar strict dac fiecare
nod care are descendeni direci are exact doi astfel de descendeni.
Definiie. Un arbore binar se numete arbore binar plin dac are un
numr de n nivele i pentru toate nodurile de pe nivele 1, 2, ... , n l exist
doi descendeni direci.
Un arbore plin cu n nivele are

1 + 2 + ... + 2n 1 = 2n 1
noduri.
Definiie. Un arbore binar se numete arbore binar complet dac pe
primele n 1 niveluri are toate nodurile posibile, iar pe ultimul nivel n are o
parte din noduri, considerate pe orizontal n ordinea de la stnga la dreapta.
Modaliti statice de memorare
1.
Putem memora un arbore binar prin memorarea etichetei nodului
rdcin i folosind doi vectori ST i DR ce memoreaz etichetele
descendenilor direci stng respectiv drept. Dac nu exist descendent
direct, pe poziia respectiva se va memora valoarea 0.
2.
Dac arborele este arbore binar complet, sau apropiat de un arbore
binar complet putem folosi eficient un singur vector, n care legturile stnga
i dreapta sunt implicite.

3.2.4. Parcurgerea arborilor binari


Preordine
Parcurgerea n preordine const n vizitarea rdcinii urmat de
vizitarea subarborelui stng i apoi a subarborelui drept, acest lucru fiind
valabil recursiv, pentru orice subarbore al arborelui considerat. Algoritmul
recursiv este urmtorul:
algoritm preordine(A:arbore);
{
if (A<>NIL) then
{
write (A->INF) ;
preordine(A->ST);
preordine(A->DR);
}
}

Inordine
Parcurgerea n inordine viziteaz, pentru fiecare subarbore, mai nti
subarborele stng, apoi rdcina, apoi subarborele drept. Dac arborele binar
respectiv este i arbore de cutare, atunci parcurgerea n inordine viziteaz

25

vrfurile n ordinea cresctoare a cheilor. Prezentm algoritmul recursiv:


algoritm inordine(A:arbore);
{
if (A<>NIL) then
{
inordine(A->ST);
write(A->INF);
inordine(A->DR);
}
}

Postordine
Parcurgerea n postordine viziteaz, pentru fiecare subarbore, mai
nti subarborele su stng, apoi subarborele su drept, apoi vrful rdcin.
Parcurgerea n postordine se poate realiza recursiv astfel:
algoritm postordine(A:arbore);
{
if (A<>NIL) then
{
postordine(A->ST);
postordine(A->DR);
write(A->INF);
}
}

Toi algoritmii recursivi prezentai au i variante iterative, eliminarea


recursivitii realizndu-se prin folosirea explicit a unor stive. Prezentm n
continuare algoritmul iterativ de parcurgere n preordine:
algoritm RSD_iterativ
{
stiva<-vida;
I :=RAD;
OK:=true;
while OK=true do
{
while (I<>NIL) do
{
write( I );
stiva<-I;
I:=ST[I);
}
if (stiva<>vida) then
{
I<-stiva;
I:=DR[I);
}
else OK:=false;
}
}

Parcurgerea pe nivele
Dndu-se un arbore binar, s se viziteze vrfurile acestuia n ordinea
cresctoare a nivelelor. Acest lucru se realizeaz folosind o coad auxiliar
de noduri vizitate dar neprelucrate. Algoritmul se ncheie cnd coada devine
vid, i este o particularizare a parcurgerii n lime a unui graf.

26

Procedura este iterativ i poate fi prezentat astfel:


algoritm nivele{A:arbore);
ST:stiva; P,U:intregi;
{
P:=O;U:=O;
U:=U+1;ST[U):=A;write {A->INF);
while (P<U) do
{ P:=P+1; NOD:=ST[P];
if {NOD->ST<>NIL) then
{
U:=U+1; ST[U):=NOD->ST;
write{NOD->ST->INF);}
if {NOD->DR<>NIL) then
{
U:=U+1; ST[U]:=NOD->DR;
write{NOD->DR->INF);}
}
}

27

28

Capitolul 4
PARCURGERI DE GRAFURI

Problema parcurgerii unui digraf G = (N,A), N = {1, ... , n},


A = {1, ... , m} are urmtoarea formulare: s se genereze mulimea W N
a nodurilor y pentru care exist drum de la un nod surs dat s la nodul y n
digraful G. Dac exist drum, n digraful G, de la nodul surs s la nodul y
atunci se spune c nodul y este accesibil din nodul s.
Algoritmii pe care i vom prezenta pentru rezolvarea problemei
parcurgerii unui digraf G sunt metode sistematice de vizitare a nodurilor y
accesibile din s. Fiecare iteraie a execuiei oricrui algoritm de parcurgere
stabilete pentru fiecare nod apartenena la una din urmtoarele trei stri:
nevizitat;
vizitat i neanalizat, adic un nod vizitat ai crui succesori au
fost parial vizitai;
vizitat si analizat, adic un nod vizitat ai crui succesori au
fost n totalitate vizitai.
Dac nodul x este vizitat si neanalizat, exist arcul (x,y) i nodul y
este nevizitat, atunci se poate vizita nodul y. n acest caz se spune c arcul
(x,y) este arc admisibil i dac nodul y este vizitat explornd arcul (x,y) se
spune c nodul x este predecesorul parcurgere al nodului y.
Se vor prezenta urmtorii algoritmi pentru parcurgerea unui digraf:
algoritmul BF i algoritmul DF. Aceti algoritmi utilizeaz urmtoarele
notaii comune:
U mulimea nodurilor nevizitate;
V mulimea nodurilor vizitate i neanalizate;
W mulimea nodurilor vizitate i analizate;
p tabloul predecesor, care este unidimensional cu n elemente.

4.1. Parcurgerea BF a grafurilor


Parcurgerea se face "mai nti n lime". n englez "breadth first"
(BF).
Fie digraful G = (N,A) cu nodul surs s i Dx mulimea drumurilor de
la nodul sursa s la nodul x N. Numrul de arce ce compun un drum Dx Dx
definete lungimea acestui drum pe care l notm l(Dx). Distana de la nodul
s la nodul x se definete n modul urmtor:
min{l(D x ) D x Dx }, Dx 0/
d(x) =
, Dx = 0/

29

D cu l( D
) = d(x) se numete cel mai scurt drum
Un drum D
x
x
x
de la nodul surs s la nodul x.
Observaia 1. Pentru orice arc (x,y) A avem
d(y) d(x) + 1.
ntr-adevr, dac Dx = 0/ atunci d(x) = i inegalitatea se pstreaz.
un cel mai scurt drum de la s
Dac Dx 0/ atunci evident Dy 0/ . Fie D
x
) = d(x). Mulimea Dy poate conine un drum Dy, astfel nct
la x, deci l( D
x

l(Dy) < d(x) + 1. Conform definiiei distanei avem d(y) l(Dy) i rezult c
de la s la y
d(y) < d(x) + 1. Avem egalitate cnd un drum cel mai scurt D
y
are lungimea
) = d(x) + 1,
d(y) = l( D
y

de exemplu
{(x,y)}.
= D
D
y
x
n algoritmul parcurgerii BF (algoritmul PBF) se utilizeaz tabloul
lungime l care este unidimensional i are n elemente. Mulimea nodurilor
vizitate i neanalizate V este organizat, ca structur de date, ca o coad.
Algoritmul PBF este urmtorul:
(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
(9)
(10)
(11)
(12)
(13)
(14)
(15)

PROGRAM PBF;
BEGIN;
U := N - {s} ; V := {s} ; W := 0/ ;
FOR toi y N DO p(y) := 0;
l(s) := 0;
FOR toi y U DO l(y) := ;
WHILE V 0/ DO
BEGIN
se selecteaz cel mai vechi nod x introdus In V;
FOR (x, y) A DO
IF y U
THEN U:=U{y}; V:=V {y}; p(y):=x:
l(y) := l(x) + 1;
V:=V-{x}; W:=W {x};
END;
END.

Teorema 1 .
(1)
Algoritmul PBF calculeaz elementele tabloului l astfel nct
d(y) l(y), y N ;
(2)
Dac la iteraia k oarecare a algoritmului PBF avem V = (x1, ..., xr) n
aceast ordine, atunci l(x r ) l(x1 ) + 1 i l(x i ) l(x i +1 ), i = 1, r 1 .

30

Demonstraie.
(1)
Utilizm inducia dup k, numrul de iteraii ale ciclului WHILE.
Iniial l(s) := 0, l(y) := pentru yU i evident d(y) l(y), y N .
Presupunem c, la iteraia k avem d(y) l(y) pentru y N . La iteraia
k + 1 pot exista cazurile:
(Cl ) Exist arc (x,y) admisibil ((x,y) A i y U). n acest caz
l(y) = l(x) + 1
i
d(y) d(x) + 1 l(x) + 1 = l(y)
(l(x) pentru x V nu se modific). Deci pentru toate arcele (x,y) A i
y U avem d(y) l(y) . Pentru celelalte noduri y, conform ipotezei
induciei, avem d(y) l(y) , deoarece la iteraia k + 1, l(y) nu se mai
modific.
(C2) Nu exist arc (x,y) admisibil ((x,y) A sau y U). n acest caz la
iteraia k + 1 nu se modific nici un element l(y) i conform ipotezei
induciei d(y) l(y) pentru y N .
(2)
Utilizm inducia dup k numrul de iteraii ale ciclului WHILE.
Iniial V := {s}. Deci x1 = a, xr = a i l(s) < l(s) + 1, l(s) = l(s). Presupunem
c la iteraia k avem l(xr) l(x1) + 1 i l(xi) < l(xi+1), pentru i = 1, r 1 . La
iteraia k + 1 pot exista cazurile:
(Cl ) Exist arc (x,y) admisibil ((x,y) A i y U). n acest caz
V={x1, ..., xr, xr+1}, x1 = x, xr+1 = y. Astfel, l(xr+1) = l(y) = l(x) + 1 = l(x1)+1.
De asemenea, avem l(xr) l(xr) + 1 = l(x) + 1 = l(y) = l(xr+1) i inegalitile
l(xi) l(xi+1), i = 1, r 1 au rmas nemodificate.
(C2) Nu exist arc (x,y) admisibil ((x,y) A sau y U). n acest caz
V = {x2, ..., xr}. Avem l(xr) l(x1) + 1 l(x2) + 1 i inegalitile
l(xi) l(xi+1), i = 1, r 1 au rmas nemodificate.
Teorema 2. Algoritmul PBF este convergent i la terminarea
execuiei determinm mulimea tuturor nodurilor care sunt accesibile
din nodul surs s n digraful G = (N,A).
Demonstraie. Din liniile (10), (11) i (12) ale algoritmului
rezult c toate nodurile introduse n V sunt eliminate dup ce sunt
analizate. Deci dup un numr finit de iteraii se obine V = 0/ i
execuia algoritmului se oprete. Pentru a arta c la terminarea
execuiei, algoritmul determin mulimea tuturor nodurilor care sunt
accesibile din nodul surs s n digraful G = (N,A), trebuie s artm c
la terminarea execuiei algoritmului mulimea W este:
W = {y y N i exist drum de la s la y}.
Din liniile (10), (11) i (12) ale algoritmului rezult c n V sunt

31

introduse numai noduri y care sunt accesibile din s i c dup ce un nod


x V a fost analizat el este eliminat din V i introdus n W. Deoarece
algoritmul se oprete cnd V = 0/ rezult c W conine toate nodurile
y N care sunt accesibile din s i introduse n V. S artm c W
conine toate nodurile y N care sunt accesibile din s. Prin reducere la
absurd s presupunem c exist un drum D = (yl,y2, ... ,yk-l,yk) cu yi = s,
yk = y n G i y W. Rezult c yk V. Deoarece yk V i (yk-h,yk) A
deducem c yk-1 V, astfel yk ar fi fost introdus n V. Continund
procedeul vom deduce n final c s = y1 V. Aceasta contrazice faptul
c n linia (3) a algoritmului iniializm V:={s}. Rezulta c y V, deci y W
i teorema este demonstrat.
Teorema 3.
Algoritmul PBF este convergent i determin:
(1) mulimea tuturor nodurilor care sunt accesibile din nodul surs s;
(2) elementele tabloului l astfel nct l(y) = d(y) pentru y N.
Demonstraie. Convergena i punctul (1) se demonstreaz la fel
ca Teorema 2. Punctul (2) se demonstreaz prin inducie dup k numrul
iteraiilor ciclului WHILE. Fie mulimea Nk = {y N |d(y) = k}. Pentru k
= 0 avem N0 = {s} i deci d(s) = l(s) = 0. Presupunem afirmaia adevrat
pentru k. Afirmaia pentru k + 1 rezult cu uurin, deoarece, n
conformitate cu Teorema 1 punctul (2), un nod y Nk+l este vizitat plecnd
de la un nod x Nk numai dup ce toate nodurile din Nk sunt vizitate. Deci,
dac y Nk+l i este vizitat explornd arcul (x,y), x Nk, atunci,
l(y) = l(x) + 1 = d(x) + 1 = k + 1 = d(y).
Teorema 4.
Algoritmul PBF are complexitatea O(m).
Demonstraie. Din liniile (10) , (11) i (12) ale algoritmului rezult
c fiecare nod al digrafului G este introdus i eliminat din V cel mult o dat.
Deoarece execuia algoritmului se termin cnd V = 0/ deducem c
algoritmul execut cel mult 2n iteraii. Fiecare arc (x,y)A este explorat cel
mult o dat pentru identificarea arcelor admisibile. Deci complexitatea
algoritmului PBF este O(m + n) = O(m).
n parcurgerea BF, dac Np = W i subgraful predecesor
Gp = (Np,Ap) este o arborescen atunci Gp se numete arborescen
parcurgere BPF.
Teorema 5.
Algoritmul PBF determin elementele tabloului p astfel nct
subgraful predecesor Gp = (Np,Ap) este o arborescen parcurgere BPF.
Demonstraie. Din liniile (10), (11) i (12) ale algoritmului rezult
c p(y) := x numai dac y este accesibil din s. Evident c la terminarea
execuiei algoritmului avem Np = W. Din modul cum sunt definite Np i Ap

32

rezult c Gp este o arborescen. Deci subgraful predecesor Gp este o


arborescen parcurgere a digrafului G = (N,A).
Observaia 2. Drumul unic de la nodul surs s la un nod y din
arborescena parcurgere BF este un cel mai scurt drum de la nodul surs s la
acelai nod y din digraful G, conform punctului (2) al Teoremei 3.
Observaia 3. Algoritmul PBF sau PTBF se poate aplica i
grafurilor neorientate. n acest caz, subgraful predecesor Gp = (Np,Ap)
este o arborescen. sau mai multe arborescene.
Observaia 4. Un drum unic de la nodul surs s la un nod y din
arborescenta parcurgere BF se poate determina cu urmtoarea procedur.
(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
(9)
(10)
(11)

PROCEDURA DRUM (G,s,y);


BEGIN;
se tiprete u;
WHILE p (y)i-0 DO
BEGIN
x := p(y); se tiprete x;
IF xs
THEN y := x
ELSE EXIT;
END;
END.

Observaia 5. Mulimea W este n general submulimea mulimii


nodurilor N. Pentru parcurgerea ntregului digraf G = (N,A) se utilizeaz
algoritmul parcurgerii totale generice (algoritmul PTG). Algoritmul PTG
este urmtorul:
(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
(9)
(10)
(11)
(12)
(13)
(14)
(15)
(16)
(17)
(18)

PROGRAM PTG;
BEGIN;
U := N - {s}; V :== {s}; W := 0/ ;
FOR toi y N DO p(y) := 0;
k:= 1; o(s):= 1;
FOR toi y U DO o(y) := ;
WHILE WN DO
BEGIN
WHILE V 0/ DO
BEGIN
se selecteaz un nod x din V;
IF exist arc (x, y) A i y U
THEN
U:=U-{y}; V:=V {y};p(y):=x;
k := k + 1; o(y) :=k
ELSE V:=V-{x}; W:=W {x};
END;
se selecteaz
s U; U:= U - {s}; V:= {s};
k := k + 1: o(S) := k;
END;
END.

Este evident c algoritmul PTG are complexitatea tot O(m) i c


vectorul p determin una sau mai multe arborescente parcurgeri.
33

Exemplu 1.
Se aplic algoritmul PBF digrafului din figura 1 .

Figura 1
Iniializri:
s = 1, U = {2,3,4,5,6},
V = {1}, W = 0/ , p = (0,0,0,0,0,0), l = (0, , , , , ).
Iteraia 1:
x = 1, (1,2) A, 2 U: U = {3,4,5,6},
V = {1,2}, p = (0,1,0,0,0,0) ,
l = (0,1, , , , ); (1,3) A, 3 U: U = {4,5,6},
V = {1,2,3}, p= (0,1,1,0,0,0),
l = (0,1, 1, , , ); V = {2, 3}; W = {1}.
Iteraia 2:
x = 2, (2,4) A, 4 U: U = {5,6}, V = {2,3, 4},
p = (0,1,1,2,0,0), l = (0,1,1,2, , ); (2,5) A,
5 U : U = {6}, V = {2,3,4,5} , p = (0,1,1,2,2,0) ,
l = (0,1,1,2,2, ) ; V = {3, 4, 5} ; W = {1, 2}.
Iteraia 3:
x = 3, V = {4, 5}, W = {1, 2, 3}.
Iteraia 4:
x = 4, (4, 6) A, 6 U: U = 0/ , V = {4, 5,6},
p = (0,1,1,2,2,4), l = (0,1,1,2,2,3); V = {5,6};
W = {1,2,3,4}.
Iteraia 5:
x =5, V={6}, W = {1,2,3,4,5}.
Iteraia 6:
x = 6, V = 0/ , W = {1,2,3,4,5,6}.
Np = {1,2,3,4,5,6} = W.
Arborescena parcurgere BF este prezentat n figura 2.

34

Figura 2
Drumul unic de la nodul 1 la nodul 6 se obine cu PROCEDURA
DRUM n modul urmtor:
y = 6 este ultimul nod al drumului;
Iteraia 1: x = p(6) = 4, y = 4.
Iteraia 2: x = p(4) = 2, y = 2.
Iteraia 3: x = p(2) = 1, y = l.
Drumul este: 1,2,4,6.

4.2. Parcurgerea DF a grafurilor


Parcurgerea se face "mai nti n adncime". n englez "depth first"
(DF).
n algoritmul parcurgerii DF (algoritmul PDF) se folosesc aceleai
notaii ea n algoritmul PBF cu deosebirea c, n locul tabloului
unidimensional de lungime l se utilizeaz tablourile timp unidimensionale t1
i t2 care au fiecare n elemente. Mulimea nodurilor vizitate i neanalizate V
este organizat ca structur de date, ca stiv.
Algoritmul PDF este urmtorul:
(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
(9)
(10)
(11)
(12)
(13)
(14)

PROGRAM PDF;
BEGIN;
U := N-{s}; V := {s}; W := 0/ ;
FOR toi y N DO p(y) := 0;
t := 1; t1(s) := 1; t2(s) := ;
FOR toi y U DO t1(y) := ; t2(y) := ;
WHILE V 0/ DO
BEGIN
se selecteaz cel mai nou nod x introdus in V;
IF exist arc (x,y) A i y U
THEN
U := U - {y}; V := V {y}; p (y) := x;
t := t + 1; t1(y) := t
ELSE
V := V-{x}; W := W {x}; t:=t+1;t2(x):=t;
END;
END.

35

Din liniile (10), (11), (12) ale algoritmului PDF rezult c elementul
t1(y) reprezint momentul cnd y devine nod vizitat i neanalizat i
elementul t2(x) reprezint momentul cnd x devine nod vizitat i analizat.
Se va studia n continuare algoritmul parcurgerii totale DF
(algoritmul PTDF).
Algoritmul PTDF este urmtorul:
(1)
PROGRAM PTDF;
(2)
BEGIN;
(3)
U:=N-{s}; V:={s}; W:= 0/ ;
(4)
FOR toi y N DO p(y) := 0;
(5)
t:=1; t1(s):= l; t2(s):= ;
(6)
FOR toi y U DO t1(y) := ; t2(y) := ;
(7)
WHILE WN DO
(8)
BEGIN
(9)
WHILE V 0/ DO
(10)
BEGIN
(11)
se selecteaz cel mai nou nod x introdus
n V;
(12)
IF exist arc (x,y) A i y U
(13)
THEN
U := U - {y}; V := V {y};
p (y) := x; t := t + 1; t1(y)
:= t;
(14)
ELSE
V:= V - {x}; W:= W {x};
t:= t + 1; t2 (x) := t;
(15)
END;
(16)
se selecteaz
s U; U := U - {s}; V := {s};
t:=t+l; t1(s):=t;
(17)
END;
(18)
END.

Fie mulimea S = {s s N , s selectate n linia (3) i linia (16)}.

Teorema 6.
Algoritmul PTDF este convergent i determin mulimile nodurilor
accesibile din s, s S.
Demonstraie. Se demonstreaz la fel ca Teorema 2.
Teorema 7.
Algoritmul PTDF are complexitatea O(m).
Demonstraie. Evident c. algoritmul PTDF are complexitatea
O(m).
= (N,
se numete pdure dac este format din una
A)
Un digraf G
= (N,
se numete
A)
sau mai multe arborescene. Un graf neorientat G

pdure dac este format din unul sau mai muli arbori.
n parcurgerea total DF, dac subgraful predecesor Gp = (Np,Ap),
N p = {y p(y) 0} S, A p = {(p(y), y) y N p S} este o pdure i
Np = W, atunci Gp se numete pdure parcurgere DF.
36

Teorema 8.
Algoritmul PTDF determin elementele tabloului p astfel nct
subgraful predecesor Gp = (Np,Ap) este o pdure parcurgere DF.
Demonstraie. Se demonstreaz analog ca Teorema 5.
Exemplul 2.
Se aplic algoritmul PTDF digrafului

Figura 3
Iniializri:
s = 1,U = {2,3,4,5,6, ,8}, V = {1}, W = 0/ , p
p = (0,0,0,0,0,0,0,0), t = 1,
t1 = (1, , , , , , , ),
t2 = ( , , , , , , , ).
Iteraia 1:
x = 1, (1,2) A, 2 U: U = {3,4,5,6,7,8}, V = {1,2},
p = (0,1,0,0,0,0,0,0), t = 2,
tl = (1,2, , , , , , , ).
Iteraia 2:
x = 2, (2,3) A,3 U: U = {4,5,6,7,8}, V = {1,2,3},
p = (0,1,2,0,0,0,0,0), t = 3,
t1 = (1, 2, 3, , , , , ).
Iteraia 3:
x = 3, (3,4) A,4 U: U = {5,6,7,8}, V = {1,2,3,4},
p = (0,1,2,3,0,0,0,0), t = 4, t1 = (1,2,3,4, , , , ).
Iteraia 4:
x = 4: V = {1,2, 3}, W = {4}, t = 5,
t2 = ( , , ,5, , , , ).
Iteraia 5:
x = 3: V = {1,2}, W = {4,3}, t = 6,
t2 = ( , ,6,5, , , , ).
Iteraia 6:
x = 2, (2,5) A, 5 U: U = {6,7,8},
V = {1,2,5}, p = (0,1,2,3,2,0,0,0), t = 7,
tl = (1,2,3,4,7, , , ).
Iteraia 7:
x = 5: V = {1,2}, W = {4,3,5}, t = 8,
t2 = ( , ,6,5,8, , , ).
37

Iteraia 8:
x = 2 : V = {1}, W = {4,3,5,2}, t = 9,
t2 = ( ,9,6,5,8, , , ).
Iteraia 9:
x = 1: V = 0, W = {4,3,5,2,l}, t = 10,
t2 = (10,9,6,5,8, , , ).
Actualizri:
s = 6, U = {7,8}, V = {6}, t = 11, t1 = (1,2,3,4,7,11, , )
Iteraia 10:
x = 6, (6, 7)A, 7U : U = {8}, V = {6, 7},
p = (0,1,2,3,2,0,6,0), t = 12,
t1 = (1,2,3,4,7,11,12, ).
Iteraia 11:
x = 7 : V = {6}, W = {4, 3,5,2,1,7}, t = 13,
t2 = (10,9,6,5,8,00,13, ).
Iteraia 12:
x = 6, (6,8) A,8 U: U = 0/ , V = {6,8}, p = (0,1,2,3,2,0,6,6),
t = 14, tl = (1,2,3,4,7,11,12,14).
Iteraia 13:
x = 8 : V = {6}, W = {4, 3, 5, 2,1, 7,8}, t = 15,
t2 = (10,9,6,5,8, ,13,15).
Iteraia 14:
x = 6: V = 0/ , W = {4,3,5,2,1,7,8,6}, t = 16,
t2 = (10,9,6,5,8,16,13,15).

4.3. Aplicaii
4.3.1. Sortarea topologic
Teorema 9. Un digraf G = (N,A) este fr circuite dac i numai
dac orice parcurgere total DF a lui G nu produce arce de revenire.
Demonstraie. Presupunem c digraful G este fr circuite. Prin
reducere la absurd presupunem ca o parcurgere total DF a lui G produce
arce de revenire ( R 0/ ). Fie arcul (z, x) R . n acest caz nodul z este un
descendent al nodului x n pdurea parcurgere DF. Deci exist un drum D de
o

la x la z n G. Atunci D = D {z,x} este un circuit n G i aceasta


contrazice ipoteza c digraful G este fr circuite.
Reciproc, presupunem c o parcurgere total DF a digrafului G nu
produce arce de revenire ( R 0/ ). Prin reducere la absurd presupunem c
o

G conine un circuit D . Fie x primul nod vizitat din D i fie arcul


o

(z,x) D . Deoarece nodurile x, z D rezult c exist un drum D de la x

38

la z. De asemenea x fiind primul nod vizitat din D rezult c nodul z


devine un descendent al nodului x la pdurea PDF. Deci (z,x) este un arc
de revenire ce contrazice ipoteza R = 0/ .
Sortarea topologic a unui digraf G = (N,A) fr circuite const
ntr-o ordonare liniar a nodurilor din N astfel nct dac (x, y) A
atunci x apare naintea lui y n ordonare.
Algoritmul sortare topologic (algoritmul ST) se obine din
algoritmul PTDF fcnd urmtoarele dou completri:
(1)
n partea de iniializri (liniile (3)-(6)) se iniializeaz o list a
nodurilor;
(2)
n linia (16) dup calculul lui t2(X), nodul x se introduce la
nceputul listei.
La terminarea algoritmului ST, lista furnizeaz sortarea topologic
a digrafului G = (N,A) fr circuite i nodurile x sunt plasate n list n
ordinea descresctoare a timpilor t2(X).

4.3.2. Componentele conexe ale unui graf


Definiia 1. Un digraf G = (N,A) se numete conex dac pentru
oricare dou noduri x, y exist un lan care are aceste dou noduri drept
extremiti.
Noiunea de conexitate are sens i pentru grafuri neorientate.
Definiia 2. Se numete component conex a unui digraf
G = (N,A) un subgraf G' = (N',A') al lui G, care este conex i care este
maximal n raport cu incluziunea fa de aceast proprietate (oricare ar fi
x N ' = N N ' , subgraful G 'x generat de N 'x = N ' {x} nu mai este

conex).
O component conex G' = (N',A') a unui digraf G = (N,A) se poate
identifica cu mulimea N' care genereaz subgraful G'.
Deoarece n problema conexiunii sensul arcelor nu conteaz se va
considera c grafurile sunt neorientate. Dac G = (N,A) este digraf atunci i se
= (N,
, unde N
= {[x, y] (x, y) A
A)
= N, A
asociaz graful neorientat G
au aceleai componente conexe.
i / sau (y, x) A }. Este evident c G i G
Algoritmul componentelor conexe (algoritmul CC) este o adaptare a
algoritmului PTDF aplicat unui graf neorientat G = (N,A). Nu se calculeaz
tablourile timp t1, t2 i prin p notm o variabil scalar a crei valoare
reprezint numrul componentelor conexe. Algoritmul CC este urmtorul:
(1)
(2)
(3)
(4)
(5)

PROGRAM CC;
BEGIN
U:= N - {s}; V:= {s}; W:= 0/ ; p:= l; N' = {s};
WHILE W N DO
BEGIN

39

WHILE V 0/ DO
BEGIN
se selecteaz cel mai nou nod x introdus n V;
IF exist muchie [x, y] A i y V
THEN U:= U-{y}; V:=V {y};N':=N' {y}
ELSE V:= V-{x}; W:=W {x};
END;
se tipresc p i N';
se selecteaz s U; U:=U-{s}; V:={s};
p:= p+1;N':={s};

(6)
(7)
(8)
(9)
(10)
(11)
(12)
(13)
(14)
(15)
(16)

END;
END.

La terminarea algoritmului pot exista cazurile:


(Cl) se tiprete o singur component conex i n acest caz graful
G = (N,A) este conex;
(C2) se tipresc mai multe componente conexe i n acest caz graful
G = (N,A) nu este conex, obinndu-se toate componentele conexe ale lui G.
Teorema 10.
Algoritmul CC determin componentele conexe ale unui graf
neorientat G = (N,A).
Demonstraie.
La terminarea execuiei ciclului WHILE se determin mulimea N' a
tuturor nodurilor accesibile printr-un lan cu aceeai extremitate, nodul s.
Mulimea N' genereaz evident o component conex G' = (N',A').
Deoarece la terminarea execuiei algoritmului avem W = N rezult c
algoritmul CC determin toate componentele conexe ale lui G = (N,A).
Teorema 11.
Algoritmul CC are complexitatea O(m).
Demonstraie. Algoritmul CC are aceeai complexitate cu a
algoritmului PTDF, adic O(m).
Exemplul 3.
Fie digraful din figura 4.
Pentru a determina componentele conexe ale acestui digraf se
transform ntr-un graf neorientat reprezentat n figura 5 cruia i se aplic
algoritmul CC.

Figura 4

40

Figura 5
Iniializri:
s = 1, U = {2,3,4,5,6,7,8}, V = {1}, W = 0/ , p = 1, N'={1}.
Iteraia 1:
x = 1, [1,2]A, 2U : U = {3,4,5,6,7,8}, V = {1,2}, N'={1,2}.
Iteraia 2:
x = 2, [2,3]A, 3U: U={4,5,6,7,8}, V={1,2,3}, N'={1,2,3}.
Iteraia 3:
x=3, [3,4]A, 4U: U={5,6,7,8}, V={1,2,3,4}, N'={1,2,3,4}.
Iteraia 4:
x = 4: V = {1,2,3}, W = {4}.
Iteraia 5:
x = 3: V = {1,2}, W = {4,3}.
Iteraia 6:
x = 2, V = {1}, W = {4,3,2}.
Iteraia 7:
x = 1 : V = 0/ , W = {4, 3, 2, 1}.
Se tipresc:
p = 1 i N' = {1,2,3,4}
Actualizri:
s = 5, U = {6,7,8}, V = {5}, p = 2, N' = {5}.
Iteraia 8:
x = 5, [5,6] A, 6 U : U = {7,8}, V = {5,6}, N' = {5,6}.
Iteraia 9:
x = 6, [6,8] A, 8 U : U = {7}, V = {5,6,8}, N' = {5,6,8}.
Iteraia 10:
x = 6, [8, 7]A, 7U: U = 0/ , V = {5,6,8,7}, N'={5,6,8,7}.
Iteraia 11:
x = 7 : V = {5,6,8}, W = {4,3,2,1,7}.
Dup nc trei iteraii se obine
V = 0/ , W = {4,3,2,1,7,8,6,5}
Se tipresc
p = 2 i N' = {5,6,8,7}
i execuia algoritmului se oprete.

41

42

Capitolul 5
PROBLEME DE DRUM N (DI)GRAFURI

5.1.

Problema celui mai scurt drum

n teoria grafurilor, problema celui mai scurt drum const n


gsirea unui drum astfel nct suma costurilor muchiilor constituente s fie
minim. Un exemplu l constituie gsirea celei mai rapide modaliti de a
trece de la o locaie la alta pe o hart; n acest caz nodurile sunt reprezentate
de ctre locaiile respective, iar muchiile reprezint segmentele de drum, i
sunt ponderate, costurile constituind timpul necesar parcurgerii acelui
segment.
Formal, fiind dat un graf ponderat (adic, o mulime de vrfuri V, o
mulime a muchiilor E, i o funcie de cost
f :E R
cu valori reale) i un element v al lui V, s se gseasc un drum P de la v la
fiecare v din V astfel nct
f ( p)
pP

s fie minim ntre toate drumurile ce leag v de v .


Uneori mai poate fi recunoscut sub numele de problema drumului
cel mai scurt corespunztor perechii singulare, cu scopul deosebirii
acesteia de urmtoarele generalizri:
problema drumului cel mai scurt corespunztor sursei
unice, o problem mai general, n care trebuie s gsim cele
mai scurte drumuri de la un nod surs v la toate celelalte noduri
ale grafului.
problema drumului cel mai scurt corespunztor tuturor
perechilor reprezint o problem i mai general, n care
trebuie s gsim cele mai scurte drumuri ntre oricare pereche
de noduri (vrfuri) v, v din graf.
Ambele generalizri amintite au algoritmi mai performani n practic
dect simpla rulare a algoritmului corespunztor drumului cel mai scurt n
cazul perechii-unice (singulare) pentru toate perechile relevante de vrfuri.
Algoritmi
Cei mai importani algoritmi care rezolv aceast problem sunt:
Algoritmul lui Dijkstra rezolv problema sursei unice, dac
toate muchiile sunt ponderate pozitiv Acest algoritm poate

43

genera cele mai scurte drumuri de la un anumit punct de


placare s la toate celelalte noduri.
Algoritmul Bellman-Ford rezolv problema sursei unice i
pentru costuri negative ale muchiilor.
Algoritmul de cutare A* - rezolv problema drumurilor cele
mai scurte n cazul sursei unice, folosind euristica, n
ncercarea accelerrii cutrii.
Algoritmul Floyd-Warshall rezolv problema celor mai
scurte drumuri corespunztoare tuturor perechilor.
Algoritmul lui Johnson - rezolv problema celor mai scurte
drumuri corespunztoare tuturor perechilor; poate fi mai rapid
ca Algoritmul Floyd-Warshall, n cazul grafurilor rare.

Aplicaii
Algoritmii ce rezolv problema celui mai scurt drum se aplic, n
mod evident, pentru a gsi, n mod automat, adrese ntre diferite locaii
fizice, cum ar fi spre exemplu instruciuni legate de ofat oferite de GPS
uri sau programele web de mapare (Mapquest).
Dac reprezentm, spre exemplu, o main abstract nedeterminist
sub forma unui graf, n care vrfurile descriu state, iar muchiile descriu
posibile tranziii, algoritmii de identificare a celui mai scurt drum pot fi
folosii pentru a gsi o secven optimal de alegeri, astfel nct s ajung
ntr-un stat prestabilit, sau pentru a minimiza timpul necesar pentru a ajunge
n acel stat.

44

5.1.1. Arborele Steiner

Soluia pentru 3 puncte; punctul Steiner este cel din mijloc


a se remarca faptul c nu exist conexiuni directe ntre A, B, C

Soluia pentru 4 puncte a se remarca faptul c exist 2 puncte Steiner


Problema Arborelui Steiner este, aproximativ, similar problemei
arborelui parial de cost minim: fiind dat o mulime V de vrfuri,
interconectai aceste puncte prin intermediul unui graf de lungime minim,
unde lungimea reprezint suma lungimilor tuturor muchiilor. Diferena ntre
Problema Arborelui Steiner i Problema Arborelui Parial de Cost Minim
const n faptul c n cadrul Arborelui Steiner pot fi adugate grafului iniial
vrfuri i muchii intermediare, cu scopul reducerii lungimi arborelui parial.
Aceste vrfuri nou introduse, n scopul reducerii lungimii totale a conexiunii,
sunt cunoscute sub numele de Puncte Steiner sau Vrfuri Steiner. S-a
demonstrat c acea conexiune rezultant este un arbore, numit i Arborele
Steiner. Pot exista mai muli arbori Steiner pentru o mulime dat de vrfuri
iniiale.
Problema original a fost formulat n forma cunoscut sub numele
de Problema Arborelui Euclidean Steiner: Fiind date N puncte n plan, se
cere s se conecteze prin intermediul liniilor, valoarea rezultant a acestora

45

fiind minim, astfel nct oricare dou puncte sunt interconectate, fie printrun segment de linie, fie via alte puncte, respectiv alte segmente de dreapt.
Pentru Problema Euclidean Steiner, punctele adugate grafului
(Punctele Steiner) trebuie s aib gradul trei, iar cele trei muchii incidente
corespunztoare trebuie s formeze trei unghiuri de 120 de grade. Rezult c
numrul maxim de Puncte Steiner pe care le poate avea un Arbore Steiner
este de N-2, unde N reprezint numrul iniial de puncte considerate.
Se poate nc generaliza pn la Problema Metric a Arborelui
Steiner. Fiind dat un graf ponderat G(S,E,w) ale crui vrfuri corespund unor
puncte n spaiul metric, iar costul muchiilor este reprezentat de distanele
n spaiu, se cere s se gseasc un arbore de lungime total minim, ai crui
vrfuri constituie o supermulime a mulimii S, mulime a vrfurilor grafului
G.
Versiunea cea mai general o constituie Arborele Steiner n
grafuri: Fiind dat un graf ponderat G(V,E,w) i o submulime de vrfuri
S V gsii un arbore de cost minim care include toate nodurile mulimii S.
Problema Metric a Arborelui Steiner corespunde problemei
Arborelui Steiner n grafuri, unde graful are un numr infinit de noduri, toate
fiind puncte n spaiul metric.
Problema arborelui Steiner are aplicaii n design-ului reelelor.
Majoritatea versiunilor Problemei Arborelui Steiner sunt NP complete, i.e.,
gndite ca fiind computaional-dificile. n realitate, una dintre acestea se
numra printre cele 21 de probleme iniiale ale lui Karp, NP complete.
Unele cazuri restrictive pot fi rezolvate ntr-un timp polinomial. n practic
se folosesc algoritmii euristici.
O aproximare comun a Problemei Arborelui Euclidian Steiner este
reprezentat de calcularea arborelui parial de cost minim Euclidian.

5.1.2. Algoritmul lui Dijkstra


Algoritmul lui Dijkstra, dup numele celui care l-a descoperit,
expertul n calculatoare Edsger Dijkstra, este un algoritm greedy care rezolv
problema celui mai scurt drum cu o singur surs pentru un graf orientat,
care nu are muchii ponderate negativ.
Spre exemplu, dac vrfurile grafului reprezint orae, iar costurile
muchiilor reprezint distanele de parcurs ntre perechi de orae conectate
printr-un drum direct, algoritmul lui Dijkstra poate fi folosit pentru
depistarea celui mai scurt traseu ntre cele dou orae.
Datele de intrare necesare implementrii algoritmului sunt: un graf
orientat ponderat G i un vrf surs s n G. Vom nota cu V mulimea tuturor
vrfurilor grafului G. Fiecare muchie a grafului reprezint o pereche
ordonat de vrfuri (u, v), semnificaia acesteia fiind legtura ntre u i v.
Mulimea tuturor muchiilor este notat cu E. Costurile muchiilor sunt date de
46

funcia de cost w : E [0, ) ; astfel, w(u , v) reprezint costul muchiei (u,v).


Costul unei muchii poate fi nchipuit ca o generalizare a distanei ntre aceste
dou vrfuri. Costul unui drum ntre dou vrfuri este dat de suma tuturor
costurilor muchiilor componente. Pentru o pereche dat de vrfuri s i t din
V, algoritmul gsete drumul de cost minim ntre s i t (i.e. cel mai scurt
drum). Algoritmul poate fi folosit, n aceeai msur pentru depistarea
drumurilor de cost minim ntre vrful surs s i toate celelalte vrfuri ale
grafului.
Descrierea algoritmului
Algoritmul funcioneaz reinnd, pentru fiecare vrf v, costul d [v ] al
celui mai scurt drum gsit pn n acel moment ntre s i v. Iniial, aceast
valoare este 0, pentru vrful surs s ( d [s ] = 0 ), respectiv infinit pentru restul
vrfurilor, sugernd faptul c nu se cunoate nici un drum ctre aceste noduri
(vrfuri) ( d [v ] = pentru fiecare v din V, exceptnd s). La finalul
algoritmului, d [v ] va reprezenta costul celui mai scurt drum de la s la v sau
infinit, dac nu exist un astfel de drum.
Algoritmul presupune existena a dou mulimi de vrfuri S i Q.
Mulimea S conine toate vrfurile pentru care se cunoate valoarea d [v ] ,
valoare ce corespunde costului celui mai scurt drum, iar mulimea Q conine
toate celelalte vrfuri . Mulimea S este, iniial,goal (nu are elemente), iar cu
fiecare pas un vrf din mulimea Q devine element al mulimii S. Acest vrf
este ales astfel nct d [v ] s corespund celei mai mici valori. Odat cu
mutarea vrfului u n mulimea S, algoritmul relaxeaz fiecare muchie
de forma (u,v). Aceasta nseamn c, pentru fiecare vecin al lui v sau al lui u,
algoritmul verific dac poate optimiza drumul (la v) cunoscut ca fiind cel
mai scurt pn la acel moment, urmnd drumul cel mai scurt de la sursa s la
u, traversnd n cele din urm muchie (u, v). Dac acest nou drum este mai
bun (n sensul unui cost mai mic), algoritmul actualizeaz d [v ], atribuindu-i
valoarea mai mic.

Execuia algoritmului Dijkstra asupra unui graf mic, demonstrnd dou


operaii de relaxare
Pe msur ce se gsesc drumuri mai scurte, costul estimat este redus,
iar sursa se relaxeaz. Eventual, drumul cel mai scurt, dac exist, se
relaxeaz la maximum.

47

Pseudocodul
n algoritmul ce urmeaz, u := extract_min(Q) caut vrful u n
mulimea vrfurilor Q, care are cea mai mic valoare asociat dist[u]. Vrful
este scos din mulimea Q i returnat utilizatorului. length(u, v) calculeaz
distana ntre cele dou vrfuri vecine u i v alt de pe linia 10 reprezint
lungimea drumului de la rdcin la v, dac ar fi s treac prin u. Dac acest
drum este mai scurt dect drumul considerat n momentul respectiv ca fiind
cel mai scurt, acel drum curent este nlocuit cu acest alt drum.
1
2
3
4
5
6
7
8
9
10
11
12
13

function Dijkstra(Graph, source):


for each vrf v in Graph:
dist[v] := infinity
previous[v] := undefined
dist[source] := 0
Q := copy(Graph)
while Q is not empty:
u := extract_min(Q)
for each vecin v of u:
alt = dist[u] + length(u, v)
if alt < dist[v]
dist[v] := alt
previous[v] := u

Dac, ns ne intereseaz doar un drum mai scurt ntre vrfurile surs


i int, cutarea poate nceta la punctul 9 dac u=target. Acum putem citi
cel mai scurt drum de la surs la int prin iterare:
1 S := empty sequence
2 u := target
3 while este definit previous[u]
4
insereaz u la nceputul of S
5
u := previous[u]

Acum secvena S reprezint lista vrfurilor ce constituie unul dintre


cele mai scurte drumuri de la surs la int, sau secvena nul dac un astfel
de drum nu exist.
O problem mult mai general ar fi aceea a determinrii tuturor celor
mai scurte drumuri ntre surs i int (pot fi mai multe astfel de drumuri, de
aceeai lungime). n acest caz, n locul memorrii unui singur nod la fiecare
intrare previous[], se vor pstra toate vrfurile ce satisfac condiia de
relaxare. Spre exemplu, dac att r ct i sursa sunt conectate (sunt n
legtur) cu inta i ambele aparin unor celor mai scurte drumuri distincte,
ce ating inta (deoarece costul muchiilor este acelai n ambele cazuri),
atunci vom aduga ambele vrfuri r i surs valorii anterioare [target].
Cnd algoritmul este complet, structura de date previous[] va descrie un graf,
care este subgraf al grafului iniial din care au fost nlturate unele muchii.
Proprietatea esenial va fi dat de faptul c dac algoritmul a rulat cu un
48

anumit vrf de nceput, atunci fiecare drum de la acel vrf ctre oricare alt
vrf, n noul graf, va fi cel mai scurt ntre nodurile respective n graful
original, iar toate drumurile de aceiai lungime din garful original vor fi
prezente n graful rezultant. Astfel, pentru a gsi aceste drumuri scurte ntre
oricare dou vrfuri date vom folosi algoritmul de gsire a drumului n noul
graf, asemenea depth-first search (cutrii n adncime).
Timpul de rulare
Timpul de rulare al algoritmului lui Dijkstra ntr-un graf cu |E| muchii
i |V| noduri poate fi exprimat ca o funcie de E i V , folosind notaia O.
Cea mai simpl implementare a algoritmului lui Dijkstra stocheaz
vrfurile mulimii Q ntr-o list de legtur ordinar sau ntr-un tablou, iar
operaia Extract-Min(Q) este o simpl cutare liniar a vrfurilor mulimii Q.
2

n acest caz, timpul de rulare este O( V + E ) .


Pentru cazul grafurilor rare, adic, grafuri cu un numr de muchii
2
mult mai mic dect V , algoritmul Dijkstra se poate implementa ntr-un
mod mult mai eficient, prin stocarea grafului sub forma listelor de adiacen
i folosirea heap binar sau heap Fibonaci pe post de coad cu prioriti n
implementarea funciei Extract-Min. Cu heap binar algoritmul necesit un
timp de rulare de ordinul O(( E + V ) log V ) (dominat de ctre O( E log V )
presupunnd c E V 1 ), iar heap Fibonaci mbuntete acest timp la
O( E + V log V ) .

5.1.3. Probleme similare i algoritmi


Funcionalitatea algoritmului original al lui Dijkstra poate fi extins
dac se efectueaz anumite schimbri. De exemplu, n unele cazuri este de
dorit a se prezenta unele soluii ce nu sunt chiar optimale din punct de vedere
matematic . Pentru a obine o list consistent de astfel de soluii mai puin
optimale, se calculeaz, totui, nc de la nceput, soluia optim. Se elimin,
din graf, o singur muchie ce apare n soluia optim, iar soluia optim a
acestui nou graf este calculat. La ntoarcere, fiecare muchie a soluiei
originale este suprasaturat, iar drept urmare se calculeaz un nou cel mai
scurt drum. Soluiile secundare astfel obinute sunt niruite imediat dup
prima soluie optim.
OSPF (open shortest path first) reprezint o implementare real a
algoritmului lui Dijkstra, n rout-area internet-ului.
Spre deosebire de algoritmul lui Dijkstra, algoritmul Bellman-Ford
poate fi folosit i n cazul grafurilor ce au muchii cu costuri negative, att
timp ct graful nu conine nici un ciclu negativ care se poate atinge din vrful
surs s. (Prezena unor astfel de cicluri sugereaz faptul c nu exist ceea ce
49

numim cel mai scurt drum, avnd n vedere c valoarea descrete de fiecare
dat cnd ciclul este traversat.)
Algoritmul A* este o generalizare a algoritmului Dijkstra, care
reduce mrimea subgrafului care urmeaz s fie explorat, aceasta n cazul n
care sunt disponibile informaii adiionale, menite s micoreze distana
ctre int.
Procesul care st la baza algoritmului lui Dijkstra este similar
procesului greedy, folosit n cazul algoritmului lui Prim.
Scopul algoritmului lui Prim l constituie gsirea arborelui parial de cost
minim corespunztor unui graf.

5.1.4. Probleme legate de drum


Drumul Hamiltonian i probleme legate de cicluri
Arborele parial de cost minim
Problema inspeciei drumului (cunoscut i sub numele de
Problema Potaului Chinez)
Cele apte Poduri din Knigsberg
Problema celui mai scurt drum
Arborele Steiner
Problema Comisului Voiajor (NP - complet)

5.1.5. Algoritmul Bellman-Ford


Algoritmul Bellman Ford calculeaz cele mai scurte drumuri de la
un vrf-surs ctre celelalte vrfuri ale unui digraf ponderat (unde unele
muchii pot avea costuri negative). Algoritmul lui Dijkstra rezolv aceeai
problem, chiar cu un timp de execuie mai mic, ns necesit muchii ale
cror costuri s fie nenegative. Astfel, algoritmul Bellman Ford se
folosete doar atunci cnd exist costuri negative ale muchiilor.
Potrivit lui Robert Sedgewick, Valorile negative intervin n mod
natural n momentul n care se reduc alte probleme la probleme de studiu a
drumului cel mai scurt, i ofer ca exemplu specific problema reducerii
complexitii -NP a drumului Hamiltonian. Dac un graf conine un ciclu
avnd valoare negativ, atunci nu exist soluie; Bellman Ford rezolv
acest caz.
Algoritmul Bellman Ford, n structura sa de baz, este similar
algoritmului Dijkstra, dar n locul unei selecii de tip greedy a nodului minim
poderat, apeleaz la simpla relaxare a muchiilor, acest proces executndu-se
de V 1 ori, unde V reprezint numrul vrfurilor dintr-un graf. Aceste
repetri permit propagarea distanelor minime n graf, innd cont de faptul
c, n absena ciclurilor negative, cel mai scurt drum poate vizita fiecare nod
cel mult o dat. Spre deosebire de abordarea greedy, care depinde de anumite

50

consideraii structurale derivate din costurile pozitive, aceast abordare


direct se extinde la cazul general.
Timpul de rulare al algoritmului Bellman Ford este de ordinul
O(|E|).
procedure BellmanFord(list vertices, list edges, vertex source)
// Pasul 1: Iniializarea grafului
for each vertex v in vertices:
if v is source then v.distance := 0
else v.distance := infinity
v.predecessor := null
// Pasul 2: Relaxarea repetitiv a muchiilor
for i from 1 to size(vertices):
for each edge uv in edges:
u := uv.source
v := uv.destination //uv este muchia de la u la v
if v.distance > u.distance + uv.weight:
v.distance := u.distance + uv.weight
v.predecessor := u
// Depistarea ciclurilor negative
for each edge uv in edges:
u := uv.source
v := uv.destination
if v.distance > u.distance + uv.weight:
error "Graful cinine un ciclu negativ"

Demonstraia corectitudinii
Corectitudinea algoritmului poate fi artat cu ajutorul induciei.
Propoziia care va fi demonstrat prin inducie este dat de urmtoarea:
Lem.
Dup i repetiii ale buclei for:

Dac Distance(u) nu este infinit, atunci este egal cu lungimea unui


anumit drum de la s la u;

Dac exist un drum de la s la u cu cel mult i muchii, atunci


Distance(u) corespunde cel mult lungimii celui mai scurt drum de la s la u
cu cel mult i muchii.
Demonstraie.
Pentru etapa I, considerm i = 0 i momentul apriori ciclului for
considerndu-l ca fiind executat pentru prima dat. Apoi, pentru vrful surs,
source.distance=0, ceea ce este corect. Pentru alte vrfuri u,
u.distance=infinity, ceea este deopotriv corect deoarece nu exist nici un
drum de la surs la u cu 0 muchii.
Pentru pasul inductiv, demonstrm pentru nceput prima parte.
Considernd un moment n care distana la un vrf este dat de:
v.distance:=u.distance+uv.weight. Prin presupunere inductiv, u.distance
este lungimea unui drum oarecare de la surs la u. Astfel,

51

u.distance+uv.weight este lungimea drumului de la surs la v, care nu


prsete drumul de la surs la u i ajunge la v.
Pentru cea de-a doua parte, considerm cel mai scurt drum de la
surs la u cu cel mult i muchii. Fie v ultimul vrf naintea lui u pe acest
drum. Atunci, poriunea de drum de la surs la v este cel mai scurt drum de
la surs la v cu cel mult i-1 muchii. Prin presupunere inductiv, v.distance,
acestui drum. De aceea,
dup i-1 cicluri, are cel mult lungimea
uv.weight+v.distance are cel mult lungimea drumului de la s la u. La ciclul
cu numrul i, u.distance este comparat cu uv.weight+v.distance, i se
egaleaz cu aceast cantitate dac uv.weight+v.distance este mai mic. De
aceea, dup i cicluri, u.distance are cel mult lungimea celui mai scurt drum
de la surs la u, drum ce folosete cel mult i muchii.
Cnd i egaleaz numrul vrfurilor grafului, fiecare drum va fi cel
mai scurt ntre toate vrfurile, doar dac nu exist cicluri negative. Dac
exist totui un ciclu ponderat negativ i accesibil de la surs, atunci dat fiind
un drum oarecare, exist unul mai scurt, deci nu exist un cel mai scurt
drum. Altfel, cel mai scurt drum nu va include nici un ciclu (deoarece
ocolirea ciclului ar presupune scurtarea drumului), pentru ca fiecare drum
mai scurt s viziteze fiecare nod cel mult o dat, iar numrul de muchii
corespunztor s fie mai mic dect numrul vrfurilor grafului.
Aplicaii n rutare
O variant distribuit a algoritmului Bellman Ford se folosete n
protocoalele de rutare distan-vector, de exemplu Protocolul de Rutare a
Informaiei (RIP)(Routing Information Protocol). Algoritmul const din
urmtorii pai:
1.
Fiecare nod calculeaz distana ntre sine i toate celelate noduri i
stocheaz aceast informaie ca un tabel.
2.
Fiecare nod i trimite tabelul corespunztor tuturor celorlalte noduri.
3.
n momentul n care un nod primete un astfel de tabel de la vecinii
si, calculeaz cele mai scurte ci ctre toate celelalte noduri i actualizeaz
propriul tabel astfel nct s fie reflectate toate schimbrile survenite.
Marele dezavantaj al algoritmului Bellman-Ford n aceste condiii
const n:

Msurarea incorect

Schimbrile n topologia reelei nu sunt reflectate n timp util,


odat cu actualizarea succesiv a tabelelor nodurilor.

Numrarea la infinit (proces ce survine ca urmare a eecului


transmiterii tabelelor)
Implementare
Urmtorul program implementeaz algoritmul Bellman-Ford n C.

52

#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
/* S considerm INFINIT-ul o valoare ntreag, pentru a nu
interveni confuzia n valorarea real, chiar i cea negativ*/
#define INFINITY ((1 << 14)-1)
typedef struct {
int source;
int dest;
int weight;
} Edge;
void BellmanFord(Edge edges[], int edgecount, int nodecount, int
source)
{
int *distance = (int*) malloc(nodecount * sizeof(*distance));
int i, j;
for (i=0; i < nodecount; i++)
distance[i] = INFINITY;
/* distana nodului surs este presetat ca fiind nul */
distance[source] = 0;
for (i=0; i < nodecount; i++) {
for (j=0; j < edgecount; j++) {
if (distance[edges[j].source] != INFINITY) {
int new_distance = distance[edges[j].source] +
edges[j].weight;
if (new_distance < distance[edges[j].dest])
distance[edges[j].dest] = new_distance;
}
}
}
for (i=0; i < edgecount; i++) {
if (distance[edges[i].dest] > distance[edges[i].source] +
edges[i].weight) {
puts("S-au detectat cicluri cu muchii ponderate negativ
(cu costuri negative)!");
free(distance);
return;
}
}
for (i=0; i < nodecount; i++) {
printf("Cea mai scurt distan dintre nodurile %d i %d este
%d\n",
source, i, distance[i]);
}
free(distance);
return;
}
int main(void)
{
/* Acest test ar trebui s genereze distanele 2, 4, 7, -2, and
0. */
Edge edges[10] = {{0,1, 5}, {0,2, 8}, {0,3, -4}, {1,0, -2},
{2,1, -3}, {2,3, 9}, {3,1, 7}, {3,4, 2},
{4,0, 6}, {4,2, 7}};
BellmanFord(edges, 10, 5, 4);
return 0;
}

53

5.1.6. Algoritmul de cutare A


n tiina calculatoarelor, A este un algoritm de cutare a grafurilor
de tipul best-first, care gsete drumul de cost de minim de la un nod
iniial la un nod int (din una sau mai multe inte posibile).
Folosete o funcie euristic distan-plus-cost (notat de regul cu
f ( x ) ) pentru a determina ordinea n care sunt vizitate nodurile arborelui.
Euristic-ul distan-plus-cost reprezint o sum de dou funcii: funcia
cost-drum (notat de obicei cu g ( x ) , care poate fi, sau, nu euristic) i o
estimare euristic admisibil a distanei ctre int (notat de regul cu
h( x ) ). Funcia cost-drum g ( x ) determin costul de la nodul de start la nodul
curent.
Avnd n vedere faptul c h( x ) , parte a funciei f ( x ) , trebuie s fie
euristic admisibil, trebuie s se subestimeze distana ctre int. Astfel,
pentru o aplicaie ca rout-area, h( x ) ar putea reprezenta distana n linie
dreapt la int, innd cont i de faptul c, din punct de vedere fizic, este cea
mai mic distana posibil ntre oricare dou noduri.
Algoritmul a fost descris pentru prima dat n anul 1968 de ctre
Peter Hart, Nils Nilsson, respectiv Bertram Raphael. Algoritmul era numit
algoritmul A. Avnd n vedere faptul c se face apel doar la comportamentul
optimal pentru un anumit euristic, a fost numit A .
Descrierea algoritmului
A caut toate drumurile de la nodul de start, oprindu-se n
momentul n care s-a gsit drumul cel mai scurt la nodul int. Ca toi
algoritmii de cutare informaionali, cerceteaz mai nti drumurile ce par a
conduce la int. Ceea ce prezint A n plus fa de cutarea greedy de tip
best-first este reprezentat de faptul c ia n considerare distana deja parcurs
ncepnd cu un anumit nod (iniial), algoritmul extinde nodul cu cea
mai mic valoare a lui f ( x ) - nodul care are cel mai mic cost-per-beneficiu.
A menine o mulime de soluii pariale - noduri frunz neextinse -, stocat
ntr-o coad cu prioriti. Prioritatea asociat unui drum x este determinat de
funcia f ( x ) = g ( x ) + h( x ) . Funcia continu pn cnd o int are o valoare
corespunztoare f ( x ) mai mic dect a oricrui nod din coad (sau pn
cnd arborele va fi fost parcurs n totalitate). Multe alte inte pot fi trecute cu
vederea dac exist un drum care putea conduce la o int avnd costul
mai mic.
Cu ct f ( x ) are o valoare mai mic, cu att prioritatea este mai mare
(astfel, s-ar putea folosi o min-heap pentru a implementa coada)

54

function A*(start,goal)
var closed := the empty set
var q := make_queue(path(start))
while q is not empty
var p := remove_first(q)
var x := the last node of p
if x in closed
continue
if x = goal
return p
add x to closed
for each y in successors(x)
enqueue(q, p, y)
return failure

Mulimea nchis poate fi omis (transformnd algoritmul de cutare


ntr-unul mai maleabil) dac, fie existena soluiei este garantat, fie
membrul successors este adaptat ciclurilor (respinse).
Proprieti
Asemenea cutrii bredth-first, A este complet, n sensul c va
gsi ntotdeauna o soluie, n cazul n care aceasta exist.
Dac funcia euristic h este admisibil, adic nu supraestimeaz
costul minim actual de atingere a scopului, atunci A nsui este admisibil
(sau optimal) dac nu se folosete o mulime nchis. Dac se folosete o
astfel de mulime nchis, h ar trebui s fie de asemenea monoton (sau
consistent) pentru A astfel nct s fie optimal. A fi admisibil nseamn
c funcia euristic nu supraestimeaz ,niciodat , costul trecerii de la un nod
la vecinii si, n timp ce a fi monoton nseamn c dac exist o conexiune de
la nodul A la nodul C, respectiv o legtur de la nodul A la nodurile B i C,
costul estimat de la A la C va fi, ntotdeauna, mai mic sau egal cu cel estimat
de la A la B + costul estimat de la B la C. (Monotonia este cunoscut i sub
numele de inegalitate triunghiular). Formal, pentru toate drumurile (x, y),
unde y este un succesor al lui x:
g ( x ) + h( x ) g ( y ) + h ( y ) .

A este deopotriv eficient pentru orice euristic h, aceasta nsemnnd


c nici un alt algoritm ce folosete acelai euristic nu va extinde mai puine
noduri dect A , exceptnd doar cazul n care exist cteva soluii pariale
pentru care h prezice cu exactitate costul drumului optimal.
Optimalitatea n grafurile arbitrare nu garanteaz performane mai
mari ca algoritmii simpli de cutare, care dein mai multe informaii legate
de acest domeniu. Spre exemplu, ntr-un mediu de tip labirint, singura
posibilitate prin care se poate atinge scopul ar putea necesita o prim
parcurgere (ce evit inta), ntorcndu-se ulterior la int. Astfel, n acest

55

caz, probarea prioritar a nodurilor din imediata apropiere a destinaiei ar


putea implica un cost ridicat n ceea ce privete timpul implicat.
Cazuri speciale
n general vorbind, depth-first search i bredth-first search reprezint
dou cazuri speciale (particulare) ale algoritmului A . Algoritmul lui
Dijkstra, un alt exemplu de algoritm de tip best-first search (cutare
prioritar), reprezint un caz special al A , unde h( x ) = 0 x . Pentru
depth-first search (parcurgerea n adncime), putem considera c exist un
contabilizator C, iniializat cu o valoare foarte mare. De fiecare dat cnd
se proceseaz un nod i atam C corespunztor tuturor vecinilor si astfel
descoperii. Dup fiecare astfel de assign-are, micorm contabilizatorul C
cu o unitate. Astfel, cu ct un nod este descoperit mai repede, cu att
valoarea h(x) corespunztoare este mai mare.
De ce A este admisibil i optimal din punct de vedere
computaional

A este att admisibil, iar, pe de alt parte, implic i mai puine


noduri dect orice alt algoritm de cutare avnd acelai euristic, aceasta
deoarece A pornete de la cost aproximativ optim al drumului ce
parcurge toate nodurile, ctre int (optim nsemnnd c acel cost final
va fi cel puin la fel de mare cu cel estimat).
Cnd A finalizeaz cutarea, a gsit, prin definiie, un drum al crui
cost actual este mai mic dect costul estimat al oricrui alt drum ce parcurge
nodurile. Avnd n vedere, ns, faptul c aceste estimri sunt optimiste, A
poate ignora toate aceste noduri deschise. Cu alte cuvinte, A nu va omite
niciodat posibilitatea existenei unui drum avnd un cost mai mic, fiind
astfel admisibil.
S presupunem acum c un algoritm oarecare de cutare A finalizeaz
cutarea gsind un drum al crui cost nu este mai mic dect cel estimat.
Algoritmul A nu poate exclude posibilitatea existenei unui drum al crui
cost prin acel nod s fie mai sczut, bazndu-se pe informaia euristic pe
care o deine. Astfel, att timp ct A poate considera mai puine noduri dect
A* , nu poate fi admisibil. Deci, A reprezint algoritmul de cutare cu cele
mai puine noduri ce poate fi considerat ca fiind admisibil.
Complexitate
Complexitatea n timp a lui A depinde de euristic. Potrivit celui mai
sumbru scenariu, numrul nodurilor extinse este de ordin exponenial, n
ceea ce privete lungimea soluiei (cel mai scurt drum), ns este de ordin
polinomial atunci cnd funcia euristic h satisface urmtoarea condiie:

56

| h(x) h (x) | O(log h (x))


unde h reprezint euristicul optimal, i.e. costul exact ce-l implic drumul
de la x la int. Cu alte cuvinte, eroarea corespunztoare lui h nu ar trebui
s creasc mai rapid dect logaritmul euristicului perfect h , ce returneaz
distana real de la x la int.
O chestiune i mai problematic a A dect cea legat de
complexitatea n timp, o constituie uzul de memorie. n cel mai ru caz, ar
trebui s memoreze un numr exponenial de noduri. S-au elaborat mai multe
variante ale algoritmului A astfel nct s poat face fa acestei probleme,
printre care amintim: adncirea iterativ A (ID A ),

memoriagrani

(la limit) A (M A ), respectiv varianta simplificat a memoriei grani (la


limit) A (SM A ) i best-first search varianta recursiv (RBFS).

5.1.7. Algoritmul Floyd-Warshall


n tiina calculatoarelor, algoritmul Floyd-Warshall (ntlnit uneori
i sub denumirea de algoritmul Roy-Floyd sau algoritmul WFI, nc din
anul n care acest algoritm a fost descris de ctre Bernard Roy (1959))
reprezint un algoritm de analiz a grafului, n vederea gsirii celor mai
scurte drumuri ntr-un graf ponderat orientat. O singur execuie a
algoritmului va determina cel mai scurt drum ntre toate perechile de vrfuri.
Algoritmul Floyd-Warshall
reprezint un exemplu de programare
dinamic.
Algoritm
Algoritmul Floyd-Warshall compar toate drumurile posibile ale
grafului ntre fiecare pereche de vrfuri. Poate realiza acest lucru prin
intermediul a doar V

comparaii (acest lucru este remarcabil, innd cont

de faptul c ar putea exista V

muchii n graf, fiecare combinaie de astfel

de muchii fiind testat). Acest lucru este posibil prin mbuntirea


incremental a estimrii celui mai scurt drum ntre dou vrfuri, pn cnd
estimarea este considerat a fi optim.
Considerm un graf G, cu nodurile corespunztoare V, fiecare dintre
acestea fiind numerotat de la 1 la n. Mai mult, fie funcia shortestPath(i,j,k)
ce returneaz cel mai scurt drum posibil de la i la j, folosind doar vrfurile de
la 1 la k, pe post de puncte intermediare de-a lungul drumului. Acum, fiind
dat aceast funcie, scopul nostru l constituie gsirea celui mai scurt drum
de la fiecare i la fiecare j, folosind doar nodurile numerotate de la 1 la k+1.

57

Exist dou candidate la statutul de cel mai scurt drum, i anume: fie
adevratul cel mai scurt drum, ce folosete doar noduri ale mulimii (1k),
fie exist un anume drum ce unete i de k+1, pe acest k+1 de j, ce este mai
bun. tim c cel mai bun drum de la i la j, care folosete doar nodurile
mulimii (1k) este definit de shortestPath(i,j,k), i este evident faptul c
dac ar exista un drum mai bun de la i la k+1, respectiv la j, atunci lungimea
acestui drum ar reprezenta concatenarea celui mai scurt drum de la i la k+1
(folosind vrfuri ale mulimii (1k)), respectiv a celui mai scurt drum de la
k+1 la j (folosindu-se deopotriv vrfurile mulimii (1k)).
Astfel, putem defini shortestPath(i,j,k) n termenii urmtoarei
formule recursive:
shortestPath(i, j, k) = min(shortestPath(i, j, k 1) + shortestPath(i, k, k 1) +
+shortestPath(k, j, k 1));
shortestPath(i, j, 0) = edgeCost(i, j);
Aceast formul constituie inima lui Floyd Warshall. Algoritmul
funcioneaz calculnd mai nti shortestPath(i,j,1) pentru toate perechile de
tipul (i,j), folosind acest rezultat, ulterior, pentru a calcula shortestPath(i,j,2)
pentru toate perechile de tipul (i,j), etc. Acest proces continu pn cnd
k = n, iar drumul cel mai scurt corespunztor tuturor perechilor (i,j), folosind
nodurile intermediare, va fi fost gsit.
Pseudocodul
n mod convenabil, cnd se calculeaz cazul de ordinul k, se poate
rescrie informaia salvat la calculul corespunztor etapei k-1. Acesta
nseamn c algoritmul folosete memorie ptratic. (A se lua n considerare
condiiile de iniializare!):
1

/* Fie o funcie edgeCost(i,j) ce returneaz costul muchiei ce


unete vrfurile i i j
2
(infinit dac nu exist).
3
Presupunem de asemenea c n reprezint numrul nodurilor iar
edgeCost(i,i)=0
4 */
5
6 int path[][];
7
/*
O
matrice
2-Dimensional.
La
fiecare
pas
(etap)
a
algoritmului, path[i][j] constituie cel mai scurt drum
8 de la i la j folosind valorile intermediare ale mulimii(1..k-1).
Fiecare drum [i][j] este iniializat la
9
edgeCost(i,j).
10 */
11
12 procedure FloydWarshall ()
13
for k: = 1 to n
14
begin
15
for each (i,j) in (1..n)
16
begin
17
path[i][j] = min ( path[i][j], path[i][k]+path[k][j] );

58

18
end
19
end
20 endproc

Comportamentul n cazul ciclurilor negative


Pentru un rezultat numeric semnificativ, Floyd-Warshall presupun c
nu exist cicluri negative (de fapt, ntre oricare dou perechi de vrfuri care
reprezint parte constituent a unui ciclu negativ, drumul cel mai scurt nu
poate fi definit n mod corect deoarece drumul poate fi infinit de mic).
Totui, dac exist cicluri negative, Floyd-Warshall poate fi folosit pentru
identificarea acestora. Dac se ruleaz algoritmul nc odat, unele drumuri
pot s scad, ns nu se garanteaz c, ntre toate vrfurile, drumul
corespunztor va fi afectat de aceeai manier. Dac numrul de pe
diagonal matricei drumului este negativ, este necesar i suficient ca acest
vrf s aparin unui ciclu negativ.
Analiza
Gsirea tuturor n 2 ai Wk din cei ai Wk 1 necesit 2n 2 operaii.
innd cont de faptul c am considerat, iniial, W0 = WR , respectiv am
calculat secvenele matricelor cu elemente 0 i 1 de ordin n
W1 , W2 ,K , Wn = M ,
R

numrul total de operaii efectuate este


n 2 n 2 = 2n 3 .
Deci, complexitatea algoritmului este de ordinul O(n 3 ) i poate fi
rezolvat cu ajutorul unei maini deterministe ntr-un timp de ordin
polinomial.
Aplicaii i generalizri
Algoritmul Floyd-Warshall poate fi folosit, printre altele, la
rezolvarea urmtoarelor probleme:
Cele mai scurte drumuri n grafuri orientate (algoritmul Floyd)
nchiderea tranzitiv a grafurilor orientate (algoritmul
Warshall). n formularea original a algoritmului a lui Warshall,
graful nu este ponderat i este reprezentat cu ajutorul unei
matrice de adiacen boolean. Mai mult, operaia de adunare
este nlocuit de conjuncia logic (AND) iar operaia de
scdere de disjuncia logic (OR).
Gsirea unei expresii regulare, indicnd limbajul regulat,
acceptat de ctre un automat finit (algoritmul lui Kleene)
Inversarea matricelor reale (algoritmul Gauss-Jordan)
Rout-area optimal. n cazul acestei aplicaii preocuparea
principal o constituie gsirea drumului caracterizat de flux

59

maxim ntre dou vrfuri. Aceasta reprezint c, n loc s


considerm minimul ca n cazul pseudocodului de mai sus, vom
fi interesai de maxim. Costurile muchiilor constituie restricii n
ceea ce privete fluxul. Costurile drumului reprezint blocaje.
Astfel, operaia de sumare de mai sus este nlocuit cu operaia
corespunztoare minimului.
Testarea bipartiiei unui graf neorientat.

5.1.8. Algoritmul lui Johnson


Algoritmul lui Johnson reprezint o modalitate de gsire a celor mai
scurte drumuri ntre toate perechile de vrfuri ale unui graf rar orientat. El
permite ca, costurile unor muchii s fie numere negative, ns nu permite
existena ciclurilor ponderate negativ.
Descrierea algoritmului
Algoritmul lui Johnson const n urmtorii pai:
1. Pentru nceput, se adaug un nod nou q mulimii iniiale a
nodurilor, legat, prin muchii de ponderi nule, de toate celelalte
noduri.
2. n cea de-a doua etap, se folosete algoritmul Bellman-Ford,
ncepnd cu vrful nou introdus q, n vederea gsirii, pentru
fiecare vrf n parte, cel mai puin costisitor h(v) a unui drum
de la q la v. Dac n aceast etap se gsete un ciclu negativ,
algoritmul se oprete.
3. n continuare, muchiile grafului iniial sunt re-ponderate,
folosind valorile calculate de algoritmul Bellman-Ford: unei
muchii ce leag u i v, avnd lungimea w(u, v), i este ataat
noua lungime w (u, v)+h(u)-h (v).
4. n final, pentru fiecare nod s, se face apel la algoritmul lui
Dijkstra cu scopul de a gsi cele mai scurte drumuri de la s la
toate celelalte noduri ale grafului re-ponderat.
n graful re-ponderat, toate drumurile ntre o pereche de noduri s
respectiv t au o aceeai cantitate adugat h(s)-h(t), astfel c un drum cel mai
scurt n graful iniial rmne cel mai scurt n graful modificat i vice versa.
Totui, datorit modului de calcul al valorilor h(v), toate lungimile muchiilor
modificate sunt nenegative, asigurnd optimalitatea drumurilor gsite prin
intermediul algoritmului lui Dijkstra. Distanele n graful iniial pot fi
calculate cu ajutorul distanelor calculate cu algoritmul lui Dijkstra, n graful
re-ponderat, inversnd transformarea de re-valorare.
Analiza
Complexitatea n timp a algoritmului, folosind heap Fibonacci n
implementarea
algoritmului
lui
Dijkstra,
este
de
ordinul

60

O(| V |2 log | V | + | V || E |) : algoritmul folosete un timp de ordinul


O(| V || E |) pentru etapa Bellman-Ford a algoritmului, respectiv de ordinul
O (| V | log | V | + | E |) pentru fiecare din cele |V| apelri ale algoritmului lui
Dijkstra. Astfel, cnd graful este rar, timpul total poate fi mai rapid dect cel
corespunztor algoritmului Floyd-Warshall, care rezolv aceeai problem
ntr-un timp de ordinul O(| V |3 ) .

5.2.

Probleme de conexiune. Teorema lui Menger i aplicaii

Definiie. Fie G = (V,E) (di)graf i X, Y V . Numim XY drum n


G orice drum D n G de la un vrf x X la un vrf y Y , astfel nct V (D)
X = {x} i V (D) Y = {y}.
Vom nota cu D(X,Y;G) mulimea tuturor XY - drumurilor n G. S
observm c dac x X Y atunci drumul de lungime 0, D = {x} este XY drum.
Vom spune c drumurile D1 i D2 sunt disjuncte dac
V (D1) V (D2) = 0/ .
Probleme practice din reelele de comunicaie, dar i unele probleme
legate de conexiunea grafurilor i digrafurilor, necesit determinarea unor
mulimi de XY - drumuri disjuncte i cu numr maxim de elemente.
Vom nota cu p(X,Y;G) numrul maxim de XY drumuri disjuncte n
(di)graful G, numr ce a fost stabilit de Menger.
Definiie. Fie G = (V,E) un digraf i X, Y V . Numim mulime XYseparatoare n G o mulime Z V astfel nct D D(X, Y;G)

V (D) Z .
Notm cu
S(X,Y;G) = {Z | Z XY - separatoare n G},
k(X,Y;G) = min {|Z|;Z S(X, Y ;G)}.
Din definiie, rezult urmtoarele proprieti imediate ale mulimilor
XY - separatoare:
(a)
Dac Z S(X,Y;G) atunci D D(X,Y;G), D nu este drum n G Z.
(b)
X, Y S(X,Y;G).
(c)
Dac Z S(X,Y;G) atunci A astfel nct Z A V avem
A S(X,Y;G).
(d)
Dac Z S(X,Y;G) i T S(X,Z;G) sau T S(Z,Y;G) atunci
T D(X,Y;G).
Dm fr demonstraie urmtorul rezultat.
Teorem.
Fie G = (V,E) (di)graf i X, Y V . Atunci
p(X,Y;G) = k(X,Y;G).
61

Remarcm:
1)
Egalitatea min-max din enunul teoremei este interesant i conduce
la rezultate importante, n cazuri particulare.
2)
Teorema se poate demonstra i algoritmic ca o consecin a teoremei
fluxului maxim - seciunii minime.
Forma echivalent (a teoremei de mai sus) care a fost enunat i
demonstrat iniial de Menger este:
Teorem.
Fie G = (V,E) un (di)graf i s, t V, astfel nct s t, st E. Exist k
drumuri intern disjuncte de la s la t n graful G dac i numai dac
ndeprtnd mai puin de k vrfuri diferite de s i t, n graful rmas exist un
drum de la s la t.
Notm c dou drumuri sunt intern disjuncte dac nu au vrfuri
comune cu excepia extremitilor.
Am definit un graf G p-conex ( p N* ) dac G = Kp sau dac |G| > p
i G nu poate fi deconectat prin ndeprtarea a mai puin de p vrfuri.
Avem i rezultatul.
Corolar.
Un graf G este p-conex dac G = Kp sau st E(G) exist p
drumuri intern disjuncte de la s la t n G.
Determinarea numrului k(G) de conexiune a grafului G (cea mai
mare valoare a lui p pentru care G este p-conex) se reduce deci la
determinarea lui
max p({s},{t};G)
stE(G)

problem care se poate rezolva n timp polinomial.


Un caz particular interesant al teoremei 1, se obine atunci cnd G
este un graf bipartit iar X i Y sunt cele dou clase ale bipartiiei:
Teorem. (Konig)
Dac G = (S,R;E) este un graf bipartit, atunci cardinalul maxim al
unui cuplaj (o mulime independent de muchii) este egal cu cardinalul
minim al unei mulimi de vrfuri incidente cu toate muchiile grafului.

5.3.

Structura grafurilor p-conexe

Lem.
Fie G = (V,E) p-conex, |V|p+1,U V, |U| = p i x V-U. Exist n G
p U drumuri cu singurul vrf comun x.
Lem.
Dac G = (V,E) este un graf p - conex, p 2, atunci oricare ar fi dou
muchii e1 i e2 i p - 2 vrfuri x1, x2, . . . , xp2 exist un circuit n G care le
conine.
62

Teorem. (Dirac)
Dac G = (V,E) este un graf p-conex, p2, atunci prin orice p vrfuri
ale sale trece un circuit.
Pe baza acestei teoreme, se poate demonstra o condiie suficient de
hamiltonietate.
Teorem.
Fie G p-conex. Dac (G)p atunci G este hamiltonian.

5.4.

Problema drumului Hamiltonian

n teoria grafurilor Problema drumului Hamiltonian, respectiv cea


a Ciclului Hamiltonian reprezint probleme de determinare a existenei
unui drum Hamiltonian, respectiv a unui ciclu Hamiltonian ntr-un graf dat
(orientat sau nu). Ambele probleme sunt NP- complete.
Exist o relaie simpl ntre cele dou probleme. Problema Drumului
Hamiltonian pentru un graf G este echivalent cu problema Ciclului
Hamiltonian ntr-un graf H obinut din G prin adugarea unui nou nod, ce va
fi conectat cu toate nodurile grafului iniial G.
Problema Ciclului Hamiltonian este un caz special al problemei
Comis Voiajorului, obinut prin setarea distanei ntre dou orae la o
anumit valoare finit, dac acestea sunt adiacente, respectiv infinite dac
cele dou orae nu sunt adiacente.
Problemele Ciclului Hamiltonian orientat sau neorientat reprezint
dou din cele 21 de probleme NP complete ale lui Karp. Garey i Johnson
au artat la scurt timp dup aceasta, n anul 1974, c problema Ciclului
Hamiltonian orientat rmne NP complet pentru grafurile planare, iar
problema ciclului Hamiltonian neorientat rmne NP complet pentru
grafurile planare cubice.
Algoritmul aleatoriu
Un algoritm aleatoriu pentru un Ciclu Hamiltonian, care este destul
de rapid pentru ambele tipuri de grafuri, este urmtorul: Se ncepe ntr-un
nod oarecare, i se continu dac exist un vecin nevizitat. Dac nu mai
exist vecini nevizitai, iar drumul rezultat nu este Hamiltonian, se alege un
vecin la ntmplare, urmnd o rotaie folosindu-se pe post de pivot vecinul n
cauz.
Are loc urmtorul rezultat:
Teorema 1.
Fie G un graf cu cel puin trei vrfuri. Dac, pentru un s, G este sconex i conine o mulime neindependent cu mai mult de s vrfuri, atunci
G are un circuit Hamiltonian.
Aceast teorem ne arat c graful complet bipartit K(s,s+1) este sconex, conine mulimi neindependente cu mai mult de s+1 vrfuri i nu are

63

circuit Hamiltonian. Similar, graful Petersen este 3-conex, conine mulimi


neindependente cu mai mult de patru vrfuri i nu are circuit Hamiltonian.
Demonstraie.
Fie G ce satisface ipoteza Teoremei 1. Evident, G conine un circuit;
fie C cel mai lung circuit. Dac G nu are circuit Hamiltonian, atunci exist
un vrf x, x C. Deoarece G este s-conex, exist s drumuri ncepnd din x i
terminnd n C, care sunt perechi disjunctive desprite din x i partajeaz cu
C chiar n vrfurile lor terminale x1,x2,,xs. Pentru i=1,2,,s , fie yi
succesorul lui xi ntr-un ciclu ordonat fix al lui C. Nici un yi nu este adiacent
cu x altfel am putea nlocui muchiile xiyi n C prin drumul de la xi la yi n
afara lui C (ctre x) i am obine un circuit mai lung. Cu toate acestea, G nu
conine mulimi independente cu s+1 vrfuri i deci exist o muchie yiyj.
terge muchiile xiyi, xjyj din C i adug muchia yiyj mpreun cu drumul de
la xi la xj n afara lui C. n acest sens obinem un circuit mai lung dect C,
ceea ce este o contradicie.
Fie G un graf cu n vrfuri , n 3 . G nu conine vrfuri cu grad mai
1
mic dect k unde k este un ntreg astfel nct k ( n + 2 ) . Atunci G ori are
3
un circuit Hamiltonian, ori este separabil, ori are k+1 vrfuri independente.
Ca o consecin simpl a teoremei 1 obinem:
Teorema 2.
Fie G un graf s-conex fr mulimi independente de s+2 vrfuri.
Atunci G are un circuit Hamiltonian.
Demonstraie.
ntr-adevr, dac G satisface ipoteza Teoremei 2, atunci G+x (graful
obinut din G prin adugarea lui x i reunindu-l cu toate vrfurile lui G)
satisface ipoteza Teoremei 1 cu s+1 n loc de s. Aadar G+x are un circuit
Hamiltonian i G are un drum Hamiltonian. Graful bipartite complet
K(s,s+2) arat c Teorema 2 este evident.
Tehnica utilizat n demonstrarea Teoremei 1 ne d de asemenea
Teorema 3.
Fie G un graf s-conex ce nu conine s vrfuri independente. Atunci G
este Hamiltonian conex (i.e. fiecare pereche de vrfuri este unit printr-un
drum Hamiltonian).

5.5.

Problema Ciclului Hamiltonian

Punerea problemei
Problema Ciclului Hamiltonian (PCH) difer de Problema ComisVoiajorului (PCV) prin faptul c graful nu este neaprat complet i n plus nu
se cere ca ciclul s aib costul minim.

64

Fie G = (V,U) un graf conex neorientat. Fiecrei muchii i se ataeaz


un cost strict pozitiv. Ca urmare, graful va fi reprezentat prin matricea
costurilor C, avnd drept componente:
0, dac muchia (i, j) exist;
ci, j =
0, dac nu exist muchia (i, j);
Costul unui ciclu este definit ca sum a costurilor ataate muchiilor
componente.
Definiie. Se numete ciclu hamiltonian un ciclu care trece exact o
singura dat prin fiecare vrf.
Pentru determinarea ciclurilor Hamiltoniene vom folosi metoda
backtracking. Astfel, dac N = card(V), atunci o soluie oarecare a problemei
se poate scrie sub forma unui vector X = (x1,x2,...,xN+1) .
Condiiile de continuitate ce trebuie satisfcute n construcia soluiei
sunt:
- x1 = xN+1;
- xi xj, (i,j) cu i j;
- (xi, xi+1)U, i {1,...,N}.
Pentru a nu obine de mai multe ori acelai ciclu, se poate fixa x1=1.
Fie alese x1,..., xk-1 cu k{2,...,N}. Atunci, condiiile de continuitate, care
stabilesc dac o valoare a lui xk poate conduce la o soluie posibil, sunt
urmtoarele:
- muchie ntre vrfurile xk-1 i xk, cu xk {x1,..., xk-1}
- xN trebuie s ndeplineasc i condiia ca (xN, x1)U.
Procedura de calcul [1]
Procedura PCH (N, C, X)
/* i este varful din care incepe constructia ciclului */
x[1]=1
x[2]=1
k=2
while k>1
v=0
while x[k]<N
x[k]=x[k]+1
PROC1(c,X,N,k,v)
if v=1 then
exit
endif
repeat
if v=0 then
k=k-1
else
if k=N then

65

endif

if c[N,1]< then
x[N+1]=1
write x
endif
else
k=k+1
x[k]=1

endif
repeat
return
end
Procedura PROC1(c,N,X,k,v)
v = 0
if c[x[k-1],x[k]] = then
return
endif
for i=2, k-1
if x[k] = x[i] then
return
endif
repeat
v = 1
return
end

Nu se cunosc condiii necesare i suficiente direct verificabile pentru


a stabili dac ntr-un graf dat exist un ciclu hamiltonian.
Are loc urmtorul rezultat
Teorem.
ntr-un graf cu cel puin 3 vrfuri, cu proprietatea c gradul fiecrui
N
vrf este , unde N = |V|, exist un ciclu hamiltonian.
2
Demonstraie.
Fie G=(V,U) un graf cu proprietatea din enun. S presupunem prin
absurd c el nu conine nici un ciclu hamiltonian. Fie H=(V,D) graful obinut
din G prin adugarea de noi muchii ntre vrfurile neadiacente atta timp ct
acest lucru este posibil, fr ca astfel s se obin vreun ciclu hamiltonian.
N
Bineneles c i n H fiecare vrf are gradul .
2
Graful H nu este complet, deoarece ntr-un graf complet exist
evident un ciclu hamiltonian. Exist deci dou vrfuri i,j V, neadiacente n
H. Printr-o renumerotare a vrfurilor, putem considera c i = 1 i j = N.
Din modul de construcie al grafului H rezult c adugarea muchiei
(1, N) ar conduce la apariia unui ciclu hamiltonian.
Rezult deci c exist n H un lan L = {1, i1, ..., iN - 2, N} cu
{i1, ..., iN-2} = {2,...,N-1}.

66

Fie i j ,..., i j vrfurile adiacente vrfului 1.


1
k
N
Evident k .
2
Vrful N nu este adiacent cu nici unul dintre vrfurile i j ,..., i j
I 1
k 1
pentru c dac N ar fi adiacent cu i j
atunci s-ar obine urmtorul ciclu
s 1

hamiltonian: sublanul lui L ce unete pe 1 cu

ij

s 1

, muchia

(i j

, N ) sublanul din L ce unete pe N cu i j , muchia (i j , I ) , ceea ce nu


s
s
este posibil. Rezult c vrful N nu poate fi adiacent dect cu
N
N
N ( k +1) N 1 = 1
2
2
vrfuri, ceea ce duce la o contradicie, deoarece fiecare vrf din graful H are
N
, prin ipotez.
cel puin gradul
2
s 1

/* Program de construire a unui circuit hamiltonian de cost minim */


#include <stdio.h>
#include <conio.h>
#define max 21
#define inf 10000
int k,n,i,j,cont;
int c[max][max];
/* matricea costurilor deplasarilor intre 2
noduri*/
char nume[max][20];
/* numele nodurilor */
int cost_curent, cost_minim;
int x[max];
/* solutia curenta */
int y[max];
/* solutia de cost minim */
int PotContinua()
{
/* nodul curent (x[k]) trebuie sa fie vecin cu anteriorul nod */
if (c[x[k]][x[k-1]]==inf) return 0;
/* ultimul nod trebuie sa fie vecin cu primul */
if (k==n) if (c[x[n]][x[1]]==inf) return 0;
/* trebuie sa nu se mai fi trecut prin acest nod */
for (i=1; i<k; i++)
if (x[i]==x[k]) return 0;
return 1;
}
void main()
{
clrscr();
printf("Problema circuitului hamiltonian de cost minim\n\n");
printf("Scrieti numarul de noduri: ");
scanf("%d",&n);
for (i=1; i<=n; i++)

67

{
printf("Scrieti numele nodului %d: ",i);
scanf("%s",&nume[i]);
}
for (i=1; i<=n-1; i++)
for (j=i+1; j<=n; j++)
{
printf("Care este costul legaturii de la %s la
%s (0=infinit) ? ",nume[i],nume[j]);
scanf("%d",&c[i][j]);
if (c[i][j]==0) c[i][j]=inf;
c[j][i]=c[i][j];
}
x[1]=1;
k=2;
x[k]=1;
cost_minim=inf;
while (k>1)
{
cont=0;
while ((x[k]<n) && (!cont))
{
x[k]++;
cont=PotContinua();
}
if (cont)
if (k==n)
{
cost_curent=0;
for (i=1; i<n; i++)
cost_curent+=c[x[i]][x[i+1]];
cost_curent+=c[x[n]][x[1]];
if
(cost_curent<cost_minim)
{
cost_minim=cost_curent;
for (i=1; i<=n; i++)
y[i]=x[i
];
}
}
else x[++k]=1;
else --k;
}
printf("\n\nCircuitul de cost minim este: \n");
for (i=1; i<=n; i++)
printf("%s -> ", nume[y[i]]);
printf("%s", nume[y[1]]);
printf("\nCostul sau este : %d\n",cost_minim);
getch();
}

68

5.6.

Arborele parial de cost minim

Arborele parial de cost minim a unui graf planar. Fiecare muchie


este etichetat cu costul corespunztor, care, n exemplul de fa, este egal
cu lungimea sa.
Fiind dat un graf conex, neorientat, un arbore parial al acestui graf
este un subgraf, care este un arbore. Putem atribui, de asemenea, fiecrei
muchii, o valoare, care este reprezentat de un numr, ce indic ct de
dezavantajoas este.
Un arbore parial de cost minim sau arbore parial minim
ponderat este un arbore parial avnd valoarea mai mic sau cel mult
egal cu valoarea tuturor celorlali arbori pariali. Mai general, orice graf
neorientat are o pdure parial de cost minim.
Un astfel de exemplu l-ar putea constitui o companie de cablu TV,
care i desfoar cablurile ntr-un cartier nou. Dac exist o clauz
conform creia compania ar trebui s ngroape cablurile doar ntr-o anumit
poriune, atunci aceasta s-ar putea reprezenta cu ajutorul unui graf, n care,
prin intermediul drumurilor se vor conecta aceste regiuni. Unele dintre aceste
drumuri ar putea fi mai costisitoare, fiind mai lungi, sau fiind nevoie ca acele
cabluri s fie ngropate mai adnc; aceste drumuri se vor reprezenta cu
ajutorul muchiilor al cror costuri ataate vor fi mai mari. Un arbore parial
corespunztor acestui graf l-ar constitui o submulime a acelor drumuri care
nu au cicluri dar conecteaz toate imobilele. Ar putea exista mai muli astfel
de arbori pariali. Un arbore parial de cost minim ar fi reprezentat de acela
al crui cost total ar fi cel mai mic.
Proprieti
P1)
Posibil multiplicitate
Ar putea exista mai muli arbori pariali de cost minim avnd acelai
cost; n particular, dac toate aceste valori sunt egale, fiecare arbore parial
este minim.

69

P2)

Unicitatea
Dac fiecare muchie are un cost distinct, atunci exist un unic arbore
parial de cost minim. Demonstraia acestui lucru este trivial i se poate face
folosind inducia.
P3)
Subgraful de cost minim
Dac costurile sunt nenegative, atunci un arbore parial de cost
minim reprezint, de fapt, subgraful de cost minim ce conecteaz toate
nodurile, innd cont i de faptul c subgrafurile ce conin cicluri au,
implicit, o valoare total mai mare
P4)
Proprietatea ciclului
Pentru orice ciclu C al grafului, dac costul unei muchii e C este
mai mare ca valoarea tuturor celorlalte muchii din C, atunci aceast muchie
nu poate aparine unui MST (Minimal Spanning Tree (Arbore Parial de
Cost Minim)).
P5)
Proprietatea tieturii
Pentru orice tietur C din graf, dac costul unei muchii e din C este
mai mic dect toate costurile celorlalte muchii din C, atunci aceast muchie
aparine tuturor MST urilor (Arborilor pariali de cost minim)
corespunztori grafului. ntr-adevr, presupunnd contrariul, i.e., e nu
aparine unui MST T1, atunci adugnd e lui T1 va rezulta un ciclu, care
,implicit, trebuie s mai conin o alt muchie e2 din T1 n tietura C.
nlocuirea muchiei e2 cu e ar da natere unui arbore avnd un cost mai mic.
Algoritmi
Primul algoritm de gsire a unui arbore parial de cost minim a fost
conceput de ctre omul de tiin ceh Otakar Borvka n anul 1926
(algoritmul lui Borvka). Astzi se folosesc, cu precdere doi algoritmi, i
anume: Algoritmul lui Prim, respectiv Algoritmul lui Kruskal. Toi aceti trei
algoritmi sunt algoritmi greedy ,al cror timp de rulare este de ordin
polinomial, astfel c problema gsirii unor astfel da arbori se ncadreaz n
clasa P. Un alt algoritm greedy, ce-i drept nu prea folosit, este algoritmul
reverse - delete, opusul algoritmului lui Kruskal.
Cel mai rapid algoritm de gsire a arborelui parial de cost minim a
fost elaborat de ctre Bernard Chazelle, i se baza pe cel al lui Borvka.
Timpul su de rulare este de ordinul O(e(e, v)) , unde e reprezint numrul
muchiilor, v reprezint numrul vrfurilor, iar este funcionala clasic,
inversa funciei Ackermann. Funcia crete foarte ncet, astfel c n
scopuri practice poate fi considerat o constant nu mai mare ca 4; aadar
algoritmul lui Chazelle se apropie (d.p.d.v. al timpului de rulare) de O(e) .
Care este cel mai rapid algoritm ce poate rezolva aceast problem?
Aceasta este una din cele mai vechi ntrebri deschise a tiinei
calculatoarelor. Exist, n mod cert, o limit inferioar liniar, avnd n

70

vedere faptul c trebuie s examinm cel puin toate costurile. Dac aceste
costuri ale muchiilor sunt ntregi, atunci algoritmii determiniti sunt
caracterizai de un timp de rulare de ordinul O(e) . Pentru valorile generale,
David Karger a propus un algoritm aleatoriu al crui timp de rulare a fost
preconizat ca fiind liniar.
Problema existenei unui algoritm determinist al crui timp de rulare
s fie liniar, n cazul costurilor oarecare, este nc deschis. Cu toate acestea,
Seth Pettie i Vijaya Ramachandran au gsit un posibil algoritm determinist
optimal pentru arborele parial de cost minim, complexitatea computaional
a acestuia fiind necunoscut.
Mai recent, cercettorii i-au concentrat atenia asupra rezolvrii
problemei arborelui parial de cost minim de o manier paralel. De
exemplu, lucrarea pragmatic, publicat n anul 2003 Fast Shared-Memory
Algorithms for Computing the Minimum Spanning Forest of Sparse Graphs"
a lui David A. Bader i a lui Guojing Cong, demonstreaz un algoritm care
poate calcula MST de cinci ori mai rapid pe 8 procesoare dect un algoritm
secvenial optimizat. Caracteristic, algoritmii paraleli se bazeaz pe
algoritmul lui Borvka algoritmul lui Prim, dar mai ales cel al lui Kruskal
nu au aceleai rezultate n cazul procesoarelor adiionale.
Au fost elaborai mai muli astfel de algoritmi de calculare a arborilor
pariali de cost minim corespunztori unui graf mare, care trebuie stocat pe
disc de fiecare dat. Aceti algoritmi de stocare extern, aa cum sunt
descrii n "Engineering an External Memory Minimum Spanning Tree
Algorithm", a lui Roman Dementiev et al., pot ajunge s opereze cel puin de
dou pn la cinci ori mai lent ca un algoritm tradiional in-memory; ei
pretind c problemele aferente unui arbore parial de cost minim masiv, ce
ocup mai multe hard disk-uri, pot fi rezolvate pe un PC. Se bazeaz pe
algoritmi de sortare - stocare extern eficieni i pe tehnici de contracie a
grafului, folosite n scopul reducerii eficiente a mrimii acelui graf .

5.7.

Algoritmul lui Prim

Algoritmul lui Prim este un algoritm care gsete un arbore parial


de cost minim pentru un graf conex. Aceasta nseamn c gsete o
submulime de muchii care formeaz un arbore, ce include toate nodurile, iar
valoarea tuturor muchiilor arborelui corespunztor este minimizat.
Algoritmul a fost descoperit n anul 1930 de ctre matematicianul Vojtch
Jarnk, iar mai apoi, n mod independent, de ctre cercettorul n domeniul
calculatoarelor Robert C. Prim, n anul 1957, respectiv redescoperit de
Dijkstra n anul 1959. De aceea mai este numit, uneori, Algoritmul DJP sau
Algoritmul Jarnik.

71

Descriere
Algoritmul mrete n permanen dimensiunea arborelui iniial, care
conine un singur vrf, astfel nct la sfritul parcurgerii algoritmului acesta
(n.arborele) s se fi extins la toate nodurile.
Date de intrare: Un graf conex ponderat G = (V,E)
Iniializare: V = {x}, unde x este un nod arbitrar din V,
E = { }
Repet pn cnd V = V :
Alegei o muchie (u,v) din E, avnd valoare minim,
astfel nct u este din V iar v nu aparine mulimii V
(dac exist mai multe muchii ce au aceeai valoare,
alegerea uneia dintre ele este arbitrar)
Adugai v la V , adugai (u,v) mulimii E
Date de ieire: G = (V , E ) este arborele parial de cost

minim
Complexitate n timp
Complexitatea n timp (total) pentru:
cutarea cu ajutorul matricei de adiacen este |V|2;
- heap binar (ca n pseudocodul de mai jos) i lista de adiacen este:
O((|V| + |E|) log(|V|)) = |E| log(|V|)
- heap Fibonaci i lista de adiacen este:
|E| + |V| log(|V|)
O simpl implementare ce folosete o matrice de adiacen pentru
reprezentarea grafului, i care cerceteaz un tablou de costuri pentru a gsi
muchia de cost minim ce urmeaz a fi adugat, necesit un timp de rulare
de ordinul O(|V|2). Folosind o structur de date simpl de tip heap binar,
respectiv o reprezentare cu ajutorul listei de adiacen, se poate demonstra c
algoritmul lui Prim ruleaz ntr-un timp de ordinul
O(| E | log | V |) ,
unde |E| reprezint numrul muchiilor, iar |V| reprezint numrul vrfurilor.
Apelnd la mai sofisticata heap Fibonacci, acest timp de rulare poate fi redus
pn la
O(| E | + | V | log | V |) ,
semnificativ mai rapid pentru grafurile destul de dense (|E| este
(| V | log | V |) ).

72

Exemple.

Acesta este graful ponderat, iniial. Nu este arbore


Nevizitai: C, G
Fringe: A, B, E, F
Mulimea soluiilor: D

Cel de-al doilea nod ales este nodul cel mai apropiat lui D: A, cu un cost de
5.
Nevizitai: C, G
Fringe: B, E, F
Mulimea soluiilor: A, D

Urmtorul nod ales este acela situat n imediata apropiere fie a nodului D fie
a lui A. B se afl la o deprtare 9 de D, respectiv 7 fa de A, E la 15, iar F
la 6. 6 este cea mai mic valoare, astfel c vom marca vrful F i arcul DF.
Nevizitai: C
Fringe: B, E, G
Mulimea soluiilor: A, D, F

73

Se marcheaz nodul B, care se afl la o distan 7 de A. De data aceasta


arcul DB va fi colorat cu rou , deoarece att nodul B ct i nodul D au fost
marcate, deci nu mai pot fi folosite.
Nevizitai: null
Fringe: C, E, G
Mulimea soluiilor: A, D, F, B

n acest caz, putem alege ntre C, E i G.C se afl la o distana de 8 fa de


B, E la 7 faa de B, iar G la 11 fa de F. E este cel mai apropiat, astfel c va
fi marcat vrful E i arcul EB. Alte dou arce au fost colorate cu rou,
deoarece ambele legau noduri deja marcate
Nevizitai: null
Fringe: C, G
Mulimea soluiilor: A, D, F, B, E

n acest caz, singurele vrfuri disponibile sunt C i G. C se afl la o


distan 5 de E, iar G la 9 faa de E. Se alege aadar C, fiind marcat odat
cu arcul EC.
Nevizitai: null
Fringe: G
Mulimea soluiilor: A, D, F, B, E, C
74

Vrful G este singurul vrf rmas. Se afl la o distana 11 de F, respectiv 9


fa de E. E este mai aproape, astfel c l marcm mpreun cu arcul EG. La
acest moment toate vrfurile vor fi fost marcate, arborele parial de cost
minim fiind marcat cu verde. n acest caz, are o valoare de 39.
Nevizitai: null
Fringe: null
Mulimea soluiilor: A, D, F, B, E, C, G
Pseudocodul
Iniializare
Date de intrare: Un graf, o funcie ce returneaz costurile
muchiilor funcia costurilor, respectiv un nod iniial.
Starea iniial a tuturor vrfurilor: nevizitai, mulimea iniial de
vrfuri ce urmeaz a fi adugai arborelui, plasndu-le ntr-o Min-heap cu
scopul de extrage distana minim din graful minim.
for each vertex in graph
set min_distance of vertex to
set parent of vertex to null
set minimum_adjacency_list of vertex to empty list
set is_in_Q of vertex to true
set distance of initial vertex to zero
add to minimum-heap Q all vertices in graph.

Algoritm
n descrierea algoritmului de mai sus:
cel mai apropiat vrf este Q[0], acum ultima adugare
fringe este v n Q unde distana lui v < dup extragerea celui mai
apropiat vrf
nevizitat este v din Q pentru care distana corespunztoare v = ,
dup extragerea celui mai apropiat vrf

Bucla while se termin n momentul n care gradul minim


returneaz null. Lista de adiacen este astfel construit nct permite
ntoarcerea pe un graf direcionat.

75

Complexitatea n timp: |V| pentru bucl, log(|V|) pentru funcia de


ntoarcere
while latest_addition = remove minimum in Q
set is_in_Q of latest_addition to false
add latest_addition to (minimum_adjacency_list of (parent of
latest_addition))
add (parent of latest_addition) to (minimum_adjacency_list of
latest_addition)

Complexitate n timp: |E| / |V|, numr mediu de vrfuri


for each adjacent of latest_addition
if (is_in_Q of adjacent) and (weight-function(latest_addition,
adjacent) < min_distance of adjacent)
set parent of adjacent to latest_addition
set min_distance of adjacent to weightfunction(latest_addition, adjacent)

Complexitate n timp: log (|V|), nlimea heap


update adjacent in Q, order by min_distance

Demonstraia corectitudinii
Fie P un graf conex, ponderat.
La fiecare iteraie a algoritmului lui Prim, trebuie s se gseasc o
muchie ce leag un vrf ce aparine subgrafului de un altul din afara acestuia.
Avnd n vedere faptul c P este conex, va exista ntotdeauna un drum ctre
orice vrf.
Ceea ce rezult n urma parcurgerii algoritmului lui Prim este un
arbore Y, explicaia fiind dat de faptul c muchia i vrful adugate lui Y
sunt conexe. Fie Y1 un arbore parial de cost minim al lui Y.
Dac Y1 = Y atunci Y este un arbore parial de cost minim.
Altfel, fie e prima muchie adugat la construcia lui Y, muchie ce
nu este n Y1 , i fie V mulimea vrfurilor conectate prin intermediul
muchiilor adugate naintea muchiei e. Atunci unul dintre vrfurile ce
compun muchia e se va gsi n V iar cellalt nu. innd cont de faptul c Y1
este un arbore parial al lui P, exist un drum n Y1 ce unete aceste dou
vrfuri. Pe msur ce se parcurge acest drum, trebuie s se gseasc o
muchie f ce unete un vrf din V de un altul ce nu se gsete n V. Acum, la
momentul iteraiei n care e este adugat lui Y, exist posibilitatea ca i f s
fi fost adugat, acest lucru fiind posibil n eventualitatea deinerii unui cost
mai mic dect cel al muchiei e.

76

Dat fiind faptul c f nu a fost adugat deducem c


w ( f ) w (e) .
Fie Y2 graful obinut prin nlturarea muchiei f, respectiv adugarea
muchiei e din Y1 .
Se arat uor faptul c Y2 este conex, are acelai numr de muchii ca
i Y1 , iar costul total al muchiilor constituente nu-l depete pe cel al lui Y1 ,
astfel c este de asemenea un arbore parial de cost minim al lui P, coninnd
muchia e i toate celelalte muchii ce o precedau n construcia V.
Repetnd paii anteriori vom putea obine un arbore parial de cost
minim al lui P, identic cu Y.
Aceasta demonstreaz c Y este un arbore parial de cost minim.

5.8.

Algoritmul lui Kruskal

Algoritmul lui Kruskal este un algoritm n teoria grafurilor, care


determin arborele parial de cost minim pentru un graf conex ponderat.
Aceasta nseamn c determin o submulime de muchii care formeaz un
arbore ce include fiecare vrf, iar valoarea total a costurilor ataate
muchiilor arborelui este minimizat. Dac graful nu este conex, atunci
algoritmul determin o pdure parial de cost minim (cte un arbore parial
de cost minim pentru fiecare component conex). Algoritmul lui Kruskal
reprezint un exemplu de algoritm greedy.

Este un exemplu pentru algoritmul lui Kruskal


Principiul de funcionare (al algoritmului):
construiete o pdure F (o mulime de arbori), n care fiecare nod
al grafului simbolizeaz un arbore individual
construiete o mulime S, ce conine toate muchiile grafului
ct timp S este nevid

77

se terge o muchie avnd valoarea cea mai mic din


mulimea S
dac acea muchie leag doi arbori diferii, atunci adaug
aceti arbori pdurii, combinndu-i ntr-unul singur
altfel, elimin muchia respectiv
Acest algoritm a aprut pentru prima dat n Proceedings of the
American Mathematical Society, n anul 1956, i a fost scris de ctre Joseph
Kruskal.
Funcionare
innd cont de faptul c |E| reprezint numrul muchiilor grafului, iar
|V| reprezint numrul vrfurilor grafului, se poate demonstra c timpul de
rulare al algoritmului lui Kruskal este de ordinul O(| E | log | E |) , sau,
echivalent, de ordinul O(| E | log | V |) , n cazul structurilor de date simple.
Aceti timpi de rulare sunt echivaleni deoarece:
|E| este cel mult | V |2 , iar
log | V |2 = 2 log | V |
este
O(log | V |) .
Dac ignorm vrfurile izolate, care vor constitui propriile
componente ale arborilor pariali de cost minim, | V | 2 | E | , astfel c
log | V | este O(log | E |) .
Putem obine aceasta astfel: se sorteaz, pentru nceput, muchiile,
dup costuri folosind o sortare de comparare, al crui timp de rulare este de
ordinul O(| E | log | E |) ; acest lucru permite pasului elimin o muchie de
cost minim din S s opereze ntr-un timp constant. n continuare, folosim o
mulime de separaie a structurilor de date, astfel ca s se poat contabiliza
vrfurile i apartenena la anumite componente. Este nevoie de execuia a
O(| E |) operaii, pentru gsirea operaiilor i a unei posibile uniuni pentru
fiecare muchie n parte. Chiar i o simpl structur de date de tip mulime de
separaie, cum ar fi pdurile pot executa O(| E |) operaii ntr-un timp de
ordinul O(| E | log | V |) . Astfel, timpul total este
O(| E | log | E |) = O(| E | log | V |) .
Dac muchiile sunt deja sortate sau pot fi sortate ntr-un timp liniar,
algoritmul poate folosi structuri de date de tip mulime de separaie mult mai
sofisticate pentru a rula ntr-un timp de ordinul O(| E || (V) |) , unde
reprezint inversul unei funcii ponderate-singular Ackermann, ce crete
foarte ncet.

78

Exemplu

Acesta este graful iniial. Numerele ataate muchiilor indic valoarea


acestora. Nici unul dintre aceste arce nu este colorat.

AD i CE sunt cele mai scurte arce, avnd lungimea 5, iar AD a fost ales
arbitrar, astfel c apare colorat

Oricum, CE este , la momentul actual, cel mai scurt arc care nu formeaz
bucl, de lungime 5, astfel c este colorat.

Arcul urmtor, DF de lungime 6, este colorat, pe baza aceluiai principiu.


79

Urmtoarele cele mai scurte arce sunt AB i BE, ambele avnd lungimea 7.
Se alege n mod arbitrar AB, i se coloreaz. Arcul BD se coloreaz cu rou,
deoarece ar forma o bucl ABD dac ar fi ales.

Procesul continu colornd urmtorul cel mai scurt arc, BE de lungime 7.


Mult mai multe arce sunt colorate cu rou n aceast etap:BC deoarece ar
forma bucla BCE, DE deoarece ar forma bucla DEBA, respectiv FE
deoarece ar forma FEBAD.

n cele din urm, procesul se ncheie cu arcul EG de lungime 9, gsindu-se


arborele parial de cost minim.
Demonstraia corectitudinii
Fie P un graf conex, ponderat i fie Y subgraful lui P, rezultat al
algoritmului. Y nu poate conine cicluri, odat ce aceast din urm muchie
adugat ciclului respectiv ar fi aparinut unui subarbore i nu ar fi fcut
legtura ntre doi arbori diferii. Y nu poate fi neconex , avnd n vedere
faptul c prima muchie ntlnit ce unete dou din componentele lui Y este
aleas de ctre algoritm. Astfel, Y este arbore parial al lui P.
Rmne de demonstrat faptul c arborele parial Y este de cost
minim:
80

Fie Y1 un arbore parial de cost minim. Dac Y = Y1 atunci Y este un


arbore parial de cost minim. Altfel, fie e prima muchie considerat de ctre
algoritm, muchie ce este n Y dar nu este n Y1 . Y1 e conine un ciclu,
deoarece nu se poate aduga o muchie unui arbore parial astfel nct s
continum s avem un arbore. Acest ciclu conine o alt muchie f ,care, n
etapa n care e a fost adugat, nu a fost luat n considerare. Aceasta din
pricina faptului c n acest caz e nu ar fi conectat arbori diferii, ci dou
ramuri ale aceluiai arbore. Astfel, Y2 = Y1 e \ f este, de asemenea, un
arbore parial. Valoarea sa total este mai mic sau cel mult egal cu
valoarea total a lui Y1 . Aceasta se ntmpl deoarece algoritmul viziteaz
muchia e naintea muchiei f, i drept urmare w ( e ) w ( f ) . Dac se ntmpl
ca aceste valori s fie egale, considerm urmtoarea muchie e, ce se gsete
n Y dar nu n Y1 . Dac nu mai sunt astfel de muchii, valoarea lui Y este egal
cu cea a lui Y1 , dei sunt caracterizai de mulimi diferite de muchii, iar Y este
de asemenea un arbore parial de cost minim. n cazul n care valoarea lui Y2
este mai mic dect valoarea lui Y1 , putem concluziona c acesta din urm
( Y1 ) nu este un arbore parial de cost minim, iar presupunerea conform creia
exist muchii e, f cu w ( e ) < w ( f ) este fals. De aceea, Y este un arbore
parial de cost minim (egal cu Y1 sau cu o alt mulime de muchii, dar avnd
aceeai valoare).
Pseudocodul
1
function Kruskal(G)
2
for each vertex v in G do
3
Define an elementary cluster C(v) {v}.
4
Initialize a priority queue Q to contain all edges in G,
using the weights as keys.
5
Define a tree T
//T will ultimately
contain the edges of the MST
6
// n is total number of vertices
7
while T has fewer than n-1 edges do
8
// edge u,v is the minimum weighted route from/to v
9
(u,v) Q.removeMin()
10
// prevent cycles in T. add u,v only if T does not already
contain an edge consisting of u and v.
// Note that the cluster contains more than one vertex only
if an edge containing a pair of
// the vertices has been added to the tree.
12
Let C(v) be the cluster containing v, and let C(u) be the
cluster containing u.
13
if C(v) C(u) then
14
Add edge (v,u) to T.
15
Merge C(v) and C(u) into one cluster, that is, union C(v) and
C(u).
16
return tree T

81

82

Capitolul 6
PROBLEME DE FLUXURI N REELE

6.1.

Problema fluxului maxim

Numim reea (de transport) cu intrarea s i ieirea t, 4 uplul


R = (G,s,t,c) unde:
G = (V, E) este un digraf;

s, t V, s t, d G
(s) > 0, d G
(t) > 0 ;

c : E R + , c(e) este capacitatea arcului e.


Vom presupune c
V = {1, 2, ..., n} ( n N )

i c
|E| = m.
Extindem funcia c la
c : V V R+
prin:
c(ij), ij E
c((i, j)) =
ij E
0,

i vom nota c((i,j)) = cij .


Definiie. Numim flux n reeaua R = (G,s,t,c) o funcie
x : V V R care satisface
0 x ij cij , ij V V ;
(i)
(ii)

x ji x ij = 0, i V {s, t} .

jV

jV

Dac ij E atunci x ij se numete fluxul (transportat) pe arcul ij.


Evident, condiia (i) cere ca fluxul pe orice arc s fie nenegativ i
subcapacitar, iar condiia (ii) (legea de conservare a fluxului) cere ca suma
fluxurilor pe arcele care intr n vrful i s fie egal cu suma fluxurilor pe
arcele care ies din vrful i.
Cu convenia fcut la extensia funciei de capacitate, se observ
c pentru perechile (i, j) care nu sunt arce n reea condiia (i) impune ca
fluxul s fie 0, i evident cele doua definiii sunt echivalente.
Dac se sumeaz relaiile (ii) (pentru i V {s, t} ) se obine:

83

0 = x ji x ij = x ji x ij +

i s, t j s,t
i s, t jV
jV
i s, t j s, t

+ x si + x ti x is x it = x is x si x it x ti ,
i s, t
i s, t
i s,t
i s, t
i
i
i
i

Definiie. Dac x este un flux n reeaua R = (G,s,t,c) se numete


valoarea fluxului x numrul
v(x) = x jt x tj .
jV

jV

v(x) se poate interpreta ca fiind fluxul net care ajunge n ieirea reelei sau
(conform egalitii obinute mai sus) fluxul net care iese din intrarea reelei.
n orice reea R = (G,s,t,c) exist un flux, fluxul nul x ij = 0 ij , de
valoare 0.
Problema fluxului maxim
Dat R = (G,s,t,c) o reea, s se determine un flux de valoare maxim.
Problema se poate formula, ca o problem de programare liniar:
max v

x ji x ij = 0, i s, t
j
j

x js x sj = v
j
j

x jt x tj = v
j
j
0 x ij cij ij

Definiie. Dac P este un drum n G , multigraful suport al digrafului


G, i e = vi v j este o muchie a lui P atunci:
-

dac e corespunde arcului vi v j al lui G, e se numete arc direct al


drumului P;
dac e corespunde arcului v j vi al lui G, atunci e se numete arc

invers.
Definiie. Fie R = (G,s,t,c) i x flux n R. Se numete C-drum (n R
relativ la fluxul x) un drum D n G cu proprietatea c ij E(D) :
x ij < cij dac ij este arc direct;

x ji > 0 dac ij este arc invers.

84

Dac D este un C drum i ij E(D) , se numete capacitate


rezidual a lui ij (relativ la C drumul D) numrul
cij x ij , ij arc direct n D
r(ij) =
ij arc invers n D.
x ji ,
Capacitatea rezidual a drumului D este:
r(D) = min r(e) .
eE(D)

Definiie. Se numete drum de cretere a fluxului x, n reeaua R =


(G,s,t,c), un C-drum de la s la t.
Se arat c:
Lem.
Dac D este un drum de cretere a fluxului x n reeaua R = (G,s,t,c),
atunci x1 = x r(D) definit prin
x ,
ij
1
x ij = x ij + r(D),

x ij r(D),

ij E(D)
ij E(D), ij arc direct n D
ji E(D), ji arc invers n D

este flux n R i v(x1 ) = v(x) + r(D) .


Rezult c dac x admite un drum de cretere atunci x nu este flux de
valoare maxim.
Definiie. Fie R = (G,s,t,c). Se numete seciune n reeaua R, o
partiie (S,T) a lui V cu s S i t T .
Capacitatea seciunii (S,T) este
c(S, T) = cij
iS jT

(suma capacitilor arcelor de la S la T).


Se arat c:
Lem.
Dac x este un flux n R = (G,s,t,c) i (S,T) este o seciune a reelei,
atunci
v(x) = (x ij x ji )
iS jT

(valoarea fluxului este egal cu fluxul net ce trece prin orice seciune)
Lem. Dac x este un flux n R = (G,s,t,c) i (S,T) este o seciune,
atunci v(x) c(S,T).
Teorem. (Teorema drumului de cretere)
Un flux x este de valoare maxim ntr-o reea R, dac i numai dac,
nu exist drumuri de cretere a fluxului x n reeaua R.

85

S observm c i S i j T avem:
- dac ij E atunci x ij = cij i
- dac ji E atunci x ji = 0
(altfel, C-drumul de la s la i se poate extinde la un C-drum de la s la j).
Deci, conform lemei precedente:
v(x) = (x ij x ji ) = (cij 0) = c(S, T)
iS jT

iS jT

i prin urmare x este flux de valoare maxim.


Teorem. (Teorema fluxului ntreg)
Dac toate capacitile sunt ntregi, atunci exist un flux de valoare
maxim cu toate componentele ntregi (flux ntreg de valoare maxim).
Demonstraie.
Fie algoritmul
1:

x 0 0; i 0;

2:

while ( P drum de cretere relativ la x i ) do


i
{

x i +1 x i r(Pi ) ;
i + +
}

Se observ c x i are componente ntregi este un invariant al


algoritmului (din definiia lui r(Pi ) , dac toate capacitile sunt ntregi,
rezult c r(Pi ) este ntreg n ipoteza c x i este ntreg) i c la fiecare
iteraie a pasului 2 valoarea fluxului curent crete cu mcar o unitate, deci
pasul 2 se repet de cel mult c({s}, V {s}) Z + ori. Fluxul final obinut
este de valoare maxim.
Observaie. Algoritmul, descris mai sus, este finit i n cazul
capacitilor raionale.
Teorem. ( Ford-Fulkerson)
Valoarea maxim a unui flux n reeaua R =(G,s,t,c) este egal cu
capacitatea minim a unei seciuni a reelei.
Demonstraie.
Dac dispunem de un algoritm care, pornind de la un flux iniial x 0
( x 0 exist ntotdeauna, de exemplu x 0 = 0), construiete ntr-un numr finit
de pai un flux x, care nu admite drumuri de cretere, atunci seciunea

86

construit n demonstraia teoremei antecedente satisface mpreun cu x


enunul teoremei.
Pentru cazul capacitilor raionale algoritmul descris satisface
aceast condiie.
Pentru cazul capacitilor reale exist un algoritm, datorat lui
Edmonds i Karp.
Algoritmul lui Ford i Fulkerson pentru aflarea unui flux de
valoare maxim
Se va folosi un procedeu de etichetare a vrfurilor reelei, n vederea
depistrii drumurilor de cretere a fluxului curent x. Dac nu exist drumuri
de cretere, fluxul va fi de valoare maxim.
Eticheta atribuit unui vrf j V are trei componente (e1 , e2 , e3 )
unde e1 V {0} , e2 {direct, invers}; e3 R +
semnificaie:
- dac e2 = direct i e1 = i atunci

i au urmtoarea

un C-drum P de la s la j cu ultimul arc ij, arc direct i r(P) = e3 ;


- dac e2 = invers i e1 = i atunci
un C-drum P de la s la j cu ultimul arc ij, arc invers i r(P) = e3 .
Iniial, se eticheteaz sursa s cu eticheta (0, . , ) . Celelalte vrfuri
primesc etichet prin cercetarea vrfurilor deja etichetate:
Dac i este un vrf etichetat, atunci j V :
- dac j neetichetat,
ij E i x ij < cij
atunci j se eticheteaz
e = (i, direct, min(e3 [i], cij x ij )) ;
-

dac j neetichetat,

ji E i x ji > 0
atunci j se eticheteaz
e = (i,invers, min(e3 [i], x ji )) .
Evident, n acest fel se respect semnificaia celor trei componente
ale etichetelor.
Numim aceast procedur etichetare(i).
Atunci cnd n procedura de etichetare s-a atribuit etichet vrfului t,
s-a obinut un drum de cretere P a fluxului curent, de capacitate rezidual
r(P) = e3 [t] i ale crui vrfuri se depisteaz n O(n) explornd prima
component a etichetelor. Modificarea fluxului x r(P) se execut n acest
mers napoi, tot n O(n).
87

Pentru noul flux se reia procedura de etichetare.


Dac toate vrfurile etichetate au fost cercetate i nu s-a reuit
etichetarea vrfului t, rezult c fluxul curent nu admite drumuri de cretere,
este deci de valoare maxim, iar dac S = mulimea vrfurilor etichetate
atunci (S, V S) este o seciune de capacitate minim.
Descrierea algoritmului
1.
2.

3.

Se alege x = (x ) flux iniial (de exemplu fluxul nul);


ij
Se eticheteaz s cu (0, . , ) .
while ( vrfuri etichetate necercetate) do
{
alege un vrf etichetat i necercetat i;
etichetare(i);
if (t a primit etichet) then
{
modific fluxul pe drumul dat de etichete;
terge toate etichetele;
eticheteaz s cu (0, . , )
}
}
S {i i are etichet}

T V S
x este flux de valoare maxim.
(S,T) este seciune de capacitate minim.

Complexitatea algoritmului
Pentru fiecare cretere a fluxului, sunt necesare cel mult 2m (m = |E|)
inspecii de arce n vederea etichetrii.
Dac toate capacitile sunt ntregi atunci vor fi necesare cel mult v
(v = valoarea fluxului maxim) creteri succesive. Rezult c algoritmul are
complexitatea O(mv).
Dac U este o margine superioar a capacitilor arcelor atunci
v (n 1)U
((n 1)U este o margine superioar a capacitii seciunii
({s}, V {s})),
deci algoritmul are complexitatea
O(nmU).
Dezavantajele algoritmului sunt legate de neconvergena n cazul
capacitilor iraionale (dei practic, n implementri nu este cazul), i de
faptul ca mrimile capacitilor influeneaz comportarea sa, acestea
neconstituind o msur a volumului datelor de intrare.

88

6.2.

Fluxuri de cost minim

Fie R = (G,s,t,c) o reea i x un flux de la s la t n R.


Considerm a : E R o funcie de cost care asociaz fiecrui arc
ij E , a(ij) = a ij costul (transportului unei uniti de flux) pe arcul ij.
Costul fluxului x se definete ca fiind
a(x) = a ij x ij .
i, j

Problema fluxului de cost minim


Dat R o reea, v R + i a : E R funcie de cost, s se determine
x 0 flux n R astfel nct

a(x 0 ) = min {a(x) x flux n R, v(x) = v} .

Observm c, dac v nu depete valoarea fluxului maxim n reeaua


R, atunci problema are ntotdeauna soluii, a(x) fiind liniar, iar mulimea
fluxurilor de valoare dat v fiind mrginit i nchis n R m .
Definiie. Fie x un flux n R = (G,s,t,c) i a : E R o funcie de
cost.
Dac P este un C-drum n R relativ la fluxul x, atunci costul drumului
P se definete
a(P) = a ij a ji .
ijP
ij direct

ijP
ij invers

Dac C este un C-drum nchis, a(C) se calculeaz dup aceeai


formul, dup stabilirea unui sens de parcurgere a lui C (este posibil ca
ambele sensuri de parcurgere ale lui C s satisfac definiia unui C-drum).
Din definiia dat, rezult c dac P este drum de cretere relativ la
1.
fluxul x, atunci x1 = x r(P) este un flux de valoare v(x1 ) = v(x) + r(P) i
de cost a(x) + r(P) a(P) .
2.

Dac C este un C-drum nchis relativ la x, atunci x1 = x r(C) este

un flux de valoare v(x1 ) = v(x) i de cost a(x1 ) = a(x) + r(C) a(C) .


Dac a(C) < 0 atunci x1 este un flux de aceeai valoare ca i x, dar de
cost strict mai mic.
Teorem.
Un flux de valoare v este de cost minim dac i numai dac nu admite
C - drumuri nchise de cost negativ.
Demonstraie.
Necesitatea este evident din observaia anterioar.

89

Suficiena.
Fie x un flux de valoare v, care nu admite C - drumuri
nchise de cost negativ.

Fie x un flux de valoare v, de cost minim astfel nct


(x, x ) = min{ (x, x ') x ' flux de valoare v i cost minim}

unde (x, x ') = | ij x ij x 'ij | .


Dac (x, x ) = 0 rezult c x = x i deci x este de cost minim.
Dac

(x, x ) > 0 , fie ij astfel nct

x ij xij . Presupunem

0 x ij < x ij cij (astfel, raionamentul este similar). Din legea de conservare


a fluxurilor rezult c

jk E astfel nct 0 x jk < xjk c jk


sau

kj E astfel nct 0 xkj < x kj c jk .


Repetnd acest raionament, deoarece numrul vrfurilor este finit, se
va obine C, un C-drum nchis relativ la x n R.
Considernd sensul invers de parcurgere pe C se obine un C-drum
C ' , nchis relativ la x .
Deoarece a(C) 0 din ipotez, iar a( C ' ) = a(C), rezult, din

necesitatea teoremei ( x este de cost minim), c a(C) = 0.


Modificnd fluxul x cu ( C ' ) pe C ' , unde
(C ') = min{

min

kj direct n C '

x kj xkj ,

xjk x jk }
kj invers n C '
min

se obine un flux x ' cu


v(x ') = v(x ) = v , a(x ') = a(x ) + (C ') a(C ') = a(x ) ,
deci de cost minim, dar, cu (x, x ') < (x, x ) , contradicie.
Deci (x, x ) = 0 .
Teorem.
Dac x este un flux de valoare v i de cost minim iar P0 este un drum
de cretere, astfel nct
a(P0 ) = min{a(P) P drum de cretere relativ la x}
atunci x1 = x r(P0 ) este un flux de valoare v(x1 ) = v + r(P0 ) i de cost
minim.

90

Linia demonstraiei este urmtoarea: presupunnd prin reducere la


absurd c x1 nu este de cost minim, atunci x1 admite un C drum nchis C
de cost negativ. Cum x era flux de cost minim rezult c E(C) E(P0 ) 0/ .
Dac ij E(C) E(P0 ) , atunci va rezulta c P0 C ij conine un
drum de cretere relativ la x de cost mai mic dect P0 .
Un drum de cretere de cost minim poate fi depistat cu ajutorul
algoritmilor de drum minim.
Dac x este un flux n R i a : E R este funcia de cost atunci
considernd a ij = dac ij E (caz n care x ij = 0 ), construim
x ij < cij i x ji = 0
a ij ,

min{a ij , a ji }, x ij < cij i x ji > 0


a ij =
x ij = cij i x ji > 0
a ji ,
,
x ij = cij i x ji = 0

Un drum de pondere minim de la s la t n raport cu ponderile aij


corespunde unui drum minim de cretere n R relativ la fluxul x.
Un circuit de pondere negativ n raport cu ponderile aij corespunde

unui C drum nchis n R relativ la x, de cost negativ.


Rezult, urmtorul algoritm pentru rezolvarea problemei fluxului de
cost minim.
Algoritm generic de rezolvare a problemei fluxului de cost minim
{
0:

Se consider x = ( x ) un flux cu valoarea v ' v ;


ij

{x poate fi fluxul nul sau un flux y determinat cu


ajutorul algoritmului de flux maxim i apoi
considernd x =
1:

2:

v
y}
v(y)

while ( circuite de pondere < 0 relativ la a ) do


ij
{
determin un astfel de circuit;
modific fluxul pe acest circuit
}
while v(x) < v do
{
aplic un algoritm de drum minim n raport cu
ponderile a pentru depistarea unui C drum
ij

P de cost minim;

x x min(r(P), v v(x))

}
}

91

Complexitatea pentru pasul 2 este O( n 3 v ), dac se pleac de la


fluxul nul. Se poate dovedi c pasul 1 se poate implementa astfel ca numrul
iteraiilor s fie O( nm 2 log n ).
n continuare se prezint o nou descriere a algoritmului lui Ford i
Fulkerson i se aplic acest algoritm pe un exemplu.

6.3.

Algoritmul Ford-Fulkerson

Algoritmul Ford-Fulkerson (denumit astfel dup L.R. Ford, Jr i


D.R. Fulkerson) calculeaz fluxul maxim ntr-o reea de fluxuri. A fost
publicat 1956.
Ideea algoritmului este foarte simpl: Atta timp ct exist un drum
de la surs la int, cu capaciti disponibile pe toate muchiile drumului, vom
trimite flux pe unul din aceste drumuri. Se gsete, ulterior, un astfel de drum
i aa mai departe. Un drum cu capaciti disponibile se numete drum de
cretere.
Algoritmul
Se d un graf G = (V,E), avnd capacitatea c(u,v) i fluxul f(u,v)=0
pentru muchia de la u la v. Vrem s gsim fluxul maxim de la sursa s la inta
t. Dup fiecare pas al algoritmului se menin urmtoarele:
f (u , v ) c(u , v ) . Fluxul de la u la v nu depete capacitatea.
f (u , v ) = f (v, u ) . Se menine fluxul net ntre u i v. Dac n
realitate a uniti trec de la u la v, iar b uniti trec de la v la u, meninem
f (u , v ) = a b i f (v, u ) = b a .

f (u, v ) = 0 f (u ) =
in

f out (u ) .

Pentru

toate

nodurile

u,

exceptnd s i t. Fluxul ce intr ntr-un nod trebuie s fie egal cu cel ce iese
din nodul respectiv.
Aceasta nseamn c fluxul prin reea este ceea ce numim flux
legal dup fiecare etap parcurs a algoritmului. Definim reeaua
rezidual G f (V , E f ) ca fiind reeaua cu capacitate

c f (u , v ) = c(u, v ) f (u, v )
i fr flux. A se ine cont de faptul c nu se tie cu certitudine c
E = Ef ,
deoarece se poate ntmpla ca, trimind flux pe (u, v) acesta s se blocheze
(satureze), ns d natere unei noi muchii (v, u) n reeaua rezidual.
Algoritmul Ford-Fulkerson
Date de intrare:
Graful G cu capacitatea c, nodul surs s i
nodul int t.
Date de ieire:
Un flux maxim f de la s la t

92

1. f ( u, v ) 0 pentru toate muchiile (u, v)


2. Ct timp exist un drum P de la s la t, astfel nct
c f (u, v) > 0 pentru toate muchiile ( u, v ) P :
1. Gsirea c f

2. Pentru fiecare muchie


1.

( p ) = min c f ( u, v ) ( u, v ) p

( u, v ) P
( p)

f ( u, v ) f ( u, v ) + c f

(Se trimite flux de-a lungul drumului)


2.

f ( v, u ) f ( v, u ) c f

( p)

(Fluxul ar putea fi ntors ulterior)

Drumul poate fi gsit cu ajutorul, spre exemplu, metodei breadth-first


search sau al metodei depth-first search n graful G f (V , E f ) . Dac se
folosete cel dinti, algoritmul se numete Edmonds-Karp.
Complexitate
Fluxul maxim va fi atins n momentul n care nu vor mai fi gsite
drumuri ce permit creterea fluxului corespunztor. Cu toate acestea, nu
exist certitudinea unei astfel de situaii, astfel c singurul lucru ce se poate
garanta este acela c, odat cu parcurgerea algoritmului, rezultatul este cel
corect. n cazul n care algoritmul ruleaz la infinit, s-ar putea ntmpla ca
fluxul s nici nu convearg ctre fluxul maxim. Dar aceast se poate
ntmpla doar n cazul valorilor iraionale atribuite fluxului. Cnd
capacitile sunt ntregi, timpul de rulare al algoritmului Ford-Fulkerson este
de ordinul O (| E | f ) , unde |E| reprezint numrul de muchii ale grafului, iar

f reprezint fluxul maxim al grafului. Acesta deoarece fiecare drum de


cretere poate fi gsit ntr-un timp de ordinul O (| E |) , mrind fluxul cu o
cantitate ntreag, care este cel puin 1.
O variant a algoritmului Ford-Fulkerson , ce garanteaz finalitatea i
un timp de rulare independent de valoarea fluxului maxim, este algoritmul
Edmonds Karp, a crui timp de rulare este de ordinul O(| V || E |2 ) .
Exemplu
Urmtorul exemplu indic primii pai ai algoritmului Ford-Fulkerson
ntr-o reea cu 4 vrfuri, sursa fiind A, iar inta (nodul terminal) D.
Drumurile de cretere sunt gsite cu ajutorul metodei depth-first search
(cutrii n adncime), unde vecinii sunt vizitai n ordine alfabetic. Acest
exemplu imagineaz cel mai sumbru comportament al algoritmului. La
fiecare pas, este trimis un flux avnd valoarea 1 de-a lungul reelei. A se
vedea c dac s-ar fi folosit o cutare de tipul breadth-first search, ar fi fost
nevoie de doar doi pai.

93

Drum

Capacitate

Fluxul n reea rezultat

Fluxul iniial n reea

A,B,C,D

min(cf(A,B),cf(B,C),cf(C,D))
= min(c(A,B) f(A,B),
c(B,C) f(B,C),
c(C,D) f(C,D))
= min(1000 0,
1 0,1000 0) = 1

A,C,B,D

min(cf(A,C),cf(C,B),cf(B,D))
= min(c(A,C) f(A,C),
c(C,B) f(C,B),
c(B,D) f(B,D))
= min(1000 0,
0 ( 1),1000 0) = 1

Dup nc1998 pai.

Reeaua final a fluxului

A se remarca modul n care fluxul este mpins napoi de la C la B,


n momentul n care se gsete drumul A, B, C, D.

94

Capitolul 7
NUMRUL DE STABILITATE I
DENSITATEA UNUI GRAF

7.1.

Mulimi stabile i clici

Definiie.
Numim mulime stabil n graful G o mulime de
vrfuri S X pentru care
[S]G = [S, 0]
/ ,

adic, x, y S [x, y] U . Notm cu P familia mulimilor stabile n graful


G. O mulime stabil S care este maximal n raport cu relaia de incluziune
ntre mulimi se numete mulime stabil maximal, adic S S' S' P
( S' X ).
Numrul
(G) = max | S |
SP

se numete numrul de stabilitate al grafului G, iar o mulime S P cu


| S | = (G) va fi numit sistem de stabilitate al grafului G.
Definiie.
Se numete clic n graful G o mulime de vrfuri
C X care genereaz un subgraf complet n graful G, adic
x, y C [x, y] U .
Se numete densitatea grafului G, numrul
(G) = max | C | ,
CC

unde C este familia clicilor grafului G.


Observaii.
a)
Pentru orice mulime stabil S P i orice clic C C are loc
relaia:
| S C | 1.
b)
Orice mulime stabil n graful G este o clic n graful su
complementar G i invers. Avem evident:
(G) = (G) i (G) = (G) .
Un graf G cu n vrfuri i m muchii va fi notat cu G(n,m). Una dintre
cele mai importante probleme privind densitatea unui graf este urmtoarea:
Fie n i k < n dou numere naturale. Care este cel mai mic numr
z k +1 (n) cu proprietatea:

95

m z k +1 (n) (G(n, m)) k + 1 ?


Pentru a rspunde la aceast ntrebare s considerm:
n = tk + r,
n
unde t = , 0 r k 1 i s construim graful Tnk n felul urmtor:
k
Graful Tnk are n vrfuri repartizate n clasele S1 ,S2 ,...,Sk cu
t + 1, i = 1, 2,..., r
| Si | =
i = r + 1,..., k,
t,
iar dou vrfuri diferite vor fi unite printr-o muchie dac i numai dac
aparin la clase diferite.
Se constat uor c numrul muchiilor grafului Tnk este:
k(k 1)t 2
r(r 1)
+ r(k 1)t +
2
2
k 1 2 2 r
(n r ) + .
=
2k
2

f k (n) =

7.2.

Problema mulimii independente

n matematic, problema mulimii independente (independent set


problem (IS)) este recunoscut ca o problem de teoria grafurilor sau/i
combinatoric. Problema mulimii independente este de tipul NP complet.
Descriere
Fiind dat un graf G, o mulime independent reprezint o submulime
a nodurilor grafului considerat, noduri neadiacente. Cu alte cuvinte,
subgraful indus de aceste noduri nu are muchii, ci doar vrfuri izolate. n
aceste condiii, problema mulimii independente cere: Fiind dat un graf G i
un ntreg k, are G o mulime independent de mrime cel puin k?
Problema de optimizare corespunztoare este cunoscut sub numele
de problema mulimii independente maxime, care ncearc s gseasc cea
mai extins mulime independent dintr-un graf. Odat gsit soluia
problemei decizionale, se poate face uz de cutarea binar pentru a rezolva
problema iniial, apelarea soluiei fiind de ordinul O(log V ) . Se cunoate
faptul c pentru aceast problem nu avem un algoritm de aproximare al
factorului constant dac P NP .
Algoritmi
Cel mai simplu algoritm pentru mulimile independente examineaz
fiecare submulime de vrfuri de mrime cel puin k, verificnd dac este
independent sau nu. Acest lucru implic un timp de ordin polinomial dac

96

acest k egaleaz numrul vrfurilor, sau dac este mai mic cu o unitate ca
acesta, dar nu dac reprezint jumtate din numrul vrfurilor.
O problem mult mai uor de rezolvat este aceea a gsirii unei
mulimi independente maximale, care s nu fie coninut n nici o alt astfel
de mulime independent. Pornim de la un singur vrf. Gsim un vrf
neadiacent celui considerat iniial i-l adugm mulimii respective, apoi
gsim un alt nod neadiacent niciunui vrf menionat anterior .a.m.d. pn
cnd nu mai gsim astfel de noduri. La acel moment mulimea este maximal
independent. Se cunosc algoritmi mult mai compleci, de listare a tuturor
mulimilor independente maximale, dar, n general, numrul unor astfel de
mulimi poate fi foarte mare.
Demonstraia NP complet
Se poate observa uor c problema este de tipul NP (aparine clasei
NP), innd cont de faptul c, dac avem o submulime de vrfuri, putem
verifica dac exist muchii ntre oricare din dou vrfuri ntr-un timp
polinomial. Pentru a arta c problema este de tipul dificultate NP
(NP dificil), vom folosi o reducere a unei alte probleme de tipul
NP complet.
Presupunem c se cunoate deja rezultatul lui Cook, conform cruia
problema satisfacerii booleene este NP complet. Orice formul boolean
poate fi redus, n mod eficient, la forma sa normal conjunctiv
(conjunctive normal form CNF). n forma normal conjunctiv:
Formula este o conjuncie (and ( i)) de propoziii.
Fiecare propoziie reprezint o disjuncie (or(sau)) de literali.
Fiecare literal reprezint fie o variabil fie negaia acesteia.
Spre exemplu, urmtoarea formul constituie o form CNF, unde ~
denot negaia:
( x1 sau ~ x2 sau ~ x3 ) i ( x1 sau x2 sau x4 )
O astfel de formul este satisfctoare dac putem atribui valori
adevrat / fals fiecrei variabile n parte astfel nct cel puin un literal din
fiecare propoziie s aib valoarea de adevr adevrat. Spre exemplu, orice
atribuire a lui x2 cu valoarea de adevr fals, respectiv a lui x4 cu valoarea de
adevr adevrat satisface formula mai sus amintit.
n cele ce urmeaz, se va prezenta o reducere de tipul mai muli - la
unul (timp - polinomial), de la CNF- la problema mulimii independente.
Mai nti, se ataeaz cte unu nod pentru fiecare literal din formul; se
includ duplicate ale vrfurilor pentru apariii multiple. Se traseaz o muchie
ntre:
1. Oricare doi literali, fiecare reprezentnd negaia celuilalt.
2. Oricare doi literali, ce se afl n aceeai propoziie.

97

Astfel, n exemplul de mai sus, x2 ar fi adiacent cu ~ x2 , primul x1 ar


fi adiacent cu ~ x2 , iar cel de-al doilea x1 ar fi adiacent cu x4 .

Graful rezultat n urma reducerii, pentru exemplul de mai sus


Rmne de vzut dac acest graf are o mulime independent de
mrime cel puin k, unde k reprezint numrul propoziiilor, dac i numai
dac formula rmne satisfctoare.
S presupunem c avem o atribuire ce satisface formula iniial. n
aceste condiii putem alege un literal din fiecare propoziie, care devine
adevrat prin atribuirea acestei valori. Aceast mulime este independent,
deoarece include un literal din fiecare propoziie (nu exist muchii de tipul
2), i deoarece nici o atribuire nu transform att literalul ct i negaia
acesteia propoziii adevrate(nu exist muchii de tipul 1). Pe de alt parte,
ns, presupunnd c avem o mulime independent de mrime k, sau mai
mare; nu poate conine oricare doi literali n aceeai propoziie, odat ce
acestea constituie perechi adiacente. Dar, innd cont de faptul c exist cel
puin k noduri i k propoziii, trebuie s avem cel puin unul n fiecare
propoziie (de fapt exact 1). De asemenea nu se poate ntmpla s coexiste un
literal i negaia sa, deoarece exist muchii ntre acestea. Aceast nseamn
c este uor s alegem o atribuire astfel nct toate cele k propoziiile s
devin adevrate, aceast atribuire satisfcnd formula iniial. Ceea ce face
ca reducerea la mulimea independent s fie att de simpl este capacitatea
muchiilor de a exprima, n graf, constrngerile, dar i necesitatea de a nu
alege simultan un literal i negaia sa. Problema colorrii grafurilor
beneficiaz, de asemenea, de aceast proprietate.

7.3.

Problema clicii

n teoria complexitii computaionale, problema clicii este o


problem teoretic n grafuri, de complexitate NP. Problema se numr
printre problemele iniiale, de complexitate NP, prezentate de ctre Richard
Karp n cadrul seminarului din 1972 intitulat Reductibility Among
Combinatorial Problems. Aceast problem a fost, de asemenea, menionat
i n articolul lui Cook, o introducere n teoria problemelor NP - complete.

98

Graf coninnd clic de mrime 3


Clica ntr-un graf reprezint o mulime de vrfuri adiacente perechi,
adic subgraful indus, care este un graf complet.
n cele din urm, problema clicii const n determinarea existenei
unei clici ntr-un graf, a crei mrime s fie cel puin k (ordin predefinit).
Odat identificate k sau mai multe vrfuri ce formeaz o clic, este trivial s
demonstrm acest lucru, fapt ce-i justific complexitatea NP. Problema
corespunztoare de optimizare, problema clicii maxime, const n gsirea
celei mai mari clici din graf.
Complexitatea NP a problemei clicii deriv din complexitatea NP a
problemei mulimii independente, deoarece exist o clic de mrime k (cel
puin) dac i numai dac exist o mulime independent de mrime k (cel
puin) n graful complementar. Acest lucru este uor de observat, innd cont
de faptul c dac un subgraf este complet, atunci subgraful complementar nu
are muchii.
Algoritmi
Un algoritm primitiv de gsire a clicilor ntr-un graf const n
examinarea fiecrui subgraf ce conine cel puin k vrfuri, i ndeplinirea
condiiei de formare a unei clici. Algoritmul este polinomial (complexitate
polinomial) dac acel k coincide cu numrul vrfurilor, sau cu o constant
mai puin, dar nu dac k este, s spunem, jumtate din numrul total al
vrfurilor. Numrul total al clicilor de mrime k a unui graf de mrime |V|
este egal cu
| V |
| V |!
.

=
k k!(| V | k)!
n mod euristic am ncepe prin considerarea fiecrui nod ca fiind o
clic, iar mai apoi s se uneasc aceste clici n altele mai mari pn cnd
acest lucru nu mai este posibil.
Dou clici A i B pot fuziona dac fiecare vrf din clica A este
adiacent fiecrui vrf din clica B. Aceasta presupune un cost, n ceea ce
privete timpul, liniar (liniar n numrul muchiilor), dar poate eua n gsirea
unei clici mari, ntruct dou sau mai multe pri a clicii mari vor fi fost
fuzionat anterior, prin intermediul unor vrfuri care nu aparin clicii.
Se gsete, totui, cel puin o clic maximal, care nu este coninut
n nici o alt clic mai mare.

99

Unele cazuri mai speciale, pot fi rezolvate ntr-un timp mai scurt
dect cel exponenial. Pentru k = 3, algoritmul are o complexitate O(n1,41 ) ,
unde n reprezint numrul muchiilor.

7.4.

Determinarea mulimilor stabile maximale

Fie G = [X,U] un graf simplu cu mulimea de vrfuri


X = {x1 , x 2 ,..., x n } . Notm cu S n S familia mulimilor stabile maximale
ale grafului G. Exist mai muli algoritmi pentru determinarea familiei Sn. n
continuare vom prezenta algoritmul lui Bednarek i Taulbee. Pentru acesta s
punem pentru 1 k n :
X k = {x1 , x 2 ,..., x k },

G k = [X k ]G ,
X k +1 = {y | y X k , [y, x k +1 ] U},
i fie S k familia mulimilor stabile maximale ale grafului G k .
Algoritmul B T. (Bednarek i Taulbee)
Se consider X1 = {x1}, S1 = {x1} (k = 1).
Se determin familia Ik = {T | T = S Yk + 1, S Sk }

1.
2.

familia I 'k a mulimilor maximale fa de incluziune din Ik .


3.

Se determin familia Sk + 1 dup cum urmeaz:


Pentru fiecare S Sk punem

S {x k + 1} Sk + 1 , dac S Yk + 1
sau

dac

S / Yk + 1

punem

S Sk + 1

{x k + 1} (S Yk + 1) Sk + 1

atunci i numai atunci cnd S Yk + 1 I 'k .

Familia Sk + 1 conine numai mulimile specificate mai sus.


4.
5.

Se determin familia Sk + 1 a mulimilor maximale din Sk + 1 .


Algoritmul se termin cnd k = n 1.

n ultima faz obinem familia Sn a mulimilor stabile maximale n


graful Gn = G. Pentru justificarea acestui algoritm demonstrm urmtoarea
afirmaie:
Teorem.
Pentru fiecare k = 1, 2, , n 1 familia Sk+1 furnizat de algoritmul
B T., este familia tuturor mulimilor stabile maximale ale grafului Gk+1.
Demonstraie.
Presupunem c Sk este familia mulimilor stabile maximale ale
grafului Gk. Este suficient s artm c orice element al familiei Sk +1 este o

100

mulime stabil a grafului Gk+1 i c orice mulime stabil maximal a acestui


graf aparine familiei Sk +1 .
Prima parte a afirmaiei rezult din modul de construcie al familiei
Sk +1 , deoarece Sk +1 conine mulimi sau submulimi din Sk (care fiind
stabile n Gk, sunt stabile i n graful Gk+1) la care se adaug elementul xk+1
dac i numai dac xk+1 nu este adiacent n Gk+1 cu nici unul dintre
elementele mulimii sau submulimii considerate.
Fie acum S o mulime stabil maximal a grafului Gk+1. Dac
x k +1 S atunci S S k i S / Yk +1 . Rezult, conform pasului 3 al

algoritmului (alternativa a doua) c S Sk +1 .


Dac x k +1 S atunci T = S {x k +1} este stabil n graful Gk i
T Yk +1 .
Dac T S k , atunci
S = T {x k +1} Sk +1 .

n cazul cnd T S k exist o mulime T ' S k cu T T ' . Avem


T T ' Yk +1
i din cauza maximalitii lui S rezult c
T = T ' Yk +1 , T ' / Yk +1 , T ' Yk +1 I 'k .
Deci

S = (T ' Yk +1 ) {x k +1} Sk +1 , i astfel, teorema este

demonstrat.
Exemplu.
S se determine familia S7 pentru graful din figur:

2.

X1 = {1}, S1 = {1}
Y2 = {1}
I1 = {{1}} = I '1

3.

S2 = {{1, 2}}

1.

(k = 1)

101

2.

S2 = {{1,2}}
X2 = {1,2}, S2 = {{1,2}}
Y3 = {1}
I2 = {{1}} = I '2

3.

Avem {1,2} / Y3 i {1,2} Y3 I '2 . Deci S3 = {{1, 2},{1,3}} .

4.

S3 = S3
Y4 = {2}
I3 = {{2}, 0/ }
I '3 = {{2}}

4.

2.

(k = 2)

3.

S4 = {{1, 2},{2, 4},{1,3}}

4.

S 4 = S4
Y5 = 0/

2.

I4 = { 0/ , 0/ , 0/ , 0/ }, I '4 = {0}
/

3.

S5 = {{1, 2},{5},{2, 4},{5},{1,3},{5}}

4.
2.

S5 = {{1, 2},{2, 4},{1,3},{5}}


Y6 = {1,2,3,4,5}
I5 = {{1,2},{2,4},{1,3},{5}} = I '5

3.

S6 = {{1, 2, 6},{2, 4, 6},{1,3, 6},{5, 6}}

2.

S6 = {{1, 2, 6},{2, 4, 6},{1,3, 6},{5, 6}}


Y7 = {1,2,3,4,5}
I6 = {{1,2},{2,4},{1,3},{5}} = I '6

3.

S7 = {{1, 2, 6},{1, 2, 7},{2, 4, 6},{2, 4, 7},{1,3, 6},

{1,3, 7},{5, 6},{5, 7}} = S7 .


Deoarece k = n 1 = 6, algoritmul se oprete. Familia mulimilor
stabile maximale n graful G considerat este S7, iar numrul de stabilitate
este (G) = 3 .
Observaii.
Determinare familiei Cn a clicilor maximale n graful G revine,
a)
pe baza observaiei b) anterioare, la determinarea familiei mulimilor stabile
maximale n graful G (complementarul grafului G).
b)
Determinarea familiei Sn i a familiei Cn este necesar printre
altele n problema gsirii unei acoperiri minimale a mulimii vrfurilor unui
graf cu mulimi stabile (problema colorrii vrfurilor) i respectiv cu clici.

102

Capitolul 8
PROBLEME DE DESCOMPUNERI N GRAFURI

8.1.

Tipuri de descompuneri n grafuri

n acest paragraf ne referim la evoluia descompunerii n grafuri, din


care prezentm cteva din rezultatele, deja obinute, despre tipuri de
descompuneri n grafuri i anume: descompunerea n care o anumit
caracteristic numeric a grafului are proprietatea de aditivitate,
descompunerea n care legea de adiacen ntre submulimile partiiei este
cunoscut, descompunerea n funcie de operaia de compoziie,
G-descompunerea i n final, descompunerea substituie i partiionarea
vrfurilor.
Fie G un graf cu mulimea vrfurilor V(G) = V i mulimea muchiilor
E(O}= E.
n teoria grafurilor, o clas foarte larg de probleme se refer la
descompunerea (partiia) mulimii vrfurilor V n submulimile Xi , i I ,

astfel nct proprieti de urmtoarele tipuri au loc (Olaru, Antohe):


1)
Subgraful indus [Xi ] (i I) trebuie s aib proprieti prescrise; de
exemplu, problema colorrii grafurilor n care Xi trebuie s fie mulimi
stabile i problema acoperirii grafurilor cu clici;
2)
Descompunerea n care o anumit caracteristic numeric a
grafului G trebuie s aib proprietatea de aditivitate, adic relaia
([Xi ]G ) = (G) are loc;
iI

Legea de adiacen ntre submulimile Xi , X j ,i j , trebuie s fie


cunoscut. Apare ca o problem de descompunere referitoare la o operaie de
un tip oarecare, care este, esenial, legea de adiacen; o astfel de
descompunere este numit descompunere n funcie de un tip de operaie.
Apar de asemenea combinaii ale tipului 1) i 3); n astfel de
descompuneri, subgrafurile [Xi] trebuie s satisfac nite condiii (de
indecompozabilitate, coindecompozabilitate). Exist de asemenea probleme
care sunt combinaii ale tipurilor 1) i 2) i acestea sunt n acelai timp
impuse fiecrui subgraf. Aici este inclus problema grafurilor perfecte.
3)

8.1.1. Descompunerea de tip 2


Rezultatele urmtoare au fost obinute de Olaru.
Propoziia 1.
Orice graf care admite o clic drept cutset este - decompozabil.
103

Propoziia 2.
Grafurile - critice nu au cutset care s fie clic.
Propoziia 3.
Dac G este un graf - decompozabil atunci exist o
- descompunere n componente - indecompozabile care sunt tare
stabile.
Teorema 1.
Pentru un graf G cu (G) 2, urmtoarele afirmaii sunt echivalente:
G este minimal imperfect (adic este minimal critic);
(i)
(ii)
G este minimal tare stabil;
(iii) G este minimal cu: (G x) < (G), x V(G) .
{(i) echivalent (ii): E. Olaru, (i) echivalent (iii): W. Wessel }.
Propoziia 4.
Un graf G este perfect dac i numai dac singurele subgrafuri
- indecompozabile ale lui G sunt clici.
Propoziia 5.
Un graf G este perfect - decompozabil dac i numai dac el
conine un graf parial - critic i perfect - decompozabil.
Propoziia 6.
Un graf G - critic este perfect - decompozabil dac i numai
dac componentele sale conexe sunt clici.
Remarcm c orice graf admite cel puin un graf parial - critic. Un
criteriu de decompozabilitate este urmtorul.
Propoziia 7.
Un graf G este - decompozabil dac i numai dac el are cel puin
un graf parial - critic decompozabil.

8.1.2. Descompunerea de tip 3


Descompunerea de tip 3 nseamn descompunerea mulimii vrfurilor
V n submulimile Xi , i I astfel nct i, j I, i j , Xi i X j sunt total
adiacente n G sau G (adic Xi ~ X j n G sau G ).
Acest tip de descompunere coincide cu descompunerea cu
respectarea operaiei graf-adiacen (X-join), introdus de Sabidussi. O astfel
de descompunere se numete S-descompunere, iar factorii Xi , i I ,
S-componente.
Orice graf admite o S-descompunere n care toate S-componentele au
numai un element, numit banal.
Definiie.
Un graf G se numete S-indecompozabil dac el
admite numai S-descompunerea banal, altfel se numete S-decompozabil.

104

Observm c un graf decompozabil poate fi prezentat n diverse


forme ca S-descompunere de subgrafuri indecompozabile. Este, deci necesar
a considera altfel S-descompunerea, proprie (Olaru, Antohe).
Definiie. O S-descompunere n subgrafuri indecompozabile este
proprie dac ea conine un numr minim de S-componente indecompozabile
banale.
Teorema 2. (Olaru, Antohe).
Orice graf finit decompozabil admite o S-descompunere proprie,
unic pn la un izomorfism.
Definiie.
Un subgraf [A] a unui graf G este numit
coindecompozabil dac A este omogen i este maximal cu aceast
proprietate.
Teorema 3. (Olaru, Antohe).
Orice graf (finit sau nu) admite o unic S-descompunere n care
S-componentele sunt coindecompozabile.

8.1.3. Descompunerea n funcie de compoziie


Aceast descompunere este n funcie de operaia boolean numit
compoziie, care a fost introdus de Harary i investigat de Sabidussi, care
se mai numete i produs lexicografic. Reamintim definiia acestei operaii.
Date fiind dou grafuri G1 = (V1,E1) i G2 = (V2,E2), compoziia, notat
G = G1[G2] se definete astfel: V(G) = V1 V2 i pentru
u = (u1 , u 2 ) V1 V2 , v = (v1 , v 2 ) V1 V2 , uv E(G) dac i numai
dac u1v1 E1 sau ( u1 = v1 i u 2 v 2 E 2 ).
Rezultatele urmtoare se gsesc n (Golumbic, Shamir).
Fie H0 un graf neorientat cu n vrfuri v1 ,..., v n i fie H1 ,..., H n
n grafuri disjuncte. Graful compoziie H = H 0 [H1 ,..., H n ] este format astfel.
Pentru i, j = 1, , n, nlocuim vrful vi din H0 cu graful Hi i lum
fiecare vrf din Hi adiacent la fiecare vrf din Hj ori de cte ori vi este
adiacent lui vj n H0.
Formal, pentru Hi = (Vi,Ei) definim H = (V,E) astfel:
V = U Vi
i 1

i
E = U Ei {xy | x Vi , y Vj i vi v j E 0 } .
i 1

Mai notm E = E 0 [E1 ,..., E n ] .


H0 se numete factor extern a lui H, Hi, i = 1, , n se numesc factori
interni ai lui H.

105

Un graf neorientat G = (V,E), care prin orientarea fiecrei muchii


obinem graful orientat (V,F) care satisface urmtoarea condiie: dac ab F
i bc F implic ac F ( a, b, c V ), se numete graf de comparabilitate
(Golumbic, Shamir).
Teorema 4.
Fie G = G 0 [G1 ,..., G n ] , unde Gi sunt grafuri neorientate disjuncte.
Atunci G este graf de comparabilitate dac i numai dac Gi i = 0, l, ..., n este
graf de comparabilitate.
Definiie.
Un graf se numete decompozabil dac el poate fi
exprimat ca o compoziie nebanal de subgrafuri induse; altfel, el se numete
indecompozabil.
Pentru orice graf exist compoziia banal: G = K1[G].
Formal, G = (V,E) este decompozabil dac exist o partiie
V = V1 + ... + Vn a vrfurilor n submulimi nevide disjuncte dou cte dou
cu 1 < r < |V| astfel nct G = G R [G V ,..., G V ] pentru orice mulime de
1
v
reprezentani R = {x1 ,..., x n } , xi din Vi. O astfel de partiie induce o
descompunere proprie a lui G.
G are o mulime partitiv nebanal dac i numai dac G este
decompozabil.

8.1.4. G-descompunerea
Un graf orientat este o pereche G = (V,E), unde V este o mulime
nevid, iar E este o mulime de perechi ordonate de elemente distincte ale lui
V. Elementele lui E se numesc arce.
Pentru un graf orientat G = (V,E), notm cu G 1 = (V, E 1 ) , graful
invers, unde E 1 = {(x, y) | (y, x) E} .
Fie G = (V,E) un graf. Un graf orientat H =(V,F) (avnd aceeai
mulime de vrfuri ca i G) cu proprietatea c F F1 = 0/ i F F1 = E se
numete orientarea grafului G. (H se obine asociind o orientare fiecrei
muchii a lui G).
n acest paragraf prezentm un algoritm pentru G - descompunere.
Fie R o relaie binar pe mulimea muchiilor unui graf neorientat
G = (V,E), definit astfel:
abRxy dac i numai dac ori a = x i byE ori b = y i axE.
nchiderea reflexiv i tranzitiv R' a lui R definete o relaie de
echivalen pe E, ale crei clase de echivalen se numesc clase de implicaii.
= A A 1 este nchiderea
Dac A este o clas de implicaie atunci A
simetric a lui A.

106

Pentru G = (V ,E), un graf, o partiie a lui E n k mulimi:


+ ... + B
se numete G-descompunere dac B sunt clase de
E=B
1
k
i
+B

), i = 1, k .
implicaii din graful G = (V, B
+ ... + B
i

i +1

O secven de muchii [x1 y1 ,..., x n y n ] se numete schem de


+ ... + B

descompunere pentru G dac exist o G-descompunere E = B


1
k
astfel nct x i yi Bi , i = 1, k .
Are loc urmtorul algoritm de descompunere:
Input:
Output:

Un graf G = (V,E).
O G-descompunere; Un numr k;

,..., B

k mulimi de muchii din G: B


1
k
begin
fie

E1 := E
i := 1

loop:

Alege arbitrar o muchie ei = x i yi Ei .


Determin clasele de implicaii Bi din Ei coninnd xiyi

Fie Ei + 1 := Ei B
i
If Ei + 1 = 0/
then
Fie k := i
stop
else
Incrementeaz i cu 1
go to loop
end if
end

8.1.5. Descompunerea substituie i partiionarea vrfurilor


Un graf conex, nenul, care nu conine vrfuri separatoare se numete
bloc (Behzad, Chartrand, Foster). Un bloc al unui graf G este un subgraf
indus al lui G care este el nsui un bloc i care este maximal cu respectarea
acestei proprieti.
Operaia numit partiionarea vrfurilor este definit n cele ce
urmeaz.
Presupunem c sunt date un graf G = (V,E) i o partiie iniial P a lui
V n blocurile disjuncte B1 ,..., Bk . Problema partiionrii grafului cere a gsi
partiia avnd puine blocuri a lui V, fie P' = (E1, ..., Ej), astfel nct:
1)
Fiecare Ei este o submulime a unui Bh;
x, y Ei implic N(x) Ei = N(y) Ei .
2)

107

Condiia a doua poate fi reformulat astfel. Fiecare bloc Ei verific:


pentru fiecare i ori x ~ Ei ori x ~/ Ei pentru x V Ei , adic Ei este
modul.
R. McConnell i Spinrad au descoperit un algoritm O(m+n) pentru
partiionarea vrfurilor.
Vrful v separ (spliteaz) un bloc B ori de cate ori v este utilizat
pentru a divide B n blocurile B N(v) i B N(v) .
Descompunerea modular (Jamison, Olariu) sau descompunerea
substituie (descoperit independent de mai muli autori printre care R. H.
Mohring i F. J. Radamacher) nseamn partiionarea unui graf G n
subgrafuri, fiecare din ele este un modul ntr-un subgraf al lui G.
n particular, graful nsui i mulimile cu un singur vrf sunt
considerate module.
Algoritmul urmtor partiioneaz un graf n O(mlogn) timp.
Algoritmul alege un vrf v care ori
i)
nu a fost folosit nainte ca element de splitare ori
| B' |
ii)
v B, | B |
, B' care a coninut v ultima dat cnd v a fost ales
2
ca element de separare ori
iii)
este ntr-un bloc care nu va fi separat n viitor.
Vrful v este folosit s separe fiecare bloc care nu conine v.
Separarea cauzat de v poate fi executat n O(|N(v) |).
Pentru a separa pe B, prima dat verificm dac v nu este n B; apoi
loca1izm vecinii lui v ntr-un nou bloc B' , care este pstrat "legat" de B
pn la sfritul separrii cauzat de v.
Dac nici un vrf nu satisface criteriul i) sau ii) pentru alegerea
elementului de separare, orice vrf din cel mai mare bloc activ C rmas, va
satisface criteriul iii). Orice alt vrf v a ncercat s separe C, deoarece v a
fost separat de C la un moment dat i este acum ntr-un bloc care este cel
mult de lungimea lui C.
Algoritmul propriu-zis:
Fie partiia iniial ( B1,..., B j );
Pentru fiecare bloc Bi execut
lastused[Bi] = cea mai mare valoare;
{ folositultimadata[Bi] = cea mai mare valoare}
READY = (B1,..., B j);
Ct timp (G este nevid) execut
Ct timp (READY 0/ ) execut
C = orice bloc din READY;
lastused[C] = |C|;
pentru fiecare vrf x din C execut
separ toate blocurile exceptnd C n funcie de
adiacena la x;

108

pentru fiecare bloc B separat n B, B2 prin x execut


lastused[B2] = lastused[B];
dac |B| lastused[B]/2 atunci
adaug B la READY;
dac |B2| lastused[B2]/2 atunci
adaug B2 la READY;
C = cel mai mare bloc rmas;
returneaz C ca parte a partiiei finale;
folosete fiecare vrf din C pentru a separa celelalte
blocuri;
G = G C.

Prezentm n continuare un algoritm de complexitate O(mlogn) dat


de McConnell pentru gsirea descompunerii substituie a unui graf. Aceast
metoda de descompunere se bazeaz pe algoritmul de partiionare de mai
sus. Algoritmul lucreaz n dou faze. Prima faz gsete o submulime de
module din arborele de descompunere utiliznd partiionarea i produce o
ordine pe vrfuri astfel nct celelalte module vor fi gsite (specificate) prin
alegerea diferitelor vrfuri ca elemente de separare.
Descriem procedura de baz. Ori de cte ori procesul de partiionare
returneaz o mulime S de lungime mai mare dect 1, S este modul al lui G.
Alegem orice vrf s din S, mprim S n s i S s i rencepem procedura de
partiionare. Pstram un arbore a mulimii partiiilor care se produc n timpul
acestei proceduri. Iniial, arborele are o rdcin, s ca descendentul direct
stng i V s ca descendentul direct din dreapta. Ori de cate ori o mulime
este separat n vecini i nevecini, lum un nou nod intern cu vecinii drept
descendentul direct stng i nevecinii drept descendentul direct drept. Dac S
a fost specificat (menionat, gsit) ca a fi un modul, marcm nodul intern
corespunztor lui S.
Notm c aceast procedur va gsi modulele care nu conin un vrf
arbitrar ales s, dar nu va gsi modulele coninnd s. Acestea vor fi gsite de
faza a doua. Ideea este de a ordona vrfurile astfel nct ntotdeauna alegem
vrfuri pentru separare pentru faza a doua care nu apar mpreun cu s ntr-un
submodul. Numrm vrfurile din timpul traversrii standard postordine, n
care mulimea descendenilor copilului (descendentului direct) drept dintr-un
nod dat va fi mai mare dect a descendenilor nodului stng al aceluiai copil
(descendent direct).
Faza a doua a procedurii este aceeai cu prima, excepie fiind atunci
cnd avem un modul S, ntotdeauna alegem un vrf x cu cel mai mare numr
din S cu respectarea procedurii de ordonare din prima faz, separnd S n x i
S x i continum ca mai sus. Timpul total luat pentru gsirea celui mai
mare numr de vrfuri este O(nlogn), astfel se termin cele dou faze n
O(mlogn) timp.

109

Arborele de descompunere este produs prin combinarea modulelor


gsite n timpul celor dou faze.
Fie un modul M. Daca exist un descendent direct c al lui M care nu
formeaz muchii cu nici un alt descendent direct al lui M din G, tergem c
din M i adugm un nod etichetat P cu c drept un descendent direct i M
drept cellalt descendent direct. Similar, dac exist un descendent direct c '
al lui M, extremitate a tuturor muchiilor cu toi ceilali descendeni direci ai
lui M, tergem c' din M i adugm un nod S cu c' drept un descendent direct
i M drept cellalt descendent direct. Aceasta ia O(n+m) timp. Unim arborii
gsii n fiecare din cele dou stagii astfel. Traversm arborele n ordinea
primul n adncime. Dac ntlnim un nod serie (care corespunde unui modul
M astfel nct [M]G este neconex) sau paralel (care corespunde unui modul
astfel nct [M]G este neconex) x, care are un ascendent direct p de acelai
tip, lum toi descendenii direci ai lui x descendeni direci ai lui p.
n final, combinm modulele gsite n timpul fiecreia din cele dou
faze ntr-un singur arbore de descompunere, T. Fie T1 i T2 arborii gsii n
timpul celor dou faze. Fie toate nodurile lui T1 i T2 n ordine
nedescresctoare a numrului de descendeni direci vrfuri pendante. Cnd
un modul M este ntlnit, adugm M dac M nu este deja parte a arborelui
combinat. Pentru a cunoate dac un modul M cu k descendeni vrfuri
pendante este deja n arbore este suficient a verifica dac cel mai mic numr
de vrfuri din M este deja ntr-un modul de lungime k. Dac memorm cel
mai mic numr de vrfuri din fiecare modul i modificm variabila i pentru
un vrf v cnd v este vrful cu cel mai mic numr dintr-un modul de lungime
i, acest pas ia timp constant pe modul. Adugarea unui modul M la T se face
astfel. Orice descendent direct c al lui M se afl n T i pentru orice rdcin
r din arborele curent care conine un descendent direct al lui M, r devine un
descendent direct al lui M n arbore. Orice metod natural de a marca un
arbore, pentru ca un drum s nu fie traversat de dou ori, ne permite s
combinm doi arbori n O(n) timp.
La sfritul acestui paragraf, prezentm urmtorul rezultat (Olariu).
Pentru un graf G urmtoarele dou afirmaii sunt echivalente:
G nu are nici un subgraf indus izomorf cu grafurile cu secvena de
(i)
grade (2,2,2,3,3), (1,1,2,3,3), (2,2,3,3,4,4);
(ii)
pentru fiecare subgraf indus H a lui G, cel puin una din
urmtoarele afirmaii sunt adevrate:
(a)
H conine o mulime omogen;
(b)
(H) 2 .

110

8.2.

Descompunerea slab a grafurilor

8.2.1. Introducere
Fie G = (V,E) un graf neorientat, fr bucle i muchii multiple. n
diverse probleme de teoria grafurilor, cu precdere n construcia unor
algoritmi de recunoatere apare frecvent un anumit tip de partiie a mulimii
vrfurilor n trei clase A, B, C astfel nct A s induc graf conex, iar C s fie
total adiacent cu B i total neadiacent cu A. Aa se ntmpl, de exemplu, cu
construcia cografurilor pornind de la K1,2 i substituind vrfurile cu
cografuri. Introducerea noiunii de descompunere slab (C. Croitoru) i
studiul proprietilor ei ne permite s obinem alte rezultate de acest tip, cum
ar fi: caracterizarea cografurilor cu coarbori ( rezultat cunoscut, obinut de
Lerchs, dar pentru care obinem demonstraie mai uoar). De asemenea,
caracterizm grafurile K1,3 free i dm un algoritm de recunoatere i un
altul pentru determinarea unui cuplaj de cardinal maxim n aceast clas de
grafuri. De asemenea, alte proprieti se obin pentru grafuri triangulate,
garfuri {P4, C4}- free, grafuri paw free, grafuri confidenial conexe.
O parte din acest capitol a fost prezentat la ROSYCS 2000 Iai.

8.2.2. Descompunerea slab a unui graf


nainte de a da definiia central din acest capitol, reamintim c
pentru un graf G=(V,E) i A V , am notat:
N G ( A) = {v | v V A, w A si v ~ w}
N G [ A] = A N G ( A)
i
N G ( A) = V N G [ A] .
(Dac nu sunt posibile confuzii, indicele G poate fi omis).
Fie G1 = (V1 , E1 ) i G2 = (V2 , E2 ) , dou grafuri oarecare. Notm cu
G1+G2, K2 - adiacena (K2 join) a grafurilor G1 i G2, adic, graful obinut
din K2 prin substituia vrfurilor sale cu G1 i G2 i orice vrf din G1 este
adiacent cu orice vrf din G2. Graful G1+G2 va fi numit suma grafurilor G1
cu G2.
Definiia 1. Fie G=(V,E) un graf. O mulime de vrfuri , A, se
numete mulime slab dac N G ( A) V A i subgraful indus de A este
conex. Dac A este mulime slab, maximal n raport cu incluziunea,
subgraful indus de A se numete component slab. Pentru simplificare,
componenta slab G(A), se va nota cu A.
Denumirea de component slab este justificat de urmtorul rezultat.
Propoziia 2.
Orice graf conex i incomplete G=(V,E) admite o component slab
A astfel nct G (V A) = G ( N ( A)) + G ( N ( A)) .
111

Demonstraie. Deoarece graful G este incomplet, (G ) 2 , exist


vrfurile x y , neadiacente. Fie
A0 = {x}; B0 = N ( x); C0 = N ( x) .

Avem y C0 . Dac N ( x) ~ N ( x) atunci A = A0 . Dac nu, fie

x1 N ( x), y1 N ( x) astfel nct x 1 y 1 .


Pentru A1 = A0 {x1},[ A1 ] este conex, deoarece [ A0 ] este conex i
x1 N ( x) .
N ( A1 ) = ( N ( A0 ) {x1}) ( N ( x1 ) C0 ). y1 N ( A1 )
(deoarece x 1 y 1 i y1 N ( x) i y 1 A0 ).
Deci
N ( A1 ) .
Dac
N ( A1 ) ~ N ( A1 )
atunci [V A1 ] = [ N ( A1 )]G + [ N ( A1 )]G . Presupunem c s-a construit Ai

Bi=N(Ai) , Ci = N ( Ai ) .
Dac Bi ~ Ci atunci A = Ai. Dac nu, fie xi +1 Bi i yi +1 Ci cu
x i + 1 y i + 1 .
Notm
Ai +1 = Ai {xi +1}; Bi +1 = N ( Ai +1 ); Ci +1 = N ( Ai +1 ) .
[Ai+1] este conex, deoarece [Ai] este conex i xi +1 N ( Ai ) .
yi +1 N ( Ai +1 ) (deoarece x i + 1 y i + 1 i yi +1 N ( Ai ) i y i + 1 A i ).
Deci
N ( Ai +1 ) .
Dac Bi +1 ~ Ci +1 atunci A=Ai+1 i
[V Ai +1 ]G = [ N ( Ai +1 )]G + [ N ( Ai +1 )]G .
Deoarece

A0 A1 ... Ai ... V
i V < rezult p N astfel nct N ( Ap ) ~ N ( Ap ) i deci A = Ap este
componenta slab cu proprietatea din enun.
Propoziia 3.
Fie G = (V,E) un graf conex i incomplet i A V . Atunci A este
component slab a lui G dac i numai dac G(A) este conex i
N ( A) ~ N ( A) .

112

Demonstraie. Presupunem c exist n N ( A) i n N ( A) astfel


nct nn E (G ) .
Fie A = A {n} i N = ( N ( A) {n}) ( N (n) N ( A)) .
[ A]G este conex, N ( A) = N i V (G ) ( A N ( A)) {n } . Deci
N ( A) V (G ) A , contrazicnd maximalitatea lui A.
Invers.
Fie G(A) conex i N ( A) ~ N ( A) . Artm c G(A) este component
slab. Fie A A , component slab.
A A N ( A) (deoarece A N ( A ) i G ( A) conex).
Fie n A A . Atunci N ( A) N (n) . Deci N ( A) , contrazicnd
definiia componentei slabe.
Definiia 4. O partiie de forma ( A, N ( A),V N [ A]) , unde A este
mulime slab o numim descompunere slab n raport cu A a grafului G.
Numim A component slab, N(A) mulime separatoare minimal, iar VN[A] mulime ndeprtat (remote set).
Propoziia 5.
Dac G=(V,E) este un graf conex i incomplet atunci mulimea
vrfurilor V admite o descompunere slab (A,B,C) astfel nct G(A) este
component slab i G(V-A)=G(B)+G(C).
{Demonstraia este cea dat n propoziia 2}.
Observaia 6. Fie G=(V,E) un graf conex i incomplet. Dac A este
mulime slab atunci A V .
{ A mulime slab i G conex rezult A V , altfel N G ( A) = ,V A = ,
adic N G ( A) = V A }.
Fie G un graf conex i WG={A: A mulime slab n G}.
Observaia 7. Fie G=(V,E) un graf conex. WG are cel puin un
element dac i numai dac G nu-i complet.
{Dac G nu este complet atunci v V (G ) astfel nct N G ( A) V A .
Deci {v} este mulime slab, adic {v} WG . Artm implicaia invers.
Presupunem c exist A mulime slab n G. Atunci N G ( A) V A . Deci
N G ( A) . Deci a Ab N G ( A) astfel nct ab E (G ) . Deci G nu este
complet.}
Fie WG0 = { A | A WG , A maximal n raport cu incluziunea }.
Mai numim componentele slabe ale unui graf G i frunze. Mulimea
frunzelor o notm cu LG. Deci LG = WG0 .

113

Remarca 8. Fie G=(V,E) un graf conex i incomplet. Dac A WG0

atunci A este cutset (mulime separatoare) n G .


{n G A, R = N ( A) i N sunt mulimi nevide de vrfuri total
neadiacente}
Remarca 9. Fie G=(V,E) un graf conex i incomplet. Dac A WG0
atunci N G ( A) este cutset (mulime separatoare) n G.
{n G A, R = N ( A) i A sunt mulimi nevide de vrfuri total
neadiacente}
Demonstraia dat n propoziia 3. ofer un algoritm polinomial
pentru construirea unei descompuneri slabe pentru un graf conex i
incomplet.
Algoritm de descompunere slab a unui graf
Input: Un graf conex i cu cel puin dou vrfuri neadiacente,
G=(V,E).
Output: O partiie V=(A,N,R) astfel nct G(A) conex, N=N(A),

A R = N ( A ) .
begin
A := o mulime arbitrar de vrfuri astfel nct

A N ( A) V

N:=N(A)

R := V A N ( A)
while ( n N , r R astfel nct nr E ) do
A := A {n}
N := ( N {n}) ( N (n) R )
R := R ( N (n) R )
end.

Se observ c [A]G este conex, N=NG(A), R este un invariant al


algoritmului.
Consecina 10. Dac G este conex i cu cel puin dou vrfuri
neadiacente i A WG0 atunci

(G ) = max{ ([ A]G ) + ( N G ( A)), ( NG ( A) A)}.


{ntr-adevr, orice mulime stabil de cardinal maxim ori intersecteaz
N G ( A) i atunci are cardinalul ([ A]G ) + ( N G ( A)) ori nu intersecteaz
N G ( A) i atunci are cardinalul ( N G [ A]) .}
Observaia 11. Dac G este un graf conex cu (G ) = 2 atunci A este
clic i R este clic, pentru orice descompunere slab (A,N,R) a lui G cu
A WG0 .

114

{ 2 = (G ) ([ A]) + ([ R]) 1 + 1 = 2 .}.


n continuare reamintim urmtorul rezultat.
Lema 12.
Dac G este un graf conex, C este cutset, K1,K2,,Kp (p 2) sunt
componentele conexe ale lui G-C atunci:
N ( K i ) C , i = 1,..., p;
(i)
(ii) C este cutset minimal dac i numai dac N ( K i ) = C , i = 1,..., p
n ncheierea acestei seciuni caracterizm grafurile G cu proprietatea
A ~ N , unde (A,N,R) este descompunere slab.
Fie G=(V,E) un graf, X V i k N* .
Numim vecintatea de ordin k a lui X, mulimea
k
N G ( X ) = { a | a X , un drum indus n G, P, de lungime k de la x X la
a astfel nct V ( P ) X = {x} }.
Evident,
N G ( A) = N G ( A) .
Lema 13.
Fie G conex i (A,N,R) o descompunere slab cu A WG0 . Atunci
N G3 ( R) = dac i numai dac A ~ N .
Demonstraie.
Fie N G3 ( R) = . Presupunem, totui, c a A i n N cu a n .
Deoarece [ A {n}] este conex atunci un drum P de lungime 2 de la a la
n. ntruct N ~ R i R A atunci P , obinut din P la care adugm muchia
nr (r R) , este un drum indus n G de lungime 3. Obinem c
N G3 ( R) , o contradicie.
Dac A ~ N , avnd i N ~ R rezult c pentru r R , nu exist
drum indus de lungime 3 cu o extremitate n r i restul vrfurilor n V-R.
Deci N G3 ( R) = .

8.3.

Teorema celor patru culori

Teorema celor patru culori (cunoscut i sub numele de teorema de


colorare a hrii cu ajutorul a patru culori) afirm urmtoarele: fiind dat un
plan separat n regiuni, regiunile pot fi colorate folosind nu mai mult de patru
culori, astfel nct dou regiuni adiacente nu sunt colorate cu aceeai culoare.
Dou regiuni se numesc adiacente doar dac mpart un segment de
grani.
Teorema celor patru culori a fost prima teorem major ce a necesitat
computerul pentru a fi demonstrat, iar aceast demonstraie nu este
acceptat de toi matematicienii deoarece ar fi omenete imposibil de
115

demonstrat un astfel de lucru. n ultim instan, pentru a da crezare


demonstraiei, trebuie s se ncread n corectitudinea compilrii i a
execuiei hardware.
Istoric
Se ridic problema folosirii a cinci sau mai multe culori.
n anul 1890, Heawood a demonstrat c toate grafurile planare sunt
cinci-colorabile.
ntre 1960 i 1970 matematicianul german Heinrich Heesch a
dezvoltat metode de utilizare a calculatorului n scopul gsirii acelei
demonstraii att rvnite.
Nu mai devreme de anul 1976 s-a demonstrat ipoteza celor patru
culori a lui, de ctre Kenneth Appel i Wolfgang Haken la Universitatea din
Illinois. Au fost asistai, n ceea ce privete algoritmica, de John Koch.
Dac s-ar fi ntmplat ca ipoteza privind cele patru culori s fie fals,
ar fi existat cel puin o hart cu cele mai puine regiuni posibile care s
necesite cinci culori pentru colorare. Demonstraia a artat c un astfel de
contraexemplu minimal nu poate exista.
Odat cu demonstraia teoremei, au fost elaborai algoritmi eficieni
de 4-colorare a hrilor, necesitnd doar O (n 2 ) timp de rulare, unde n
reprezint numrul de noduri. n anul 1996, Neil Robertson, Daniel P.
Sanders, Paul Seymour i Robin Thomas au creat un algoritm cu timpul
ptratic.
n anul 2004 Benjamin Werner i Georges Gonthier au formalizat o
demonstraie a teoremei.
Determinarea suficienei folosirii a trei culori n colorarea optim a
unei hri, este de complexitate NP, ceea ce indic faptul c nu vom avea o
soluie rapid. Determinarea posibilitii de 4-colorare a unui graf general
(posibil ne-planar) are de asemenea complexitatea NP.
Expunere formal n teoria grafurilor
Pentru a expune formal teorema, este mai simplu s o reformulm n
teoria grafurilor. Teorema afirm c vrfurile fiecrui graf planar pot fi
colorate cu ajutorul a cel mult patru culori, astfel ca dou vrfuri adiacente
oarecare s nu aib aceeai culoare. Sau, pe scurt: orice graf planar este
patru-colorabil. n cazul acesta, fiecare regiune a hrii este nlocuit cu un
vrf, iar dou vrfuri sunt conectate prin intermediul unei muchii dac i
numai dac regiunile corespunztoare mpart un segment de grani.
Generalizri
S-ar putea pune problema colorrii suprafeelor ce nu sunt neaprat
plane. Problema corespunztoare sferei este echivalent cu cea din plan.
Pentru suprafeele nchise (orientate sau neorientate), de clas pozitiv,

116

numrul maxim p de culori necesare depinde de caracteristica Euler a


suprafeelor conform formulei:
7 + 49 24
p=
,
2

unde parantezele indic partea ntreag a funciei. Singura excepie n ceea ce


privete aceast formul o reprezint sticla lui Klein, a crei caracteristic
a lui Euler are valoarea 0 i necesit 6 culori. Aceasta a fost denumit iniial
ipoteza Heawood, fiind demonstrat ca i Teorema colorrii hrii de ctre
Gerhard Ringel i J. T. W. Youngs n anul 1968.
Alternativ, pentru o suprafa orientat, formula poate depinde de
parametrul g (parametru ce caracterizeaz clasa (genul) suprafeei):
7 + 1 + 48 g
p=
.
2

8.3.1. Colorarea grafurilor


n teoria grafurilor, colorarea grafurilor const n atribuirea de
culori vrfurilor unui graf astfel ca oricare dou vrfuri adiacente s nu
aib aceeai culoare. n mod analog, colorarea muchiilor const n
atribuirea unei culori fiecrei muchii n parte, astfel nct oricare dou
muchii incidente s nu aib aceeai culoare, iar colorarea feelor unui graf
planar atribuie o culoare fiecrei fee in parte, inndu-se cont de faptul c
oricare dou astfel de fee, ce au o frontier comun, nu pot avea aceeai
culoare.

O 3-colorare este suficient acestui graf, ns, dac s-ar folosi mai puine
culori ar rezulta noduri (vrfuri) adiacente de aceeai culoare.
Gsirea numrului minim de culori necesare colorrii unui graf
oarecare are dificultate NP

8.3.2. Colorarea vrfurilor


O colorare ce folosete cel mult k culori se numete k-colorare i
este echivalent cu problema partiionrii mulimii vrfurilor n k sau mai
puine mulimi independente. Problema colorrii grafurilor i-a gsit
aplicaii, cum ar fi n planificarea calendaristic, nregistrarea alocrilor n
compilatoare, distribuia frecvenelor radiourilor mobile, respectiv
compatibilitatea modelelor.

117

8.3.3. Numrul cromatic


Cel mai mic numr de culori necesare colorrii unui graf se numete
numrul cromatic corespunztor. De exemplu, numrul cromatic al unui
graf complet K n cu n vrfuri (un graf cu o muchie ntre oricare dou
vrfuri), este (K n ) = n .
Un graf cruia i poate fi atribuit o k-colorare (corespunztoare) este
k-colorabil, i este k-cromatic dac numrul su cromatic este chiar k.
Problema gsirii unei colorri minime a unui graf are o dificultateNP. Problema deciziei corespunztoare (exist o colorare care folosete cel
mult k culori?) are o complexitate de ordinul NP, reprezentnd, la origine,
una din cele 21 de probleme ale lui Karp NP-complete. Rmne
NP-complet chiar i n cazul grafurilor planare de grad cel mult 4, aa cum
a fost demonstrat de ctre Garey i Johnson n 1974, chiar dac n cazul
grafurilor planare este trivial (n. demonstraia) pentru k>3 (acest lucru
datorndu-se teoremei celor patru culori). Exist, totui, unii algoritmi de
aproximare eficieni, care folosesc programarea semidefinit.
Proprieti ale (G ) :
1. (G) = 1 dac i numai dac G este total neconex.
2. (G) 3 dac i numai dac G are un ciclu impar (echivalent, dac
G nu este bipartit).
3. (G) (G).
4. (G) (G)+1.
5. (G) (G) pentru G conex, doar dac nu cumva G este un graf
complet sau un ciclu impar (Teorema lui Brook).
6. (G) 4, pentru orice graf planar G. Acest faimos rezultat este numit
Teorema celor patru culori.
Aici, (G ) reprezint gradul maxim, iar (G ) , numrul clic.

8.3.4. Aspecte algoritmice


Colorarea optimal
Colorarea vrfurilor, n general, este o problem NP-complet. n loc
s cerem cel mai mic numr culori necesare colorrii unui graf, putem s
ridicm probleme mult mai simple, cum ar fi Putem colora graful cu cel
mult k culori?.
Cazul corespunztor lui k = 2 este echivalent determinrii bipartiiei,
respectiv a non-bipartiiei grafului. Aceasta se poate realiza ntr-un timp de
ordin polinomial. Pentru k 3 problema este NP-Complet. Exist un
rezultat remarcabil, al lui Lszl Lovsz, care enun c este permis s se
afirme c numrul cromatic al unui graf perfect implic timpul polinomial.

118

9
9

Algoritmi predefinii
Algoritmii de colorare pot fi divizai n dou categorii:
Algoritmi optimali de colorare (de exemplu, Algoritmul lui Zykov,
metoda ramificrii i mrginirii, etc. )
Algoritmi care nu asigur un rezultat cu cele mai puine culori
posibile. n aceast categorie se pot ncadra algoritmii secveniali,
algoritmii euristici, algoritmi globali aleatori, algoritmi
metaeuristici, respectiv algoritmii genetici.

8.3.5. Algoritmul Welsh Powell


Algoritmul Welsh-Powell de colorare a grafurilor folosete o
mbuntire euristic a unui algoritm greedy. Se demonstreaz uor c o
astfel de abordare folosete cel mult (G ) + 1 culori, unde (G ) este gradul
maxim al grafului. Algoritmul este urmtorul:
1.
Sortarea nodurilor n ordine descresctoare a gradului,
iniial considerndu-se toate nodurile necolorate.
2.
Traversarea (Parcurgerea) nodurilor n ordine, atribuindu-i
unui nod culoarea 1 dac este necolorat i nu are vecini
colorai cu aceeai culoare.
3.
Se repet acest proces i n cazul culorilor 2, 3, etc. pn
cnd toate vrfurile vor fi fost colorate.
Acest algoritm nu gsete neaprat o colorare (G ) .

8.3.6. Polinomul cromatic


Polinomul cromatic contorizeaz numrul posibilitilor de colorare
a unui graf , utiliznd un numr prestabilit de culori.
Polinomul cromatic este o funcie P(G, t ) ce contorizeaz numrul
t-colorrilor lui G. Aa cum indic i numele, pentru un graf G dat funcia
este ntr-adevr polinomial n t.
Polinomul cromatic conine cel puin la fel de multe informaii legate
de colorabilitatea lui G ca i numrul cromatic.
ntr-adevr, este cel mai mic ntreg pozitiv care nu este rdcin a
polinomului cromatic,
(G ) = min{k : P(G, k ) > 0}
A fost folosit pentru prima dat de ctre Birkhoff i Lewis n
demersul lor mpotriva teoremei celor patru culori.
A rmas o problem nerezolvat, n ceea ce privete eficiena
caracterizrii grafurilor ce au acelai polinomul cromatic.

119

Exemple

Graful Petersen are numrul cromatic 3


K3
Graful complet Kn
Arbore cu n noduri
Ciclul Cn
Graful Petersen

Polinomul cromatic pentru grafurile


t(t-1)(t-2)
t(t-1)(t-2)...(t-n+1)
t(t-1)n-1
(t-1)n + (-1)n(t-1)
t(t-1)(t-2)(t7-12t6 + 67t5-230t4 + 529t3-814t2 + 775t-352)

Proprieti
P(G,0) = 0
P(G,1) = 0 dac G conine o muchie
P(G,t) = 0, dac t < (G).
P(G, 1) este numrul orientrilor aciclice ale lui G
Dac G are n noduri, m muchii, i k componente G1,G2,,Gk, atunci
o P(G,t) are gradul n.
n
o Coeficientul lui t n P(G,t) este 1.
n1
o Coeficientul lui t
n P(G,t) este m.
0 1
k1
o Coeficienii corespunztori : t ,t , t
sunt toi zero.
k
o Coeficientul lui t este diferit de zero.

o P(G,t) = P(G1,t)P(G2,t)P(Gk,t)
Coeficienii fiecrui polinomul cromatic n parte alterneaz n ceea ce
privete semnele.
Un graf G cu n vrfuri este arbore dac i numai dac
P(G,t) = t(t 1)n 1.
Derivata evaluat n 1, P'(G,1), reprezint invariantul cromatic (G).
Calcularea polinomului cromatic
De fiecare dat cnd G conine o bucl, acesta nu poate fi colorat,
astfel c P(G, t ) = 0 .
Dac e nu este o bucl, atunci polinomul cromatic satisface relaia de
recuren P(G, t ) = P(G e, t ) P(G / e, t ) unde G e reprezint graful G
din care a fost nlturat muchia e, iar G / e reprezint graful pentru care
nodurile finale ale muchiilor sale sunt contractate ntr-un singur vrf.
Cele dou expresii dau natere unei proceduri recursive, numit
(n.procedura) algoritmul suprimare (tergere) contractare.

120

BIBLIOGRAFIE

[1]
Aho, Hopcroft and Ullman, The Design and Analysis of Computers
Algorithms, Addison Wesley, 1975.
[2]
L. Babel, S. Olariu, On the Structure of Graphs with Few P4s, Work
supported by NSF grants CCR-9407180 and CCR-95-22093, as well as by
ONR grandt N00014-1-95-0779, Discrete Applied Mathematics, 1998.
[3]
T. Blnescu, Corectitudinea algoritmilor, Editura Tehnic,
Bucureti, 1995.
[4]
M. Behzad, G. Chartand, L. L. Foster, Graphs and Digraphs,
Prindle, Weber & Schmidt International Series, 1973.
[5]

C. Berge, Graphs (Nort-Holland, Amsterdam, 1985).

[6]
V. Chvatal, Perfectly orderable graphs in "Topics on Perfect
Graphs" (C. Berge and V. Chvatal), Ann. Discrete Math.21(1984), 63-65.
[7]
V. Chvatal, Star cutest and Perfect Graphs, Journal of Comb. Th.,
B, 39, 189-199 (1985).
[8]
E. Ciurea, Algoritmi. Introducere n algoritmica grafurilor, Editura
Tehnic, Bucureti, 2001.
[9]
E. Ciurea, L. Ciupal, Algoritmi. Introducere n algoritmica
fluxurilor n reele, Editura MATRIXROM, Bucureti, 2006.
[10] T. H. Cormen, C. E. Leiserson, R. L. Rivest, Introducere n
algoritmi (traducere), Computer Libris Agora, 2000.
[11] D. G. Corneil, H. Lerchs, L. Stewart Burlingham, Complement
Reductible Graphs, Discrete Appl. Math. 3(1981), pp.163-174.
[12] D. G. Corneil, D. G. Kirkpatrick, Families of recursively defined
perfect graphs, Congr. Numer., 39(l983), 237-246.

121

[13] D. G. Corneil, Y. Perl, L. K. Stewart, A linear recognition


algorithmic for cographs, SIAM.J. Comput., 14(l985), 926-934.
[14] C. Croitoru, Tehnici de baz n optimizarea combinatorie, Editura
Universitii "Al. I. Cuza", Iai, 1992.
[15] C. Croitoru, M. Talmaciu, A new graph search algorithm and some
applications, presented at ROSYCS 2000, Universitatea "Al.I.Cuza", Iai,
2000.
[16]
E. Dahlhaus, Efficient parallel recognition algorithms of cographs
and distance hereditary graphs, Discrete Applied Mathematics 57(1995),
29-44.
[17] G. A. Dune, Generalisation du theoreme de Menger, C. R. Acad.
Sci. Paris 250 (26) (1960), 4252-4253.
[18] H. Georgescu, Tehnici de programare, Editura Universitii din
Bucreti, 2005.
[19] M. C. Golumbic, Algorithmic Graphs Theory and Perfect Graphs,
Academic Press 1980.
[20] F. Harary, On the number of bicolored graphs, Pacific J. Math.
8(1958), 743-755.
[21] X. He, Parallel Algorithm for Cograph Recognition With
Applications, in: O. Nurmi and E. Ukkonen eds. AIgorithm Theory-SWAT
'92, Lecture Notes in Computer Science 621 (Springer Berlin 1992), 94-105.
[22] B. Jamison and S. Olariu, On the clique-kernel structure of graphs,
Department of Computer Science, University of' Toronto, Toronto, Ontario,
Octobre,1972.
[23] B. Jamison, S. Olariu, A tree representation for P4 sparse graphs,
Discrete Appl. Math., 35(1992), 115-129, North-Holland.
[24] B. Jamison, S. Olariu, P-components and the homogeneous
decomposition of graphs, SIAM J. DISC. MATH. Vol. 8, No.3, 448463,1995.
[25] D. Knuth, Arta programrii calculatoarelor, Editura Teora,
Bucureti, 2002.

122

[26]
H. Lerchs, On clique-kernel structure of graphs, Department of
Computer Science, University of Toronto, Toronto, Ontario, October 1972.
[27] R. Lin, S. Olariu, An Nc Recognition Algorithm for Cographs,
Journal of Parallel and Distributed Computing, 13, 76-90 (1991).
[28] L. Livovschi, H. Georgescu, Sinteza i analiza algoritmilor, Editura
tiinific, Bucureti, 1986.
[29] R. H. Mohring, F. J. Radamacher, Substitution decomposition and
connections with combinatorial optimization, Ann. Discrete Math. 19(1984),
257-266.
[30] J. A. Nash-Williams, Edge-disjoint Hamiltonian circuits in graphs
with vertices of large valency, L. Musky, ed ., Studies in pure mathematics
(papers presented to Richard Ratio), (Academic Press, New York. 1971).
[31] I. Odagescu, C. Copos, D. Luca, F. Furtuna, I. Smeureanu,
Metode i tehnici de programare, Editura Intact, Bucureti, 1994.
[32] E. Olaru, On strongly stable graphs and some consequences for
partitionable graphs, Analele tiintifice ale Universitii "Al.I.Cuza" din
Iai, Tomul VII, 1998, 33-41.
[33] E. Olaru, On strongly perfect graphs and the structure of criticallyimperfect graphs, tiintifice ale Universitii "Al.I.Cuza" din Iai, Tomul II,
Informatic, 1993.
[34] E. Olaru, Some results on a-partitionable graphs and perfect graphs,
Analele Univ. D. de Jos Galai, Fascicola II, Supliment la tomul XVI/(XXI)
1998, Vol. I, Matematica, 171-185.
[35] E. Olaru, Introducere n teoria grafurilor, Univ. "Al.I.Cuza"
Iai,1975.
[36] E. Olaru, St. Antohe, Decomposition with respect to the graph-join
operation, Analele Universitii din Galai, fascicula II, I(VI)(1983), 15- 26.
[37] E. Olaru, S. Antohe, Some results concerning graphs
decomposition, Analele Universitii din Galai, Matematic, Fascicula II,
Anul III(VIII)1985.

123

[38] E. Olaru, Gh. Suciu, Dauerstabile und Kritisch imperfekte Graphen,


An.Univ. Timioara, vol. XVII, fasc.l, 1970, 59-64.
[39] E. Olaru, - Zerlegbare Graphen, Bul. Univ. Galati, fasc.II, 1980,
39-45.
[40] St. Olariu, On the closure of triangle-free graphs under substitution,
Information Processing Letters 34(1990), 97-101.
[41] O. Ptracoiu, Gh. Marian, N. Mitroi, Elemente de grafuri i
combinatoric. Metode, algoritmi i programe, Editura All, Bucureti, 1994.
[42]

G. Sabidussi, Graph derivatives, Math, Z76(l 961), 385-401.

[43] G. Sabidussi, The composition of graph, Duke Math. J. 26 (1959),


693-696.
[44] G. Sabidussi, The lexicographic product of graphs, Duke Math. J. 28
(1961), 573-578.
[45] R. Shamir, Advanced Topics in Graph Algorithms, Tehnical Reports,
Tel Aviv. University, Sprin 1994.
[46] D. Summer, Graphs indecomposable with respect to the X-join,
Discrete Math. 6(1973), 281-298.
[47] I. Tomescu, Probleme de combinatoric i teoria grafurilor, Editura
Didactic i Enciclopedic, Bucureti, 1981.
[48] W. Wessel, Some color-critical equivalents of the strong perfect
graph conjecture, in Beitrage zur Graphentbeorie und deren Anwendungen,
Obezhof (DDR), 10-16 April 1977, 300-309.
[49] R. Yuster, Independent Transversals in r-partit graphs, Department
of Mathematics Raymond and Beverly Sackler Faculty of Exact Sciences Tel
Aviv University, Tel Aviv, Israel, (electronic), 2001.
[50] R. Yuster, Independent Transversals and Independent Coverings in
Sparse Partite Graphs, Department of Mathematics Raymond and Beverly
Sackler Faculty of Exact Sciences Tel Aviv University, Tel Aviv, Israel,
(electronic), 2001.

124