Mihai TALMACIU

AAllggoorriittmmiiccaa ggrraaffuurriilloorr

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.1. Definiia unui graf 1 1. 2. Grade 3 1.3. Subgrafuri 3 1.4. Operaii cu grafuri 3 1.5. Clase de grafuri 4 1.6. Drumuri i circuite 5 1.7. Mulimi separatoare, transversale i mulimi omogene 6 1.8. Algoritmi i complexitate de calcul 7

Capitolul 2 Metode de cutare i programare 9 2.1. Cutarea n lime 9 2.1.1. Algoritmul 9 2.1.2. Implementarea C++ 9 2.1.3. Complexitate i optimalitate 10 2.1.4 Aplicaii ale BFS 11 2.2. Cutarea n adncime 11 2.3. Metoda Greedy 13 2.4. Metoda backtracking 14 2.5. Metoda divide et impera 16 2.6. Metoda branch and bound 17

Capitolul 3 Structuri de date 21 3.1. Liste 21 3.1.1. Liste simplu nlnuite 21 3.1.2. Parcurgerea unei liste simplu nlnuite 22 3.1.3. Liste dublu nlnuite 22 3.1.4. Parcurgerea unei liste dublu nlnuite 23 3.2. Arbori 24 3.2.1. Arbori liberi 24 3.2.2. Arbori cu rdcin 24 3.2.3. Arbori binari 25 3.2.4. Parcurgerea arborilor binari 25

Capitolul 4 Parcurgeri de grafuri 29 4.1. Parcurgerea BF a grafurilor 29 4.2. Parcurgerea DF a grafurilor 35 4.3. Aplicaii 38 4.3.1. Sortarea topologic 38 4.3.2. Componentele conexe ale unui graf 39

Capitolul 5 Probleme de drum n (di)grafuri 43 5.1. Problema celui mai scurt drum 43 5.1.1. Arborele Steiner 45 5.1.2. Algoritmul lui Dijkstra 46 5.1.3. Probleme similare i algoritmi 49 5.1.4. Probleme legate de drum 50 5.1.5. Algoritmul Bellman-Ford 50 5.1.6. Algoritmul de cutare A 54 5.1.7. Algoritmul Floyd-Warshall 57 5.1.8. Algoritmul lui Johnson 60 5.2. Probleme de conexiune. Teorema lui Menger i aplicaii 61 5.3. Structura grafurilor p-conexe 62 5.4. Problema drumului Hamiltonian 63 5.5. Problema ciclului Hamiltonian 64 5.6. Arborele parial de cost minim 69 5.7. Algoritmul lui Prim 71 5.8. Algoritmul lui Kruskal 77

Capitolul 6 Probleme de fluxuri n reele 83 6.1. Problema fluxului maxim 83 6.2. Fluxuri de cost minim 89 6.3. Algoritmul Ford-Fulkerson 92

Capitolul 7 Numrul de stabilitate i densitatea unui graf 95 7.1. Mulimi stabile i clici 95 7.2. Problema mulimii independente 96 7.3. Problema clicii 98 7.4. Determinarea mulimilor stabile maximale 100

Capitolul 8 Probleme de descompuneri n grafuri 103 8.1. Tipuri de descompuneri n grafuri 103 8.1.1. Descompunerea de tip 2 103 8.1.2. Descompunerea de tip 3 104 8.1.3. Descompunerea n funcie de compoziie 105 8.1.4. G-descompunerea 106 8.1.5. Descompunerea substituie i partiionarea vrfurilor 107 8.2. Descompunerea slab a grafurilor 111 8.2.1. Introducere 111 8.2.2. Descompunerea slab a unui graf 111 8.3. Teorema celor patru culori 115 8.3.1. Colorarea grafurilor 117 8.3.2. Colorarea vrfurilor 117 8.3.3. Numrul cromatic 118 8.3.4. Aspecte algoritmice 118 8.3.5. Algoritmul Welsh Powell 119 8.3.6. Polinomul cromatic 119 Bibliografie 121

1

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

GN (v) {w | w V(G) {v}, vw E(G)}= , se numete vecintatea vrfului v n G.

GN (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/ .

2

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 1c (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.

3

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 Gd (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 AV(G), vV, UE(G),eE(G) atunci notm: AG 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 1G i 2G sunt dou grafuri cu V( 1G )V( 2G ) = 0/ atunci reuniunea disjunct a grafurilor 1G i 2G nseamn graful G = 1G 2G cu V(G) = V( 1G )V( 2G ) i E(G) = E( 1G ) E( 2G ). 2) Se numete graf adiacen (X - adiacen) (Sabidussi, Olaru, Antohe) a unei familii de grafuri x x V(X)(G ) , indexat de mulimea de vrfuri a grafului X, graful notat X xx X GU , unde: ( )

( )X

x Xxx X

Xx V(X)x xx X

x x '

V G V(X) {x};

E G E(G )

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

= =

U U

U U

3) Produsul lexicografic (compoziia) (Harary) a dou grafuri 1G i 2G este graful notat G = 1G [ 2G ], unde V(G) = V( 1G )V( 2G ) i dou vrfuri

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

1 1 1u v E(G ) sau ( 1 1u v= i 2 2 2u v E(G ) ). 4) Suma a dou grafuri. Dac luam X = 2K , 2K - adiacena grafurilor oarecare 1G i 2G se mai numete suma celor dou grafuri i se noteaz cu

1G + 2G .

4

1.5. Clase de grafuri Se numete graf complet de ordin n, graful notat, nK , unde

n| V(K ) | n= i n 2 nE(K ) P (V(K ))= , iar 2P (X) este mulimea prilor cu dou elemente ale lui X. Se numete graf nul de ordin n, graful n nN K= . Se numete ciclu de lungime n ( n 3 ) graful notat, nC , unde

nV(C ) {1,2,..., n}= i nE(C ) {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 n n nP C e (e E(C ))= . 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 1 2 nV ,V ,...,V nevide astfel nct

i G i[V ] (V ,0)= / , i 1, n = (adic, orice muchie din E este incident cu un vrf din iV i un vrf din jV , 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 1 2 nV ,V ,...,V au proprietatea c pentru orice u din iV i orice v din jV , i j , uv este muchie a lui G. Un graf bipartit complet cu mulimile partiiei 1V i 2V , unde | 1V | = m i | 2V | = n este notat K(m,n) ( m,nK ). Graful K(l,n) (sau 1,nK ) 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

cE i numim c cG (V,E )= scheletul critic a lui G. Dac cE = E, graful se numete - critic.

5

Un graf G se numete ( ,) partiionabil (a se vedea Golumbic, Olaru) dac pentru fiecare vV(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 1 mZ {V ,...,V }= a lui V, cu m > 1 astfel nct

mii 1 (G ) (G)= = , unde i iG G(V ), i 1,m= = .

Z se numete partiie a lui G, iar iG 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 5P 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 AV(G) i xV(G) A, distana de la x la A nseamn

a Ad(x,A) min d(x,a)= .

6

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 SV 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 AV 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 i i IF {M }= o familie de submulimi a lui M i TM. Mulimea T este o transversal a lui F dac

iT M 0, i I / . Transversala T este perfect dac

i| T M | 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.

7

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 AT (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

A AT (n) sup{T (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 AT (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 p P ;

determinarea mediei variabilei aleatoare AT (p) : medA AT (n) M({T (p) | p P i g(p) n})= = .

Fie f : N N . Atunci 0 0O(f ) {g | g : , c ,c 0, n : g(n) cf (n), n n }N N R N= > .

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.

8

9

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 out; ... };

10

std::vector graph(vertices); bool BFS(const std::vector& graph, int start, int end) { std::queue next; std::vector 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::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 ( )EVO + , unde V reprezint numrul nodurilor, iar E numrul muchiilor grafului. Alt modalitate de a consemna

acest lucru: complexitate ( )MBO , 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.

11

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 ne-recursiv, 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

12

ramurilor asemntoare. Complexitatea n timp a ambilor algoritmi este proporional cu numrul vrfurilor plus numrul muchiilor grafului corespunztor ( )( )EVO + . 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.

13

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

1 nA {a ,..., a }= i o proprietate p definit pe mulimea submulimilor lui A:

p : P(A) {0,1} cu p(0) 1p(X) 1 p(Y) 1, Y X/ = = =

O submulime SA se numete soluie dac p(S) = 1.

14

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 1 nA {a ,..., a }= . 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 n = 40 n = 60 n3 - - 0,2 sec 2n 1 sec 12,7 zile 366 secole 3n 58 min 3855 secole 1013 secole

Tabelul de mai sus arat c algoritmii exponeniali nu sunt acceptabili.

15

Descrierea metodei Backtracking Fie produsul cartezian 1 nX X ... X= . 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

1 k 1x ,..., x i k 1 1 k 1(x ,..., x ) 1 = . Funciile k 1 n: X ... X {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

16

Pentru cazul particular 1 nX ... X {1,...,s}= = = , algoritmul se simplific

k

17

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

18

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.

19

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

20

21

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 (A0) do { new(Pl); P->inf:=A; P->leg:=L; L:=P; readln (A); } } Procesul se ncheie la citirea numrului 0. Prezentam n continuare o

22

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 (PNIL) 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:

23

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. a) S se parcurg lista de la stnga la dreapta i de la dreapta la 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 (AUXNIL) do { write (AUX->inf, ); AUX:=AUX->succ; } } algoritm listare2(P,Q:lista); { AUX:=Q; while (AUXNIL) do { write (AUX->inf, ) ; AUX:=AUX->pred; } } algoritm cautare(P,Q:lista):lista; { AUXl:=P; AUX2:=Q; while (AUXlAUX2) do { AUXl:=AUXl->succ; if (AUXl=AUX2) then return (AUXl); AUX2:=AUX2->pred; if (AUXl=AUX2) then return (AUXl); } }

24

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.

25

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

n 1 n1 2 ... 2 2 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 (ANIL) 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

26

vrfurile n ordinea cresctoare a cheilor. Prezentm algoritmul recursiv: algoritm inordine(A:arbore); { if (ANIL) 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 (ANIL) 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

27

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 (PSTNIL) then { U:=U+1; ST[U):=NOD->ST; write{NOD->ST->INF);} if {NOD->DRNIL) then { U:=U+1; ST[U]:=NOD->DR; write{NOD->DR->INF);} } }

28

29

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 xN. Numrul de arce ce compun un drum DxDx definete lungimea acestui drum pe care l notm l(Dx). Distana de la nodul s la nodul x se definete n modul urmtor:

x x x x

x

min{l(D ) D }, 0d(x)

, 0

/= = /D D

D

30

Un drum x xD D cu l( xD ) = d(x) se numete cel mai scurt drum 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. Dac Dx 0/ atunci evident Dy 0/ . Fie xD un cel mai scurt drum de la s la x, deci l( xD ) = d(x). Mulimea Dy poate conine un drum Dy, astfel nct l(Dy) < d(x) + 1. Conform definiiei distanei avem d(y) l(Dy) i rezult c d(y) < d(x) + 1. Avem egalitate cnd un drum cel mai scurt yD de la s la y

are lungimea d(y) = l( yD ) = d(x) + 1,

de exemplu

yD = xD {(x,y)}. 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) PROGRAM PBF; (2) BEGIN; (3) U := N - {s} ; V := {s} ; W := 0/ ; (4) FOR toi yN DO p(y) := 0; (5) l(s) := 0; (6) FOR toi yU DO l(y) := ; (7) WHILE V 0 / DO (8) BEGIN (9) se selecteaz cel mai vechi nod x introdus In V; (10) FOR (x, y) A DO (11) IF y U (12) THEN U:=U{y}; V:=V {y}; p(y):=x: l(y) := l(x) + 1; (13) V:=V-{x}; W:=W {x}; (14) END; (15) 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 r 1l(x ) l(x ) 1 + i i i 1l(x ) l(x ), i 1, r 1 + = .

31

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 yU). n acest caz

l(y) = l(x) + 1 i

d(y) d(x) 1 l(x) 1 l(y) + + = (l(x) pentru xV nu se modific). Deci pentru toate arcele (x,y)A i yU 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 yU). 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 yU). 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 yU). 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

32

introduse numai noduri y care sunt accesibile din s i c dup ce un nod xV 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 yN care sunt accesibile din s i introduse n V. S artm c W conine toate nodurile yN 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 yW. Rezult c ykV. Deoarece ykV i (yk-h,yk)A deducem c yk-1V, astfel yk ar fi fost introdus n V. Continund procedeul vom deduce n final c s = y1V. Aceasta contrazice faptul c n linia (3) a algoritmului iniializm V:={s}. Rezulta c yV, deci yW 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 yN. 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 = {yN |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 yNk+l este vizitat plecnd de la un nod xNk numai dup ce toate nodurile din Nk sunt vizitate. Deci, dac yNk+l i este vizitat explornd arcul (x,y), xNk, 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

33

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) PROCEDURA DRUM (G,s,y); (2) BEGIN; (3) se tiprete u; (4) WHILE p (y)i-0 DO (5) BEGIN (6) x := p(y); se tiprete x; (7) IF xs (8) THEN y := x (9) ELSE EXIT; (10) END; (11) 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) PROGRAM PTG; (2) BEGIN; (3) U := N - {s}; V :== {s}; W := 0/ ; (4) FOR toi yN DO p(y) := 0; (5) k:= 1; o(s):= 1; (6) FOR toi yU DO o(y) := ; (7) WHILE WN DO (8) BEGIN (9) WHILE V 0/ DO (10) BEGIN (11) se selecteaz un nod x din V; (12) IF exist arc (x, y)A i yU (13) THEN U:=U-{y}; V:=V {y};p(y):=x; k := k + 1; o(y) :=k (14) ELSE V:=V-{x}; W:=W {x}; (15) END; (16) se selecteaz sU; U:= U - {s}; V:= {s}; k := k + 1: o(S) := k; (17) END; (18) END. Este evident c algoritmul PTG are complexitatea tot O(m) i c vectorul p determin una sau mai multe arborescente parcurgeri.

34

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, 2U: U = {3,4,5,6}, V = {1,2}, p = (0,1,0,0,0,0) , l = (0,1, , , , ); (1,3) A, 3U: 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, 4U: U = {5,6}, V = {2,3, 4}, p = (0,1,1,2,0,0), l = (0,1,1,2, , ); (2,5)A, 5U : 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, 6U: 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.

35

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) PROGRAM PDF; (2) BEGIN; (3) U := N-{s}; V := {s}; W := 0/ ; (4) FOR toi yN DO p(y) := 0; (5) t := 1; t1(s) := 1; t2(s) := ; (6) FOR toi yU DO t1(y) := ; t2(y) := ; (7) WHILE V 0 / DO (8) BEGIN (9) se selecteaz cel mai nou nod x introdus in V; (10) IF exist arc (x,y)A i yU (11) THEN U := U - {y}; V := V {y}; p (y) := x; t := t + 1; t1(y) := t (12) ELSE V := V-{x}; W := W {x}; t:=t+1;t2(x):=t; (13) END; (14) END.

36

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 yN DO p(y) := 0; (5) t:=1; t1(s):= l; t2(s):= ; (6) FOR toi yU DO t1(y) := ; t2(y) := ; (7) WHILE WN DO (8) BEGIN (9) WHILE V0/ DO (10) BEGIN (11) se selecteaz cel mai nou nod x introdus n V; (12) IF exist arc (x,y)A i yU (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 sU; 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, sS. 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). Un digraf G (N,A)= se numete pdure dac este format din una sau mai multe arborescene. Un graf neorientat G (N,A)= se numete pdure dac este format din unul sau mai muli arbori. n parcurgerea total DF, dac subgraful predecesor Gp = (Np,Ap),

p p pN {y p(y) 0} S, A {(p(y), y) y N S}= = este o pdure i Np = W, atunci Gp se numete pdure parcurgere DF.

37

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, 2U: 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,3U: 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,4U: 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, 5U: 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, , , ).

38

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,8U: 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

la x la z n G. Atunci Do

= 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 G conine un circuit D

o. Fie x primul nod vizitat din D

o i fie arcul

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

39

la z. De asemenea x fiind primul nod vizitat din Do

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 xG ' generat de xN ' 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 asociaz graful neorientat G (N,A)= , unde N N, A {[x, y] (x, y) A= = i / sau (y, x) A }. Este evident c G i G au aceleai componente conexe. 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) PROGRAM CC; (2) BEGIN (3) U:= N - {s}; V:= {s}; W:= 0/ ; p:= l; N' = {s}; (4) WHILE W N DO (5) BEGIN

40

(6) WHILE V0/ DO (7) BEGIN (8) se selecteaz cel mai nou nod x introdus n V; (9) IF exist muchie [x, y] A i yV (10) THEN U:= U-{y}; V:=V {y};N':=N' {y} (11) ELSE V:= V-{x}; W:=W {x}; (12) END; (13) se tipresc p i N'; (14) se selecteaz sU; U:=U-{s}; V:={s}; p:= p+1;N':={s}; (15) END; (16) 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

41

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, 6U : U = {7,8}, V = {5,6}, N' = {5,6}. Iteraia 9: x = 6, [6,8]A, 8U : 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.

42

43

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

REf : 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

( )Pp

pf

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

44

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.

45

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

46

fiind minim, astfel nct oricare dou puncte sunt interconectate, fie printr-un 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

VS 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

47

funcia de cost : [0, ) w E ; 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 [ ]vd al celui mai scurt drum gsit pn n acel moment ntre s i v. Iniial, aceast valoare este 0, pentru vrful surs s ( [ ] 0=sd ), respectiv infinit pentru restul vrfurilor, sugernd faptul c nu se cunoate nici un drum ctre aceste noduri (vrfuri) ( [ ] =vd pentru fiecare v din V, exceptnd s). La finalul algoritmului, [ ]vd 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 [ ]vd , 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 [ ]vd 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 [ ]vd , 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.

48

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 function Dijkstra(Graph, source): 2 for each vrf v in Graph: 3 dist[v] := infinity 4 previous[v] := undefined 5 dist[source] := 0 6 Q := copy(Graph) 7 while Q is not empty: 8 u := extract_min(Q) 9 for each vecin v of u: 10 alt = dist[u] + length(u, v) 11 if alt < dist[v] 12 dist[v] := alt 13 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

49

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. n acest caz, timpul de rulare este 2O( V E )+ . Pentru cazul grafurilor rare, adic, grafuri cu un numr de muchii mult mai mic dect 2V , 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 1 VE ), 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

50

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 1V 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

51

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,

52

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, dup i-1 cicluri, are cel mult lungimea acestui drum. De aceea, 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.

53

#include #include #include /* S considerm INFINIT-ul o valoare ntreag, pentru a nu interveni confuzia n valorarea real, chiar i cea negativ*/ #define INFINITY ((1 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; }

54

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 ( )xf ) 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 ( )xg , care poate fi, sau, nu euristic) i o estimare euristic admisibil a distanei ctre int (notat de regul cu ( )xh ). Funcia cost-drum ( )xg determin costul de la nodul de start la nodul curent. Avnd n vedere faptul c ( )xh , parte a funciei ( )xf , trebuie s fie euristic admisibil, trebuie s se subestimeze distana ctre int. Astfel, pentru o aplicaie ca rout-area, ( )xh 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 ( )xf - 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 ( ) ( ) ( )xhxgxf += . Funcia continu pn cnd o int are o valoare corespunztoare ( )xf 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 ( )xf are o valoare mai mic, cu att prioritatea este mai mare (astfel, s-ar putea folosi o min-heap pentru a implementa coada)

55

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 succ