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. 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 ) .
2

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
3

comparaii (acest lucru este remarcabil, innd cont

2

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 ) .

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)

5.2.

Probleme de conexiune. Teorema lui Menger i aplicaii

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 endif repeat return end

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

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 (i j

s 1

ij

s 1

, muchia

, 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
/* 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

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

P2)

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