Proiectarea Algoritmilor

UNIVERSITATEA DIN BACU FACULTATEA DE INGINERIE
Gheorghe Hazi
PROIECTAREA ALGORITMILOR
CURS PENTRU UZUL STUDENILOR
Bacu - 2007
Proiectarea algoritmilor
CUPRINS 1. Introducere n proiectarea algoritmilor............................................4 1.1. Definiii..........................................................................................4 1.2. Obiectul disciplinei........................................................................4 1.3. Proprieti ale algoritmilor.............................................................5 1.4. Date7 1.5. Tipuri de prelucrri........................................................................7 1.6. Exerciii..........................................................................................8 2. Descrierea algoritmilor...................................................................12 2.1. Limbaj algoritmic..........................................................................12 2.2. Specificarea datelor.......................................................................15 2.3. Exemple de algoritmi....................................................................16 2.4. Tehnica rafinrii succesive i subalgoritmi...................................21 2.5. Exerciii.........................................................................................22 3. Verificarea corectitudinii algoritmilor.............................................24 3.1. Etapele verificrii corectitudinii....................................................24 3.2. Elemente de analiz formal a corectitudinii................................26 3.3. Exerciii.........................................................................................30 4. Analiza complexitii algoritmilor...................................................32 4.1. Scopul analizei complexitii.........................................................32 4.2. Timpi de execuie...........................................................................33 4.3. Ordin de cretere............................................................................37 4.4. Notaii asimptotice.........................................................................38 4.5. Etapele analizei complexitii........................................................42 4.6. Analiza empiric a complexitii algoritmilor...............................42 4.7. Exerciii..........................................................................................43 5. Metode elementare de sortare..........................................................46 5.1. Problematica sortrii......................................................................46 5.2. Sortare prin inserie........................................................................47 5.3. Sortare prin selecie........................................................................49 5.4. Sortare prin interschimbarea elementelor vecine...........................50 5.5. Exerciii..........................................................................................54 6. Tehnici de elaborare a algoritmilor: reducere i divizare.................56 6.1. Motivaie.........................................................................................57 6.2. Algoritmi recursivi.........................................................................58 6.3. Tehnica reducerii............................................................................61 6.4. Tehnica divizrii.............................................................................66 6.5. Exerciii..........................................................................................70 7. Aplicaii ale tehnicii divizrii. Sortarea prin interclasare i sortarea rapid..............................................................................71 7.1. Introducere......................................................................................71 Cuprins -2-
Proiectarea algoritmilor 7.2. Sortare prin interclasare...................................................................71 7.3. Sortare rapid...................................................................................74 7.4. Exerciii............................................................................................78 8. Tehnica alegerii local optimale ("greedy").80 8.1. Introducere........................................................................................80 8.2. Principiul tehnicii.............................................................................80 8.3. Verificarea corectitudinii si analiza complexitii............................83 8.4. Aplicaii............................................................................................84 8.5. Exerciii............................................................................................88 8.6. Anexa - Program pentru mpachetare optim (varianta 3)...............89 9. Tehnica programrii dinamice............................................................93 9.1. Introducere........................................................................................93 9.2. Principiul tehnicii i etapele aplicrii...............................................93 9.3. Aplicaii............................................................................................98 9.4. Exerciii...........................................................................................105 10. Tehnica cutrii cu revenire..............................................................107 10.1. Introducere.....................................................................................107 10.2. Principiul metodei i structura general a algoritmului.................107 10.3. Aplicaii..........................................................................................111 10.4. Exerciii..........................................................................................117 Epilog. Sfaturi pentru proiectarea algoritmilor............................................118 Exerciii suplimentare...................................................................................122 Bibliografie...................................................................................................141
Cuprins -3-
Proiectarea algoritmilor 1. INTRODUCERE N PROIECTAREA ALGORITMILOR 1.1. Definiii Un algoritm este o metod de rezolvare pas cu pas a problemelor. O problem este constituit din date de intrare i un enun care specific relaia existent ntre datele de intrare i soluia problemei. n cadrul algoritmului sunt descrise prelucrrile necesare pentru a obine soluia problemei pornind de la datele de intrare. O definiie mai precis, n sensul cursului nostru, este: Un algoritm este o succesiune bine precizat de prelucrri care aplicate asupra datelor de intrare ale unei probleme permit obinerea n timp finit a soluiei acesteia. Acesta trebuie s poat fi implementat pe un calculator. Termenul de algoritm provine de la numele unui matematician persan, alKhowarizmi (al-Kwarizmi), ce a trit n secolul al IX-lea i care a scris o lucrare despre efectuarea calculelor numerice ntr-o manier algebric. Primul algoritm se consider a fi algoritmul lui Euclid (utilizat pentru determinarea celui mai mare divizor comun a dou numere naturale). Termenul de algoritm poate fi neles n sens larg, nefiind neaprat legat de rezolvarea unei probleme cu caracter tiinific, ci doar pentru a descrie ntr-o manier ordonat activiti care constau n parcurgerea unei succesiuni de pai (cum este de exemplu utilizarea unui telefon public sau a unui bancomat). n matematic exist o serie de algoritmi: cel al rezolvrii ecuaiei de gradul doi, algoritmul lui Eratostene (pentru generarea numerelor prime mai mici dect o anumit valoare), schema lui Horner (pentru determinarea ctului i restului mpririi unui polinom la un binom) etc. Soluia problemei se obine prin execuia algoritmului. Algoritmul poate fi executat pe o main formal (n faza de proiectare i analiz) sau pe o main fizic (calculator) dup ce a fost codificat ntr-un limbaj de programare. Spre deosebire de un program, care depinde de un limbaj de programare, un algoritm este o entitate matematic care este independent de maina pe care va fi executat. Dac pn acum ai scris programe, este posibil ca, la unele probleme, s fi avut dificulti n gsirea soluiei de rezolvare. Atunci cnd ai gsit o soluie nu tiai dac ea este cea mai bun. Aceast carte v va ndruma cum s lmurii asemenea probleme. 1.2. Obiectul disciplinei Obiectul disciplinei de Proiectarea algoritmilor l reprezint studiul algoritmilor din perspectiva elaborrii i analizei lor. Elaborarea unui algoritm necesit: cunotine specifice domeniului de unde provine problema de rezolvat; tehnici generale de rezolvare a problemelor; intuiie i gndire algoritmic. Analiza algoritmilor presupune verificarea corectitudinii acestora i a eficienei. Un algoritm este considerat corect dac prin aplicarea lui asupra datelor problemei conduce Introducere -4-
Proiectarea algoritmilor la soluia acestuia i eficient dac prin execuia acestuia rezultatul se obine ntr-un interval de timp rezonabil. Analiza presupune aplicarea unor tehnici de demonstrare specifice matematicii. Indiferent de complexitatea unei aplicaii informatice, la bazele ei stau algoritmi destinai rezolvrii problemelor fundamentale ale aplicaiei. Orict de sofisticat ar fi tehnologia software utilizat (interfee, structurare global a aplicaiei) eficiena aplicaiei este n mod esenial determinat de eficiena algoritmilor implicai. Un algoritm prost conceput nu poate fi reparat prin artificii de programare. Din acest motiv dobndirea unor cunotine solide privind elaborarea i analiza algoritmilor este o condiie necesar n formarea unui bun programator. 1.3. Proprieti ale algoritmilor Un algoritm trebuie s posede urmtoarele proprieti: Generalitate. Un algoritm destinat rezolvrii unei probleme trebuie s permit obinerea rezultatului pentru orice date de intrare valide i nu numai pentru date particulare de intrare. Finitudine. Un algoritm trebuie s admit o descriere finit i fiecare dintre prelucrrile pe care le conine trebuie s poate fi executat n timp finit. Prin intermediul algoritmilor nu pot fi prelucrate structuri infinite. Rigurozitate. Prelucrrile algoritmului trebuie specificate riguros, fr ambiguiti. n orice etap a execuiei algoritmului trebuie s se tie exact care este urmtoarea etap ce va fi executat. Eficien. Algoritmii pot fi efectiv utilizai doar dac folosesc resurse de calcul n volum acceptabil. Prin resurse de calcul se nelege volumul de memorie i timpul necesar pentru execuie. Exemple 1. Nu orice problem poate fi rezolvat algoritmic. Considerm un numr natural n i urmtoarele dou probleme: (i) s se construiasc mulimea divizorilor lui n; (ii) s se construiasc mulimea multiplilor lui n. Pentru rezolvarea primei probleme se poate elabora uor un algoritm, n schimb pentru a doua problem nu se poate scrie un algoritm atta timp ct nu se cunoate un criteriu de oprire a prelucrrilor. 2.Un algoritm trebuie s funcioneze pentru orice dat de intrare. S considerm problema ordonrii cresctoare a irului de valori: (2, 1, 4, 3, 5). O modalitate de ordonare ar fi urmtoarea: se compar primul element cu al doilea iar daca nu se afl n ordinea bun se interschimb (n felul acesta se obine (1, 2, 4, 3, 5)); pentru irul astfel transformat se compar al doilea element cu al treilea i dac nu se afl n ordinea dorit se interschimb (la aceast etap irul rmne neschimbat); se continu procedeul pn penultimul element se compar cu ultimul. In felul acesta se obine (1, 2, 3, 4, 5). Dei metoda descris mai sus a permis ordonarea cresctoare a irului (2, 1, 4, 3, 5) Introducere -5-
Proiectarea algoritmilor ea nu poate fi considerat un algoritm de sortare ntruct dac este aplicat irului (3, 2, 1, 4, 5) conduce la (2, 1, 3, 4, 5). 3. Un algoritm trebuie s se opreasc. Se consider urmtoarea secven de prelucrri: Pas 1. Atribuie variabilei x valoarea 1; Pas 2. Mrete valoarea lui x cu 2; Pas 3. Dac x este egal cu 100 atunci se oprete prelucrarea altfel se reia de la Pas 2. Este uor de observat c x nu va lua niciodat valoarea 100, deci succesiunea de prelucrri nu se termin niciodat. Din acest motiv succesiunea de prelucrri nu poate fi considerat un algoritm corect. 4. Prelucrrile dintr-un algoritm trebuie s fie neambigue. Considerm urmtoarea secven de prelucrri: Pas 1. Atribuie variabilei x valoarea 0; Pas 2. Fie se mrete x cu 1 fie se micoreaz x cu 1; Pas 3. Dac x [-10, 10] se reia de la Pasul 2, altfel se oprete algoritmul. Att timp ct nu se stabilete un criteriu dup care se decide dac x se mrete sau se micoreaz, secvena de mai sus nu poate fi considerat un algoritm. Ambiguitatea poate fi evitat prin utilizarea unui limbaj riguros de descriere a algoritmilor. S considerm c Pas 2 se nlocuiete cu: Pas 2. Se arunc o moned. Dac se obine cap se mrete x cu 1 iar dac se obine pajur se micoreaz x cu 1; n acest caz specificarea prelucrrilor nu mai este ambigu chiar dac la execuii diferite se obin rezultate diferite. Ce se poate spune despre finitudinea acestui algoritm ? Dac s-ar obine alternativ cap respectiv pajur, prelucrarea ar putea fi infinit. Exist ns i posibilitatea s se obin de 11 ori la rnd cap (sau pajur), caz n care procesul s-ar opri dup 11 repetri ale pasului 2. Att timp ct ansa ca algoritmul s se termine este nenul algoritmul poate fi considerat corect (n cazul prezentat mai sus este vorba despre un algoritm aleator). 5. Un algoritm trebuie s se opreasc dup un interval rezonabil de timp. S considerm c rezolvarea unei probleme implic prelucrarea a n date i c numrul de prelucrri T (n) depinde de n. Presupunem c timpul de execuie a unei prelucrri este -3 10 s i c problema are dimensiunea n = 100. Dac se folosete un algoritm caracterizat -3 -1 prin T(n) = n atunci timpul de execuie va fi 100 x 10 = 10 secunde. Dac, ns se folosete un algoritm caracterizat prin T (n) = 2 atunci timpul de execuie va fi de circa 27 19 10 secunde adic aproximativ 10 ani.
n
Introducere -6-
Proiectarea algoritmilor 1.4. Date Prelucrrile efectuate n cadrul unui algoritm se efectueaz asupra unor date. Acestea sunt entiti purttoare de informaie (relevant pentru problema de rezolvat). Considerm datele ca fiind containere ce conin informaie, valoarea curent a unei date fiind informaia pe care o conine la un moment dat. n funcie de rolul jucat n cadrul algoritmului datele pot fi constante (valoarea lor rmne nemodificat pe parcursul algoritmului) sau variabile (valoarea lor poate fi modificat). Din punctul de vedere al informaiei pe care o poarta datele pot fi: Simple: conin o singura valoare (poate fi un numr, o valoare de adevr sau un caracter). Structurate: sunt constituite din mai multe date simple ntre care exista o relaie de structur. Daca toate datele componente au aceeai natur atunci structura este omogen, altfel este o structura heterogen. Datele structurate omogene ce vor fi utilizate n continuare sunt cele destinate reprezentrii unor structuri algebrice simple: mulime finit - ansamblu de valori distincte pentru care nu are importanta ordinea n care sunt reinute ir finit - ansamblu de valori, nu neaprat distincte, pentru care are importan ordinea n care sunt reinute matrice - tabel bidimensional de valori Pentru reprezentarea acestor date vom folosi structura de tablou caracterizat prin faptul ca fiecare valoare component poate fi specificat prin precizarea unuia sau mai multor indici. Cel mai frecvent sunt folosite tablourile unidimensionale (pentru reprezentarea irurilor i mulimilor) i cele bidimensionale (pentru reprezentarea matricelor). 1.5. Tipuri de prelucrri Asemenea datelor i prelucrrile pot fi clasificate n simple si structurate. Prelucrrile simple sunt: Atribuire. Permite afectarea unei valori unei variabile. Valoarea atribuita poate fi rezultatul evalurii unei expresii. O expresie descrie un calcul efectuat asupra unor date i conine operanzii (specific datele asupra crora se efectueaz calculele) i operatori (specific prelucrrile ce se vor efectua). Transfer. Permit preluarea datelor de intrare ale problemei i furnizarea rezultatului. Control. n mod normal prelucrrile din algoritm se efectueaz n ordinea n care sunt specificate. n cazul n care se dorete modificarea ordinii naturale se transfer controlul execuiei la o anumita prelucrare. Introducere -7-
Proiectarea algoritmilor Structurile de prelucrare sunt: Secveniala. Este o succesiune de prelucrri (simple sau structurate). Execuia structurii secveniale consta n execuia prelucrrilor componente n ordinea n care sunt specificate. De decizie (alternativ). Permite specificarea situaiilor n care, n funcie de realizarea sau nerealizarea unei condiii, se efectueaz o prelucrare sau o alta prelucrare. Condiia este, de regul, o expresie a crui rezultat este o valoare logic (adevrat sau fals). O astfel de prelucrare apare, de exemplu, n evaluarea unei funcii definite prin: x, x (,1] f ( x) = 1 + ( x 1) 2 , x (1, ) De ciclare (repetitiv). Permite modelarea situaiilor cnd o prelucrare trebuie repetat. Se caracterizeaz prin existena unei prelucrri care se repet i a unei condiii de oprire (sau de continuare). n funcie de momentul n care este analizat condiia exista prelucrri repetitive condiionate anterior (condiia este analizata nainte de a efectua prelucrarea) i prelucrri condiionate posterior (condiia este analizat a dup efectuarea prelucrrii). Un exemplu de prelucrare n 1 ciclic este calcul sumei 1 + . n acest caz prelucrarea este dat de adunare n i =1 iar condiia de oprire este aceea ca s se fi adunat toi termenii. 1.6. Exerciii 1. Se consider urmtoarea metod de nmulire a doua numere ntregi x si y. Se scrie x alturi de y (pe aceeai linie). Se mparte x la 2 si ctul mpririi se scrie sub x (restul se ignor). Se nmulete y cu 2 iar produsul se scrie sub y. Procedeul continu construindu-se astfel doua coloane de numere. Calculele se opresc n momentul n care pe prima coloan se obine valoarea 1. Se adun toate valorile de pe coloana a doua care corespund unor valori impare aflate pe prima coloan. Este metoda descrisa un algoritm ? Este el corect (determina produsul celor doua numere) ? S considerm calculul produsului 12 x 5. x | y ------------12 | 5 6 | 10 3 | 20 1 | 40 ----------60 Introducere -8-
Proiectarea algoritmilor Ca urmare a mpririlor succesive la 2 valorile de pe prima coloana descresc pn se ajunge la un ct egal cu 1. Prin urmare prelucrarea este finit. Corectitudinea prelucrrii deriv din faptul ca metoda realizeaz de fapt conversia n baza 2 a primului numr, iar produsul se obine prin nmulirea succesiv a celui de al doilea numr cu puteri ale lui 2 i prin nsumarea acelor produse care corespund unor cifre nenule n reprezentarea binara a primului numr. 2. Propunei un algoritm pentru determinarea prii ntregi a unui numr real. Indicaie. Se va tine cont de semnul numrului. n cazul n care este pozitiv se scade succesiv valoarea 1 pn cnd se ajunge la o valoare mai mica strict dect 1. Numrul de scderi efectuate indica valoarea prii ntregi. Pentru numere negative se aduna succesiv 1 pn se obine o valoare mai mare sau egala cu 0. 3. Consideram ca o vnztoare dispune doar de monede de 2 uniti i 5 uniti. Propunei un algoritm care sa stabileasc modul de plata a unui rest (restul este de cel puin 4). Indicaie. Dac restul este un numr par atunci vnztoarea poate da doar monede de 2. Daca numrul este impar vnztoarea poate da o moneda de 5 iar ceea ce rmne (un numr par) n monede de 2. 4. Consideram urmtoarele doua probleme: (a) O gospodina a fcut o serie de cumpraturi i are la dispoziie doua sacoe. Problema consta n a distribui cumpraturile n cele doua sacose astfel nct diferena ntre greutile celor doua sacoe sa fie ct mai mic. (b) Se consider doua dispozitive de stocare (de exemplu discuri magnetice) si o mulime de fiiere a cror dimensiuni nsumate nu depete capacitatea global a celor dou discuri. Se ncearc repartizarea fiierelor n cele doua discuri astfel nct diferena dintre spatiile rmase libere sa fie ct mai mic. Este vreo legtur ntre cele dou probleme ? Gsii metode de rezolvare. Indicaie. Ambele probleme pot fi formalizate astfel: se considera o mulime de numere pozitive, A = {a1,a2,...,an } i se cere s se determine doua submulimi disjuncte B si C astfel nct B C = A i
a i B
ai ai
a i C
este minim. Cea mai simpl metod
este cea a forei brute prin care se genereaz toate perechile de submulimi (B, C) i se alege cea care minimizeaz diferena specificat mai sus. Numrul de partiii distincte n-1 este 2 -1 daca. Pentru n mare, numrul de partiii ce trebuie testate devine mare 29 (pentru n = 10 este 511 iar pentru n = 100 este de ordinul 10 ). O variant de generare a submulimilor B, C este aceea a utilizrii unui numr binar cu n bii, biii cu valoarea 0 indicnd apartenena la mulimea B, iar cei cu valoarea 1, apartenena la mulimea C. Starea cu toi biii1 sau 0 nu este luat n considerare, iar pentru a elimina strile n care cele dou submulimi au componena invers, un bit, de exemplu bitul n, va avea o singur valoare. Cei n bii pot fi modelai prin variabile logice. Introducere -9-
Proiectarea algoritmilor O rutin n limbajul DELPHI este artat mai jos:

procedure TForm1.Button2Click(Sender: TObject); var l,lopt:tablel; dif,difmin:real; nrst,nrstopt,nrstmax:longword; i:word; sir1,sir2:string; begin assignfile(fis_in,numef); reset(fis_in); readln(fis_in,n); for i:=1 to n do read(fis_in,a[i]); closefile(fis_in); for i:=1 to n do l[i]:=false; nrst:=1; difmin:=calcdif(n,a,l); nrstopt:=1; l[1]:=true; nrstmax:=trunc(power(2,n-1))-1; listbox1.Clear; listbox1.Items.add('Nr. maxim stari: '+inttostr(nrstmax)); while not l[n] do begin dif:=calcdif(n,a,l); if dif<difmin then begin difmin:=dif; nrstopt:=nrst; lopt:=l; end; afisiter('Nr. stare: '+inttostr(nrst),dif,a,l); i:=1; while l[i] do begin l[i]:=false; inc(i); end; l[i]:=true; inc(nrst); end; listbox1.Items.add(' '); listbox1.Items.add('Optim: '+inttostr(nrstopt)+' Diferenta: '+floattostr(difmin)); sir1:=''; sir2:=''; for i:=1 to n do if lopt[i] then sir1:=sir1+floattostr(a[i])+' ' else sir2:=sir2+floattostr(a[i])+' '; listbox1.Items.add('Sacosa 1: '+sir1);
Introducere - 10 -
listbox1.Items.add('Sacosa 2: '+sir2); listbox1.Visible:=true; button3.Visible:=true; button1.Visible:=false; button2.Visible:=false; button4.Visible:=false; end;
Procedura afisiter afieaz ntr-un box componena sacoelor n fiecare stare generat, iar funcia calcdif calculaez diferena dintre cele dou sacoe. Ea este prezentat mai jos.
function calcdif(n:word;a:tabler;l:tablel):real; var i:word; s1,s2:real; begin s1:=0; s2:=0; for i:=1 to n do if l[i] then s1:=s1+a[i] else s2:=s2+a[i]; result:=abs(s1-s2); end;
Metoda este, aa cum am specificat ineficient. O metod mai bun, care nu garanteaz ns obinerea soluiei optime, este aceea n care se sorteaz irul de intrare, dup care se selecteaz elementele din ir n cele dou submulimi astfel nct, n orice moment diferena dintre suma elementelor mulimilor s fie minim. n legtur cu aceast metod vom reveni.
Introducere - 11 -
Proiectarea algoritmilor 2. DESCRIEREA ALGORITMILOR Rezolvarea n pai a problemelor este descris, de obicei, printr-o succesiune de afirmaii prin care se precizeaz ordinea de efectuare a operaiilor i condiiile de oprire. Unele probleme pot fi rezolvate utiliznd o descriere matematic, ns acesta nu este suficient de clar, unele detalii necesare pentru codificarea ntr-un limbaj de programare neputnd fi precizate. Din acest motiv pentru descrierea algoritmilor se folosesc: Scheme logice Permit descrierea algoritmului n mod grafic. Fiecrui tip de prelucrare elementar i corespunde un simbol grafic. Prelucrrile succesive sunt indicate prin conectarea prelucrrilor elementare i prin sgei. Limbaj algoritmic Este un limbaj artificial constituit dintr-un vocabular restrns ce conine simboluri i cuvinte cheie asociate prelucrrilor i identificatori pentru memorarea datelor. Ca orice limbaj se bazeaz pe un set redus de cuvinte cheie i reguli de sintax minime. Sunt acceptate i expresii matematice. Limbajul de descriere a algoritmilor este numit i pseudocod, pentru a arta apropierea de limbajele de programare, dar cu reguli sintactice mult mai libere. Important este ca descrierea algoritmului s fie clar i fr ambiguiti. 2.1. Limbaj algoritmic Permite, utiliznd simboluri i cuvinte cheie s se precizeze prelucrrile simple i cele structurate. Prelucrrile simple sunt: Atribuire Unei variabile v i se atribuie valoarea unei expresii v < expresie> Expresiile pot fi numerice, alfanumerice sau logice, variabila v avnd acelai tip cu expresia. Ele cuprind operatori i operanzi. Operatorii pot fi: aritmetici: + (adunare), -(scdere), *(nmulire), / (mprire), ^ (ridicare la putere), DIV (mprire ntreag), MOD (restul mpririi ntregi); relaionali: = (egal), sau <> (diferit), < (strict mai mic), sau <= (mai mic sau egal), sau >= (mai mare sau egal), > (strict mai mare), sau >= (mai mare sau egal); logici: OR (sau), AND (i), NOT (negaie) funcii cu una din tipurile de mai sus. Citire ncrcarea unor variabile simple sau structurate de la dispozitivul de intrare, dintr-un fiier sau dintr-un tabel al unei baze de date: READ v READ fiier, v READ tabel, v De precizat c n cazul citirii secveniale a nregistrrilor dintr-un fiier sau o tabel a unei baze de date trebuie indicat controlul sfritului de fiier utiliznd funcii care indic acest lucru, cum ar fi funcia EOF(fiier). Descrierea algoritmilor - 12 -
Proiectarea algoritmilor Scriere Scrierea la dispozitivul de ieire, ntr-un fiier sau ntr-un tabel a unei baze de date a unei expresii: WRITE <expresie> WRITE fiier, <expresie> WRITE tabel, <expresie> Prelucrrile structurate sunt: secveniale, condiionale i repetitive. Structura secvenial O succesiune de n prelucrri se specific astfel: <prelucrarea 1 > <prelucrarea 2 > ....................... <prelucrarea n > fiecare dintre prelucrrile 1,2,..,n fiind prelucrri simple de tipul celor de mai sus. Structura condiional Se utilizeaz atunci cnd, n prezena unei condiii, se execut o ramur sau alta n funcie de valoarea adevrat sau fals a condiiei. O structur condiional, cu dou ramuri de prelucrare, se reprezint prin: IF <condiie> THEN <prelucrare 1> ELSE <prelucrare 2 > Dac <condiie> = T (adevrat) atunci se execut <prelucrare 1>, altfel se execut <prelucrare 2>. O structur condiional cu o singur prelucrare se reprezint sub forma: IF <condiie> THEN <prelucrare> O structur cu mai multe ramuri se reprezint utiliznd mai multe IF uri succesive. IF <condiie 1> THEN <prelucrare 1> ELSE IF <condiie 2> THEN <prelucrare 2> ELSE IF <condiie 3> THEN <prelucrare 3> ............................. Structurile alternative sunt prezentate grafic n figura 2.1. Structuri repetitive permit descrierea unor prelucrri repetitive, numrul de repetri fiind determinat de o condiie. Condiia poate fi precizat naintea prelucrrii sau dup aceasta. Acestea sunt prelucrri repetitive condiionate anterior sau condiionate posterior. Varianta condiionat anterior se scrie n pseudocod sub forma general: WHILE <condiie> DO <prelucrare> sau sub forma controlului unui contor: Descrierea algoritmilor - 13 -
Proiectarea algoritmilor vv1 WHILE v v2 DO <prelucrare> vv+pas sau FOR i v1 , v2 , pas DO <prelucrare>
T
condiie
T
condiie
prelucrare 1
prelucrare 2
prelucrare
Figura 2.1 Structuri condiionale
n prima form, la execuie, prelucrarea se execut ct timp condiia specificat este adevrat. Dac condiia nu este adevrat de la nceput, prelucrarea nu se execut niciodat. De asemenea este necesar ca n modulul de prelucrarea s existe posibilitatea modificrii condiiei de buclare astfel nct ea s nu se repete la infinit. Variantele cu un contor care ia valori ntre dou limite v1 i v2, modelate prin bucla WHILE sau FOR se execut de un numr finit de pai. Descrierea grafic a structurilor repetitive este artat n figura 2. Structura repetitiv condiionat posterior se scrie n pseudocod astfel: REPEAT <prelucrare> UNTIL <condiie> Prelucrarea se execut cel puin o dat i se oprete cnd condiia este adevrat. n modulul prelucrare trebuie s existe o modificare a condiiei, altcum bucla se repet la nesfrit. Reprezentarea grafic a structurii repetitive cu condiia la sfrit este reprezentat grafic n figura 3. Descrierea algoritmilor - 14 -
Proiectarea algoritmilor v=v1 T

condiie
F
prelucrare
T
prelucrare
v v2
vv+pas
Figura 2 Structuri repetitive condiionate anterior
2.2. Specificarea datelor Pentru datele simple, de regul, nu este necesar specificarea tipului de date, tipul lor fiind, de obicei, uor de intuit. Pentru datele structurate (nregistrri, tablouri) precizrile privind caracteristicile acestora sunt obligatorii. De exemplu pentru variabilele simple a,b,c,d de tipul ntreg, respectiv real, boolean i ir de caractere. Declararea tipului se face sub forma: INTEGER a REAL b BOOLEAN c CHARCATER d n cazul datelor structurate declaraiile sunt de tipul: pers=RECORD nume:CHARACTER prenume: CHARACTER nota:INTEGER; INTEGER t1[n1..,n2] REAL t2[n1..,n2, m1,..,m2] Descrierea algoritmilor - 15 -
prelucrare
T
condiie
F
Figura 3 Structura repetitiv condiionat posterior
Proiectarea algoritmilor Referirea la un cmp dintr-o nregistrare se va face sub forma: pers.nume, pers.prenume, pers.nota. Referirea la un element dintr-un tablou unidimensional se face sub forma t1i, cu n1 i n2, sau t2ij, n1 i n2, m1 j m2. 2.3. Exemple de algoritmi A. Structura secvenial S se scrie un algoritm pentru calculul ariei unui triunghi oarecare cunoscnduse lungimile laturilor a,b,c. Vom folosi formula lui Heron A = p ( p a ) ( p b) ( p c) , unde p este semiperimetrul. Algoritmul de calcul, n pseudocod, este: REAL a,b,c,p,aria READ a,b,c a+b+c p 2 aria p ( p a ) ( p b) ( p c) WRITE aria B. Structura de decizie B1.S se scrie un algoritm pentru rezolvarea ecuaiei de gradul II: 2 a x + b x + c = 0 , a,b,c R.
REAL a,b,c,delta,x1,x2 READ a,b,c IF a=0 THEN IF b=0 THEN IF c=0 THEN WRITE Identitate, a,b,c=0 ELSE WRITE Ecuatie imposibila ELSE c x1 b WRITE Ecuatie de gradul I, x=,x1 ELSE delta b 2 4 a c IF delta < 0 THEN b x1 2a delta x2 2a WRITE Solutii complex conjugate:,x1,x2
Descrierea algoritmilor - 16 -
Proiectarea algoritmilor ELSE IF delta=0 THEN b x1 = 2a WRITE Solutie unica:,x1 ELSE b + delta x1 2a b delta x2 2a WRITE Solutii reale distincte:,x1,x2 B2. Se consider trei valori reale a,b,c. a)S se scrie un algoritm pentru determinarea minimului celor 3 valori. b)S se afieze cele 3 valori n ordine cresctoare. a) O prim variant se obine uor, comparnd variabilele dou cte dou: REAL a,b,c,min READ a,b,c IF a < b THEN IF a < c THEN mina ELSE minc ELSE IF b < c THEN minb ELSE minc WRITE min O variant mai compact, care poate fi generalizat, este aceea n care se presupune c valoarea minim este dat de prima valoare, dup care aceasta se compar cu toate valorile urmtoare reinndu-se minimul la fiecare comparaie. REAL a,b,c,min READ a,b,c mina IF b < min THEN minb IF c < min THEN minc Descrierea algoritmilor - 17 -
Proiectarea algoritmilor WRITE min b) O prim variant este aceea n care se verific fiecare variant de ordonare. REAL a,b,c,min READ a,b,c IF (a < b) AND (b < c) THEN WRITE a,b,c IF (b < a) AND (a < c) THEN WRITE b,a,c IF (c < b) AND (b < a) THEN WRITE c,b,a IF (a < c) AND (c < b) THEN WRITE a,c,b IF (c < a) AND (a < b) THEN WRITE c,a,b IF (b < c) AND (c < a) THEN WRITE b,c,a O alt variant se obine comparnd, succesiv, dou cte dou valori: REAL a,b,c,min READ a,b,c IF a < b THEN IF b < c THEN WRITE a,b,c ELSE IF a < c THEN WRITE a,c,b ELSE WRITE c,a,b ELSE IF a < c THEN WRITE b,a,c ELSE IF b < c THEN WRITE b,c,a ELSE WRITE c,b,a C. Structuri repetitive. La proiectarea unei structuri repetitive trebuie stabilite: i) valorile iniiale ale variabilelor care intervin n prelucrarea repetitiv; ii) prelucrrile care se repet; iii) condiia de oprire.
xi S se scrie algoritmi pentru calculul sumelor: a) i , nN*; b) , i =1 i =1 i!
n 3 n
xi i! , x(0,1), n n(), > 0, n() fiind acea valoare a lui n pentru i =1 care raportul xi/i! < . a) Calculul sumei poate fi descris prin urmtoarele trei variante echivalente INTEGER S,i,n READ n S0 i1 WHILE i n SS+i3 ii+1 WRITE S
n
x(0,1), nN*; c)
INTEGER S,i,n READ n S0 FOR i 1, n DO SS+i3 WRITE S
INTEGER S,i,n READ n S0 i1 REPEAT SS+i3 ii+1 UNTIL i > n b) Am putea aplica metoda de mai sus, adic calculnd toi termenii sumei i adunndu-i. Putem observa ns c volumul de calcul se reduce semnificativ dac calculm termenii succesivi unul n funcie de precedentul. Dac notm termenul sumei x cu T(i) atunci putem scrie: T (i ) = T (i 1) . i INTEGER i,n REAL x,S READ n,x i1 S0 T1 WHILE i n DO TTx/i
Proiectarea algoritmilor SS+T ii+1 WRITE S c) ntruct nu cunoatem de la nceput numrul de repetri, vom stabili c sumarea se face atta timp ct termenii sumei sunt mai mari ca . INTEGER i REAL x,S, S0 i1 Tx WHILE T DO SS+T ii+1 TTx/i WRITE S d) S se scrie un algoritm pentru determinarea celui mai mare divizor comun a numerelor naturale a i b. Vom folosi algoritmul lui Euclid prin care cmmdc se determin prin mprirea succesiv mpritorului la ultimul rest, primul demprit fiind a, iar primul mpritor fiind b. Dac restul este zero, ultimul demprit este cmmdc. INTEGER a,b,d,i,r READ a,b da ib rd MOD i WHILE r0 DO di ir rd MOD i WRITE i e) S se scrie un algoritm pentru determinarea medie aritmetice a unui ir finit de numere x1, x2,...,xn. Media se calculeaz cu relaia: media =
INTEGER i,n REAL x[1..n], media READ n, x[1..n] media 0 i1 WHILE i n DO
xi
i =1
Proiectarea algoritmilor mediamedia+xi ii+1 mediamedia/n WRITE media

2.4. Tehnica rafinrii succesive i subalgoritmi
Este o metod prin care o problem iniial, complex, este descompus n mai multe probleme care se rezolv separat. Avantajul acestei tehnici rezid n aceea c problemele elementare sunt mai uor de neles i rezolvat. De asemenea o procedur elaborat pentru o subproblem poate fi utilizat pentru rezolvarea unui numr mare de probleme de acelai fel. n acest scop subalgoritmii trebuie s defineasc un set de parametrii de apel care s permit utilizarea ei n multiple cazuri. Aceti parametri au rolul de parametri formali i nu trebuie s impun limite i restricii suplimentare. Apelul unui subalgoritm se face cu parametri efectivi, specifice aplicaiei respective. Efectul unui subalgoritm este transmiterea ctre algoritmul apelant a unor parametri modificai sau modificarea direct a unor variabile n programul apelant. Structura unui subalgoritm are forma general: <nume subalgoritm> (<parametri formali>) <date locale> <prelucrri> RETURN <rezultate> n funcie de mediul de dezvoltare, subalgoritmii pot avea o serie de efecte colaterale care constau n modificarea unor variabile ale programului apelant. Aceast ultim situaie nu este de dorit n practic, ntruct la apeluri n diverse situaii poate conduce la efecte necontrolate. Din acest motiv se recomand ca toate rezultatele s fie returnate prin parametri formali. Exemplu S se determine cea mai mare valoare dintre minimele valorilor elementelor unei matrice pe linii. Considerm matricea a[m,n]. Vom reine n vectorul b[m] minimele elementelor de pe linii. Vom avea de rezolvat dou subprobleme: determinarea minimului din vectorii linie aij, j=1,2,..,n pentru fiecare linie i=1,2,..,m i apoi determinarea elementului maxim din vectorul bi, i=1,2,..,m. Algoritmul pentru determinarea minimului de pe linii: minim (real:n,x) INTEGER i REAL min minx1 FOR i = 2, n DO IF xi < min THEN minxi RETURN min
Proiectarea algoritmilor Algoritmul pentru determinarea maximului dintr-un ir, x1, x2,..,xm maxim (real:m,x) INTEGER i REAL max maxx1 FOR i = 2, m DO IF xi > max THEN maxxi RETURN max
Algoritmul principal va fi: REAL a[1..m,1..n],b[1..m], x[1..,n], maxmin INTEGER m,n,i READ n,m,a FOR i 1, m DO
FOR j 1, n DO xjaij biminim(n,x) maxminmaxim(m,b) RETURN maxmin
2.5. Exerciii
Scriei algoritmi pentru rezolvarea urmtoarelor probleme: n n 1 1. S se calculeze a) (i + 1) ; b) 2 i =1 (i!) i =1 2. S se calculeze sumele urmtoare, neglijnd termenii mai mici ca : i x x 2 i x 2i +1 xi a) ; b) ( 1)i ; c) ( 1)i ; d) ( 1)i +1 (2 i )! i = 0 (2 i + 1)! i = 0 i i =1 i! i =0 3. S se genereze primele N elemente i s se calculeze cu precizia , limitele irurilor a) xn=(1+1/n)n; b) x1=a, xn=(xn-1+a/xn-1), a > 0; c) xn=fn/fn-1, f0=1, f1=1, fn=fn-1+fn-1 (irul Fibonacci). Se va considera precizia ndeplinit atunci cnd diferena dintre doi termeni ai irului este mai mic ca . 4. a) S se determine toi divizorii unui numr natural; b) S se determine toi divizorii comuni a dou numere naturale; c) S se verifice dac un numr este prim sau nu; d) S se verifice dac dou numere sunt prime ntre ele; e) S se genereze toate numerele prime mai mici dect o valoare dat; f) S se genereze toate perechile de numere prime ntre ele mai mici ca o valoare dat; g) S se scrie descompunerea n factori primi a unui numr natural; h)
Proiectarea algoritmilor S se determine cele mai mare divizor comun i cel mai mic multiplu comun folosind descompunerea n factori primi. 5. a) S se determine suma cifrelor unui numr natural; b) S se determine toate cifrele distincte dintr-un numr natural; c) S se determine valoarea obinut prin inversarea cifrelor unui numr natural; d) S se determine reprezentarea n baza 2 a unui numr natural.
Proiectarea algoritmilor 3. VERIFICAREA CORECTITUDINII ALGORITMILOR Proiectarea unui algoritm presupune i analiza acestuia, ce const din: Verificarea corectitudinii - nseamn a verifica dac algoritmul conduce dup un numr finit de prelucrri la obinerea soluiei problemei. Analiza complexitii - nseamn a stabili volumul de resurse (spaiu i timp) necesar pentru execuia algoritmului pe o main de calcul. 3.1. Etapele verificrii corectitudinii Pentru a stabili dac un algoritm rezolv problema pentru care a fost elaborat se poate alege una dintre urmtoarele variante: o Experimental. Se testeaz algoritmul pentru diverse instane ale problemei. Principalul avantaj al acestei abordri l reprezint simplitatea, iar principalul dezavantaj l reprezint faptul c testarea nu poate acoperi ntotdeauna toate variantele posibile de date de intrare. Varianta experimental permite uneori identificarea situaiilor pentru care algoritmul nu funcioneaz corect. De obicei, prin gsirea unor situaii n care algoritmul nu funcioneaz corect, se poate trage concluzia c acesta nu satisface cerinele impuse. o Analitic. Se demonstreaz c algoritmul funcioneaz corect pentru orice date de intrare. Principalul avantaj l reprezint faptul c este garantat corectitudinea pentru orice date de intrare. Dezavantajul este reprezentat de faptul c uneori este dificil de gsit o demonstraie. Abordarea analitic poate ns conduce la o mai bun nelegere a algoritmului i la identificarea poriunilor ce conin eventuale erori. Pe de alt parte, gsirea unei justificri a corectitudinii poate fi dificil n cazul algoritmilor compleci. In aceast situaie algoritmul se descompune n subalgoritmi i se demonstreaz pentru fiecare parte corectitudinea. n verificarea analitic a corectitudinii se parcurg urmtoarele etape principale: Identificarea proprietilor datelor de intrare (precondiiile problemei). Identificarea proprietilor pe care trebuie s le satisfac rezultatul (postcondiiile problemei). Demonstrarea faptului c pornind de la precondiii i aplicnd prelucrrile specificate n algoritm se ajunge la satisfacerea postcondiiilor. n analiza corectitudinii este util noiunea de stare a unui algoritm neleas ca ansamblul valorilor pe care le au variabilele prelucrate n cadrul algoritmului la un moment dat (pas al prelucrrii). Ideea verificrii este de a stabili care trebuie s fie starea la fiecare moment astfel nct n final s fie satisfcute postcondiiile. O dat stabilite aceste stri intermediare este suficient s se verifice c fiecare prelucrare asigur transformarea strii care o precede n cea care o succede. Starea algoritmului este modificat prin atribuiri de valori variabilelor. n cazul prelucrrilor secveniale Verificrii corectitudinii algoritmilor - 24 -
Proiectarea algoritmilor (succesiuni de atribuiri), verificarea este n general simpl constnd n a analiza succesiv efectul fiecrei atribuiri asupra strii algoritmului. Principala surs de erori o reprezint prelucrrile repetitive n care se pot specifica n mod greit iniializrile, prelucrrile din corpul ciclului sau condiia de oprire (continuare). Pentru a demonstra c o prelucrare repetitiv este corect se folosete adesea metoda induciei matematice. Exemplu. Considerm urmtorul algoritm, care determin minimul unui ir finit de numere reale: minim(n,a) min a1 FOR i 2, n DO IF min > ai THEN min ai RETURN min Analiznd algoritmul de mai sus vedem c enunul problemei nu impune nici o restricie asupra tabloului a[1..n] astfel c setul de precondiii este constituit doar din n 1 (irul nu este vid). Postcondiia este reprezentat de proprietatea valorii minime: min ai pentru orice i = 1,2,.., n. Rmne s artm c postcondiia rezult n urma aplicrii algoritmului. Demonstrm prin inducie matematic dup variabila i c min ai , i = 1,2,.., n. Cum min = a1 i valoarea lui min este nlocuit doar cu una mai mic rezult c min a1. Presupunem c min ak pentru orice k = 1,2,.., i. Rmne s artm c min ai+1. La pasul i al ciclului FOR valoarea lui min se modific astfel: Dac min ai+1 atunci min rmne nemodificat. Dac min > ai+1 atunci min se nlocuiete cu ai+1 Astfel n oricare dintre variante se obine c min ai+1. Conform metodei induciei matematice rezult c postcondiia este satisfcut, deci algoritmul este corect. Dac algoritmul se scrie sub forma: minim(n,a) min a1 FOR i 1, n 1 DO IF ai+1 > ai THEN min ai ELSE min ai+1 RETURN min n acest caz prelucrarea din corpul ciclului conduce la min = min {ai, ai+1} astfel c nu mai poate demonstra c pornind de la min = min{a1,..,ai} c min = min{a1,..,ai+1}. Dealtfel este uor de gsit un contraexemplu (de exemplu irul {2, 1, 3, 5, 4}) pentru care algoritmul de mai sus nu funcioneaz corect. n schimb se poate demonstra c algoritmul returneaz min{an-1, an}. Verificrii corectitudinii algoritmilor - 25 -
Proiectarea algoritmilor 3.2. Elemente de analiz formal a corectitudinii Pentru a se introduce o disciplin n demonstrarea corectitudinii algoritmilor s-a dezvoltat o metod formal de analiz bazat pe urmtoarea strategie: pe baza precondiiilor i postcondiiilor problemei se stabilesc pentru fiecare prelucrare aseriuni privind valorile datelor i relaiile dintre ele;
pentru fiecare prelucrare se demonstreaz c asigur satisfacerea aseriunii care o urmeaz dac este satisfcut aseriunea care o precede. Notm cu P precondiiile problemei, cu A algoritmul i cu Q postcondiiile. Spunem c tripletul (P, A,Q) formeaz un algoritm corect, i notm P Q , dac urmtoarea afirmaie este adevrat:
A
Dac datele problemei satisfac precondiiile P atunci: (i)rezultatul satisface postcondiiile Q; (ii)algoritmul A se termin dup un numr finit de pai. Verificarea poate fi descompus la nivelul structurilor de prelucrare. Pentru fiecare dintre structurile de prelucrare exist reguli care uureaz verificarea. Vom stabili reguli pentru cele trei structuri de baz: structura secvenial, structura alternativ i structura repetitiv. A. Regula structurii secveniale Fie algoritmul A constituit din succesiunea de prelucrri (A1,A2,..,;An). Notm cu Pi-1 i Pi starea algoritmului nainte i respectiv dup efectuarea prelucrrii Ai. Regula structurii secveniale poate fi enunat astfel: Dac P P0, Pi 1 Pi pentru i=1,2,..,n i Pn Q, atunci P Q . Exemplu. Fie a i b dou valori ntregi, iar x i y dou variabile ce conin valorile a i b. S se interschimbe valorile celor dou variabile. Precondiiile problemei sunt: {x = a, y = b}, iar postcondiiile sunt {x = b, y = a}. Consideram prelucrrile algoritmului:
A1: aux x A2: x y A3: yaux
Ai
A
Aseriunile privind strile algoritmului sunt urmtoarele: P0 = {x = a, y = b} (nainte de A1) P1 = {aux = a, x = a, y = b} (dup A1) P2 = {aux = a, x = b, y = b} (dup A2) P3 = {aux = a, x = b, y = a} (dup A3) Este uor de remarcat c P = P0, P3 Q, Pi 1 Pi , pentru i=1,2,3. Dac ns algoritmul de mai sus se nlocuiete cu:
A1: x y A2: y x
Ai
Verificrii corectitudinii algoritmilor - 26 -
Proiectarea algoritmilor aseriunile corespunztoare sunt: {x = b, y = b}, att dup A1 ct i dup A2. n acest caz aseriunile A1 i A2 nu conduc la postcondiia Q. Aceeai problem poate fi rezolvat fr a folosi o variabil auxiliar efectund prelucrrile:
A1: x x - y A2: y x + y A3: x y - x
Aseriunile privind strile algoritmului sunt urmtoarele: P0 = {x = a, y = b} (nainte de A1) P1 = {x = a - b, y = b} (dup A1) P2 = {x = a - b, y = a} (dup A2) P3 = {x = b, y = a} (dup A3) Este uor de remarcat c P = P0, P3 Q, Pi 1 Pi , pentru i=1,2,3. Pot fi scrise i urmtoarele reguli: a) ntrirea precondiiei Dac R P i P Q atunci R Q , adic algoritmul rmne corect dac se particularizeaz datele de intrare. b) Slbirea postcondiiei Dac Q R i P Q atunci P R , adic algoritmul rmne corect dac se reduc cerinele pentru datele de ieire. c) Proprieti nsoitoare Dac P Q1 i P2 Q2 atunci P P2 Q1 Q2 . 1 1 B. Regula structurii alternative Considerm stuctura: IF c THEN A1 ELSE A2 Dac P i Q sunt precondiiile, respectiv postcondiiile atunci regula poate fi enunat n modul urmtor: Dac c este bine definit (poate fi evaluat), atunci P c Q i P c Q , atunci P Q . Regula sugereaz c trebuie verificat corectitudinea fiecrei ramuri (att cnd c este adevrat ct i n cazul n care este fals). Exemplu. Considerm problema determinrii minimului dintre dou valori reale, distincte: IF a < b THEN ma ELSE mb Verificrii corectitudinii algoritmilor - 27 A A A A A A A
Ai
A1
A2
Proiectarea algoritmilor Precondiiile sunt a R, b R, a b iar postcondiia este m = min{a, b}. Condiia c este a < b. Dac a < b atunci m = a < b deci m = min{a, b}. n caz contrar (a > b) iar prelucrarea de pe ramura ELSE conduce la m = b < a deci din nou m = min{a, b}. C. Regula structurii repetitive. ntruct toate structurile repetitive pot fi reorganizate astfel nct s conin o structur condiionat anterior o vom analiza doar pe aceasta. Considerm structura: S: WHILE c DO A, precondiia P i postcondiia Q. Structura repetitiv este corect dac exist o aseriune I (numit invariant al prelucrrii repetitive) asociat strii algoritmului i o funcie t : N N (numit funcie de terminare i care depinde de numrul de ordine al iteraiei) care satisfac proprietile: (a) Aseriunea I este adevrat la nceputul prelucrrii repetitive (P I). (b) Aseriunea I este invariant: dac I este adevrat nainte de efectuarea lui A iar c este adevrat atunci I rmne adevrat i dup efectuarea lui A ( I c I ). (c) La sfritul structurii repetitive (cnd c devine fals) postcondiia Q poate fi dedus din I c Q . (d) Dup efectuarea prelucrrii A valoarea lui t descrete A c t ( p ) = k t ( p + 1) < k . (e) Dac c este adevrat atunci t(p) 1 (mai exist cel puin o iteraie), iar cnd valoarea lui t este 0 condiia c devine fals (algoritmul se termin dup un numr finit de iteraii). Elementul esenial n demonstrarea corectitudinii unei prelucrri repetitive l reprezint gsirea proprietii invariante. Aceasta este o aseriune particular privind relaiile dintre variabilele algoritmului care este adevrat nainte de intrarea n prelucrarea repetitiv, rmne adevrat dup fiecare iteraie iar cnd condiia c devine fals implic postcondiiile. Gsirea unui invariant elimin necesitatea demonstraiei explicite prin inducie matematic. Dac se demonstreaz doar faptul c algoritmul produce rezultatul dorit fr a se analiza i terminarea acestuia atunci despre algoritm se spune c este parial corect. Un algoritm este considerat complet corect atunci cnd se justific i faptul c produce rezultatul dup un numr finit de operaii. Exemplul 1. Relum problema determinrii minimului dintr-un ir finit de valori. Considerm algoritmul:
A
A1: A2: A3: A4: A5: A6:
minim(n,a) min a1 i2 WHILE i n DO IF min > ai THEN min ai i i+1 RETURN min
{min=a1} {min=a1, i=2} {min aj, j=1,2,..,i} {min aj, j=1,2,..,i-1} {min aj, j=1,2,..,n} - 28 -
Verificrii corectitudinii algoritmilor
Proiectarea algoritmilor Precondiia este reprezentat de n 1, iar postcondiia este min xi, i = 1,2,.., n. Aseriunile marcate dup fiecare prelucrare sunt uor de stabilit. Proprietatea invariant este min aj, j =1,2,..,i-1. ntr-adevr, dup prelucrarea A2 proprietatea este satisfcut. Din aseriunea specificat dup A6 rezult c proprietatea rmne adevrat dup fiecare iteraie. Condiia de oprire este i = n + 1 i se observ c atunci cnd este satisfcut, aseriunea final implic postcondiia. Funcia de terminare este t(p) = n + 1 - ip, unde ip este valoarea indicelui i corespunztor iteraiei p. Cum ip+1 = ip + 1 rezult c t(p + 1) < t(p), iar t(p) = 0 implic i = n + 1 adic condiia de oprire a algoritmului. Exemplul 2. Analizm algoritmul lui Euclid pentru determinarea celui mai mare divizor comun a dou numere naturale nenule: Cmmd(a,b) da ib r d MOD i {restul mpririi lui d la i} WHILE r 0 DO di i r r d MOD i RETURN i Precondiiile sunt: a, b N*, iar postcondiia este: i = cmmdc(a,b). Considerm proprietatea I ca fiind cmmdc(a, b) = cmmdc(d, i) i funcia t definit prin t(p) = rp unde rp este restul obinut la iteraia p. Pentru a arta c I este o proprietate invariant este suficient s artm c dac r 0 atunci cmmdc(d, i) = cmmdc(i, r). Notm d1 = cmmdc(d, i) i d2 = cmmdc(i, r). Pe de alt parte d = i q + r. Se pot verifica uor urmtoarele implicaii: d1|d i d1|i d1|d-iq = r d1|i i d1|r d1 d2 d2|i i d2|r d2|iq+r = d d2|i i d2|d d2 d1 Rezult c d1 = d2, deci I satisface proprietile (a) i (b). Cnd ipoteza c devine fals (r = 0) se obine c cmmdc(i,r) = i adic este satisfcut i proprietatea (c). Cum funcia de terminare este chiar valoarea restului, iar acesta descrete de la o iteraie la alta pn devine nul rezult c sunt satisfcute i proprietile (d) i (e). Observaie. Invarianii pot fi utilizai nu numai pentru a determina corectitudinea unui algoritm ci i ca instrument de proiectare a algoritmilor, n sensul c identificarea unei proprieti invariante poate fi vzut ca o etap preliminar elaborrii unui ciclu. Invariantul poate fi considerat ca o specificaie pentru ciclul respectiv i poate fi utilizat n identificarea prelucrrilor necesare pentru iniializare, pentru corpul ciclului i n identificarea condiiei de oprire (continuare) a ciclului. Exemplul 3. S considerm calculul sumei, S, a primelor n numere naturale (n 1). Precondiia este P ={ n 1 } iar postcondiia este Q = {S = 1 + 2 + ::: + n}. ntruct suma va fi calculat adugnd succesiv termenul curent, i, un invariant adecvat ar fi S = 1 + 2 + .. + i. Pentru a asigura validitatea acestui invariant, termenul curent trebuie pregtit chiar nainte de a fi adugat. Pe de alt parte pentru a ne asigura c la finalul ciclului postcondiia este satisfcut rezult c la ieirea din ciclu variabila i trebuie s Verificrii corectitudinii algoritmilor - 29 -
Proiectarea algoritmilor aib valoarea n. Astfel condiia de continuare a ciclului WHILE ar trebui s fie i < n. Toate aceste observaii conduc la algoritmul: Sum(n) i1 S1 WHILE i < n DO i i+1 SS+i RETURN S Este uor de remarcat faptul c exist i alte variante corecte de calcul a sumei. Una dintre acestea este: Sum(n) i1 S0 WHILE i n DO SS+i i i+1 RETURN S Corectitudinea acestui algoritm poate fi demonstrat folosind invariantul: S = 1+2+...+(i-1). 3.3. Exerciii S se demonstreze corectitudinea urmtorilor algoritmi: 1. Algoritmul lui Euclid (varianta fr variabile ajuttoare): Cmmd2(a,b) WHILE a0 and b 0 DO a a mod b IF a 0 THEN b b mod a IF a 0 THEN ra ELSE rb RETURN r 2. Algoritmul lui Euclid (varianta bazat pe scderi succesive):
Proiectarea algoritmilor Cmmd3(a,b) WHILE ab DO IF a > b THEN aab ELSE bba RETURN a 3. Calculul mediei aritmetice a unui ir finit de valori: Medie(n,x) S0 i1 WHILE i n DO S S+xi i i+1 S S/n RETURN S 4. Determinarea prii ntregi a unui numr real: partintr(x) ax IF x 0 THEN WHILE a 1 DO a a 1 ELSE WHILE a < 0 DO a a +1 RETURN x-a 5. Cutare secvenial. Se consider un tablou x1, x2,..,xn care conine valoarea (a) S se afle prima poziie pe care se afl valoarea x0; (b) S se afle toate poziiile pe care se afl x0 n tabloul x. Cauta1(n,x,x0) i1 WHILE xi x0 DO i i+1 RETURN i b) Cauta2(n,x,x0) i1 j0 WHILE i n DO IF xi = x0 THEN j j+1 pozj i i i+1 RETURN j,poz
x0.
a)
Proiectarea algoritmilor 4. ANALIZA COMPLEXITTII ALGORITMILOR 4.1. Scopul analizei complexitii Analiza complexitii are drept scop aprecierea calitii unui algoritm, prin determinarea resurselor necesare pentru execuia algoritmului pe o main de calcul. Prin resurse necesare nelegem: Spaiul maxim de memorie necesar pentru execuia algoritmului. Trebuie luat n considerare situaia alocrii dinamice a memoriei, cnd aceasta poate avea valori diferite n puncte diferite ale algoritmului. Timpul necesar pentru execuia tuturor operaiilor cuprinse n algoritm. Aceast analiz este util pentru a aprecia dac algoritmul respectiv utilizeaz un volum de resurse acceptabile. De asemenea printr-o asemenea analiz se pot compara doi sau mai muli algoritmi din punct de vedere al eficienei. Dac un algoritm necesit resurse foarte mari, al cror cost depesc valoarea beneficiilor obinute prin aplicarea respectivului algoritm, este evident c utilizarea lui este ineficient. n majoritatea situaiilor, volumul de resurse necesar pentru execuia unui algoritm depind de dimensiunea problemei de rezolvat. Aceasta este determinat, n principal, de volumul datelor de intrare. n cazul cel mai general acest lucru este dat numrul de bii necesari pentru memorarea datelor. Dac se prelucreaz o valoare numeric, n (de exemplu dac se verific c numrul n este prim) atunci ca dimensiune a problemei se consider numrul de bii necesari pentru reprezentarea lui n, adic [lg2n]+1. Dac datele care se prelucreaz sunt forma unor tablouri, atunci dimensiunea problemei este dat de numrul componentelor din tablou. De exemplu, determinarea elementului minim dintr-un tablou cu n elemente, conduce la o problem de dimensiune n. De asemenea calculul unui polinom de grad n, conduce tot la o problem de dimensiune n. n alte cazuri, dimensiunea problemei poate fi dat de mai muli parametri care o caracterizeaz. n cazul prelucrrii unei matrice de dimensiune m x n, dimensiunea problemei este mn. Uneori dimensiunea problemei depinde de tipul prelucrrii. De exemplu la prelucrarea unui text, dac prelucrrile se fac la nivel de cuvnt, dimensiunea problemei este dat de numrul de cuvinte. Dac prelucrrile se fac la nivel de caracter atunci dimensiunea problemei este dat de numrul de caractere. Spaiul de memorie necesar pentru memorarea datelor este influenat de modul de reprezentarea datelor. De exemplu o matrice 100 x 100 care are numai 50 de elemente nenule (matrice rar) poate fi memorat n mai multe feluri: Tablou 100 x 100, cu 10000 locaii de memorie. Tablou 50 x 3, cu trei coloane, indicnd linia, coloana i valoarea. Rezult 150 de locaii de memorie. Pe de alt parte, modul de reprezentare influeneaz rapiditatea calculelor. De exemplu, adunarea a dou matrice reprezentate n varianta a II-a (cu trei coloane) este mai complicat dect n situaia reprezentrii normale. n general un algoritm eficient solicit mai mult memorie, iar utilizarea unui volum de memorie mic necesit algoritmi mai complicai. n general se alege o soluie de compromis, innd seama i de situaia concret. Analiza complexitii algoritmilor - 32 -
Proiectarea algoritmilor n continuare vom analiza dependena dintre timpul de execuie, reflectat prin numrul de operaii, i dimensiunea problemei. 4. 2. Timpi de execuie n continuare vom nota cu T(n) timpul de execuie al unui algoritm pentru rezolvarea unei probleme de dimensiune n. Pentru a stabili timpul de execuie trebuie stabilit un model de calcul i o unitate de msur. Vom considera un model de calcul (numit i main de calcul cu acces aleator) caracterizat prin: - prelucrrile se efectueaz n mod secvenial - operaiile elementare se execut n acelai timp indiferent de valoarea operanzilor - timpul de acces la o informaie nu depinde de poziia acesteia (de exemplu, ntrun ir de caractere timpul de acces este acelai pentru orice element din ir) A stabili o unitate de msur nseamn a stabili care sunt operaiile elementare i a considera ca unitate de msur timpul de execuie a acestora. n acest fel timpul total de execuie va fi dat de numrul operaiilor elementare. Operaiile elementare sunt cele aritmetice (adunare, scdere, nmulire, mprire), comparaiile ntre dou valori, operaiile logice (AND , OR , NOT). Cum scopul calculului timpului de execuie este acela de a compara calitatea algoritmilor, uneori este suficient s se contorizeze doar anumite tipuri de operaii elementare, numite operaii de baz (de exemplu n operaii de sortare se pot considera doar operaiile de comparare i mutare a elementelor) i/sau s se considere c timpul de execuie a acestora este unitar (este acelai pentru toate operaiile, dei, de exemplu, operaiile de nmulire i mprire sunt mai costisitoare ca cele de adunare sau scdere). Timpul de execuie al ntregului algoritm se obine nsumnd timpii de execuie a prelucrrilor componente. Exemplul 1. Considerm problema calculului
i .
i =1
Dimensiunea acestei
probleme este n. Algoritmul de rezolvare poate fi descris prin: Suma(n) 1: S 0 2: i 1 3: WHILE i n DO 4: || S S + i 5: || i i+ 1 RETURN S n algoritmul de mai sus operaiile care sunt contorizate sunt numerotate. Timpul de execuie al algoritmului poate fi determinat folosind tabelul de costuri: Analiza complexitii algoritmilor - 33 -
Proiectarea algoritmilor Operaie 1 2 3 4 5 Cost Nr. repetri c1 1 c2 1 c3 n+1 c4 n c5 n
nsumnd timpii de execuie se obine T(n) = c1+ c2+n( c3+ c4+ c5)+ c3 = =k1n+k2, adic timpul de execuie este proporional cu dimensiunea problemei. Se observ c valoarea costurilor operaiilor elementare influeneaz doar constantele care intervin n T(n). Prelucrarea repetitiv de mai sus poate fi nlocuit cu FOR i 1, n DO S S+i. n acest caz, T(n) = c1+ c2+(n+1) c3+n c5. De remarcat c instruciunea FOR se repet de n+1 ori, datorit controlului limitelor pentru contor. Dac incrementarea lui i i controlul depirii valorii n au acelai cost (= 1), atunci ciclul FOR cost 2(n+1), pentru o bucl care se repet de n ori. Exemplul 2. S considerm problema calculului produsului a dou matrici: A de dimensiune m x n i B de dimensiune n x p. n acest caz dimensiunea problemei este dat de trei valori (m,n,p). Algoritmul de calcul poate fi descris prin: Produs(a,b,m,n,p) 1: FOR i= 1, n DO
2: FOR j= 1, p DO 3: cij 0 4: FOR k= 1, n DO 5: cij cij + aik bkj RETURN c

Costul prelucrrilor de pe liniile 1,2 i 4 reprezint costul gestiunii contorului i va fi tratat global. Presupunnd c toate operaiile aritmetice i de comparare au acelai cost unitar, tabelul costurilor este:
Operaie 1 2 3 4 5
Cost Nr. repetri 2(m+1) 1 2(p+1) m 1 mp 2(n+1) mp 2 mpn
Rezult timpul de execuie n acest caz: T(m,n,p)=4mnp+5mp+4m+2. n practic nu este necesar o analiz att de detaliat, ci este suficient s se identifice operaia de baz i s se estimeze numrul de repetri ale acestuia. Prin operaia de baz se nelege operaia care contribuie cel mai mult la timpul de execuie Analiza complexitii algoritmilor - 34 -
Proiectarea algoritmilor al algoritmului i este operaia ce apare n ciclul cel mai interior. n exemplul de mai sus se poate considera ca operaie de baz operaia de nmulire. n acest caz costul execuiei algoritmului ar fi T(n,m,p)=mnp. Exemplul 3. Considerm algoritmul pentru determinarea minimului dintr-un ir x1, x2,....,xn. Dimensiunea problemei este dat de numrul n de elemente din ir. Algoritmul este: Minim(x,n) 1: m x1 2: FOR i = 2, n DO 3: IF m > xi THEN 4: m xi RETURN m Tabelul costurilor pe prelucrri este: Operaie 1 2 3 4 Cost 1 2n 1 1 Nr. repetri 1 1 n-1 (n)
Spre deosebire de exemplele anterioare, n exemplul de mai sus, nu putem stabili apriori de cte ori se repet operaia 4. Numrul de prelucrri depinde valorile din ir. Dac cea mai mic valoare se afl pe prima poziie atunci prelucrarea 4 nu se efectua niciodat, iar (n)=0. Acesta este cazul cel mai favorabil, iar T(n) = 3n. Dac ns irul este ordonat descresctor, atunci prelucrarea 4 se va efectua de fiecare dat, adic (n) = n 1. Acesta este cazul cel mai defavorabil, iar T(n) = 4n 1. De remarcat c, n acest caz, putem considera ca operaie de baz comparaia efectuat n prelucrarea 3, rezultnd T(n) = n -1. Exemplul 4. Considerm problema cutrii unei valori v n irul x1, x2,....,xn. Dimensiunea problemei este n, iar algoritmul de rezolvare este: Cautare(n,x) 1: gasit false 2: i 1 3: WHILE (gasit = false) and (i n) DO 4: || IF v = xi THEN 5: || gasit true 6: || ELSE 7: || ii+1 RETURN gasit Considernd prelucrrile de cost unitar rezult: Analiza complexitii algoritmilor - 35 -
Proiectarea algoritmilor Operaie 1 2 3 4 5 6,7 Cost 1 1 3 1 1 1 Nr. repetri 1 1 1(n) + 1 1(n) 2(n) 3(n)
Am alocat costul egal cu 3 pentru instruciunea WHILE deoarece conine trei verificri ale unei expresii logice. n ceea ce privete 1(n), 2(n), 3(n), acestea iau urmtoarele valori: k valoarea se afla in sir 1 (n) = deci 1 1(n) n n valoarea nu se afla in sir unde k reprezint prima poziie n care este gsit valoarea v 1 valoarea se afla in sir 2 ( n) = 0 valoarea nu se afla in sir k 1 valoarea se afla in sir 3 ( n) = deci 0 3(n) n n valoarea nu se afla in sir Cel mai favorabil caz este acela n care valoarea v se afl pe prima poziie din ir i 1(n)=1, 2(n)=1, 3(n)=0, iar T(n)= 1 + 1 + 32+1+1=10. Cazul cel mai defavorabil este acela n care valoarea v nu se afl n ir i atunci 1(n)=n, 2(n)=0, 3(n)=n, iar T(n)= 1 + 1 + 3(n+1)+n+n=5(n+1). Cel mai defavorabil caz este prezint interes ntruct d cel mai mare timp de execuie pentru orice set de date de intrare. Pe de alt parte, trebuie apreciat, pentru o problem dat, care este frecvena de apariie a celui mai defavorabil caz. Cel mai favorabil caz ne indic n ce situaie timpii de execuie sunt cei mai mici. Dac pentru un algoritm oarecare, timpii de execuie sunt mari, chiar pentru cazul cel mai favorabil, atunci este clar c el este ineficient. Timp mediu de execuie reprezint valoarea medie a timpul de execuie al unui algoritm atunci cnd datele de intrare sunt repartizate probabilistic pe domeniul lor de existen. Dac (n) reprezint numrul variatelor posibile pentru datele de intrare, Pk reprezint probabilitatea de apariie a variantei k, iar Tk(n) reprezint timpul de execuie corespunztor variantei k, atunci timpul mediu de execuie este dat de relaia:
Tm (n) = Tk (n) Pk
k =1
(n)
Dac toate cazurile sunt echiprobabile, atunci: 1 Pk = , k = 1,2,.., (n) ( n) Analiza complexitii algoritmilor - 36 -
(n)
Tm (n) =
T ( n)
k =1 k
( n)
Exemplu. Considerm problema cutrii unei valori ntr-un ir x1, x2,....,xn (exemplul 4). Considerm c elementele irului sunt distincte. Vom calcula timpul mediu n ipoteza c valoarea v se poate afla n oricare din poziiile din ir cu aceeai probabilitate. Cum avem n cazuri pentru poziionarea n ir i nc un caz n care valoarea nu se afl n ir, atunci (n) = n + 1. Rezult: 1 Pk = , k = 1,2,.., n + 1 n +1 Timpul corespunztor cazului n care valoarea v se afl pe poziia k este: Tk (n) = 5 (k + 1) iar timpul pentru situaia n care valoarea v nu se afl n ir este: Tn+1 (n) = 5 (n + 1)
(n)
Tm (n) =
T ( n)
k =1 k
(n)
5 n+1 5 (n + 1) (n + 2 ) (k + 1) = + n + 1 2 n + 1 k =1 n +1
5 (n + 4) 2 Problema principal n asemenea situaii o constituie stabilirea distribuiei datelor de intrare. De exemplu, pentru problema de mai sus s-ar putea considera i ipoteza: - p=0.5 valoarea v se afl n tablou, iar probabilitatea de a se afla pe oricare din poziiile din ir este aceeai 1/n - p=0.5 valoarea v nu se afl n tablou n acest caz, timpul mediu de execuie este: 1 1 n 1 5 Tm (n) = 5 (k + 1) + 5 (n + 1) = (3 n + 5) 2 n k =1 2 4 Se constat c timpul mediu de execuie depinde de ipotezele acceptate pentru datele de intrare i nu este o medie aritmetic ntre timpul corespunztor cazului cel mai nefavorabil i cel corespunztor cazului cel mai favorabil. Datorit dificultilor de estimare a timpului mediu, ntruct acesta difer de timpul corespunztor cazului cel mai defavorabil printr-o constant, n practic se estimeaz timpul pentru cazul cel mai defavorabil. Timpul mediu de execuie are relevan n situaiile n care cazul cel mai defavorabil este puin probabil s apar. Tm (n) =
4.3. Ordin de cretere
Pentru a aprecia eficiena unui algoritm nu este necesar cunoaterea exact a expresiei timpului de execuie. Mai degrab intereseaz modul n care variaz timpul de execuie o dat cu creterea dimensiunii problemei. O msur util n acest sens este Analiza complexitii algoritmilor - 37 -
Proiectarea algoritmilor ordinul de cretere. Acesta este determinat de termenul dominant din expresia T(n) n funcie de dimensiunea n a problemei. Acest lucru este justificat de faptul c pentru n mare, termenii diferii de cel dominant sunt neglijabili. Exemple. Dac T(n) = an + b, (a > 0) atunci la creterea lui n de k ori, termenul a) dominant crete i el de k ori, T(kn) = akn + b. n acest caz avem o dependen liniar a ordinului de cretere. b) Dac T(n) = an2 + bn+c, (a > 0) atunci la creterea lui n de k ori, termenul dominant crete de k2 ori, T(kn) = ak2n2 + bkn+c. n acest caz avem o dependen ptratic a ordinului de cretere. c) Dac T(n) = algn, atunci T(kn) = algn +algk, adic n acest caz termenul dominant nu se modific, timpul de execuie crescnd cu o constant. S precizm c prin lg nelegem logaritm n baza 2. d) Dac T(n) = a2n atunci T(kn) = a2k2n= a(2n)k, adic termenul dominant crete exponenial. ntruct problema eficienei este important la valori mari ale lui n (teoretic n ), analiza complexitii intereseaz doar n asemenea situaii. Acest lucru justific considerarea numai a termenului dominant. Acest tip de analiz se mai numete i analiz asimptotic. n cadrul analizei asimptotice se consider c un algoritm este mai eficient dect altul dac ordinul de cretere al timpului de execuie al primului este mai mic dect ordinul de cretere al celui de-al doilea. Relaia ntre ordinele de cretere are semnificaie doar pentru dimensiuni mari ale problemei. Dac considerm timpii T1(n) = 10n + 10 i T2(n) = n2, atunci se observ cu uurin ca T1(n) > T2(n) pentru n 10, dei ordinul de cretere al lui T1 este mai mic dect al lui T2. Prin urmare un algoritm asimptotic mai eficient dect altul reprezint varianta cea mai bun doar n cazul problemelor de dimensiuni mari.
4.4. Notaii asimptotice
Pentru a uura analiza asimptotic i pentru a permite gruparea algoritmilor n clase n funcie de ordinul de cretere a timpului de execuie (fcnd abstracie de eventualele constante ce intervin n expresiile detaliate ale timpilor de execuie) s-au introdus nite clase de funcii i notaii asociate. a) Notaia . Pentru o funcie g: N R+, (g(n)) reprezint mulimea de funcii: * f : N R; c1 , c2 R+ , n0 N astfel incat ( g (n )) = (4.1) 0 c1 g (n) f (n) c2 g (n) n > n0 Despre timpul de execuie al unui algoritm, T(n), spunem c este (g(n) dac T(n) (g(n). n practic se mai folosete notaia abuziv T(n)= (g(n). Practic, prin notaia f(n) g(n) nseamn c f(n) i g(n) sunt asimptotic echivalente. Matematic, acest lucru se traduce prin: f ( n) lim = k, k > 0 n g ( n) Analiza complexitii algoritmilor - 38 -
Proiectarea algoritmilor S considerm funcia f(n)=n2+5nlgn+10 i g(n)=n2. Cu constantele c1=1 i c2=4 vom verifica grafic pentru ce valori ale lui n, are loc inegalitatea 0 c1 g (n) f (n) c2 g ( n) . n figura 4.1 sunt reprezentate cele 3 funcii pentru n 10, iar n figura 4.2, pentru n 50.
Figura 4.1 Reprezentarea funciilor f(n), c1g(n) i c2g(n), pentru n 10
Din figura 4.1 se poate vedea c este suficient s considerm n > n0= 4 pentru ca relaia 0 c1 g (n) f (n) c2 g ( n) s fie respectat. Pentru valori mari, aa cum rezult din figura 4.2, condiia este respectat. Putem stabili forma funciei g , c1, c2 i valorile lui n0 i n cazul exemplelor analizate mai sus (pct. 4.2): - exemplul 1 (calcul sum) T(n) = k1n + k2 putem lua c1=k1 i c2=k1+1 i n0 > k2, c1n T(n) c2n, pentru n n0, deci T(n) (n);
Figura 4.2 Reprezentarea funciilor f(n), c1g(n) i c2g(n), pentru n 50
pentru exemplul 3 (determinare minim din ir) 3n T(n) 4n-1, deci T(n) (n) (este suficient s alegem c1=3, c2=4, n0=1). n general se poate demonstra c dac T(n) = akxk+ ak-1xk-1+...+ a1x+a0, atunci T(n) (nk). ntr-adevr, din Analiza complexitii algoritmilor - 39 -
T ( n) = ak n n k Rezult c > 0 i n0() astfel nct T (n) / n k a k < pentru n > n0(), sau lim
T ( n) ak + . k n Dac notm cu c1 = ak- i c2 = ak+ atunci relaia de mai sus se scrie: c1 n k T (n) c2 n k - n cazul exemplului 4 (cutarea unei valori n ir) s-a obinut 10 T(n) 5(n+1) ceea ce sugereaz c exist cazuri n care numrul de operaii nu depinde de dimensiunea problemei (valoarea cutat se afl pe prima poziie din ir). n aceast situaie T (n) (n) deoarece nu poate fi gsit c1n T(n), pentru n > n0. n astfel de situaii se analizeaz comportarea asimptotic a timpului de execuie n cazul cel mai defavorabil. - n situaia n care timpul de execuie nu depinde de volumul acestora, pentru orice set de date de intrare, vom nota T(n)=(1), adic timp de execuie constant. b) Notaia O. Pentru o funcie g: N R+, O(g(n)) reprezint mulimea de funcii: * f : N R; c R+ , n0 N astfel incat O( g (n )) = (4.2) 0 f (n) c g (n) n > n0 Aceast clas de funcii permite descrierea comportrii unui algoritm n cazul cel mai defavorabil, fr a se face referire la celelalte situaii. ntruct intereseaz comportarea algoritmului pentru date arbitrare, este suficient s specificm o margine superioar pentru timpul de execuie. Dac f(n) O(g(n)) nseamn c f(n) crete asimptotic la fel de repede ca g(n). Astfel spus: f ( n) lim k , k fiind o valoare strict pozitiv n g ( n ) Din definiiile lui i O rezult c ( g (n)) O( g (n)) , incluziunea fiind strict. Prin urmare dac T(n)=(g(n)) atunci T(n) = O(g(n)). Folosind definiia lui O se verific uor c dac g1(n) < g2(n) pentru n > n0, iar f ( n) O ( g1 ( n)) atunci f (n) O ( g 2 (n)) . Prin urmare, dac T(n)=O(n) atunci T(n)=O(nd) d 1. n general, dac T(n) = akxk+ ak-1xk-1+...+ a1x+a0, ak > 0 atunci T(n)= O(nd) pentru orice d k. Evident, n analiza algoritmilor este util s se pun n eviden cea mai mic margine superioar. Astfel, n exemplul 4, vom spune c algoritmul are ordinul de complexitate O(n) i nu O(n2), chiar dac afirmaia este corect din punct de vedere al definiiei. c) Notaia Pentru o funcie g: N R+, (g(n)) reprezint mulimea de funcii: * f : N R; c R+ , n0 N astfel incat (g (n )) = (4.3) 0 c g (n) f (n) n > n0
altfel a k
Analiza complexitii algoritmilor - 40 -
Proiectarea algoritmilor Aceast funcie este o msur a ordinului de cretere a timpului de execuie n cazul cel mai favorabil. Dac f (n) ( g (n)) nseamn c f(n) crete asimptotic cel puin la fel ca g(n), adic f ( n) lim k , k fiind o valoare strict pozitiv, limita putnd s fie i infinit. n g ( n ) Din definiii se observ c ( g (n)) ( g (n)) incluziunea fiind strict. n exemplul 4 avem T(n) = (1) atunci cnd valoarea cutat se afl pe prima poziie, ns T (n) (1) ntruct n cazul cel mai defavorabil timpul de execuie depinde de n. Relaia dintre cele 3 mari clase de funcii este: ( g (n)) = O( g (n)) I ( g (n)) Analiza asimptotic a structurilor fundamentale prezint interes. Dac avem o structur secvenial format din prelucrrile A1, A2,...,An i fiecare din acestea au ordinul de complexitate O(gi(n)), i=1,2,..,n. Structura secvenial va avea ordinul de complexitate: O(max { g1(n), g2(n),..., gn(n)}). n cazul unei structuri alternative cu cele dou prelucrri avnd costurile g1(n), respectiv, g2(n), atunci costul structurii alternative va fi: O(max { g1(n), g2(n)}). n cazul structurilor repetitive, determinarea ordinului de complexitate n cazul cel mai defavorabil se consider numrul maxim de iteraii. Dac numrul de repetri este n, iar dac n interiorul buclei prelucrrile sunt de cost constant atunci de obine ordinul de complexitate O(n) sau (n). Dac avem un ciclu dublu, n care indicii variaz ntre 1 i n, atunci obinem un ordin de complexitate O(n2) sau (n2). Dac limitele ciclului interior se modific dinamic atunci se poate obine un alt ordin de complexitate. De exemplu s considerm urmtoarea prelucrare: m1 FOR i 1, n DO m3*m FOR j 1, m DO (1) Cum pentru fiecare i se obine m = 3i rezult c timpul de execuie este de forma:
T (n) = (3i + 1) (3n ) .

n i =1
Clase de complexitate. n ierarhizarea algoritmilor dup ordinul de complexitate se ine cont de urmtoarele proprieti ale funciilor ce intervin cel mai frecvent n analiz: (lg n )b = 0, lim n k = 0, lim a n = 0, lim a n = 0, a > 1 lim n n! n n n n n a n nk Clasa de complexitate Ordin Exemplu (cazul cel mai defavorabil) logaritmic O(lgn) Cutarea binar radical Cutarea numerelor prime O n
( )
Proiectarea algoritmilor liniar ptratic cubic exponenial factorial O(n) O(nlgn) O(n2) O(n3) O(2n) O(n!) Cutarea secvenial Sortarea prin interclasare Sortarea prin inserie Produsul a dou matrice ptrate de ordin n Prelucrarea tuturor submulimilor unei mulimi cu n elemente Prelucrarea tuturor permutrilor unei mulimi cu n elemente
Algoritmii din clasele exponenial i factorial pot fi utilizai doar pentru probleme de dimensiune mic.
4.5. Etapele analizei complexitii
n analiza complexitii unui algoritm se parcurg urmtoarele etape: 1. Se stabilete dimensiunea problemei 2. Se stabilete operaia de baz 3. Se verific dac numrul de execuii ale operaiei de baz depinde doar de dimensiunea problemei. Dac da, se determin acest numr. Dac nu, se analizeaz cazul cel mai favorabil, cazul cel mai defavorabil i (dac este posibil) cazul mediu. 4. Se stabilete clasa de complexitate a algoritmului.
4.6. Analiza empiric a complexitii algoritmilor
Analiza matematic a complexitii algoritmilor poate fi dificil n cazul unor algoritmi care nu sunt simpli, mai ales dac este vorba de analiza cazului mediu. O alternativ la analiza matematic a complexitii algoritmilor o reprezint analiza empiric. Aceasta poate fi util pentru: - a obine informaii preliminare privind clasa de complexitate a unui algoritm; - compararea eficienei a doi sau mai muli algoritmi destinai rezolvrii aceleiai probleme; - compararea eficienei mai multor implementri ale aceluiai algoritm; - obinerea de informaii privind eficiena implementrii unui algoritm pe un anume calculator. n analiza empiric a eficienei unui algoritm se parcurg urmtoarele etape: 1. Se stabilete scopul analizei 2. Se stabilete metoda de apreciere a eficienei: numr de execuii ale unei/unor operaii sau timp de execuie a ntregului algoritm sau poriune de algoritm. 3. Se stabilesc proprietile datelor de intrare n raport cu care se face analiza (dimensiunea acestora sau ale proprieti specifice). Analiza complexitii algoritmilor - 42 -
Proiectarea algoritmilor 4. Se transcrie algoritmul ntr-un limbaj de programare. 5. Se genereaz mai multe seturi de date de intrare. 6. Se execut programul pentru fiecare set de date de intrare. 7. Se analizeaz rezultatele obinute. Alegerea msurii de eficien depinde de scopul analizei. Dac, de exemplu, se urmrete obinerea unor informaii privind clasa de complexitate sau chiar verificarea acurateei unei estimri teoretice atunci este adecvat utilizarea numrului de opearii efectuate (numrarea prin program a numrului de operaii). Dac scopul evalurii este analiza comportrii unui algoritm, atunci este potrivit timpul de execuie (msurarea timpului de execuie prin program). Pentru a efectua o analiz empiric nu este suficient un singur set de date de intrare ci mai multe, care s pun n eviden diferitele caracteristici ale algoritmului. n general este bine s se aleag date de diferite dimensiuni astfel nct s fie acoperit plaja tuturor dimensiunilor care vor apare n practic. Pe de alt parte are importan i analiza diferitelor valori sau configuraii ale datelor de intrare. Dac se analizeaz un algoritm care verific dac un numr este prim sau nu i testarea se face doar pentru numere prime sau numai pentru numere care nu sunt prime atunci nu se va obine un rezultat relevant. Acelai lucru se poate ntmpla pentru un algoritm a crui comportare depinde de gradul de sortare a unui tablou (dac se utilizeaz fie tablouri aproape sortate sau ordonate n sens invers atunci analiza nu va fi relevant). n vederea analizei empirice, la implementarea algoritmului ntr-un limbaj de programare, vor fi introduse secvene de cod al crui scop o reprezint monitorizarea execuiei. Dac metrica de eficien o reprezint numrul de execuii ale unei operaii atunci se utilizeaz un contor care se incrementeaz dup fiecare execuie a operaiei respective. Dac metrica este timpul de execuie atunci trebuie nregistrate momentul nceperii secvenei monitorizate i momentul ncheierii acesteia. Majoritatea limbajelor de programare ofer funcii care calculeaz timpul scurs ntre dou momente. Este important ca n sistem s nu fie mai multe taskuri active sau s fie contorizat numai timpul afectat execuiei programului analizat. Se recomand s fie executat programul de mai multe ori i s se fac media timpului de execuie. La generarea seturilor de date de intrare scopul urmrit este acela de a se obine date tipice rulrilor uzuale (s nu fie cazuri extreme sau excepii). n acest scop datele se genereaz n manier aleatoare. n realitate este vorba de generare pseudo-aleatorie ntruct este generat prin tehnici cu caracter determinist. Rezultatele nregistrate n urma testelor efectuate se nregistreaz i se fac prelucrri statistice (media, abaterea standard, etc). Este interesant de asemenea reprezentarea grafic a timpului de execuie n funcie de dimensiunea problemei.
4.7. Exerciii
1. S se stabileasc ordinul de complexitate pentru urmtorul algoritm care prelucreaz date de volum n: Analiza complexitii algoritmilor - 43 -
Proiectarea algoritmilor FOR i 1,n DO .(1) FOR j 1, 2i DO .(1) kj WHILE k 0 DO .(1) kk-1 Indicaie: Operaia de baz este operaia de timp constant care se realizeaz sub bucla WHILE. De remarcat c numrul de repetri ale buclei este j. Rezult numrul de repetri ale operaiei de baz: n 2i n n n (n + 1) (2n + 1) 1 T (n) = j = (2i ) (2i + 1) = (2i 2 + i ) = 2 + 6 i =1 j =1 i =1 2 i =1
n (n + 1) 2 3 3 2 5 = n + n + n 2 3 2 6 3 T ( n) n +
( )
2. S se stabileasc ordinul de complexitate al algoritmului h1 WHILE h n DO ..(1) h 2*h Indicaie: Numrul de repetri k ale buclei WHILE rezult din ecuaia: 2 k 1 n k = 1 + [lg n] 3. S se stabileasc ordinul de complexitate al algoritmului Calcul(n,x) k0 FOR i 0,n-1 DO FOR j 0,n-1 DO yk xi * yk k k + 1 RETURN y 4. Se consider urmtorii doi algoritmi pentru calculul puterii unui numr:
Proiectarea algoritmilor Putere1(x,n) p1 FOR i 1,n DO np 0 FOR j 1,x DO np np +p p np RETURN p Putere2(x,n) p1 FOR i 1,n DO p p*x RETURN p S se stabileasc ordinele de complexitate considernd c toate operaiile au acelai cost. 5. Ce relaie exist ntre (logan) i (logbn) dac a > b > 0.
6. Propunei un algoritm de complexitate (n2) i unul de complexitate (n) pentru evaluarea unui polinom de gradul n: P(x)=anxn + an-1xn-1 + a1x + a0.
Proiectarea algoritmilor 5. METODE ELEMENTARE DE SORTARE 5.1. Problematica sortrii Se consider un set finit de obiecte, fiecare avnd asociat o caracteristic, numit cheie, care ia valori ntr-o mulime pe care este definit o relaie de ordine. Sortarea este procesul prin care elementele setului sunt rearanjate astfel nct cheile lor s se afle ntr-o anumit ordine. Exemplul 1. Considerm setul de valori ntregi: (5,8,3,1,6). n acest caz cheia de sortare coincide cu valoarea elementului. Prin sortare cresctoare se obine setul (1,3,5,6,8) iar prin sortare descresctoare se obine (8,6,5,3,1). Exemplul 2. Considerm un tabel constnd din nume ale studenilor i note: ((Popescu,9), (Ionescu,10), (Voinescu,8),(Adam,9)). n acest caz cheia de sortare poate fi numele sau nota. Prin ordonare cresctoare dup nume se obine ((Adam,9),(Ionescu,10),(Popescu,9), (Voinescu,8)) iar prin ordonare descresctoare dup not se obine ((Ionescu,10),(Popescu,9),(Adam,9),(Voinescu,8)). Pentru a simplifica prezentarea n continuare vom considera c setul prelucrat este constituit din valori scalare care reprezint chiar cheile de sortare i c scopul urmrit este ordonarea cresctoare a acestora. Astfel, a ordona setul (x1, x2,..., xn) este echivalent cu a gsi o permutare de ordin n, (p(1), p(2),..., p(n)) astfel nct xp(1) xp(2) .... xp(n). De asemenea vom considera c elementele setului sunt stocate pe un suport de informaie care permite accesul aleator la date. n acest caz este vorba despre sortare intern. n cazul n care suportul de informaie permite doar accesul secvenial la date trebuie folosite metode specifice ncadrate n categoria metodelor de sortare extern. Pe de alt parte, n funcie de spaiul de manevr necesar pentru efectuarea sortrii exist: Sortare ce folosete o zon de manevr de dimensiunea setului de date. Dac setul iniial de date este reprezentat de tabloul x1, x2,..,xn cel sortat se va obine ntr-un alt tablou y1,y2,..,yn. Sortare n aceeai zon de memorie (sortare pe loc - in situ). Elementele tabloului x1, x2,..,xn i schimb poziiile astfel nct dup ncheierea procesului s fie ordonate. Este posibil ca i n acest caz s se foloseasc o zon de memorie ns aceasta este cel mult de dimensiunea unui element i nu de dimensiunea ntregului tablou. n continuare vom analiza doar metode de sortare intern n aceeai zon de memorie. Metodele de sortare pot fi caracterizate prin: Simplitate. O metod este considerat simpl dac este intuitiv i uor de neles. Eficien. O metod este considerat eficient dac nu necesit un volum mare de resurse. Din punctul de vedere al spaiului de memorie o metod in situ este mai eficient dect una dect una bazat pe o zon de manevr de dimensiunea tabloului. Din punct de vedere al timpului de execuie este important s fie Algoritmi de sortare - 46 -
Proiectarea algoritmilor efectuate ct mai puine operaii. n general n analiz se iau n considerare doar operaiile efectuate asupra elementelor tabloului (comparaii i mutri). Naturalee. O metod de sortare este considerat natural dac numrul de operaii scade odat cu distana dintre tabloul iniial i cel sortat. O msur a acestei distane poate fi numrul de inversiuni al permutrii corespunztoare tabloului iniial. Stabilitate. O metod de sortare este considerat stabil dac ordinea relativ a elementelor ce au aceeai valoare a cheii nu se modific n procesul de sortare. De exemplu dac asupra tabelului cu note se aplic o metod stabil de ordonare descresctoare dup not se obine ((Ionescu,10), (Popescu,9), (Adam,9), (Voinescu,8)) pe cnd dac se aplic una care nu este stabil se va putea obine ((Ionescu,10), (Adam,9), (Popescu,9), (Voinescu,8)). n continuare vom considera cteva metode elementare de sortare caracterizate prin faptul c sunt simple, nu sunt cele mai eficiente metode dar reprezint punct de pornire pentru metode avansate. Pentru fiecare dintre aceste metode se va prezenta: principiul, verificarea corectitudinii i analiza complexitii. 5.2. Sortare prin inserie Principiul acestei metode este: ncepnd cu al doilea element, fiecare este nserat pe poziia adecvat n subirul care l precede. La fiecare etap a sortrii, elementului xi i se caut poziia adecvat n subirul destinaie x1, x2,...,xi-1(care este deja ordonat) comparnd pe xi cu elementele x1, x2,...,xi-1 ncepnd cu xi-1 i crend spaiu prin deplasarea spre dreapta a elementelor mai mari dect xi (figura 5.1). Astfel structura general a algoritmului este: Inserie(n,x) FOR i 2,n DO <nsereaz xi n subirul x1, x2,,xi-1, astfel nct irul x1, x2,,xi s fie ordonat> Algoritmul detaliat este: Inserie1(n,x) FOR i 2,n DO ji-1 aux xi
{i -1 este indicele de la care se pornete cutarea } { salvarea valorii lui xi} WHILE aux < xj j 1 DO { cutarea poziiei pentru inserie } {deplasarea lui xj cu o poziie la dreapta } xj + 1 xj j j-1 xj + 1 aux {nserarea valorii analizate pe poziia adecvat }
RETURN x Algoritmi de sortare - 47 -
Proiectarea algoritmilor Exist i alte metode de implementare a metodei. Astfel, pentru a evita efectuarea comparaiei j 1 la fiecare iteraie interioar, se plaseaz pe poziia 0 n tabloul x valoarea lui xi, aceast poziie jucnd rolul unui fanion. Astfel cel mai trziu cnd j = 0 se ajunge la xj = xi. Aceast variant poate fi descris dup cum urmeaz: Inserie2(n,x) FOR i 2,n DO x0 xi ji-1
WHILE x0 < xj DO xj + 1 xj j j-1 xj + 1 x0
{ salvarea valorii lui xi pe poziia x0}
{nserarea valorii fanion pe poziia adecvat }
RETURN x
Figura 5.1 Sortarea prin inserie
Verificarea corectitudinii. Precondiia problemei este {n 1}, iar postcondiia este {x1, x2,..., xn este ordonat cresctor}. Pentru ciclul exterior (dup i) demonstrm c proprietatea invariant este {x1, x2,..., xi-1 este ordonat cresctor}. La nceputul ciclului i = 2 deci x1 este implicit cresctor. La sfritul prelucrrii (i = n + 1) invariantul implic evident postcondiia. Rmne s artm c proprietatea rmne adevrat i dup efectuarea prelucrrilor din cadrul ciclului. Pentru aceasta este suficient s artm c pentru ciclul interior (dup j) aseriunea {x1, x2,..., xj este cresctor i aux xj + 1 = xj + 2 .... xi} este invariant. La sfritul ciclului WHILE aceasta proprietate ar implica una dintre relaiile: x1 ... xj aux xj + 1 = xj + 2 .... xi n cazul n care condiia de ieire din ciclu este aux xj; aux x1 = x2 .... xi n cazul n care condiia de ieire din ciclu este j = 0. Oricare dintre aceste dou relaii ar conduce prin atribuirea xj + 1 aux la x1 ... xj xj + 1 xj + 2 .... xi iar prin trecerea la urmtoarea valoare a contorului (i i + 1) la faptul c x1, x2,..., xi-1 este cresctor. Rmne doar s justificm invariantul ciclului WHILE. La intrarea n ciclu au loc relaiile: j = i -1, aux = xi deci aux = xj + 1 = xi iar cum x1, x2,..., xi-1 este cresctor rezult c proprietatea invariant propus pentru WHILE este satisfcut. Artm c ea nu este alterat de prelucrrile din cadrul ciclului: dac aux < xj, prin atribuirea xj + 1 xj Algoritmi de sortare - 48 -
Proiectarea algoritmilor se obine: aux < xj = xj +1 .... xi iar dup j j -1 va fi adevrat aseriunea: {x1, x2,..., xj cresctor i aux < xj + 1 = xj + 2 ... xi. Cum xj + 1 = xj + 2 prin xj + 1 xj nu se pierde informaie din tablou. Oprirea algoritmului este asigurat de utilizarea cte unui contor pentru fiecare dintre cele dou cicluri. Analiza complexitii. Vom lua n considerare doar operaiile de comparare i mutare asupra elementelor tabloului. Fie TC(i) i TM(i) numrul comparaiilor respectiv al deplasrilor (mutrilor) efectuate asupra elementelor tabloului pentru fiecare i = 2,..,n. Cazul cel mai favorabil corespunde irului ordonat cresctor, iar cel mai defavorabil celui ordonat descresctor. n cazul cel mai favorabil: TC(i) = 1 iar TM(i) = 2 (este vorba de operaiile care implic variabila ajuttoare aux i care dealtfel n acest caz nu au nici un efect) deci
T (n) = [TC (i ) + TM (i )] = 3 (n 1) .
i =2 n
n cazul cel mai defavorabil TC(i) = i, iar TM(i) = i - 1 + 2 = i + 1, obinndu-se c
T (n) = [TC (i ) + TM (i )] = (i + i + 1) = n 2 + 2 n 3 .
Prin urmare 3(n-1) T(n) n2 +2n-3 adic algoritmul sortrii prin inserie se ncadreaz n clasele (n) i O(n2). Alte proprieti. Algoritmul sortrii prin inserie este natural i att timp ct condiia de continuare a ciclului interior este aux < xj este i stabil. Dac ns se folosete aux xj metoda nu mai este stabil. 5.3. Sortare prin selecie Principiul acestei metode este: Pentru fiecare poziie i, ncepnd cu prima, se selecteaz din subirul ce ncepe cu acea poziie cel mai mic element i se amplaseaz pe locul respectiv (prin interschimbare cu elementul curent de pe poziia i) Structura general a algoritmului este (vezi i figura 5.2): Selecie(n,x) FOR i 1,n-1 DO
< se determin valoarea minim din xi,...,xn i se interschimb cu xi >
i =2 i =2
Figura 5.2. Sortarea prin selecie
Algoritmi de sortare - 49 -
Proiectarea algoritmilor Ciclul FOR continu pn la n-1 deoarece subirul xn...xn conine un singur element care este plasat chiar pe poziia potrivit, ca urmare a interschimbrilor efectuate anterior. Descrierea detaliat a algoritmului este: Selecie(n,x) FOR i 1,n-1 DO k i FOR j i+1,n DO IF xk > xj THEN k j IF k i THEN x k xi RETURN x {indicele curent al minimului} {ciclu pentru cutarea minimului} {noul indice al minimului} {plasarea pe poziia adecvat}
Verificarea corectitudinii. Artm c un invariant al ciclului exterior (dup i) este: {x1,..,xi-1 este ordonat cresctor i xi-1 xj pentru j = i,.., n}. La nceput i = 1 deci x1,..,xi-1 este ir vid. Ciclul FOR interior (dup j) determin valoarea minim din xi,..,xn Aceasta este plasat prin interschimbare pe poziia i. Se obine astfel c x1,..,xi este ordonat cresctor i c xi xj pentru j = i + 1,...,n. Dup incrementarea lui i (la sfritul ciclului dup i) se reobine proprietatea invariant. La final, i = n iar invariantul conduce la x1,..,xn-1 cresctor i xn-1 xn adic x1, x2,..,xn este ordonat cresctor. Analiza complexitii. Indiferent de aranjarea iniial a elementelor, numrul de comparaii efectuate este: n 1 n n 1 1 1 TC (n) = 1 = (n i ) = n (n 1) (n 1) n = (n 1) n 2 2 i =1 j =i +1 i =1 n cazul cel mai favorabil (ir ordonat cresctor) numrul interschimbrilor este TM(n) = 0. n cazul cel mai defavorabil (ir ordonat descresctor) pentru fiecare i se efectueaz o interschimbare (trei atribuiri), deci costul interschimbrilor este TM(n) = 3(n- 1). Astfel algoritmul sortrii prin selecie aparine clasei (n2). Alte proprieti. Algoritmul este parial natural (numrul de comparaii nu depinde de gradul de sortare al irului). n varianta prezentat (cnd minimul este interschimbat cu poziia curent) algoritmul nu este stabil. Dac ns n locul unei singure interschimbri s-ar realiza deplasarea elementelor subtabloului xi,..,xk-1 la dreapta cu o poziie (ca n algoritmul inseriei) iar xk (salvat n prealabil ntr-o variabil auxiliar) s-ar transfera n xi, algoritmul ar deveni stabil. 5.4. Sortare prin interschimbarea elementelor vecine Principiul acestei metode de sortare este: Algoritmi de sortare - 50 -
Proiectarea algoritmilor Se parcurge irul i se compar elementele vecine iar dac acestea nu se afl n ordinea corect se interschimb. Parcurgerea se reia pn cnd nu mai este necesar nici o interschimbare. Structura generala a algoritmului este: Interschimbri(n,x) REPEAT < se parcurge irul i dac dou elemente vecine nu sunt n ordinea corect sunt interschimbate > UNTIL < nu mai este necesar nici o interschimbare > Dup cum se observ din figura (5.3), la sfritul irului se genereaz un ir sortat.
Figura 5.3 Sortarea prin interschibarea elementelor vecine (bubble sort)
S considerm secvena interschimbrii elementelor vecine n cazul n care nu sunt n ordinea corect: FOR i 1, n-1 DO IF xi > xi+1 THEN xi xi +1 Folosind ca invariant al prelucrrii repetitive proprietatea {xi xj, j = 1,..,i} se poate arta c prelucrarea de mai sus conduce la satisfacerea postcondiiei: {xn xi, i = 1,2,.., n}. Pentru i = 1 proprietatea invariant este adevrat ntruct x1 x1. Presupunem c proprietatea este adevrat pentru i. Dac xi xi + 1 atunci nu se efectueaz nici o prelucrare i rmne adevrat i pentru i+1. Dac n schimb xi > xi+1 atunci se efectueaz interschimbarea astfel c xi < xi + 1 deci proprietatea devine adevrat i pentru i + 1. Pe baza acestei proprieti a secvenei de interschimbri se deduce c este suficient s aplicm aceast prelucrare succesiv pentru x1,..,xn, x1,..,xn-1, .., x1,x2. Rezult c algoritmul poate fi descris prin: Algoritmi de sortare - 51 -
Proiectarea algoritmilor Interschimbri1(n,x) FOR i n, 2, -1 DO FOR j 1, i 1 DO IF xj > xj+1 THEN x j x j +1 RETURN x Verificarea corectitudinii. ntruct s-a demonstrat c efectul ciclului interior este c plaseaz valoarea maxim pe poziia i rezult c pentru ciclul exterior poate fi considerat ca invariant proprietatea {xi + 1,..,xn este cresctor iar xi + 1 xj pentru j = 1,2,.., i}. Analiza complexitii. Numrul de comparaii efectuate nu depinde de gradul de sortare al irului iniial fiind n orice situaie: n i 1 n n 1 n (n 1) TC ( n) = 1 = (i 1) = i = 2 i = 2 j =1 i =2 i =1 n schimb, numrul de interschimbri depinde de proprietile irului astfel: n cazul cel mai favorabil (ir sortat cresctor) se obine TM(n)=0, iar n cazul cel mai defavorabil (ir sortat descresctor) TM(n)=3n(n-1)/2 (o interschimbare presupune 3 atribuiri). Astfel numrul de prelucrri analizate satisface: n(n - 1)/2 T(n) 2n(n - 1) adic algoritmul prezentat mai sus aparine clasei (n2). Algoritmul poate fi ns mbuntit prin reducerea numrului de comparaii efectuate, n sensul c nu este necesar ntotdeauna parcurgerea tabloului pentru i = 2,3,..,n. De exemplu, dac tabloul este de la nceput ordonat ar fi suficient o singur parcurgere care s verifice c nu este necesar efectuarea nici unei interschimbri. Pornind de la aceast idee se ajunge la algoritmul: Interschimbri2(n,x) REPEAT inter FALSE FOR i 1, n 1 DO IF xi > xi+1 THEN xi xi +1 inter TRUE UNTIL inter = FALSE RETURN x Pentru acest algoritm numrul de comparaii efectuate n cazul cel mai favorabil este TC(n)=n-1, iar n cazul cel mai defavorabil este:
TC (n) = (n 1) = n (n 1)
j =1 n
n ceea ce privete numrul de interschimbri acesta este acelai ca pentru prima variant a algoritmului i anume Algoritmi de sortare - 52 -
3 n (n 1) 2 Prin urmare numrul total de repetri ale prelucrrilor analizate satisface: 5 n 1 T (n) n (n 1) 2 adic algoritmul este din clasa (n) i O(n2). ntruct la sfritul irului se formeaz un subir cresctor rezult c nu mai este necesar s se fac comparaii n acea poriune. Aceast poriune este limitat inferior de cel mai mare indice pentru care s-a efectuat interschimbare. Astfel algoritmul poate fi rescris astfel (a se vedea mai jos). 0 TM (n)
Atta timp ct condiia pentru interschimbare este specificat prin inegalitate strict (xi > xi + 1) oricare dintre variantele algoritmului este stabil. Valorile comparative ale numrului de prelucrri (comparaii i mutri asupra elementelor tabloului) pentru algoritmii de sortare descrii sunt prezentate n tabelul urmtor. Interschimbri3(n,x) mn REPEAT t0 FOR i 1, m 1 DO IF xi > xi+1 THEN xi xi +1 ti mt UNTIL t 1 RETURN x
{ la nceput se va parcurge tot irul} { cel mai mare indice pentru care se face interschimbarea}
{indicele ultimei interschimbri}
5.5. Exerciii 1. S se propun un algoritm care construiete tabloul sortat cresctor y1,...,yn pornind de la tabloul x1,...,xn. Indicaie: Se construiete irul sortat pe principiul metodei inseriei. Sortsirnou(n,x,y) y1 x1 FOR i 2, n DO k i-1 WHILE (xi <yk) AND (k > 0) DO yk+1 yk k k-1 yk+1 xi RETURN y 2. Se consider un tabloul ale crui elemente conin dou informaii: nume i nota. S se ordoneze descresctor dup not, iar pentru aceeai not cresctor dup nume. Indicaie: Se va realiza sortarea dup not descresctor, dup care pentru fiecare not se realizeaz sortarea cresctoare dup nume. Sortnotanum(n,x) {sortare dup nota descresctor} FOR i 2, n DO x0 xi k i-1 WHILE (x0.nota > xk.nota) DO xk+1 xk k k-1 xk+1 x0 {sortare dup nume cresctor} k1 WHILE k n -1 DO i k+1 WHILE (xi.nota = xi-1.nota) and (i n) DO i i+1 if i > k+1 then sortnum(k,i-1,x) ki RETURN x
Sortnum(k,i,x) FOR m k+1,i DO x0 xm j m-1 while (x0.nume < xj.nume) AND (j k) DO xj+1 xn jj-1 xj+1 x0 RETURN x 3. S se analizeze complexitatea algoritmului interschimbri3. 4. Se consider o matrice cu m linii i n coloane de elemente reale. S se reorganizeze matricea prin interschimbri de linii i coloane astfel nct elementele diagonalei principale s fie ordonate cresctor.
Proiectarea algoritmilor 6. TEHNICI DE ELABORARE A ALGORITMILOR: REDUCERE I DIVIZARE 6.1. Motivaie Considerm problema calculului lui xn pentru x > 0 i n = 2m, m 1 fiind un numr natural. Algoritmul general pentru calculul lui xn (pentru un n natural arbitrar): Putere1(x,n) p1 FOR i 1, n DO p p*x RETURN p are complexitatea (n). Dac se folosete ipoteza n = 2m se observ c xn = xn/2 xn/2 cci x2m = x2(m-1) x2(m-1) . Prin urmare pentru a calcula xn este suficient s se calculeze xn/2 i s se ridice la ptrat. La rndul su calculul lui xn/2 poate fi redus la calculul lui xn/4 i la o ridicare la ptrat .a.m.d. Descompunerea poate continua pn se ajunge la x2 al crui calcul este simplu. Algoritmul poate fi descris prin: Putere2(x,m) px FOR i 1, m DO p p*p RETURN p Folosind ca invariant pentru prelucrarea repetitiv afirmaia: { p = x2(i-1)} se m poate demonstra cu uurin c algoritmul putere2 calculeaz x 2 . Pe de alt parte se observ c prelucrarea este de complexitate (m) = (lg(n)). Reducerea complexitii deriv din faptul c la fiecare etap se calculeaz valoarea unui singur factor din cei doi, ntruct sunt identici. Ideea de rezolvare a acestei probleme este comun tehnicilor de reducere i divizare care se bazeaz pe nlocuirea rezolvrii unei probleme de dimensiune n pe rezolvarea uneia sau mai multor probleme similare dar de dimensiune mai mic. Reducerea dimensiunii continu pn cnd se ajunge la o problem de dimensiune suficient de mic pentru a putea fi rezolvat direct (de exemplu n = 2 sau m = 1). O descriere a acestei metode de rezolvare care ilustreaz mai bine ideea reducerii dimensiunii este: Putere3(x,n) IF n = 2 THEN RETURN x*x ELSE p putere3(x,n/2) RETURN p*p Reducere i divizare - 56 -
Proiectarea algoritmilor Dac se transmit ca parametri valorile x i m, algoritmul pentru calculul lui x 2 poate fi descris prin: Putere4(x,m) IF m = 1 THEN RETURN x*x ELSE p putere4(x,m-1) RETURN p*p Ultimii doi algoritmi prezint o particularitate: n cadrul prelucrrilor pe care le efectueaz exist i un auto-apel (n cadrul funciei se apeleaz aceeai funcie). Astfel de algoritmi se numesc recursivi. Exemplul de mai sus ilustreaz faptul c folosind ideea reducerii rezolvrii unei probleme la rezolvarea unei probleme similare dar de dimensiune mai mic poate conduce la reducerea complexitii. Pe de alt parte exist probleme pentru care abordarea rezolvrii n aceast manier este mai uoar conducnd la algoritmi intuitivi. Trebuie menionat totodat c nu ntotdeauna tehnicile din aceast categorie conduc la o reducere a complexiaii n cazul n care algoritmul este implementat pe o main secvenial. Un exemplu n acest sens l reprezint calculul factorialului (dup cum se va demonstra mai trziu, aplicnd tehnica reducerii se obine un algoritm de complexitate (n) la fel ca prin aplicarea tehnicii forei brute). Considerm problema determinrii maximului dintr-o secven finit de valori reale stocate n tabloul x1, x2,..,xn. Aplicnd ideea divizrii rezult c este suficient s determinm maximul din subtabloul x1, x2,..,x[n/2] i maximul din subtabloul x[n/2]+1, x[n/2]+2,..,xn. Rezultatul va fi cea mai mare dintre valorile obinute. Algoritmul poate fi descris n manier recursiv dup cum urmeaz: Maxim(x,s,d) IF s = d THEN max xs ELSE m [(s+d)/2] max1 maxim (x,s,m) max2 maxim (x,m+1,d) IF max1 < max2 THEN max max2 ELSE max max1 RETURN max Nu este dificil de observat c ordinul de complexitate al acestui algoritm este tot (n) ca i n cazul algoritmului clasic (afirmaia va fi justificat n seciunea dedicat analizei algoritmilor recursivi). Acest lucru este adevrat n cazul n care maina pe care Reducere i divizare - 57 m
Proiectarea algoritmilor va fi executat algoritmul este una secvenial. Dac ns maina este paralel (la un moment dat pot fi efectuate simultan mai multe prelucrri) atunci printr-o astfel de abordare se poate ajunge la ctig de timp. 6.2. Algoritmi recursivi Ultimii algoritmi prezentai n seciunea anterioar fac parte din categoria algoritmilor recursivi. Acetia sunt utilizai pentru a descrie prelucrri ce se pot specifica prin ele nsele. Un algoritm recursiv este caracterizat prin: Condiie de oprire. Specific situaia n care rezultatul se poate obine prin calcul direct fr a mai fi necesar apelarea aceluiai algoritm. Auto-apel. Se apeleaz cel puin o dat pentru alte valori ale parametrilor. Valorile parametrilor corespunztoare succesiunii de apeluri trebuie s asigure apropierea de satisfacerea condiiei de oprire. Ca urmare a cascadei de auto-apeluri un algoritm recursiv realizeaz de fapt o prelucrare repetitiv, chiar dac aceasta nu este explicit. Un exemplu simplu de prelucrare repetitiv descris recursiv este cea corespunztoare determinrii cmmdc a dou numere naturale nenule, a b > 0. Algoritmul bazat pe operaia de mprire poate fi descris prin: Cmmdr1(a,b) IF b = 0 THEN rez a ELSE rez cmmdr1(b,a MOD b) RETURN rez iar cel bazat pe operaia de scdere: Cmmdr2(a,b) IF a = b THEN rez a ELSE IF a > b THEN rez cmmdr2(b,a-b) ELSE rez cmmdr2(a,b-a) RETURN rez Exemplele de mai sus se caracterizeaz prin recursivitate simpl i direct. Un algoritm recursiv este considerat simplu recursiv dac conine un singur auto-apel i multiplu recursiv dac conine dou sau mai multe auto-apeluri (de exemplu, algoritmul maxim din seciunea anterioar).
Reducere i divizare - 58 -
Proiectarea algoritmilor Exist i posibilitatea ca algoritmul s nu se auto-apeleze direct ci indirect prin intermediul altui algoritm. De exemplu algoritmul A1 apeleaz algoritmul A2 iar acesta apeleaz algoritmul A1. n acest caz este vorba de recursivitate indirect. Noiunea de recursivitate poate fi utilizat i n contextul definirii unor concepte. De exemplu conceptul de expresie aritmetic poate fi definit astfel: "o expresie aritmetic este constituit din operanzi i operatori; un operand poate fi o constant, o variabil sau o expresie". Descrierea recursiv permite specificarea unor structuri infinite folosind un set finit de reguli. Algoritmii recursivi sunt adecvai pentru rezolvarea problemelor sau prelucrarea datelor descrise n manier recursiv. Arbori de apel. Pentru a ilustra modul de lucru al unui algoritm iterativ poate fi util s se reprezint grafic structura de apeluri i reveniri cu returnarea rezultatului obinut. n cazul unui algoritm recursiv arbitrar structura de apeluri este una ierarhic conducnd la un arbore de apel. n cazul recursivitii simple arborele de apel degenereaz ntr-o structur liniar (figura 6.1).
Figura 6.1 Structura de apel pentru algoritmul cmmdr1
Verificarea corectitudinii algoritmilor recursivi. Dac relaia de recuren care descrie legtura dintre soluiilor corespunztoare diferitelor instane ale problemei este corect atunci i algoritmul care o implementeaz este corect. Pe de alt parte ntruct un algoritm recursiv specific o prelucrare repetitiv implicit pentru a demonstra corectitudinea acestuia este suficient s se arate c: Exist o aseriune referitoare la starea algoritmului care are proprietile: (i) este adevrat pentru cazul particular (cnd e satisfcut condiia de oprire); (ii) este adevrat la revenirea din apelul recursiv i efectuarea prelucrrilor locale; (iii) implic postcondiia. Condiia de oprire este satisfcut dup o succesiune finit de apeluri recursive. Pentru algoritmul cmmdcr1 o aseriune invariant este {rez = cmmdc(a, b)}. Pentru cazul particular b = 0 avem rez = a = cmmdc(a, 0) = cmmdc(a, b). Dac rez = cmmdc(a, b) nainte de apelul recursiv putem deduce c cmmdc(a, b) = cmmdc(b,a MOD b) i rez = cmmdc(a,b) dup apelul recursiv. Reducere i divizare - 59 -
Proiectarea algoritmilor Pentru algoritmul cmmdcr2 proprietatea invariant este tot {rez = cmmdc(a; b)}. n ambele situaii condiia de oprire va fi satisfcut dup un numr finit de apeluri recursive, datorit proprietilor restului unei mpriri ntregi. Analiza complexitii algoritmilor recursivi. Considerm o problem de dimensiune n i algoritmul recursiv de forma: Algrec(n) IF n = n0 THEN P1 ELSE Algrec(h(n))
cu h(n) o funcie descresctoare cu proprietatea c exist k cu h(k)(n) = (h h... h)(n) = n0. Dac prelucrarea P1 are cost constant (c0) iar determinarea lui h(n) are costul c atunci costul algoritmului algrec poate fi descris prin:
dac n = n0 c0 T ( n) = dac n > n0 T (h( n)) + c Prin urmare timpul de execuie al unui algoritm recursiv satisface o relaie de recuren. Pentru determinarea expresiei lui T(n) pornind de la relaia de recuren se poate folosi una dintre metodele: Metoda substituiei (directe). Pornind de la relaia de recuren se intuiete forma general a lui T(n) dup care se demonstreaz prin inducie matematic validitatea expresiei lui T(n). Metoda iteraiei (substituiei inverse). Se scrie relaia de recuren pentru n, h(n), h(h(n)), ..., n0 dup care se substituie succesiv T(h(n)), T(h(h(n))) .a.m.d. Din relaia obinut, pe baza unor calcule algebrice, rezult expresia lui T(n). Metoda mai este cunoscut i ca metoda substituiei inverse.
Exemplul 1. S considerm h(n) = n 1 Prin metoda iteraiei se obine:

T(n) = T(n - 1) + c T(n - 1) = T(n - 2) + c .. T(n0+1)= T(n0) + c T(n0)=c0
Prin nsumarea tuturor relaiilor i reducerea termenilor corespunztori se obine: T(n) = c(n -n0) + c0 pentru n > n0. Exemplul 2. Considerm algoritmul recursiv (putere3) pentru calculul puterii x . Dac notm numrul nmulirilor efectuate cu T(n) se obine relaia de recuren: T(n) = 1 dac n = 2 T(n/2) + 1 dac n > 2 Aplicnd tehnica iteraiei obinem:
2m
Proiectarea algoritmilor T(n) = T(n/2) + 1 T(n/2) = T(n/22) + 1 ... T(4) = T(2) + 1 T(2) = 1 Cum numrul relaiilor de mai sus este m, prin nsumarea tuturor i reducerea termenilor corespunztori se obine T(n) = m = lgn. Exemplul 3. Analizm algoritmul maxim descris n seciunea anterioar (pct. 6.1). Notnd cu T(n) numrul de comparaii efectuate se obine relaia de recuren: dac n = 1 0 T ( n) = dac n 2 T ([n / 2]) + T (n [n / 2]) + 1 n cazul n care n nu este o putere a lui 2 metoda iteraiei este mai dificil de aplicat. Pornim de la cazul particular n = 2m pentru care relaia de recuren conduce la T(n) = 2T(n/2) + 1 pentru n 2 obinndu-se succesiunea: T(n) T(n/2) T(n/4) . T(4) T(2) = 2T(n/2) + 1 = 2T(n/4) + 1 = 2T(n/8) + 1 . = 2T(1) + 1 = 0 21 22 2m-2 2m-1
nmulind relaiile cu factorii din ultima coloan, nsumnd relaiile i efectund reducerile se obine: T(n) = 1+2+22+....+ 2m-1 = 2m - 1 = n -1. Acest rezultat este valabil doar pentru n = 2m. Pentru a arta c este adevrat pentru orice n aplicm inducia matematic. Evident T(1) = 1 - 1 = 0. Presupunem c T(k) = k-1 pentru orice k < n. Rezult c T(n) = [n/2] -1 + n-[n/2] +1 1 = n-1. Observaie. Se poate demonstra c dac T(n) (f(n)) pentru n = 2m, T(n) este cresctoare pentru argumente mari (n n0) iar f(n) are proprietatea f(cn) (f(n)) pentru c o constant (n acest caz se spune despre f c este neted) atunci T(n) (f(n)) pentru orice n. Condiiile de mai sus (T(n) cresctoare pentru valori mari ale lui n i f(cn) (f(n)) sunt satisfcute n marea majoritate a situaiilor practice. 6.3. Tehnica reducerii Principiu. Tehnica reducerii se bazeaz pe relaia care exist ntre soluia unei probleme i soluia unei instane de dimensiune redus a aceleia i probleme. De regul reducerea dimensiunii se bazeaz pe scderea unei constante (n majoritatea situaiilor 1) din dimensiunea problemei. Calculul factorialului. Cel mai simplu exemplu este cel al calculului factorialului. Relaia de la care se pornete este: Reducere i divizare - 61 -
Proiectarea algoritmilor dac n = 0 1 n! = n (n 1)! dac n > 0 Algoritmul poate fi descris n varianta recursiv astfel: Factorial(n) IF n = 0 THEN f1 ELSE f n*factorial(n-1) RETURN f Notnd cu T(n) numrul de operaii de nmulire efectuate se obine relaia de recuren: dac n = 0 0 T ( n) = T (n 1) + 1 dac n > 0 Din aceast relaie se poate intui c T(n) = n. Demonstrm acest lucru prin inducie matematic dup n. Pentru n = 1 se obine T(1) = T(0)+1 = 1. Presupunem c T(n-1) = n-1. Din relaia de recuren vom obine T(n) = T(n - 1) + 1 = n. Deci ntradevr T(n) = n. Acelai rezultat se obine aplicnd tehnica iteraiei: T(n) = T(n - 1) + 1 T(n - 1) = T(n - 2) + 1 ... ... = T(0) + 1 T(1) =0 T(0) Prin nsumarea tuturor relaiilor i efectuarea reducerilor se obine: T(n) = n. Generarea permutrilor. S considerm problema generrii permutrilor de ordin n. Exist mai multe moduri de a aplica tehnica reducerii. O variant pornete de la ideea c o permutare de ordin n se poate obine dintr-o permutare de ordin n - 1 prin plasarea valorii n pe toate cele n poziii posibile. Astfel dac n = 3 exist dou permutri de ordin n-1 = 2: (1, 2) i (2, 1). Pentru fiecare dintre acestea valoarea 3 poate fi nserat n fiecare dintre cele trei poziii posibile: prima, a doua i a treia conducnd la (3, 1, 2), (1, 3, 2), (1, 2, 3) respectiv la (3, 2, 1), (2, 3, 1), (2, 1, 3). Aceast idee ar corespunde unei abordri ascendente ("bottom-up" - pornind de la o permutare de ordin dat se construiete o permutare de ordin imediat superior). Pentru o abordare descendent ("top-down") a problemei (o permutare de ordin n se specific prin permutri de ordin n - 1) s observm c pentru a genera toate permutrile de ordin n este suficient s plasm pe poziia n succesiv toate valorile posibile (din {1, 2,.....,n}) i pentru fiecare valoare astfel plasat s generm toate permutrile corespunztoare valorilor aflate pe primele n - 1 poziii. Pentru a le genera pe acestea se folosesc permutrile de ordin n - 2 pn se ajunge la permutri de ordin 1 (o singur permutare care const chiar din valoarea aflat pe poziia 1). Reducere i divizare - 62 -
Proiectarea algoritmilor Pentru a descrie algoritmul s presupunem c permutrile se vor obine ntr-un tablou x1, x2,..., xn accesat n comun de ctre toate (auto)apelurile algoritmului i iniializat astfel nct xi = i. n momentul n care x conine o permutare ea este afiat. Permutari(k) IF k = 1 THEN Write x ELSE FOR i 1,k DO xi xk Permutri(k-1) xi xk Aplicnd acest algoritm, permutrile de ordin 3 se obin n ordinea urmtoare: (2, 3, 1), (3, 2, 1), (3, 1, 2), (1, 3, 2), (2, 1, 3), (1, 2, 3). Pentru a analiza complexitatea algoritmului contorizm numrul de interschimbri efectuate i observm c satisface: dac k = 1 0 T (k ) = dac k > 1 k (T (k 1) + 2 ) Aplicm tehnica iteraiei i obinem: T(k) T(k-1) T(k-2) ... T(2) T(1) = kT(k-1)+2k = (k-1)T(k-2)+2(k-1) = (k-2)T(k-3)+2(k-2) .... = 2T(1)+2 =0 k k(k-1) ... k(k-1) 3 k(k-1) 32
nmulind fiecare relaie cu factorii specificai n ultima coloan i nsumnd toate relaiile se obine: T(k) = k!+2 (k (k-1) 4+....+ k(k-1)+k). Prin urmare pentru k = n se obine T(n) (n!). Turnurile din Hanoi. Se consider trei vergele plasate vertical i identificate prin s (surs), d (destinaie) i i (intermediar). Pe vergeaua s se afl dispuse n discuri n ordinea descresctoare a razelor (primul disc are raza maxim), figura 6.2. Se cere s se transfere toate discurile pe vergeaua d astfel nct s fie plasate n aceeai ordine. Se poate folosi vergeaua i ca intermediar cu restricia c n orice moment peste un disc se afl doar discuri de raz mai mic. Ideea rezolvrii este: "se transfer n - 1 discuri de pe s pe i folosind d ca intermediar; se transfer discul rmas pe s direct pe d; se transfer cele n-1 discuri de pe i pe d folosind s ca intermediar". Aceast idee poate fi descris simplu n manier recursiv:
Proiectarea algoritmilor hanoi(n,s,d,i) IF n = 1 THEN sd ELSE Hanoi(n-1,s,i,d) sd Hanoi(n-1,i,d,s)
Figura 6.2 Turnurile din Hanoi
In algoritmul hanoi primul argument specific numrul de discuri ce vor fi transferate, al doilea indic vergeaua surs, al treilea vergeaua destinaie iar ultima pe cea folosit ca intermediar. Prelucrarea s d specific faptul c va fi transferat discul de pe vergeaua s pe vergeaua d. Structura apelurilor recursive pentru n = 3 este ilustrat n figura 6.3. Succesiunea mutrilor este obinut parcurgnd blocurile haurate de la stnga la dreapta: s d, s i, d i, s ! d, i s, i d, s d. Pentru a analiza complexitatea contorizm numrul de mutri de discuri. Se observ c:
Figura 6.3 Structura de apel pentru algoritmul hanoi, n=3
Proiectarea algoritmilor dac n = 1 1 T ( n) = dac n > 1 2 T (n 1) + 1 Prin metoda iteraiei se obine: T(n) = 2T(n-1)+1 T(n-1) = 2T(n-2)+1 T(n-2) = 2T(n-3)+1 ... .... T(2) = 2T(1)+2 T(1) =1
nsumnd relaiile rezult T(n) = 1+2 +2 +...+2
1 2 n-1
21 22 ... 2n-2 2n-1 = 2n -1 adic algoritmul are
ordinul de complexitate (2n). nmulirea " la russe". Reducerea dimensiunii se poate realiza nu doar prin scderea unei constante ci i prin mprirea la o constant. Cazul cel mai frecvent este acela al mpririi dimensiunii problemei la 2. Un exemplu simplu n acest sens este cel al nmulirii " la russe". Regula de calcul n acest caz este: 0 dac a = 0 a a b = 2b dac a este par 2 a 1 dac a este impar 2 2b + b Pornind de la aceast relaie algoritmul poate fi descris prin algoritmul de mai jos. Pentru a analiza complexitatea algoritmului considerm c dimensiunea problemei este reprezentat de perechea (a, b) iar operaia dominant este mprirea lui a la 2 (celelalte operaii: nmulirea lui b cu 2 i adunarea nu se efectueaz de mai multe ori). Astfel pentru timpul de execuie T(a,b) se poate scrie relaia de recuren: Produs(a,b) IF a = 0 THEN RETURN 0 ELSE IF a MOD 2 = 0 THEN RETURN produs(a DIV 2, 2*b) ELSE RETURN produs((a-1) DIV 2, 2*b)+b 0 T ( a, b) = T (a / 2, 2 b) + 1 Reducere i divizare - 65 dac a = 0 dac a > 0
Proiectarea algoritmilor Aplicm metoda iteraiei pentru cazul particular a = 2k: T(2k,b) = T(2k-1,2b)+1 T(2k-1,2b) = T(2k-2,22b)+1 k-2 2 T(2 ,2 b) = T(2k-3,23b)+1 ... .... k-1 T(2,2 b) = T(1,2kb)+1 T(1,2kb) = T(0,2k+1b)+1 k+1 T(1,2 b) =0 nsumnd relaiile rezult T(a, b) = k+1 = lga+1. Se observ c timpul de execuie depinde doar de valoarea lui a i pentru a = 2k avem T(a) (lga). ntruct T(a) este cresctoare pentru valori mari ale lui a iar lgca = lga + lgc (lga) rezult c rezultatul este valabil i pentru cazul general. 6.4. Tehnica divizrii Principiu. Tehnica divizrii (denumit i "divide et impera" sau "divide and conquer") const n: Descompunerea n subprobleme. O problem de dimensiune n este descompus n dou sau mai multe subprobleme de dimensiune mai mic. Cazul clasic este acela cnd subproblemele au aceeai natura ca i problema iniial. Ideal este ca dimensiunile subproblemelor s fie ct mai apropiate (dac problema de dimensiune n se descompune n k subprobleme e de preferat ca acestea s aib dimensiuni apropiate de n/k). Pentru ca aceast tehnic s fie efectiv (s conduc de exemplu la reducerea costului calculului) trebuie ca subproblemele care se rezolv s fie independente (o aceeai subproblem s nu fie rezolvat de mai multe ori). Rezolvarea subproblemelor. Fiecare dintre subproblemele independente obinute prin divizare se rezolv. Dac ele sunt similare problemei iniiale atunci se aplic din nou tehnica divizrii. Procesul de divizare continu pn cnd se ajunge la subprobleme de dimensiune suficient de mic (dimensiunea critic, nc) pentru a fi rezolvate direct. Combinarea rezultatelor. Pentru a obine rspunsul la problema iniial uneori trebuie combinate rezultatele obinute pentru subprobleme. Structura general a unui algoritm elaborat folosind tehnica divizrii este: Divizare(P(n)) IF n nc THEN <rezolvare direct> ELSE <descompune P(n) n k subprobleme P1(n1),.., Pk(nk)> FOR i 1,k DO Divizare(Pi(ni) <compunere rezultate> Reducere i divizare - 66 -
Proiectarea algoritmilor Exemple. n practic cel mai adesea se utilizeaz k = 2 i n1 = [n/2], n2 = n-[n/2]. Algoritmul pentru determinarea maximului prezentat n prima seciune se bazeaz pe tehnica divizrii pentru k = 2 i dimensiunea critic nc = 1. Subproblemele sunt independente iar compunerea rezultatelor const n prelucrarea "IF max1 < max2 THEN max max2 ELSE max max1". S considerm problema cutrii unei valori v ntr-un tablou a1,...,an ordonat cresctor. Tehnica divizrii se poate aplica aici astfel: se alege un element aj din a1,...,an care se compar cu v; dac v = aj atunci a fost gsit elementul cutat; dac v < aj atunci cutarea continu n subtabloul a1,...,aj altfel ea continu n subtabloul aj+1,...,an. Alegerea cea mai natural pentru j este s fie ct mai aproape de mijlocul tabloului. Pe de alt parte, se observ c pentru aceast problem doar una dintre cele dou subprobleme trebuie rezolvat. Dimensiunea critic este n acest caz nc = 1 (tablou constituit dintr-un singur element). Algoritmul elaborat n acest mod, numit algoritmul cutrii binare, poate fi descris astfel: Cautbin1(a,s,d,v) IF s > d THEN RETURN FALSE ELSE m (s+d) DIV 2 IF am = v THEN RETURN TRUE ELSE IF v < am THEN RETURN cautbin1(a,s,m-1,v) ELSE RETURN cautbin1(a,m+1,d,v) cu s i d delimitnd zona din tablou unde se concentreaz la un moment dat cutarea. La nceput se caut n ntreg tabloul astfel c la primul apel avem s = 1 i d = n. Algoritmul poate fi descris i n variant iterativ:
Proiectarea algoritmilor Cautbin2(a,n,v) s1 dn gasit FALSE WHILE (s d) AND (gasit=FALSE) DO m [(s+d)/s] IF am = v THEN gasit = TRUE ELSE IF v < am THEN d m-1 ELSE s m+1 RETURN gasit Pentru a evita compararea de dou ori a valorii cutate cu elemente ale tabloului (am = v i v < am) algoritmul poate fi rescris n forma urmtoare: Cautbin3(a,n,v) s1 dn WHILE (s < d) DO m [(s+d)/s] IF v am THEN dm ELSE s m+1 IF v = as THEN RETURN TRUE ELSE RETURN FALSE Pentru a analiza algoritmul cutrii binare s considerm c T(n) reprezint numrul maxim de comparaii efectuate asupra elementelor tabloului (se atinge n cazul cel mai defavorabil, cnd v nu se afl n tablou). Relaia de recuren corespunztoare este: dac n = 1 1 T ( n) = dac n > 1 T ([n / 2]) + 1 Pentru stabili valoarea lui T(n) s analizm pentru nceput cazul particular n = 2m. Aplicnd metoda iteraiei obinem: T(2m) T(2m-1) Reducere i divizare - 68 = T(n) = T(n/2) = T(n/2) + 1 = T(n/4) + 1
Proiectarea algoritmilor .... ..... ... T(21) = T(2) = T(1) + 1 T(20) = T(1) = 1 nsumnd cele m + 1 relaii se obine T(n) = m + 1 = lgn + 1, pentru n = 2m. Pentru n arbitrar relaia se demonstreaz prin inducie matematic. Presupunem c T(k) = [lgk] + 1 pentru orice k < n i artm c T(n) = [lgn] + 1. Tratm separat cazurile: (i) n=2k; (ii) n = 2k + 1. n primul caz se obine: T(n) = T(k) + 1 = [lgk] + 2 = [lgk + 1] + 1 = [lg(2k)] + 1 = [lgn] + 1 n al doilea caz obinem: T(n) = T(k) + 1 = [lgk] + 2 = [lgk + 1] + 1 = [lg(2k)] + 1 = Ceil(lg(2k + 1)) = [lgn]+1 unde s-au utilizat relaiile [lgn]+1= ceil(lg(n+1)) pentru nN i [x]+1=ceil(x) pentru x N . Ceil este funcia care d un numr natural rotunjit la valoarea superioar ntreag a numrului real. n concluzie cutarea binar este de complexitate O(lgn). Observaie. Algoritmul cutrii binare poate fi mai degrab vzut ca un exemplu de aplicare a tehnicii reducerii (prin mprirea problemei n dou subprobleme dintre care doar una se rezolv). Metoda master. Reprezint o tehnic de analiz a algoritmilor elaborai prin tehnica divizrii. Presupunem c o problem de dimensiune n este descompus n m subprobleme de dimensiuni n/m dintre care este necesar s fie rezolvate k m. Considerm c divizarea i compunerea rezultatelor au mpreun costul TDC(n) iar costul rezolvrii n cazul particular este T0. Cu aceste ipoteze costul corespunztor algoritmului verific relaia de recuren: dac n nc T0 T ( n) = k T (n / m) + TDC (n) dac n > nc Determinarea lui T(n) pornind de la aceast recuren este uurat de teorema urmtoare: (n d ) dac k < m d T (n) = (n d lg n) dac k = m d log m k ) dac k > m d (n Exemplu. Pentru algoritmul cutrii binare avem: TDC(n) = (1) deci d = 0, m = 2 i k = 1. Se aplic cazul al doilea al teoremei master (1 = 20) i se obine T(n) =(lgn). Pentru algoritmul maxim avem d = 0, m = 2, k = 2, deci se aplic cazul al treilea al teoremei obindu-se T(n) = n. Reducere i divizare - 69 -
Proiectarea algoritmilor 6.5. Exerciii 1. Propunei un algoritm mai eficient dect putere1 pentru calculul puterii xn pentru un n, numr natural arbitrar. Stabilii ordinul de complexitate al algoritmului propus. 2. Propunei un algoritm pentru calculul lui An, cu A matrice ptratic de ordin n care s aib o complexitate mai mic dect (n4). k k k 3. Folosind relaia Cn = Cn1 + Cn11 scriei un algoritm recursiv pentru calculul
k lui Cn . Analizai complexitatea algoritmului propus i comparai ordinul de n! k complexitate cu cel al algoritmului bazat pe relaia: C n = . k!(n k )! 4. Modificai algoritmul maxim astfel nct s permit determinarea att a valorii maxime ct i a celei minime. Stabilii numrul de comparaii efectuate. Algoritmul obinut este mai eficient dect cel care const n determinarea separat a minimului i a maximului ? 5. Scriei un algoritm care s implementeze urmtoarea idee pentru determinarea simultan a valorii minime i maxime dintr-un tablou: Se grupeaz elementele tabloului n [n/2] perechi. Pentru fiecare pereche se transfer valoarea minim ntr-o mulime cu minime iar valoarea maxim ntr-o mulime cu maxime. Se aplic aceeai prelucrare asupra celor dou mulimi eliminnd din mulimea minimelor valorile mari i din cea a maximelor valorile mici. Procesul continu pn cnd aceste mulimi conin cte un element. Analizai algoritmul propus. 6. Scriei un algoritm de generare a permutrilor bazat pe abordarea "bottom-up" i analizai complexitatea acestuia. Indicaie. Algoritmul va fi apelat cu perm(1) i poate fi descris prin:
perm(k) IF k = n + 1 THEN WRITE x1, x2,.., xn ELSE FOR i 1, k DO xi xk perm(k + 1) xi xk 7. Modificai algoritmul de cutare binar astfel nct s returneze poziia valorii cutate n cazul n care aceasta e prezent n tablou i -1 n caz contrar. 8. Modificai algoritmul de sortare prin inserie astfel nct cutarea poziiei n care se insereaz elementul xi n subtabloul x1, x2,...,xi-1, se bazeaz pe tehnica cutrii binare. Analizai complexitatea algoritmului obinut. Se modific ordinul de complexitate n raport cu algoritmul clasic de inserie ?
Proiectarea algoritmilor 7. APLICAII ALE TEHNICII DIVIZRII. SORTAREA PRIN INTERCLASARE I SORTAREA RAPID 7.1. Introducere Considerm din nou problema ordonrii cresctoare a unui ir de valori x1, x2,.., xn. Algoritmii elementari prezentai anterior au complexitate de ordinul O(n2). Ideea de start o reprezint ncercarea de a reduce aceast complexitate folosind principiul "divide et impera". Aceasta presupune: (i) descompunerea irului iniial n dou subiruri; (ii) ordonarea fiecruia dintre acestea folosind aceeai tehnic; (iii) combinarea irurilor ordonate pariale pentru a obine varianta ordonat a irului total. Dimensiunea critic, sub care problema poate fi rezolvat direct este nc = 1. n acest caz subirul se reduce la un singur element, implicit ordonat. Este posibil s se foloseasc i 1 < nc 10 aplicnd pentru sortarea acestor subiruri una dintre metodele elementare de sortare (de exemplu metoda inseriei). n continuare sunt prezentate dou metode de sortare bazate pe principiul divizrii: sortarea prin interclasare ("mergesort") i sortarea rapid ("quicksort"). Acestea difer att n etapa descompunerii irului n subiruri ct i n recombinarea rezultatelor. 7.2. Sortare prin interclasare Idee. irul x1, x2,.., xn se descompune n dou subiruri de lungimi ct mai apropiate: x1, x2,.., x[n/2] i x[n/2]+1,.., xn se ordoneaz fiecare dintre subiruri aplicnd aceeai tehnic. Se construiete irul final ordonat parcurgnd cele dou subiruri i prelund elemente din ele astfel nct s fie respectat relaia de ordine (aceast prelucrare se numete interclasare). Modul de lucru al sortrii prin interclasare este ilustrat n figura 7.1.
Figura 7.1. Sortarea prin interclasare
Aplicaii ale tehnicilor de reducere i divizare - 71 -
Proiectarea algoritmilor Structura general a algoritmului este urmtoarea: Mergesort(x,li,ls) IF li < ls THEN m [(li+ls)/s] mergesort(x,li,m) mergesort(x,m+1,ls) merge(x,li,m,ls) RETURN x
{sorteaz prima jumtate} {sorteaz a doua jumtate} {interclaseaz cele dou subiruri}
Interclasare. Etapa cea mai important a prelucrrii este reprezentat de interclasare. Scopul acestei prelucrri este construirea unui ir ordonat pornind de la dou iruri ordonate. Ideea prelucrrii const n a parcurge n paralel cele dou iruri i a compara elementele curente. n irul final se transfer elementul mai mic dintre cele dou iar contorul utilizat pentru parcurgerea irului din care s-a transferat un element este incrementat. Procesul continu pn cnd unul dintre iruri a fost transferat n ntregime. Elementele celuilalt ir sunt transferate direct n irul final. Exist diverse modaliti de a descrie algoritmic aceast prelucrare. Una dintre acestea este: Merge(x,li,m,ls) i li {contor subir lim} j m+1 {contor subir m+1ls} k1 {contor ir ieire} WHILE (i m) AND (j ls) DO IF xi xj THEN ck xi {transfer din subirul li,m} ii+1 ELSE ck xj {transfer din subirul m+1,ls} jj+1 kk+1 WHILE (i m) DO {transfer din rest din subirul li,m} ck xi ii+1 kk+1 WHILE (j ls) DO {transfer din rest din subirul m+1,ls} ck xj jj+1 kk+1 j ls FOR i 1 k-1 DO {refacere ir x} xj ci j j+1 Aplicaii ale tehnicilor de reducere i divizare - 72 -
Proiectarea algoritmilor Precondiiile prelucrrii de mai sus sunt: {xli,..,xm cresctor xm+1,..,xls cresctor} iar postcondiia este: { c1,..,cp+q este cresctor} (notm cu p numrul de elemente din primul tablou i cu q numrul de elemente din al doilea). Pentru a demonstra c algoritmul asigur satisfacerea postcondiiei este suficient s se arate c {c1,..,ck-1 este cresctor k = i +.i - 1} este proprietate invariant pentru fiecare dintre cele trei prelucrri repetitive. Contoriznd numrul de comparaii (TC (p, q) i cel de transferuri ale elementelor (TM(p,q)) se obtine: TC(p,q) (min(p,q)) - n cazul cel mai favorabil, TC(p,q) O(p+q-1) - n cazul cel mai defavorabil, iar TM(p,q) ( p+q). S analizm cazul interclasrii a dou tablouri a[1..p] i b[1..q] (independent de algoritmul de sortare prin interclasare). O variant de algoritm este cea care folosete cte un fanion pentru fiecare dintre tablourile a[1..p] i b[1..q]. Fanioanele constau n valori mai mari dect toate valorile prezente n a i b plasate pe poziiile p + 1, respectiv q + 1. n acest caz algoritmul poate fi descris ntr-o form mai condensat dup cum urmeaz: Interclasare_fanion(a,b,p,q) ap+1 {fixare fanioane} bq+1 i1 {contor de intrare} j1 FOR k 1,p+q DO IF ai bj THEN ck ai {transfer din subirul a } ii+1 ELSE ck bj {transfer din subirul b} jj+1 n acest caz att numrul de comparaii ct i numrul de transferuri este TC(p,q) = TM(p, q) = p + q. Prin urmare n varianta cu fanion se efectueaz mai multe comparaii dect n cea fr fanion. Analiza complexitii. Notnd cu T(n) numrul de prelucrri (comparaii i transferuri) efectuate de ctre sortarea prin interclasare i cu Tinter(n) cele efectuate pe parcursul interclasrii se obine relaia de recurent: n =1 0 T ( n) = n >1 T ([n / 2]) + T (n [n / 2]) + Tint er (n) Cum k = m = 2 iar Tinter(n) (n) rezult c se poate aplica cazul doi al teoremei master (d = 1, k = md) obinndu-se c sortarea prin interclasare are complexitate (nlgn). Observaii. Costul redus al prelucrrilor din metoda mergesort este ns contrabalansat de faptul c se utilizeaz (la interclasare) o zon de manevr de dimensiune proporional cu cea a tabloului iniial.
Proiectarea algoritmilor 7.3. Sortare rapid Idee. La sortarea prin interclasare descompunerea irului iniial n dou subiruri se realizeaz pe baza poziiei elementelor. Asta face ca elemente cu valori mici (sau mari) s se poat afla n fiecare dintre subiruri. Din aceast cauz este necesar combinarea rezultatelor prin interclasare. O alt modalitate de descompunere ar fi aceea n care se tine cont i de valoarea elementelor. Scopul urmrit este de a simplifica combinarea rezultatelor. Ideal ar fi ca prin concatenarea irurilor ordonate s se obin irul ordonat n ntregime. Exemplul 1. Considerm irul: x = (3,1,2,4,7,5,8). Se observ c elementul 4 se afl pe o poziie privilegiat (q = 4) ntruct toate elementele care l preced sunt mai mici dect el i toate cele care l succed sunt mai mari. Aceasta nseamn c se afl deja pe poziia final. Un element xq avnd proprietile: xi xq pentru i=1,2,..,q-1 i xi xq pentru i=q+1,..,n se numete pivot. Existenta unui pivot permite reducerea sortrii irului iniial la sortarea subirurilor x1, x2,..,xq-1 i xq+1,..,xn. Nu ntotdeauna exist un astfel de pivot dup cum se observ din subirul (3,1,2). n aceste situaii trebuie "creat" unul prin modificarea poziiilor unor elemente. Alteori pivotul, dac exist, se afl pe o poziie care nu permite descompunerea problemei iniiale n subprobleme de dimensiuni apropiate (de exemplu n subirul (7,5,8) valoarea de pe ultima poziie poate fi considerat valoare pivot). Exemplul 2. S considerm acum irul (3, 1, 2, 7, 5, 4, 8). Se observ c poziia q = 3 are urmtoarea proprietate: xi xj pentru orice i {1,..., q} i orice j {q+1,...,n}. n acest caz sortarea irului iniial se reduce la sortarea subirurilor x1, x2,..,xq i xq+1,..,xn. Poziia q este numit poziie de partiionare. Structura general. Pornind de la exemplele de mai sus se pot dezvolta dou variante de sortare bazate pe descompunerea irului initial in dou subiruri: una care folosete un element pivot iar alta care folosete o poziie de partiionare. Acest tip de sortare este cunoscut sub numele de sortare rapid (" quicksort") i a fost dezvoltat de Hoare. Structura general a acestor algoritmi poate fi descris prin: Quicksort1 (x,li,ls) IF li < ls THEN q partitie1(x,li,ls) quicksort1(x,li, q-1) quicksort1(x,q+1, ls) RETURN x respectiv Quicksort2 (x,li,ls) IF li < ls THEN q partitie2(x,li,ls) quicksort1(x,li, q) quicksort1(x,q+1, ls) RETURN x Aplicaii ale tehnicilor de reducere i divizare - 74 -
Proiectarea algoritmilor Diferena dintre cele dou variante este mic: n prima variant n prelucrarea de partiionare se asigur i plasarea pe poziia q a valorii finale pe cnd n a doua doar se determin poziia de partiionare. Partiionare. Este prelucrarea cea mai important a algoritmului. Discutm separat cele dou variante dei dup cum se va vedea diferentele dintre ele sunt puine. Considerm problema identificrii n x1,..,xn a unui pivot, xq cu proprietatea c xi xq pentru i < q i xi xq pentru i > q. Dup cum s-a vzut n exemplul anterior nu ntotdeauna exist un pivot. n aceste situaii se creeaz unul. Ideea este urmtoarea: se alege o valoare arbitrar dintre cele prezente n ir i se rearanjeaz elementele irului (prin interschimbri) astfel nct elementele mai mici dect aceast valoare s fie n prima parte a irului, iar cele mai mari n a doua parte a irului. n felul acesta se determin i poziia q pe care trebuie plasat valoarea. Algoritmul poate fi descris astfel: Partitie1 (x,li,ls) v xls i li -1 j ls WHILE i < j DO REPEAT i i+1 UNTIL xi v REPEAT jj-1 UNTIL xj v IF i < j THEN xi xj xi xls RETURN i {se alege valoarea pivotului} {contor parcurgere stnga - dreapta } {contor parcurgere dreapta - stnga}
Exemplul 1. Considerm irul (1,7,5,3,8,2,4). Iniial i = 0, j = 7 iar v = 4. Succesiunea prelucrrilor este: Etapa 1. Dup execuia primului ciclu REPEAT se obine i = 2 (cci 7 > 4) iar dup execuia celui de al doilea se obine j = 6. Cum i < j se interschimb x2 cu x6 obinnduse (1,2,5,3,8,7,4). Etapa 2. Parcurgerea n continuare de la stnga la dreapta conduce la i = 3, iar de la dreapta la stnga j = 4. Cum i < j se interschimb x3 cu x4 i se obtine (1,2,3,5,8,7,4). Etapa 3. Continund parcurgerile n cele dou direcii se ajunge la i = 4 i j = 3. Cum i > j se iese din prelucrarea repetitiv exterioar, iar elementele x4 i x7 se interschimb obinndu-se (1,2,3,4,8,7,5), poziia pivotului fiind 4. Aceast poziie asigur o partiionare echilibrat a irului. Aceast situaie nu este ins obinut ntotdeauna. Exemplul 2. S considerm irul (4,7,5,3,8,2, 1). Aplicnd acelai algoritm dup prima etap se obine: i = 1, j = 1 (a se observa c n acest caz fr a folosi o poziie suplimentar cu rol de fanion, x0 = v condiia de oprire a celui de-al doilea REPEAT nu Aplicaii ale tehnicilor de reducere i divizare - 75 -
Proiectarea algoritmilor este niciodat satisfcut), irul devine (1,7,5,3,8,2,4) iar poziia pivotului este q = 1. n acest caz s-a obinut o partiionare dezechilibrat (irul se descompune ntr-un subir vid, pivotul aflat pe prima poziie i un subir constituit din celelalte elemente). Se poate remarca c pentru primul ciclu REPEAT xls joac rolul unui fanion. Observaii. (i) Inegalitile de tip i din ciclurile REPEAT fac ca n cazul unor valori egale s se obin o partiionare echilibrat i nu una dezechilibrat cum s-ar ntmpla dac s-ar folosi inegaliti stricte. n acelai timp dac s-ar utiliza > i < valoarea v nu ar putea fi folosit ca fanion. (ii) Problema nesatisfacerii condiiei de oprire pentru ciclul dup j poate s apar doar n cazul in care li = 1 i atunci cnd v este cea mai mic valoare din ir. Este de preferat s se foloseasc valoare fanion dect s se extind condiia de oprire de la ciclu (de exemplu cu j < i). (iii) La ieirea din prelucrarea repetitiv exterioar (WHILE) indicii 'i i .i satisfac una dintre relaiile: i = j sau i = j + 1. Ultima interschimbare asigur plasarea valorii fanion pe poziia sa final. Pentru a justifica corectitudinea algoritmului partiie1 considerm aseriunea: {dac i < j atunci xk v pentru k = li,..,i, iar xk v pentru k = j,..,ls, iar dac i j atunci xk v pentru k = li,..,i, iar xk v pentru k = j+1,..,ls}. Cum precondiia este li < ls, deci i < j i postcondiiile sunt {xk xi pentru k=1,..,i-1, xk xi pentru k=i+1,..,ls} se poate arta c aseriunea de mai sus este invariant in raport cu prelucrarea repetitiv WHILE, iar dup efectuarea ultimei interschimbri implic postcondiiile. Considerm acum cealalt variant de partiionare. Aceasta difer de prima n special prin faptul c permite ca valoarea pivotului s participe la interschimbri. n plus el nu este plasat la sfrit pe poziia final fiind necesar astfel sortarea subirurilor xli,...,xq i xq+1,...,xls. Aceasta face s nu mai fie necesar plasarea pe poziia 0 a unui fanion ntruct se creeaz n mod natural fanioane pentru fiecare dintre cele dou cicluri REPEAT. Algoritmul poate fi descris dup cum urmeaz. Partitie2 (x,li,ls) v xli i li -1 j ls+1 WHILE i < j DO REPEAT i i+1 UNTIL xi v REPEAT jj-1 UNTIL xj v IF i < j THEN xi xj RETURN j
{se alege valoarea pivotului} {contor parcurgere stnga - dreapta } {contor parcurgere dreapta - stnga}
n acest caz se poate arta c aseriunea {dac i < j atunci xk v pentru k = li,..,i, iar Aplicaii ale tehnicilor de reducere i divizare - 76 -
Proiectarea algoritmilor xk v pentru k = j,..,ls, iar dac i j atunci xk v pentru k = li,..,i-1, iar xk v pentru k = j+1,..,ls} este invariant n raport cu ciclul WHILE iar la ieirea din ciclu (cnd i = j sau i = j + 1) implic xk v pentru k = li,..,j i xk v pentru k = j + 1,ls adic postcondiia xk1 xk2 pentru orice k1= li,..,j, k2=j+1,...,ls. De remarcat c dac se alege ca pivot xls varianta quicksort2 nu va funciona corect putnd conduce la situaia n care unul dintre subtablouri este vid (ceea ce provoac o succesiune nesfrit de apeluri recursive, ntruct nu se mai reduce dimensiunea problemei). n cazul n care se dorete ca xls s fie valoarea pivot este necesar ca apelurile recursive s se fac pentru: quicksort2(x,li,q-1) i qvicksort2(x,q,ls]). Analiza complexitii. Analizm complexitatea variantei quicksort1. Pe parcursul partiionrii numrul de comparaii depete n general numrul de interschimbri, motiv pentru care vom analiza doar numrul de comparaii efectuate. Pentru un ir de lungime n numrul de comparaii efectuate n cele dou cicluri REPEAT din partiionare1 este n + i - j (i i j fiind valorile finale ale contoarelor). Astfel, dac i = j se vor efectua n comparaii, iar dac i = j + 1 se vor efectua n + 1 comparaii. Influena major asupra numrului de comparaii efectuate de ctre quicksort1 o are raportul dintre dimensiunile celor dou subiruri obinute dup partiionare. Cu ct dimensiunile celor dou subiruri sunt mai apropiate cu att se reduce numrul comparaiilor efectuate. Astfel cazurile cele mai favorabile corespund partiionrii echilibrate, iar cele mai puin favorabile partiionrii dezechilibrate. Analiza n cazul cel mai favorabil. Presupunem c la fiecare partiionare a unui ir de lungime n se obin dou subiruri de lungimi [n/2], respectiv n-[n/2]-1, iar numrul de comparaii din partiionare este n. n aceste condiii putem considera c marginea superioar a numrului de comparaii satisface o relaie de recuren de forma T(n) = 2T(n/2) + n ceea ce conduce prin teorema master la o complexitate de ordin nlgn. Prin urmare n cazul cel mai favorabil complexitatea algoritmului quicksort1 este (nlgn). Analiza n cazul cel mai defavorabil. Presupunem c la fiecare partiionare se efectueaz n + 1 comparaii i c se genereaz un subir vid i unul de lungime n - 1. Atunci relaia de recuren corespunztoare este T(n) = T(n - 1) + n + 1. Aplicnd metoda iteraiei se obine T(n) = (n. + 1)(n + 2)/2 - 3. Se obine astfel c n cazul cel mai defavorabil complexitatea este ptratic, adic sortarea rapid aparine clasei O(n2). Spre deosebire de metodele elementare de sortare pentru care un ir iniial sortat conducea la un numr minim de prelucrri n acest caz tocmai aceste situaii conduc la costul maxim (pentru un ir deja ordonat la fiecare partiionare se obine pivotul pe ultima poziie). Pentru a evita partiionarea dezechilibrat au fost propuse diverse variante de alegere a valorii pivotului, una dintre acestea constnd n selecia a trei valori din ir i alegerea ca valoare a pivotului a medianei acestor valori (valoarea aflat pe a doua poziie n tripletul ordonat). Analiza n cazul mediu. Se bazeaz pe ipoteza c toate cele n poziii ale irului au aceeai probabilitate de a fi selectate ca poziie pivot (probabilitatea este n acest caz 1/n.). Presupunnd c la fiecare partiionare a unui ir de lungime n se efectueaz n + 1 comparaii, numrul de comparaii efectuate n cazul n care poziia pivotului este q satisface: Tq(n) = T(q - 1) + T(n - q) + n + 1. Prin urmare numrul mediu de comparaii satisface: Aplicaii ale tehnicilor de reducere i divizare - 77 -
1 n 2 n Tq (n) = n + 1 + Tm (q 1) n q =1 n q =1 Scznd ntre ele relaiile urmtoare (care rezult din relaia de mai sus): Tm (n) =
n Tm (n) = 2 Tm (q 1) + n (n + 1)
q =1
(n 1) Tm (n 1) = 2 Tm (q 1) + n (n 1)
q =1
n 1
se obine relaia de recuren pentru Tm: n Tm (n) = (n + 1) Tm (n 1) + 2 n Aplicnd metoda iteraiei rezult: Tm(n) Tm(n-1) Tm(n-2) .... Tm(2)
Tm(1) iar prin nsumare se obine: n 1 1 1 1 Tm (n) = 2 (n + 1) + + ... + + 2 = 2 (n + 1) + 2 3 n n 1 i =3 i 2 (n + 1) (ln n ln 3) + 2 Prin urmare numrul mediu de comparaii este de ordinul 2n lnn 1.38nlgn. Aceasta nseamn c n cazul mediu sortarea rapid este doar cu 38% mai costisitoare dect n cazul cel mai favorabil. Observaii. Sortarea rapid nu este nici stabil i nici natural. 7.4. Exerciii
n +1 Tm (n 1) + 2 n n = Tm (n 2) + 2 n 1 n 1 = Tm (n 3) + 2 n2 ..... 3 = Tm (1) + 2 2 =0 =
n +1 n n +1 n 1 ...... n +1 3
1. S se extind algoritmul de interclasare pentru un numr arbitrar de iruri ordonate. 2. S se studieze stabilitatea sortrii prin interclasare. Care este operaia determinant n asigurarea stabilitii ? 3. Descriei sortarea prin interclasare n manier nerecursiv. 4. Propunei un algoritm de complexitate (nlgn) pentru verifica dac ntr-un tablou x1, x2,..,xn exist cel puin dou elemente egale. 5. Rescriei algoritmul partiionare1 cnd valoarea pivotului este prima din ir, cnd este o valoare arbitrar aleas din ir i cnd se stabilete cu regula
Proiectarea algoritmilor medianei. 6. Construii un exemplu prin care s se ilustreze c sortarea rapid nu este stabil. 7. Propunei un algoritm eficient prin care se reorganizeaza elementele unui tablou astfel nct toate elementele negative s fie naintea celor pozitive. 8. Modificai algoritmii de sortare prin interclasare i sortare rapid astfel nct s asigure ordonarea descresctoare.
Proiectarea algoritmilor 8. TEHNICA ALEGERII LOCAL OPTIMALE ("GREEDY") 8.1. Introducere Problemele pot fi ncadrate n clase abstracte de probleme ce au anumite elemente comune. O clas frecvent ntlnit n practic este cea a problemelor de optimizare de tipul: S se determine x X astfel nct: (i) x satisface anumite condiii (restricii); (ii) x optimizeaz (minimizeaz sau maximizeaz) un criteriu. O subclas important n informatic o reprezint cea n care X este o mulime finit, problema de optimizare fiind numit n acest caz discret sau combinatorial. La o prim vedere problema pare foarte simpl ntruct este suficient s se parcurg X i s se aleag elementul care satisface restriciile i optimizeaz criteriul. O astfel de abordare (numit i metoda forei brute) devine total ineficient (sau chiar impracticabil) atunci cnd numrul de elemente din X este foarte mare. Exemplu. (problema submulimii de sum dat i cardinal minim) Se consider mulimea A = {a1, a2,..., an} R i valoarea C ai . Se cere s se determine (dac
i =1 n
exist) o submulime avnd ct mai puine elemente i a cror sum s fie egal cu C. n acest caz X reprezint ansamblul submulimilor lui A. O abordare prin metoda forei brute a unei astfel de probleme necesit generarea tuturor submulimilor lui A, reinerea celor care satisfac restricia (suma elementelor egal cu C) i alegerea celei (celor) ce au cele mai puine elemente. Un astfel de algoritm ar avea ordinul de complexitate O(2n). Pentru a rezolva mai eficient probleme de acest tip au fost dezvoltate tehnici specifice de elaborare a algoritmilor. Dou dintre acestea sunt tehnica alegerii local optimale ("greedy") i cea a programrii dinamice. 8.2. Principiul tehnicii S considerm problema de optimizare formulat ntr-o variant uor diferit: Fie A = (a1, a2,....,an) un set finit de elemente (nu neaprat distincte). S se determine S = (s1, s2,....,sk) A astfel nct S s satisfac anumite restricii i s optimizeze un criteriu. n continuare prin set vom nelege o mulime n sens general (elementele sale nu sunt neaprat distincte). Principiul metodei const n a construi succesiv soluia S pornind de la setul vid i adugnd la fiecare etap un nou element, i anume acela care pare "optim" la momentul respectiv. Selecia elementului care va fi eventual adugat urmrete apropierea de atingerea optimului. ns alegerea care pare optim la etapa curent s-ar putea s nu fie cea mai bun i din punct de vedere global astfel c e posibil Tehnica alegerii local optimale greedy - 80 -
Proiectarea algoritmilor s nu conduc la o soluie optim. Totui, o dat efectuat o alegere nu se mai revine asupra ei, aceasta fiind irevocabil. Pe de alt parte, prin strategia greedy se poate obine o singur soluie chiar dac problema are mai multe. Structura general a algoritmului este: Greedy1(A) S WHILE S nu este soluie exist elemente neselectate n A DO selecteaz a din A dac nu sunt nclcate restriciile se adaug a la S RETURN S Etapa cea mai important este cea a selectrii unui nou element. Pentru anumite probleme este posibil ca setul iniial, A, s fie ordonat dup un criteriu determinat de criteriul de optim astfel c elementele vor fi alese chiar n ordinea n care apar n A. Criteriul de sortare depinde de problema concret care se rezolv. n acest caz algoritmul poate fi descris ceva mai detaliat astfel: Greedy2(A,n) Sortare(A,n) {sortare dup un criteriu de optimizare} i0 {contor parcurgere A} k0 {contor pentru construirea mulimii S} WHILE S nu este soluie i n DO IF S1,S2,...,Sk +Ai satisface restriciile THEN k k+1 Sk Ai {se preia elementul} i i+1 {se trece la urmtorul element} RETURN S n aplicaii conteaz principiul metodei, algoritmii construii folosindu-l putnd fi destul de diferii de structurile generale greedy1 respectiv greedy2. Exemplul 1. (Problema submulimii de cardinal dat i sum maxim.) Se cere determinarea unui subset cu m elemente, S, dintr-un set A avnd n > m elemente astfel nct suma elementelor selectate s fie ct mai mare. n acest caz este suficient s ordonm descresctor elementele din A i s reinem primele m elemente: Submultime(A,n,m) Sortare_descrescatoare(A,n) FOR i 1,m DO Si Ai RETURN S Pentru aceast problem se va demonstra n seciunea urmtoare c strategia greedy produce ntotdeauna o soluie optim. Tehnica alegerii local optimale greedy - 81 -
Proiectarea algoritmilor Exemplul 2. (Problema monedelor.) Presupunem c o sum de bani C trebuie acoperit folosind ct mai puine monede. Dac valorile monedelor sunt {v1, v2,...,vn} atunci a rezolva problema nseamn a determina (k1, k2,...., kn) (ki reprezint numrul de monede de valoare vi i poate fi egal cu 0) astfel nct s fie satisfcut restricia
k
i =1
vi = C
i
iar suma
k
i =1
s fie ct mai mic. Se observ c aceast problem este similar cu
problema submulimii de sum dat i cardinal minim cu observaia c setul A este infinit: A = { v1, v1,....,v2, v2,..., vn, vn,...} (pentru fiecare valoare vi exist un numr nelimitat de elemente). O abordare de tip greedy ar conduce (n cazul n care numrul de monede de fiecare tip este nelimitat) la un algoritm de forma: Monede(v,n,C) sortare_descrescatoare(v,n) FOR i 1,n DO Si 0 i 1 WHILE C > 0 i n DO Si C DIV vi C C MOD vi i i+1 IF C = 0 THEN RETURN S ELSE WRITE Nu s-a gasit solutie! Observaie. Tehnica greedy nu conduce pentru orice instan a problemei monedelor la soluia optim. De exemplu pentru cazul monedelor cu valorile (25, 20, 10, 5, 1) i a valorii C = 40 strategia greedy ar conduce la soluia (1, 0, 1, 1, 0) n timp ce varianta (0, 2, 0, 0, 0) este optim. Pe de alt parte exist situaii n care problema nu are soluii. De exemplu pentru monede avnd valorile (20, 10, 5) i C = 17 problema nu are soluie. Se observ uor c dac exist moned cu valoarea 1 atunci pentru orice sum C se poate determina o soluie. Aceasta nu este ns neaprat optimal. Tehnica greedy conduce la o soluie optim pentru problema monedelor doar dac valorile acestora satisfac anumite restricii. Un exemplu de valori pentru care se poate demonstra optimalitatea soluiei este: vi-1 este multiplu al lui vi pentru fiecare i 2 (n condiiile n care v1, v2,..., vn este ordonat cresctor).
Tehnica alegerii local optimale greedy - 82 -
Proiectarea algoritmilor 8.3. Verificarea corectitudinii si analiza complexitii Tehnica alegerii local optimale este o tehnic intuitiv i e_cient, dar nu garanteaz obinerea soluiei optime dect pentru anumite cazuri particulare de probleme. Verificarea corectitudinii. ntruct tehnica greedy nu asigur implicit optimalitatea soluiei, aceasta trebuie demonstrat pentru cazul particular al problemei tratate. n general, problemele pentru care tehnica greedy poate fi aplicat cu succes au urmtoarele proprieti: Proprietatea de alegere greedy. nseamn c se poate ajunge la soluia optim global efectund alegeri local optimale. Pentru a demonstra c o problem are aceast proprietate se pornete de la o soluie optim global i se arat c poate fi modificat astfel nct prima component s fie obinut efectund o alegere local optimal. Se analizeaz n continuare restul soluiei (problema se reduce la una similar dar de dimensiune mai mic). Aplicnd principiul induciei matematice se arat c la fiecare pas poate fi efectuat o alegere de tip greedy. Aceast etap se reduce de fapt la a arta c problema are proprietatea de substructur optim. Proprietatea de substructur optim. Se consider c o problem are proprietatea de substructur optim dac o soluie optim a problemei conine soluii optime ale subproblemelor. Pentru a demonstra acest lucru se poate folosi tehnica reducerii la absurd. Pornind de la o soluie optim S(n) = (s1, s2,...., sn) se arat c S(n - 1) = (s2,...,sn) este soluie optim pentru subproblema de dimensiune n - 1. Se presupune c S(n-1) nu este optim. Atunci ar exista S (n 1) = ( s2 ,..., sn ) o 2 soluie mai bun. Aceasta conduce de regul la faptul c S (n) = ( s1 , s ,..., s ) n este mai bun dect S(n) ceea ce contrazice ipoteza c S(n) este optim. Exemplu. Demonstrm c algoritmul submulime genereaz soluia optim. Proprietatea de alegere greedy. Fie O = (o1,o2,...,om) o soluie optim a problemei. Cum nu conteaz ordinea elementelor n O putem presupune c o1 o2 ...om. Cum elementele lui A sunt ordonate descresctor (a1 a2 ...an) prin alegere de tip greedy prima component ar trebui s fie a1. Vom arta c o1 = a1 prin metoda reducerii la absurd. Presupunem c o1 a1. Rezult c a1 > o1 iar soluia O = (a1,o2,...,om) are proprietatea c are suma mai mare ca soluia O, deci mai bun dect O. Aceasta ns contrazice ipoteza c O este soluie optim. Prin urmare o1 = a1 adic primul element al soluiei este ales conform strategiei greedy. Este suficient acum s demonstrm c problema posed proprietatea de substructur optim.
Proiectarea algoritmilor Proprietatea substructurii optime. Fie O = (o1,o2,...,om) o soluie optim a problemei iniiale. Presupunem c elementele lui A sunt ordonate descresctor (a1 a2 ...an). Artm c O(1) = (o2,...,om) este soluie optim a problemei similare pentru A(2) = (a2,...,an) prin reducere la absurd. Dac nu ar fi soluie optim nseamn c ar exista o alt soluie mai bun: ( o2 ,..., o ) care completat pe prima poziie cu o1 ar conduce la o m soluie global mai bun dect O. S-a ajuns la o contradicie, deci problema posed proprietatea substructurii optime. Analiza complexitii. Strategia greedy conduce n general la algoritmi eficieni. Din structura general (greedy1) se observ c prelucrarea care determin ordinul de complexitate este cea de selecie. Dac aceasta este simpl se pot obine chiar algoritmi de complexitate liniar. n general ns aplicarea strategiei necesit o sortare prealabil a elementelor lui A astfel c se ajunge la complexitate de tipul O(n2) sau O(nlgn) (dac se folosete un algoritm eficient de sortare). n cazul algoritmului submulime dac m este mic n raport cu n atunci nu este justificat s se ordoneze ntregul set A ci s se aleg la fiecare etap valoarea maxim din cele ce nu au fost nc selectate. Se ajunge astfel la un ordin de complexitate O(mn). n algoritmul monede sortarea domin celelalte prelucrri astfel c aceasta impune ordinul de complexitate (O(n2) sau O(nlgn)). 8.4. Aplicaii Problema rucsacului. Este o problem clasic ce are multe aplicaii i diverse variante. Se consider un set de obiecte caracterizate prin profitul (p) i dimensiunea lor (d): A = ((p1, d1),.., (pn, dn)). Se mai consider un rucsac de capacitate maxim C i se pune problema selectrii unui subset de obiecte, ((pi1, di1),...., (pik.dik)) care s nu depeasc k k capacitatea rucsacului d ij C i s asigure un profit maxim pij = max! . j =1 j =1 Dou dintre cele mai cunoscute variante ale problemei sunt: Varianta discret (0-1). Obiectele nu pot fi divizate: un obiect este fie preluat n ntregime fie nu este preluat. Varianta continu (fracionar). Este posibil s fie transferate i fraciuni din obiecte, profitul asigurat fiind proporional cu fraciunea. Doar pentru varianta fracionar se poate obine o soluie optim aplicnd strategia greedy. n acest caz alegerea local optimal este cea care corespunde profitului relativ maxim (profitul relativ al obiectului i este pi /di). Aplicnd strategia greedy se ajunge la a efectua urmtoarele prelucrri: (i) se ordoneaz A descresctor dup profitul relativ; (ii) se transfer obiectele n ordinea n care apar n A, n ntregime cu excepia ultimului obiect din care se ia doar o fraciune, att ct s se umple rucsacul. Tehnica alegerii local optimale greedy - 84 -
Proiectarea algoritmilor Pentru a descrie algoritmul facem urmtoarele convenii: Ai.p, Ai.d reprezint profitul respectiv dimensiunea obiectului i. Soluia va fi de forma: S = (S1, S2,..., Sn ) cu Si [0, 1], iar elementele sale vor fi interpretate astfel: Si = 0 - obiectul i nu este selectat, Si = 1 obiectul i este selectat n ntregime, Si (0, 1) - este selectat doar o fraciune din obiectul i. Cu aceste convenii algoritmul poate fi descris astfel: Rucsac_fractionar(A,n,C) Sortare_descrescatoare(A,n) FOR i 1,n DO Si 0 i 1 WHILE C > 0 i n DO IF Ai.d C THEN Si 1 C C - Ai.d ELSE Si C/Ai.d C 0 ii+1 RETURN S
{dup profitul relativ Ai.p/ Ai.d}
Soluia obinut aplicnd acest algoritm va fi de forma: S = (1, 1,.., 1, f. 0,..., 0). n plus
i =1
Si di = C , astfel c n continuare considerm c restricia problemei este de
tip egalitate. Demonstrm c rucsac fracionar genereaz o soluie optim artnd c orice soluie optim trebuie s respecte criteriul alegerii greedy. Considerm c obiectele sunt ordonate descresctor dup valoarea profitului relativ: p1/d1 > p2/d2>.... >pn/dn (n cazul cnd inegalitatea nu este strict alegerea de tip greedy nu este unic i complic puin demonstraia). Considerm O = (o1, o2,..., on) o soluie optim i demonstrm c este de tip greedy prin reducere la absurd. Presupunem c O nu este de tip greedy i considerm c O = (o1, o2 ,...., on ) este generat aplicnd tehnica greedy. Fie B+ = {i | oi oi } , B = {i | oi < oi } iar k = minB_ (cel mai mic indice pentru care oi < oi). Din structura unei soluii de tip greedy rezult c dac i B+ i j B- atunci i < j. Din restricia problemei rezult:
B
i =1
oi di = oi di
i =1
iB
adic
iB+
(oi oi ) di = (oi oi ) di
Proiectarea algoritmilor Calculm profiturile corespunztoare celor dou soluii:
P = oi pi
i =1
i P = oi pi
i =1
diferena lor este
P P = (oi oi ) pi =
i =1
Se observ c pi/di > pk/dk pentru orice i B+ iar pi/di pk/dk pentru orice i B. Prin urmare
B B
iB+
(oi oi ) di d i (oi oi ) di d i
i iB i
p p P P > k (oi oi ) d i k (oi oi ) d i = 0 d k iB d k iB + ns P > P contrazice ipoteza c O este optim. Deci O are o structur greedy. Proprietatea de substructur optim rezult imediat prin reducere la absurd. Observaie. Pentru a ilustra faptul c pentru varianta discret aceast strategie nu conduce la soluia optim considerm exemplul: A = ((60, 10), (100, 20), (120, 30)), C = 50. Profiturile relative sunt: 6, 5, 4, iar A este deja ordonat descresctor dup acest criteriu. Aplicnd strategia greedy s-ar transfera primele dou obiecte ducnd la un profit egal cu 160. Dac s-ar transfera al doilea i al treilea obiect s-ar ajunge la un profit mai mare, 220. Dei nu conduce la soluia optim, strategia greedy poate fi aplicat i pentru varianta discret conducnd la o soluie sub-optimal. n schimb se poate obine o soluie optim aplicnd tehnica programrii dinamice. Problema selectrii activitilor. Se consider un set de activiti care au nevoie de o anumit resurs i la un moment dat o singur activitate poate beneficia de resursa respectiv (de exemplu activitatea poate fi un examen, iar resursa o sal de examen). Presupunem c pentru fiecare activitate, Ai, se cunoate momentul de ncepere, pi i cel de finalizare ti (ti > pi). Presupunem c activitatea se desfoar n intervalul [pi, ti). Dou activiti Ai i Aj se consider compatibile dac intervalele asociate sunt disjuncte. Se cere s se selecteze un numr ct mai mare de activiti compatibile. O soluie a acestei probleme const ntr-un subset de activiti S = (ai1, ai2,..., aim) care satisfac [pij , tij ) [pik, tik ) = pentru orice j k. Criteriul de selecie ar putea fi: (i) cea mai mic durat; (ii) cel mai mic moment de ncepere; (iii) cel mai mic moment de sfrit; (iv) intervalul care se intersecteaz cu cele mai puine alte intervale. Dintre aceste variante cea pentru care se poate demonstra c asigur obinerea soluiei optime este a treia: la fiecare etap se alege activitatea care se termin cel mai devreme. Notnd cu Ai.p, Ai.t momentul de ncepere respectiv cel de final al activitii Ai]algoritmul bazat pe strategia greedy poate fi descris astfel: Tehnica alegerii local optimale greedy - 86 -
Proiectarea algoritmilor Selectiectivitati(A,n) Sortare_descrescatoare(A,n) {dup timpul de finalizare, Ai.t} S1 A1 i2 k 1 WHILE i n DO IF Sk.t Ai.p THEN k k +1 Sk Ai ii+1 RETURN S Demonstrm c algoritmul de mai sus conduce la soluia optim. Dup ordonarea cresctoare dup timpul de final avem t1 t2 ...... tn . Considerm o soluie optim O = ((pi1, ti1), (pi2, ti2),..., (pim, tim)). Evident ti1 t1 prin urmare nlocuind Ai1 cu A1 n O, se obine o soluie n care exist acelai numr de activiti compatibile dar prima activitate este aleas conform strategiei greedy. Deci problema satisface proprietate alegerii local optimale. O dat aleas prima activitate, problema se reduce la planificarea optim a activitilor compatibile cu prima. Dac O este soluia optim a problemei iniiale atunci O = ((pi2, ti2),..., (pim, tim)) este soluie optim a subproblemei la care se ajunge dup stabilirea primei activiti. Astfel problema satisface i proprietatea substructurii optime. S considerm cazul A = ((1, 8), (2, 5), (6, 8), (5, 6)). Sortnd A n ordinea cresctoare a duratei activitilor se obine ca soluie: S = ((5, 6), (6, 8), (2, 5)). Prin selecie dup momentul de ncepere a activitilor se obine ((1, 8)), n schimb prin selecie dup momentul de finalizare se obine o soluie, S = ((2, 5), (5, 6), (6, 8)), n care activitile sunt deja ordonate n ordinea n care vor fi efectuate. Problema planificrii activitilor. Se consider un set de n prelucrri ce trebuie executate de ctre un procesor. Durata execuiei prelucrrilor este aceeai (se consider egal cu 1). Fiecare prelucrare i are asociat un termen final de execuie, ti n i un profit, pi. Profitul unei prelucrri intervine n calculul profitului total doar dac prelucrarea este executat (dac prelucrarea nu poate fi planificat nainte de termenul final de execuie profitul este nul). Se cere s se planifice activitile astfel nct s fie maximizat profitul total (acesta este corelat cu numrul de prelucrri planificate). O soluie const n stabilirea unui "orar" de execuie a prelucrrilor S = (s1, s2, ....,sn), si {1,2,..,n} fiind indicele prelucrrii planificate la momentul i. Pentru rezolvarea problemei se poate aplica o tehnic de tip greedy caracterizat prin: se sorteaz activitile n ordinea descresctoare a profitului; fiecare activitate se planific ntr-un interval liber ct mai apropiat de termenul final de execuie.
Proiectarea algoritmilor Planificare(A,n) Sortare_descrescatoare(A,n) {dup timpul de profit, Ai.p} FOR i 1,n DO Si 0 FOR i 1,n DO {termenul final de execuie} poz Ai.t WHILE Spoz 0 poz 1 DO poz poz -1 IF poz 0 THEN {se planific activitatea} Spoz I RETURN S Se observ c dac pentru fiecare i {1,2,..,n} numrul activitilor care au termenul final cel mult i este cel mult egal cu i (card{j| tj i} i) atunci toate activitile vor fi planificate, altfel vor exista activiti ce nu pot fi planificate. S considerm n = 4 activiti avnd termenele finale: (2, 3, 4, 2) i profiturile corespunztoare (4, 3, 2, 1). Atunci aplicnd tehnica greedy se obine soluia (4, 1, 2, 3). Dac ns termenele de execuie sunt: (2, 4, 1, 2) i aceleai profituri se obine soluia (3, 1, 0, 2) iar activitatea 4 nu este planificat.
8.5. Exerciii
1. Problema mpachetrii. Se consider un set de numere a1, a2,..., an cu proprietatea c ai (0, 1]. Se cere s se grupeze n ct mai puine subseturi (k) astfel nct suma elementelor din fiecare subset s nu depeasc valoarea 1. Indicaie. Elementele setului iniial pot fi n orice ordine. Varianta 1. Se construiesc succesiv submulimile: se transfer (n ordinea n care se afl n set) n primul subset attea elemente ct este posibil, din elementele rmase se transfer elemente n al doilea subset etc. (nu e garantat optimalitatea soluiei ns s-a demonstrat c k < 2kopt, k fiind numrul de subseturi generat prin strategia greedy de mai sus, iar kopt este numrul optim de subseturi). Varianta 2. Se iniializeaz n subseturi vide. Se parcurge setul de numere i fiecare numr se transfer n primul subset n care "ncape". Numrul de subseturi nevide astfel constituite k, are proprietatea k < 1,7kopt. Varianta 3. Dac se ordoneaz descresctor setul iniial i se aplic varianta 2 se obine o ^mbuntire: k < 11/9kopt + 4. n anex se prezint un program DELPHI care utilizeaz aceast variant. 2. S se aplice strategia greedy pentru a rezolva problema discret a rucsacului. Indicaie. Se ordoneaz obiectele descresctor dup profitul relativ i se selecteaz n aceast ordine. Obiectele care nu ncap n rucsac n etapa selectrii lor sunt ignorate. 3. Se consider o variant a problemei rucsacului n care ordonarea obiectelor dup profit coincide cu ordonarea obiectelor dup dimensiune (un caz particular este acela n Tehnica alegerii local optimale greedy - 88 -
Proiectarea algoritmilor care sunt egale). S se elaboreze un algoritm bazat pe strategia greedy n care selecia se face n ordinea profiturilor absolute. Conduce algoritmul la soluia optim ? 4. Se consider o variant a problemei rucsacului n care toate obiectele au aceeai dimensiune (dar profituri diferite). S se elaboreze un algoritm bazat pe strategia greedy care s rezolve problema. Se obine soluia optim ? Aceeai problem pentru cazul n care toate profiturile sunt identice (dar dimensiunile sunt diferite).
ANEXA Program pentru mpachetare optim (varianta 3)
unit impachetare; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls,math, ActnList, ExtActns, StdActns; type tabler=array [1..1000] of real; table=array [1..1000,1..1000] of tableb=array [1..1000] of word; TForm1 = class(TForm) Button1: TButton; ListBox1: TListBox; ActionList1: TActionList; FileOpen1: TFileOpen; Label1: TLabel; Button2: TButton; Button3: TButton; Button4: TButton; procedure Button1Click(Sender: procedure Button2Click(Sender: procedure Button3Click(Sender: procedure FormActivate(Sender: procedure Button4Click(Sender: private { Private declarations } public { Public declarations } end; var Form1: TForm1; fis_in:textfile; n,k,i:word; numef:string; x,suma,y:tabler; a:table; implementation {$R *.dfm} procedure afissirb(x:tableb;n:word;tit:string); var i:word; s:string; begin form1.listbox1.Items.Add(tit); form1.ListBox1.Items.Add('Numar elemente: '+inttostr(n));
real;
TObject); TObject); TObject); TObject); TObject);
s:=' '; for i:=1 to n do if length(s)<65 then s:=s+floattostr(x[i])+' ' else begin form1.ListBox1.Items.Add(s); s:=' '+floattostr(x[i])+' '; end; form1.ListBox1.Items.Add(s); end; procedure afissir(x:tabler;n:word;tit:string); var i:word; s:string; begin form1.listbox1.Items.Add(tit); form1.ListBox1.Items.Add('Numar elemente: '+inttostr(n)); s:=' '; for i:=1 to n do if length(s)<65 then s:=s+floattostr(x[i])+' ' else begin form1.ListBox1.Items.Add(s); s:=' '+floattostr(x[i])+' '; end; form1.ListBox1.Items.Add(s); end; procedure TForm1.Button1Click(Sender: TObject); var i:word; err:boolean; begin if numef<>'' then begin label1.Visible:=true; label1.Caption:='Nume fisier: '+numef; reset(fis_in); readln(fis_in,n); for i:=1 to n do read(fis_in,x[i]); closefile(fis_in); listbox1.Clear; listbox1.Visible:=true; afissir(x,n,'Sir initial:'); err:=false; for i:=1 to n do if x[i] > 1 then begin messagedlg('Element mai mare ca 1: nr. ordine: '+inttostr(i)+' valoare: '+floattostr(x[i]),mterror,[mbok],0); err:=true; end; if err then begin messagedlg('Corectati datele de intrare!', mterror,[mbok],0); application.Terminate; end; end
else messagedlg('Alegeti fisierul cu date !',mterror,[mbok],0); end; procedure TForm1.Button2Click(Sender: TObject); var i:word; begin randomize; for i:=1 to 100 do x[i]:=trunc(random*100)/100; listbox1.Clear; listbox1.Visible:=true; afissir(x,100,'Sir initial:'); n:=100; end; procedure TForm1.Button3Click(Sender: TObject); begin numef:=fileopen1.Dialog.FileName; assignfile(fis_in,numef); if fileexists(numef) then reset(fis_in) else rewrite(fis_in); closefile(fis_in); winexec(pchar('notepad '+numef),sw_show); end; procedure sortsir(n:word; var x:tabler); var test:boolean; i:word; man:real; begin repeat test:=true; for i:=1 to n-1 do if x[i]<x[i+1] then begin man:=x[i]; x[i]:=x[i+1]; x[i+1]:=man; test:=false; end; until test; end; procedure TForm1.FormActivate(Sender: TObject); begin fileopen1.Dialog.InitialDir:=getcurrentdir; numef:=''; n:=0; end; procedure TForm1.Button4Click(Sender: TObject); var j,p:word; msum:real; begin if n=0 then messagedlg('Stabiliti un sir de intrare !',mterror,[mbok],0) else begin msum:=0;
for i:=1 to n do msum:=msum+x[i]; for i:=1 to n do begin for j:=1 to n do a[i,j]:=0; suma[i]:=0; end; sortsir(n,x); k:=1; suma[1]:=x[1]; a[1,1]:=x[1]; for i:=2 to n do begin j:=1; while (suma[j]+x[i])>1.00000001 do j:=j+1; suma[j]:=suma[j]+x[i]; p:=1; while a[j,p]<>0 do p:=p+1; a[j,p]:=x[i]; if j>k then k:=j; end; listbox1.Items.Add(' '); listbox1.Items.Add('Numar pachete: '+inttostr(k)+' pachete (teoretic): '+inttostr(trunc(msum)+1)); for i:=1 to k do begin p:=1; while a[i,p]<>0 do begin y[p]:=a[i,p]; inc(p); end; afissir(y,p-1,'Pachet: '+inttostr(i)+' '+floattostr(suma[i])); end; end; end; end.
Numar
minim
de
Suma:
Proiectarea algoritmilor 9. TEHNICA PROGRAMRII DINAMICE 9.1. Introducere Programarea dinamic (introdus in 1950 de R. Bellman pentru rezolvarea problemelor de optimizare) este o metod bazat pe construirea i utilizarea unor tabele cu informaii. La construirea tabelelor pentru completarea unui element se folosesc elemente completate anterior (construirea se realizeaz n manier dinamic). Aceast tehnic se bazeaz pe descompunerea unei probleme n subprobleme i este adecvat rezolvrii problemelor (n particular celor de optimizare) care au urmtoarele proprieti: Proprietatea de substructur optim. Orice soluie optim este constituit din soluii optime ale subproblemelor. Aceast proprietatea este specific i problemelor ce pot fi rezolvate prin tehnica greedy. Pentru a verifica dac o problem posed aceast proprietate se poate folosi metoda reducerii la absurd. Proprietatea de suprapunere a problemelor. Pentru ca programarea dinamic s fie eficient este necesar ca numrul subproblemelor ce trebuie efectiv rezolvate n scopul obinerii soluiei problemei iniiale s fie relativ mic (polinomial n raport cu dimensiunea problemei). Aceasta nseamn c n procesul de descompunere a problemei se ajunge de mai multe ori la aceeai subproblem care ns va fi rezolvat o singur dat iar soluia ei va fi reinut ntr-un tabel. Ideea descompunerii problemei n subprobleme este folosit i n metoda divizrii ns n acel caz era important ca subproblemele s fie independente. 9.2. Principiul tehnicii i etapele aplicrii La aplicarea metodei se parcurg urmtoarele etape: (a) Analiza structurii unei soluii optime i a proprietilor acesteia prin punerea n evident a relaiei existente ntre soluia problemei i soluiile subproblemelor (se verific dac problema posed proprietatea de substructur optim). (b) Stabilirea unei relaii de recurent referitoare la criteriul de optimizat sau la valoarea ce trebuie calculat. Aceasta descrie legtura dintre valoarea criteriului de optim corespunztor problemei i cele corespunztoare subproblemelor. (c) Calculul valorii asociate soluiei optime dezvoltnd relaia de recuren ntr-o manier ascendent i reinnd valorile calculate asociate subproblemelor ntr-o structur tabelar. n funcie de problem, n Tehnica programrii dinamice - 93 -
Proiectarea algoritmilor aceast etap se pot retine i alte informaii care vor fi utilizate n momentul construirii soluiei. (d) Construirea unei soluii optime folosind informaiile determinate i reinute la etapa anterioar. Dei se bazeaz pe descompunerea unei probleme n subprobleme la fel ca tehnica divizrii specificul programrii dinamice este c subproblemele nu sunt independente (ci se suprapun). n schimb tehnica divizrii conduce la algoritmi eficieni doar dac subproblemele sunt independente. Dezvoltarea ascendent i descendent a unei relaii de recuren. Suprapunerea problemelor face ca obinerea valorii prin dezvoltarea relaiei de recurent s nu fie eficient dac este abordat n manier descendent (" top-down") prin implementarea recursiv a relaiei. Aceasta deoarece o aceeai valoare poate fi utilizat de mai multe ori i de fiecare dat cnd este utilizat este recalculat. S considerm problema determinrii celui de-al m-lea element din irul lui Fibonacci (f1=1, f2= 1, fn = fn-1 + fn-2, n 3). O abordare descendent conduce la algoritmul recursiv: Fib_rec(m) IF (m = 1) OR (m = 2) THEN RETURN 1 ELSE RETURN fib_rec(m-1)+ fib_rec(m-2) Numrul de adunri efectuate pentru a determina pe fm, T(m) verific relatiile: T(1) = T(2) = 0, T(m) = T(m -1) +T(m - 2) + 1. Prin urmare T(m) fm-1, pentru m 5. Cum fm
1+ 5 rezult c fib_rec are complexitate exponenial. 2 Considerm acum varianta generrii lui fm n manier ascendent: se calculeaz i se rein valorile lui f1, f2,..., fm. n acest caz algoritmul poate fi descris prin:
(m) cu =
Fib_asc(m) f1 1 f2 1 FOR i 3, m DO fi fi-1 + fi-2 RETURN fm numrul de adunri efectuate fiind de aceast dat T(m) = m - 2 (complexitate liniar). Aceast variant de implementare introduce utilizarea unui spaiu auxiliar de memorie de dimensiune m. Algoritmul poate fi uor transformat astfel nct s nu foloseasc dect trei variabile pentru reinerea elementelor irului dar s rmn cu complexitate liniar: Tehnica programrii dinamice - 94 -
Proiectarea algoritmilor Fib_asc2(m) f1 1 f2 1 FOR i 3, m DO f3 f2 + f2 f1 f2 f2 f3 RETURN f3 Numrul variabilelor de lucru poate fi redus chiar la dou n modul urmtor: Fib_asc3(m) f1 1 f2 1 FOR i 3, m DO f2 f1 + f2 f1 f2 - f1 RETURN f2
k Un exemplu similar este cel al calculului combinrilor, Cn , (n k ) , pornind de la relaia de recuren:
1 k Cn = k k 1 C n 1 + C n 1
dac k = 0 sau n = k altfel
Algoritmul in varianta recursiv: comb_rec(n,k) IF (k=0) OR (n=k) THEN RETURN 1 ELSE RETURN comb_rec(n-1,k)+ comb_rec(n-1,k-1) are complexitate exponenial ntruct T(n,k) 2min{n-k,k}. Aceasta se poate justifica utiliznd arborele de apel i observnd c cea mai scurt ramur din arbore are lungimea min{n - k, k}. Aceasta se poate demonstra dezvoltnd arborele de apel i estimnd numrul de noduri al arborelui trunchiat pn la nivelul corespunztor celei mai scurte ramuri. n abordarea ascendent ideea este s se rein toate valorile Ci j calculate pentru 0 j i n. Aceasta s-ar putea realiza prin completarea elementelor aij din zona inferior triunghiular a unei matrice n x n. De fapt este suficient s se completeze pn la coloana k. Dac n = k zona triunghiular astfel completat este cunoscut sub denumirea de triunghiul lui Pascal. Algoritmul poate fi descris prin: Tehnica programrii dinamice - 95 -
Proiectarea algoritmilor comb_asc(n,k) FOR i 0,n DO FOR j 0, min{i,k} DO IF (i = j) OR (j = 0) THEN aij 1 ELSE aij ai-1j + ai-1j-1 RETURN ank Numrul de adunri efectuate, T(n, k) satisface T ( n, k ) = 1 +
i =1 j =1 k i 1
deci T(n, k) (nk). Se observ c zona auxiliar utilizat poate fi redus, ntruct pentru completarea liniei i se folosesc doar valorile din linia i 1. Exemplu. Problema determinrii celui mai lung ir cresctor. Se consider un ir de valori reale a1, a2,..., an i se caut un subir (aj1, aj2,..., ajk) cu 1 jl < j2 < .... < jk n, aj1 < aj2 <...< ajk, i astfel nct k s fie ct mai mare. Un astfel de subir nu este neaprat unic. De exemplu pentru irul (2,5,1,3,6,8,2,10) exist dou subiruri strict cresctoare de lungime 5: (2,3,6,8,10) i (1,3,6,8,10). Pe de alt parte nu toate subirurile de aceeai lungime se termin cu acelai element. De exemplu n irul (2,1,4,3) exist patru subiruri cresctoare de lungime maxim (2): (2,4), (2,3), (1,4), (1,3). a) Caracterizarea soluiei optime. Fie aj1 < aj2 <...< ajk-1 < ajk un subir de lungime maxim. Considerm c ajk = ai iar ajk-1 = ap (evident p < i., Prin reducere la absurd se poate arta c aj1 < aj2 <.....< ajk-1 este cel mai lung dintre subirurile cresctoare ale irului parial (a1, a2,..., ap) care au proprietatea c ultimul element este chiar ap. Prin urmare problema are proprietatea de substructur optim i lungimea unui subir cresctor care se termin n ai poate fi exprimat n funcie de lungimea subirurilor cresctoare care se termin cu elemente ap ce satisfac ap < ai. b) Stabilirea unei relaii de recuren ntre lungimile subirurilor. Fie (Bi), i=1,2,..,n un tablou ce conine pe poziia i numrul de elemente al celui mai lung subir strict cresctor al lui (a1, a2,..., an) care are pe ai ca ultim element (spunem c subirul se termin n ai). innd cont de proprietile soluiei optime se poate stabili o relaie de recuren pentru Bi: i =1 1 Bi = 1 + max{B j | 1 j < i i a j < ai } i > 1 Dac mulimea MI = {Bi 1 j < i i aj < ai} este vid atunci max Mi = 0. De exemplu pentru irul iniial a = (2,5,1,3,6,8,4) tabloul lungimilor subirurilor optime care se termin n fiecare element al lui a este: B = (1,2,1,2,3,4,3). Cea mai mare valoare din B indic numrul de elemente din cel mai lung subir cresctor.
B
i = k +1 j =1
1 = (i 1) +
i =1
i = k +1
k =
k (k 1) + k (n k ) 2
Tehnica programrii dinamice - 96 -
Proiectarea algoritmilor c) Dezvoltarea, relaiei de recuren n manier ascendent. Se completeaz un tablou cu elementele lui (Bi), i=1,2,..,n.
B
completare(a,n) B1 1 FOR i 2,n DO max 0 FOR j 1, i-1 DO IF (aj < ai) AND (max < Bj) THEN max Bj Bi max + 1 RETURN B
B
Lund in considerare doar comparaia dintre dou elemente ale irului (aj < ai) costul algoritmului este T ( n) =
i = 2 j =1
1 =
n i 1
i=2
(i 1) =
n (n 1) 2
deci completarea tabelului B este de complexitate (n2). d) Construirea unei soluii optime. Se determin cea mai mare valoare din B. Aceasta indic numrul de elemente ale celui mai lung subir cresctor iar poziia pe care se afl indic elementul, am, din irul iniial cu care se termin subirul. Pornind de la acest element subirul se construiete n ordinea invers a elementelor sale cutnd, la fiecare etap, un element din ir mai mic dect ultimul completat n subir i cruia i corespunde n B o valoare cu 1 mai mic dect cea curent. Algoritmul poate fi descris prin: construire(a,B,n) {detrminarea valorii i poziiei maxumului n B} imax 1 FOR i 2,n DO IF Bimax < Bi THEN imax i m imax {construirea unei soluii} k Bm xk am {ultimul element al subirului} WHILE Bm > 1 DO i m-1 WHILE (ai am) OR (Bi Bm -1) DO ii1 mi kk1 xk am RETURN x Tehnica programrii dinamice - 97 -
Proiectarea algoritmilor Dac dup completarea elementului am n subir exist dou subiruri din zona a1, a2,...., am-1, de lungime maxim egal cu Bm - 1: unul care se termin in ap i unul care se termin in aq (astfel nct ap < am i aq < am) algoritmul va selecta ca element pentru subir pe cel cu indicele mai apropiat de m, adic mai mare. Astfel dac p < q va fi selectat q. Aplicnd algoritmul de construire a irului (2,5,1,3,6,8,4) se va porni cu m = 6 (Bm = 4) ultimul element din subir fiind astfel 8. Cum B5 = 3 i 6 < 8 penultimul element va fi 6. Continund procesul se selecteaz n continuare elementele 3 i 1 obinndu-se subirul cresctor (1,3,6,8) de lungime 4. ntruct n ciclul de construire cutarea continu de la poziia noului element selectat, chiar dac sunt dou cicluri WHILE suprapuse, ordinul de complexitate este O(n). Cum i determinarea maximului lui B are acelai ordin de complexitate rezult c algoritmul de construire are complexitate liniar.
B
9.3. Aplicaii nmulirea optimal a unui ir de matrice. Fie A1, A2, ..., An un ir de matrice avnd dimensiuni compatibile pentru a putea calcula produsul: A1 A2 An. S presupunem c aceste dimensiuni sunt: (p0, p1, p2,....,pn), adic matricea Ai are pi-l linii i pi coloane. Pentru a calcula produsul A = A1 A2 An trebuie stabilit un mod de grupare a factorilor astfel nct s se pun n evident ordinea n care vor fi efectuate nmulirile, la fiecare etap nmulindu-se dou matrice. Considerm c produsul a dou matrice se efectueaz dup metoda clasic astfel c la produsul Ai Ai+1 se efectueaz pi-l pi pi+l nmuliri scalare. Modul de grupare a factorilor (plasarea parantezelor pentru a indica ordinea de efectuare a nmulirilor) nu influeneaz rezultatul final (nmulirea este asociativ) ns poate influenta numrul de operaii efectuate. S considerm cazul a trei matrice A1, A2, i A3 avnd dimensiunile (2,20), (20,5) i (5,10). n acest caz exist dou modaliti de plasare a parantezelor: 1. A1 A2 A3= (A1 A2) A3. n acest caz se efectueaz 2205 + 2510 = 300 nmuliri scalare. 2. A1 A2 A3= A1( A2 A3). n acest caz se efectueaz 20510 + 22010 = 1400 nmuliri scalare. Pentru n mare numrul de parantezri (variante de plasare a parantezelor) poate fi foarte mare astfel c este exclus generarea tuturor parantezrilor posibile i alegerea celei mai bune. Pentru calculul produsului A1 A2 An notnd cu K(n) numrul de parantezri posibile obinem: 1 K ( n ) = n 1 ( K (i ) K ( n i ) ) i =1 n =1 n >1
ntruct ultimul nivel de paranteze poate fi aplicat n oricare dintre poziiile i {1, 2, . . . ,n - 1} i fiecare dintre cele K(i) parantezri ale produsului A1 A2 ... Ai poate fi combinat cu fiecare dintre cele K(n - i) parantezri ale produsului Ai+1 . . . An. Se poate demonstra prin inducie matematic c Tehnica programrii dinamice - 98 -
4n 1 i K (n) 3 n (n 1)2 Problema nmulirii optimale a unui ir de matrice (un caz particular al problemelor de planificare optimal a prelucrrilor) const n a determina parantezarea (ordinea de efectuare a nmulirilor) care conduce la un numr minim de nnuliri scalare. Aplicm pentru rezolvarea problemei programarea dinamic. a) Pentru a specifica produsele pariale introducem notaia Ai..j = Ai Ai+1 Aj. Fie o soluie optim caracterizat prin faptul c parantezele cele mai exterioare sunt plasate pe poziiile 1, k i n, adic ultima nmulire efectuat este: A1...kAk+1..n. Atunci parantezrile asociate lui A1...k i Ak+1..n trebuie s fie i ele optime (n caz contrar ar exist o parantezare mai bun pentru A1..n). b) Fie cij numrul de nmuliri scalare efectuate pentru calculul lui Ai..j. Valorile cij au sens doar pentru i j iar relaia de recuren dedus din proprietatea de substructur optim este: i= j 0 cij = i< j min i k < j (cik + ck +1, j + pi 1 pk p j )
K ( n) =
n 1 C2n 1) (
Relaia se bazeaz pe faptul c dintre toate parantezrile posibile ale lui Ai..j se alege cea mai bun (de cost minim). c) Valorile cij pot fi reinute n poriunea superior triunghiular a unei matrice. Construirea n manier recursiv a matricei este ineficient. Construirea n manier ascendent se bazeaz pe ideea completrii matricei astfel nct n momentul calculului lui cij toate elementele cik i ck+l,j pentru k {i, i + 1,. . ,j-1} s fie deja completate. Din acest motiv elementele se completeaz n ordinea cresctoare a diferenei j - i: prima dat se completeaz elementele diagonalei principale (i = j), apoi se completeaz elementele aflate imediat deasupra diagonalei principale (j = i + 1) .a.m.d. completare(p,n) FOR i 1,n DO cii 0 FOR l 2,n DO {l = j-i} FOR i 1, n-l DO j i+l cij cii + ci+1,j + pi-1pipj sij i FOR k i+1, j-1 DO cost cik + ck+1,j+ pi-1pipj IF cost < cij THEN cij cost sij k RETURN c, s Tehnica programrii dinamice - 99 -
Proiectarea algoritmilor O dat cu completarea matricei de costuri se reine i poziia n care se descompune un produs n doi factori: sij = k indic faptul c produsul Ai..j se descompune n Ai..k Ak+1....j. Aceste poziii sunt utile la construirea soluiei. Cum pentru determinarea valorii fiecruia dintre cele n(n-1)/2 elemente este necesar determinarea unui minim dintr-un tablou cu cel mult n elemente rezult c ordinul de complexitate al algoritmului de completare este O(n3). Pentru exemplul celor trei matricei cu dimensiunile (2,20), (20,5) i (5,10) se obin matricele: 0 200 300 0 1 1 0 400 s = 0 2 c= 0 0 d) n funcie de cerinele problemei se poate determina: (i) numrul minim de operaii; (ii) rezultatul nmulirii matricelor; (iii) modul de descompunere a produsului (parantezare). (i) Numrul minim de nmuliri este chiar c1n. (ii) Calculul produsului poate fi efectuat n manier recursiv: Produs_optimal(i,j) IF i=j THEN RETURN Ai ELSE X Produs_optimal(i, sij) Y Produs_optimal( sij+1,j) R produs(X,Y) {produs matrici} RETURN R n algoritmul de mai sus s-a presupus c pot fi accesate matricele din ir precum i elementele matricei s. (iii) Determinarea ordinii n care se efectueaz nmulirile: Parantezare(i,j) IF i < j THEN Parantezare(i, sij) WRITE sij Parantezare(sij+1,j) Problema rucsacului - varianta 0-1. Considerm varianta discret a problemei rucsacului. Presupunem c obiectele se caracterizeaz prin dimensiunile (dl, d2,...,dn) i profiturile (valorile): (p1, p2,....,pn), iar capacitatea maxim a rucsacului este C. Se pune problema selectrii unui subset de obiecte, ((pi1, di1), (pi2, di2),..., (pik, dik)) care s nu depeasc capacitatea rucsacului ( d ij C ) i s asigure un profit maxim ( pij
j =1 j =1 k k
este maxim). Se consider c dimensiunea fiecrui obiect este mai mic dect cea Tehnica programrii dinamice - 100 -
Proiectarea algoritmilor maxim (di C). Pentru a uura aplicarea tehnicii programrii dinamice vom considera c di, i=1,2,..,n i C sunt valori naturale. n varianta 0-1 a problemei un obiect poate fi selectat doar n ntregime. n acest caz tehnica greedy nu garanteaz obinerea soluiei optimale. a)Analiza structurii unei soluii optime. Problema selectrii dintre cele n obiecte poate fi redus la problema rucsacului corespunztoare primelor n - 1 obiecte i a capacitii maxime 1 Cn-l C. O soluie optim a problemei iniiale va fi constituit dintr-o soluie optim a subproblemei corespunztoare primelor n - 1 obiecte la care se adaug eventual al n-lea obiect (dac Cn-1 + dn C). Dac soluia subproblemei nu ar fi optim atunci ar putea fi nlocuit cu una mai bun ceea ce ar conduce la o soluie mai bun a problemei iniiale. b)Stabilirea unei relaii de recuren. Fie Vij valoarea obiectelor selectate n soluia optim a problemei corespunztoare primelor i obiecte i capacitii j. Cum soluia optim a problemei corespunztoare lui i poate fi exprimat prin soluia optim a problemei corespunztoare lui i - 1 rezult urmtoarea relaie de recuren pentru Vij: dac j d i < 0 Vi 1, j i = 1, n, j = 1, C Vij = dac j d i 0 max pi + Vi 1, j di , Vi 1, j cu V(0,j) = 0 pentru j = 0,1,..,C iar V(i, 0) = 0, pentru i = 1,2,...,n. Cele dou cazuri din relaia de recuren provin din faptul c o soluie optim a problemei asociate primelor i obiecte i capacitii j poate s nu conin sau s conin obiectul i. n primul caz dimensiunea obiectului i este prea mare pentru ca acesta s poat fi selectat. Astfel valoarea este identic cu cea corespunztoare subproblemei primelor i - 1 obiecte, Vi 1,j. n al doilea caz obiectul i ar putea fi selectat ns el va fi selectat doar dac conduce la o valoare total mai mare dect dac nu ar fi fost selectat. Din acest motiv se analizeaz ambele valori i se alege cea maxim. Valoarea corespunztoare cazului n care obiectul este selectat este obinut adugnd valoarea celui de-al i-lea obiect (pi) la valoarea soluiei problemei corespunztoare celor i - 1 obiecte i capacitii j- di
(capacitatea rmas disponibil dup selectarea obiectului i). VnC reprezint valoarea maxim a unui set de obiecte a cror dimensiuni nsumate nu depete pe C adic valoarea asociat soluiei optime a problemei. c) Dezvoltarea relaiei de recuren. Dac C i di, i=1,2,..,n sunt valori ntregi atunci valorile lui Vij pot fi reinute ntr-o matrice cu n + 1 linii i C + 1 coloane. Algoritmul de construire a tabelului de valori poate fi descris astfel: Tehnica programrii dinamice - 101 -
Proiectarea algoritmilor Tabel_valori (p,d,C,n) FOR i 0,n DO Vi0 0 FOR j 1,C DO V0j 0 FOR i 1,n DO FOR j 1,C DO IF (j < di) THEN Vij Vi-1,j ELSE Vij max Vi 1, j , pi + Vi 1, j di
RETURN V
S considerm cazul n care n = 5, C = 5, dimensiunile obiectelor sunt (2,4,2,1,3) iar valorile asociate (10,20,13,15,18). n acest caz matricea de valori este cu 6 linii i 6 coloane (indiciate de la 0 la 5) i conine elementele: 0 0 0 0 0 0 0 0 10 10 10 10 0 0 10 10 20 20 V = 0 0 13 13 23 23 0 15 15 28 28 38 0 15 15 28 38 38 Pornind de la elementul V55 se poate construi soluia astfel. Se observ c V55 = V45. Aceasta nseamn c obiectul o5 nu este selectat. n schimb V45 V35 adic obiectul o4 este selectat. Aceasta reduce problema la selecia dintre obiectele {o1, o2, o3} pentru un rucsac de capacitate 5 - d4 = 4. Valoarea unei soluii optime a acestei subprobleme este V34 = 23 (se observ c diferena V55 V34 = 38 - 23 = 15 reprezint chiar valoarea obiectului o4). n continuare, se observ c V34 V24 adic obiectul o3 este selectat. Astfel problema se reduce la subproblema corespunztoare setului {o1,o2} i capacitii 4 d3 = 2. Valoarea unei soluii optime a acestei subprobleme este V22 = 10. Cum V22 = V12 i V12 0 rezult c o2 nu este selectat n schimb este selectat o1. Astfel soluia problemei iniiale este {o1, o3, o4} cu dimensiunea total 5 i valoarea total 38. d) Construirea soluiei. Pentru construirea soluiei se analizeaz tabelul de valori construit la etapa anterioar iniiind parcurgerea din VnC dup strategia descris n exemplul de mai sus. Algoritmul poate fi descris prin:
Proiectarea algoritmilor Construire_solutie(V,d,C,n) in {indici matrice V} jC k0 {contor soluie} WHILE j > 0 {ct timp nu se depete cap. rucsac} WHILE Vij = Vi-1,j AND i 1 DO i i-1 k k+1 sk i j j - di i i-1 RETURN s Tehnica funciilor de memorie sau a memoizrii. Principalul dezavantaj al abordrii ascendente este faptul c se bazeaz pe completarea unui ntreg tabel de valori. n aplicaii e posibil ca anumite valori din tabel s nu fie necesare nici n calculul celorlalte valori i nici n construcia soluiei (de exemplu elementele V51, V52, V53 i V54 din tabelul construit pentru problema rucsacului). Dac se folosete abordarea top-down atunci se vor calcula doar valorile asociate subproblemelor care sunt necesare pentru a obine valoarea corespunztoare problemei iniiale. Dar dac o subproblem este ntlnit de mai multe ori atunci ea este rezolvat de fiecare dat. O soluie de compromis care mbin avantajele abordrii ascendente cu a celei descendente este de a dezvolta relaia de recurent ntr-o manier recursiv reinnd fiecare dintre valorile calculate. n felul acesta dac o valoare deja calculat este necesar din nou ea nu va fi recalculat ci se va folosi valoarea reinut anterior. Aceast variant hibrid este cunoscut ca tehnica funciilor de memorie sau tehnica memoizrii. Aplicarea ei n practic const n: iniializarea tabelului cu o valoare virtual ce va fi diferit de valorile ce se vor obine din calcule; n felul acesta se va putea verifica dac o poziie din tabel a fost calculat deja sau nu; calculul valorii corespunztoare soluiei n manier recursiv (cu reinerea valorilor calculate); aceasta presupune c tabelul de valori este o structur global ce poate fi accesat la fiecare apel recursiv. Aplicat la construirea tabelului de valori pentru problema rucsacului aceast tehnic conduce la:
Proiectarea algoritmilor Initializare(n,C) FOR i 1,n DO FOR j 0, C DO Vij -1 FOR j 0, C DO V0j 0 FOR i 0, n DO Vi0 0 RETURN V i calcul_valori(i,j) IF i = 0 OR j = 0 THEN RETURN 0 IF Vij < 0 THEN IF j < di THEN val calcul_valori(i-1,j) ELSE val max{ calcul_valori(i-1,j), pi+ calcul_valori(i-1,j-di)} Vij val RETURN Vij Algoritmul calcul_valori are acces la tablourile d1, d2,...,dn i Vij, i=0,..,n, j=0,..,C. Apelul calcul_valori(n,C) se plaseaz dup iniializarea tabloului. Problema nchiderii tranzitive. Nu doar problemele de optimizare pot fi rezolvate cu tehnica programrii dinamice ci i alte probleme a cror soluie poate fi exprimat n funcie de soluiile unor subprobleme. Considerm o relaie binar R {1, . . . ,n} x {1,. . . ,n}. nchiderea sa tranzitiv este o relaie binar R* {1,..., n} x {1,... ,n} avnd proprietatea: dac pentru i, j {1,..., n} exist il, i2,..., im, {1,..., n} cu proprietile: (i1,i2) R, (i2,i3) R,..., (im-1,im) R iar i = il i j = im atunci (i,j) R*. Pentru a construi R* se consider urmtorul set de relaii binare R0 = R, R1, ..., Rn = R*, definite astfel: dac pentru i, j {1, . . . , n} exist il, . . . ,im, {1, . . . , k} cu proprietile: (i1, i2) R, (i2,i3) R,..., (im-1,im) R iar i=i1 i j=ik atunci (i,j) Rk. Relaiile pot fi descrise prin recurene astfel: (i,j) Rk dac (i,j) Rk-1 sau (i,k) Rk-1 i (k,j) Rk-1. Pentru a elabora algoritmul de construire a lui R* considerm relaiile binare pe {1, 2, . . . ,n} reprezentate prin matrice ale cror elemente sunt definite astfel: dac (i, j ) R 1 rij = dac (i, j ) R 0 Relaiile de recuren pentru construirea matricelor asociate relaiilor binare R0, Rl,.. Tehnica programrii dinamice - 104 -
{Valoare virtual 1}
Proiectarea algoritmilor . , Rn sunt: k k 1 dac rijk 1 = 1 rik 1 = 1 rkj 1 = 1 rijk = k=1,2,..,n 0 altfel 0 cu rij = rij . Folosind aceste relaii de recuren se poate construi matricea asociat relaiei binare Rn, utiliznd doar dou matrice auxiliare astfel:
inchidere_tranzitiva(R,n) R2 R FOR k 1,n DO R1 R2 FOR i 1,n DO FOR j 1,n DO IF R1ij =1 OR (R1ik=1 AND R1kj=1) THEN R2ij 1 ELSE R2ij 0 RETURN R2 Algoritmul pentru determinarea inchiderii tranzitive este cunoscut i sub numele de algoritmul lui Warshall.
9.4. Exerciii
1. Justificai, folosind arborele de apel, c algoritmul comb_rec are complexitate exponenial. k 2. Propunei un algoritm de calculare n manier ascendent a lui Cn pe baza
dac k = 0 sau n = k 1 relaiei de recuren C nk = k folosind ct mai k 1 altfel C n 1 + C n 1 puin spaiu auxiliar. 3. Aplicai tehnica memoizrii pentru irul lui Fibonacci i studiai complexitatea algoritmului obinut. 4. Aplicai tehnica memoizrii pentru calculul costului minim in cazul nmulirii unui ir de matrice. 5. Se consider un set de valori naturale nenule A = (al, a2,,an). S se descompun A n dou subseturi B i C astfel nct sumele elementelor din cele dou subseturi s fie ct mai apropiate. Indicaie. Se reduce la un caz particular al problemei rucsacului: selecia unor obiecte care s maximizeze gradul de umplere al unui rucsac avnd capacitatea egal cu 1 n S = ai (criteriul de optim nu este legat de valorile ci de dimensiunile 2 i =1 obiectelor). Obiectele selectate vor reprezenta subsetul B, iar cele neselectate subsetul
Proiectarea algoritmilor C. Minimiznd diferena dintre suma elementelor din B i valoarea S se minimizeaz de fapt modulul diferenei dintre sumele elementelor celor dou subseturi. 6. Fie A = (al, a2,,am) i B = (bl, b2,,bm) dou iruri de valori. S se determine cel mai lung subir comun al celor dou iruri, adic (cl, c2,,ck) cu proprietatea c exist i1 < i2 <.< ik i j1 < j2 <.< jk astfel nct bq = aiq = bjq. Indicaie. Se noteaz cu T(i,j) numrul de elemente al celui mai lung subir comun al lui (al, a2,,ai) i (bl, b2,,bj) i se folosete relaia de recuren: dac i = 0 sau j = 0 0 T (i, j ) = T (i 1, j 1) + 1 dac ai = bi max{T (i 1, j ), T (i, j 1)} n celelalte cazuri
Proiectarea algoritmilor 10. TEHNICA CUTRII CU REVENIRE 10.1. Introducere Tehnica cutrii cu revenire (numit i tehnica "backtracking") se utilizeaz pentru rezolvarea problemelor printr-o cutare controlat a spaiului soluiilor. n ultim instan este o mbuntire a metodei cutrii exhaustive (metoda forei brute) care permite reducerea numrului de soluii poteniale analizate. Majoritatea problemelor ce pot fi rezolvate prin "backtracking" pot fi reduse la determinarea unei submulimi a unui produs cartezian de forma A1 x A2 x.....x An (cu mulimile Ak finite). Fiecare element al submulimii poate fi vzut ca o soluie (metoda fiind astfel adecvat n special n situaiile n care se dorete determinarea tuturor soluiilor unei probleme i nu numai a unei dintre ele). O soluie este de forma s = (s1, k k s2,...,sn) cu sk Ak = a1k , a2 ,...., amk mk = cardAk. n majoritatea cazurilor nu orice element al produsului cartezian este soluie ci doar cele care satisfac anumite restricii. De exemplu, problema determinrii tuturor permutrilor de ordin n poate fi reformulat ca problema determinrii submulimii produsului cartezian {1, 2,..., n} x... {1, 2,..., n} (Al = A2 = ... = An = {1, 2,..., n}) n care elementele au componentele distincte (restriciile problemei sunt: si sj, pentru orice i j).
10.2. Principiul metodei i structura general a algoritmului Metoda backtracking const n construirea soluiei s completnd succesiv componentele sk pentru k =1,2,...,n. Specificul metodei const n maniera de parcurgere a spaiului soluiilor: Soluiile sunt construite succesiv, la fiecare etap fiind completat cte o component (similar cu tehnica greedy ns ulterior se poate reveni asupra alegerii unei componente) Alegerea unei valori pentru o component se face ntr-o anumit ordine (aceasta presupune c pe mulimile Ak exist o relaie de ordine i se realizeaz o parcurgere sistematic a spaiului A1 x A2 x.....x An) La completarea componentei k se verific dac soluia parial (s1, s2,...,sk,) verific condiiile induse de restriciile problemei (acestea sunt numite condiii de continuare). O soluie parial care satisface condiiile de continuare este denumit soluie parial valid (sau viabil) ntruct poate conduce la o soluie a problemei. Dac au fost ncercate toate valorile corespunztoare componentei k i nc nu a fost gsit o soluie sau dac se dorete determinarea unei noi soluii atunci se revine la componenta anterioar (k-1) i se ncearc urmtoarea valoare corespunztoare acesteia .a.m.d. Aceast revenire la o component anterioar este specific tehnicii backtracking. Procesul de cutare i revenire este continuat fie pn cnd este gsit o soluie (n cazul n care este suficient determinarea uneia) sau pn cnd au fost testate Tehnica cutrii cu revenire - backtracking - 107 -
Proiectarea algoritmilor toate configuraiile posibile. Strategia de construire a soluiilor aplicnd backtracking este similar construirii unui structuri arborescente ale crei noduri corespund unor soluii pariale valide (nodurile interne) sau soluiilor finale (nodurile de pe frontier). Nodurile de pe frontier pot corespunde unor soluii parial invalide. n figura 10.1 este ilustrat modul de parcurgere a spaiului soluiilor n cazul generrii produsului cartezian {a, b, c} x {x, y}. n acest caz, neexistnd restricii, toate nodurile de pe frontier corespund unor soluii.
Figura 10.1 Parcurgerea spaiului soluiilor
n cazul n care sunt specificate restricii anumite ramuri ale structurii arborescente asociate parcurgerii sunt abandonate nainte de a atinge lungimea n. n aplicarea metodei pentru o problem concret se parcurg etapele: se alege o reprezentare a soluiei sub forma unui vector cu n componente se identific mulimile Al, A2, ..., An i relaiile de ordine care indic modul de parcurgere a fiecrei mulimi pornind de la restriciile problemei se stabilesc condiiile de validitate ale soluiilor pariale (condiiile de continuare). n descrierea structurii generale a algoritmului vom folosi notaiile: Ak = k k a1k , a2 ,...., amk , mk reprezentnd numrul de elemente din Ak; k indic componenta curent din s; ik reprezint indicele elementului curent din Ak. Structura general a algoritmului este:
Backtracking(n,A1, A2,, An) k1 {nr. component cutat} ik 0 {index cutare n Ak} WHILE k > 0 DO {ct timp sunt componente la care s se revin} ik ik + 1 valid FALSE WHILE (valid = FALSE) AND (ik mk) DO {cauta comp. k}
sk aik k
Tehnica cutrii cu revenire - backtracking - 108 -
Proiectarea algoritmilor IF (s1, s2,,sk) satisface condiiile de continuare THEN valid TRUE ELSE ik ik +1 IF valid = TRUE THEN IF (s1, s2,,sk) este soluie THEN WRITE S-a gsit o soluie ELSE k k+1 {se trece la urmtoarea component} ik 0 ELSE k k1 {se revine la precedenta} Observaii. n aplicaiile concrete pot interveni urmtoarele situaii: 1. Mulimile A1, A2,...., An, nu sunt neaprat distincte sau elementele lor pot fi generate pe parcursul algoritmului fr a fi necesar transmiterea lor ca argument algoritmului. 2. Condiiile de continuare se deduc din restriciile problemei. 3. Pentru unele probleme soluia este obinut n cazul n care k = n iar pentru altele este posibil s fie satisfcut o condiie de gsire a soluiei pentru k < n (pentru anumite probleme nu toate soluiile conin acelai numr de elemente). 4. La gsirea unei soluii de cele mai multe ori aceast se afieaz sau se reine ntr-o zon dedicat. Dac se dorete identificarea unei singure soluii atunci cutarea se oprete dup gsirea acesteia, altfel procesul de cutare continu prin analizarea urmtoarei valori a ultimei componente completate. Exemplu: generarea permutrilor de ordin n. Caracteristicile acestei probleme sunt: Reprezentarea soluiilor. O permutare de ordin n este un tablou cu n elemente distincte din {1,2,... ,n}. Mulimile Ak Mulimile ce conin componentele soluiilor sunt toate egale cu {1, 2,..., n} A1 =A2= ... = An. Ordinea de parcurgere a elementelor este cea natural: de la cel mai mic ctre cel mai mare element. Restriciile i condiiile de continuare. Dac s = (s1, s2....,sn) este o soluie atunci ea trebuie s respecte restriciile: si sj pentru oricare i j. Un vector cu k elemente, (s1, s2....,sk), poate conduce la o soluie doar dac satisface condiiile de continuare si sj pentru orice i j (i, j {1, . . . ,k}). Vom considera c verificarea condiiilor de continuare va fi efectuat in cadrul unui algoritm de validare. Se observ c este suficient s se verifice c sk este diferit de s1, s2....,sk-1. Condiia de gsire a unei soluii. n acest caz orice vector cu n componente care respect restriciile este o soluie. Deci dac k = n nseamn c a fost gsit o soluie. Prelucrarea soluiilor. Fiecare soluie obinut va fi afiat. ntruct Ak ={1,2,...,n} se poate considera sk = ik. Cu aceste precizri, algoritmul de generare a permutrilor poate fi descris prin: Tehnica cutrii cu revenire - backtracking - 109 -
Proiectarea algoritmilor permutari(n) k1 sk 0 WHILE k > 0 DO sk sk + 1 valid FALSE WHILE (valid = FALSE) AND (sk n) DO IF validare(s1, s2,,sk) THEN valid TRUE ELSE sk sk +1 IF valid = TRUE THEN IF k=n THEN WRITE s ELSE k k+1 sk 0 ELSE k k1 unde funcia de validare poate fi scris: Validare(s,k) FOR i 1, k-1 DO IF sk = si THEN RETURN FALSE RETURN TRUE Varianta recursiv a algoritmului. Datorit faptului c dup completarea componentei k problema se reduce la una similar de completare a componentei k + 1 cu una dintre valorile valide tehnica backtracking poate fi uor descris recursiv. Considernd ca parametru al algoritmului a cta component trebuie completat n cadrul apelului curent i considernd c celelalte date (n, mulimile AI,...,An) au caracter global, algoritmul poate fi descris prin: Backtracking_recursiv(k) IF (s1, s2,,sk) este soluie THEN WRITE S-a gsit o soluie ELSE FOR j 1,mk DO sk a k j IF (s1, s2,,sk) satisface condiiile de continuare THEN Backtracking_recursiv(k+1) Tehnica cutrii cu revenire - backtracking - 110 -
Proiectarea algoritmilor Algoritmul se apeleaz pentru k =1 (completarea soluiei ncepe cu prima component) Backtracking_recursiv(1) Exemplu. Pentru problema generrii perrnutrilor de ordin n varianta recursiv a algoritmului este: Permutari_recursiv(k) IF k=n + 1 THEN WRITE s1,s2,.,sk ELSE FOR j 1,n DO sk j IF validare(s,k) THEN permutari_recursiv(k+1)
10.3. Aplicaii Generarea tuturor submulimilor unei mulimi. Se consider problema determinrii tuturor celor 2n submulimi ale unei mulimi X = {x1, x2,...,xn}. Orice submulime S X poate fi descris prin vectorul caracteristic S = (s1, s2,...,sn) caracterizat prin: dac xk S 1 sk = dac xk S 0 Astfel A1= ... = An = {0,1} i orice vector cu componente 0 sau 1 este o soluie valid (nu se impun restricii) rezult c problema este echivalent cu a genera elementele produsului cartezian A1 x . . . x An = {0, 1}n. Algoritmul poate fi descris prin: submultimi(n) k1 sk -1 WHILE k > 0 DO sk sk + 1 IF sk 1 THEN IF k=n THEN WRITE s ELSE k k+1 sk -1 ELSE k k1 iar varianta recursiv prin: Tehnica cutrii cu revenire - backtracking - 111 -
Proiectarea algoritmilor subm_rec(k) IF k=n + 1 THEN WRITE s1,s2,.,sn ELSE sk 0 subm_rec(k+1) sk 1 subm_rec(k+1) Pornind de la acest algoritm poate fi descris cel pentru generarea tuturor submulimilor cu m elemente (combinri de n luate cte m). Aceast problem se caracterizeaz prin faptul c soluiile satisfac restricia c numrul de componente egale n cu 1 (sau echivalent suma tuturor componentelor) este egal cu m s j = m . Aceast j =1 restricie conduce la condiia de continuare: soluie dac
s
j =1
m . Un vector (s1,s2,...,sk) este
s
j =1
= m . Algoritmul submultimi se modific dup cum urmeaz:
combinari(n,m) k1 sk -1 WHILE k > 0 DO sk sk + 1 IF (sk 1) AND suma(s1,s2,,sk) m THEN IF suma(s1,s2,,sk)=m THEN WRITE s ELSE IF k < n THEN k k+1 sk -1 ELSE k k1
Algoritmul suma(s1,s2,,sk) calculeaz suma elementelor din s pentru indice n domeniul 1,..,k. Se observ c vectorii avnd toate componentele completate (k = n) dar pentru care suma elementelor este diferit de m sunt ignorai. Varianta recursiv se obine uor din subm_rec prin introducerea restriciilor: Tehnica cutrii cu revenire - backtracking - 112 -
Proiectarea algoritmilor comb_rec(k) IF suma(s1,s2,,sk-1)=m THEN WRITE s1,s2,.,sk-1 ELSE sk 0 comb_rec(k+1) sk 1 comb_rec(k+1)
Amplasarea dame lor pe tabla de ah. O problem clasic (enunat de Gauss n 1850) de generare a unor configuraii ce respect anumite restricii este cea a amplasrii damelor pe o tabl de ah astfel nct s nu se atace reciproc. Considerm cazul general n care n, dame trebuie amplasate n cadrul unei matrice ptratice n x n, astfel nct pe nici o linie, pe nici o coloan i pe nici o diagonal s nu se afle dou dame. Reprezentarea soluiei. ntruct pe fiecare linie se va afla exact o dam i toate damele sunt identice este suficient s reinem coloana pe care se afl fiecare dintre ele. Astfel soluia problemei va fi de forma (s1,s2,,sn) unde sk indic coloana pe care se va afla dama de pe linia k. Vectorii corespunztori configuraiilor din figura 10.2 sunt (2,4,1,3) respectiv (3,1,4,2). Pentru valori mai mari ale lui n, numrul configuraiilor devine din ce n ce mai mare (pentru n = 8 exist 92 de configuraii) .
Figura 10.2 Configuraii valide pentru problema damelor (n=4)
Restricii i condiii de continuare. Din modul de reprezentare a soluiilor restricia ca damele s nu fie plasate pe aceeai linie este implicit satisfcut. Condiia ca pe orice coloan s se afle o singur dam este echivalent cu si sj pentru orice i j. n ceea ce privete condiia referitoare la diagonale pornim de la observaia c dou elemente ale unei matrice aflate pe poziiile (i1,j1) respectiv (i2,j2) se afl pe aceeai diagonal dac i1-j1 = i2-j2 sau i1+j1 = i2+j2. Astfel condiia ca dou dame s nu se afle pe aceeai diagonal este: i - si j - sj i i _ si j + sj pentru orice i j. Cele dou relaii sunt echivalente cu | i j | |si sj| pentru orice i j. La completarea componentei k condiiile de continuare sunt: sk si i |k - i| |sk si| pentru orice ki. Descrierea algoritmului Tehnica cutrii cu revenire - backtracking - 113 -
Proiectarea algoritmilor Plasare_dame(n) k1 sk 0 WHILE k > 0 DO sk sk + 1 valid FALSE WHILE (valid = FALSE) (sk n) DO IF validare(s,k) THEN valid TRUE ELSE sk sk + 1 IF valid = TRUE THEN IF k=n THEN WRITE s1,s2,,sn ELSE k k+ 1 sk 0 ELSE kk1 Se observ c structura algoritmului este cea general, pentru A1=A2=...=An= {1,2,...,n}, iar validarea implementeaz condiiile de continuare: Validare(s,k) FOR i 1, k-1 DO IF (sk = si) OR |k-i|=|sk si| THEN RETURN FALSE RETURN TRUE n varianta recursiv algoritmul poate fi descris prin: Dame_rec(k) IF k=n+1 THEN WRITE s1,s2,,sn ELSE FOR i 1,n DO sk i IF validare(s,k) THEN dame_rec(k+1)
Proiectarea algoritmilor Colorarea hrilor. Se consider o hart cu n ri care trebuie colorat folosind m < n culori, astfel nct oricare dou ri vecine s fie colorate diferit. Relaia de vecintate dintre ri este reinut ntr-o matrice n x n ale crei elemente sunt: dac i e vecin cu j 1 vij = dac i nu e vecin cu j 0 Reprezentarea soluiilor. O soluie a problemei este o modalitate de colorare a rilor i poate fi reprezentat printr-un vector (s1,s2,...,sn) cu si {1,..., m} reprezentnd culoarea asociat trii i. Mulimile de valori ale elementelor sunt A1 = .... = An = {1,..., m}. Restricii i condiii de continuare. Restricia ca dou ri vecine s fie colorate diferit se specific prin: si sj pentru orice i i j avnd proprietatea vij = 1. Condiia de continuare pe care trebuie s o satisfac soluia parial (s1,s2,...,sk) este: sk si pentru orice i < k cu proprietatea c vik = 1. Descrierea algoritmului Colorare(n) k1 sk 0 WHILE k > 0 DO sk sk + 1 valid FALSE WHILE (valid = FALSE) (sk n) DO IF validare(s,k) THEN valid TRUE ELSE sk sk + 1 IF valid = TRUE THEN IF k=n THEN WRITE s1,s2,,sn ELSE k k+ 1 sk 0 ELSE kk1 cu algoritmul de validare: Validare(s,k) FOR i 1, k-1 DO IF (sk = si) AND (vik = 1) THEN RETURN FALSE RETURN TRUE n varianta recursiv algoritmul poate fi descris prin: Tehnica cutrii cu revenire - backtracking - 115 -
Proiectarea algoritmilor Colorare_rec(k) IF k=n+1 THEN WRITE s1,s2,,sn ELSE FOR i 1,n DO sk i IF validare(s,k) THEN colorare_rec(k+1) Determinarea tuturor drumurilor dintre dou orae. Se consider o mulime de n orae {o1, o2,...., on} i o matrice binar cu n linii i n coloane care specific ntre care orae exist drumuri directe. Elementele matricei sunt de forma: dac exist drum direct ntre i i j 1 vij = altfel 0 Se pune problema determinrii tuturor drumurilor care leag oraul op de oraul
oq .
Reprezentarea soluiilor. Spre deosebire de problemele anterioare nu toate soluiile au aceeai lungime. O soluie a problemei este de forma s1,s2,,sm cu si {1,2,..,n} indicnd oraul care va fi parcurs n etapa i a traseului.
Restricii i condiii de continuare.. O soluie (s1,s2,,sm ) trebuie s satisfac: s1 = p (oraul de start), sm = q (oraul destinaie), si sj pentru orice i j (nu se trece de dou ori prin acelai ora), vsi si +1 = 1 pentru i = 1,2,.., n - 1 (ntre oraele parcurse succesiv exist drum direct). La completarea componentei k, condiia de continuare este sk si i = 1,2,.., k - 1 i vsk 1sk = 1 . Condiia de gsire a unei soluii nu este determinat de numrul de componente completate ei de faptul c sk = q. n varianta recursiv algoritmul poate fi descris prin: Drumuri_rec(k) IF sk-1 = q THEN WRITE s1,s2,,sk-1 ELSE IF k n+1 THEN FOR i 1,n DO sk i IF validare(s,k) THEN drumuri_rec(k+1) cu validarea specific dat mai jos. nainte de apel se completeaz s1 cu p, iar la apel se specific drumuri_rec(2). Tehnica cutrii cu revenire - backtracking - 116 -
Proiectarea algoritmilor Validare(s,k) IF vsk 1 ,sk = 0 THEN
RETURN FALSE ELSE FOR i 1, k-1 DO IF (sk = si) THEN RETURN FALSE RETURN TRUE
10.4. Exerciii 1. S se modifice algoritmul pentru generarea permutrilor de ordin n astfel nct s fie generate doar permutrile ce nu conin puncte fixe (si i pentru orice i). Indicaie. Este suficient s se modifice algoritmul de validare astfel nct s se verifice n plus c sk k. 2. S se modifice algoritmul pentru generarea permutrilor de ordin n astfel nct s fie generate aranjamentele de n luate cte m. Indicaie. Este suficient s se modifice condiia de gsire a unei soluii din k = n n k = m. 3. Dezvoltai un algoritm bazat pe tehnica backtracking pentru rezolvarea variantei discrete a problemei rucsacului.
Proiectarea algoritmilor EPILOG. SFATURI PENTRU PROIECTAREA ALGORITMILOR 1. Definete complet problema. Aceast indicaie, foarte important n activitatea de programare, pare fr sens pentru unii cititori. Dar nu se poate rezolva o problem dac nu se cunoate aceast problem. Specificarea corect i complet a problemei nu este o sarcin trivial, ci una foarte important i adeseori chiar dificil. Programul trebuie s respecte aceast specificaie, s fie construit avnd tot timpul n fa aceast specificaie, s i se demonstreze corectitudinea n raport cu aceast specificaie, s fie testat i validat innd seama de aceast specificaie. Dac ai primit o sarcin fr specificaii complete atunci s le ceri! 2. Gndete mai nti, programeaz pe urm. ncepnd cu scrierea specificaiilor problemei, trebuie pus n prim plan gndirea. Este specificaia problemei corect? ntre metodele de rezolvare posibile, care ar fi cea mai potrivit scopului urmrit? n paralel cu proiectarea algoritmului demonstreaz corectitudinea lui. Verific corectitudinea fiecrui pas nainte de a merge mai departe. 3. Nu folosi variabile neiniializate. Este vorba de prezena unei variabile ntr-o expresie fr ca n prealabil aceast variabil s fi primit valoare. Este o eroare foarte frecvent a programatorilor nceptori (dar nu numai a lor). Destule compilatoare permit folosirea variabilelor neiniializate, neverificnd dac o variabil a fost iniializat naintea folosirii ei. Alte compilatoare iniializeaz automat variabilele numerice cu valoarea zero. Cu toate acestea nu e bine s ne bazm pe o asemenea iniializare ci s atribuim singuri valorile iniiale corespunztoare variabilelor. Programul realizat trebuie s fie portabil, s nu se bazeze pe specificul unui anumit compilator. 4. Verific valoarea variabilei imediat dup obinerea acesteia. Dac o variabil ntreag trebuie s ia valori ntr-un subdomeniu c1..c2 verific respectarea acestei proprieti. Orice nclcare a ei indic o eroare care trebuie nlturat. Valoarea variabilei poate fi calculat sau introdus de utilizator. n primul caz, verificarea trebuie fcut dup calcul, n al doilea caz se recomand ca verificarea s urmeze imediat dup citirea valorii respectivei variabile. 5. Cunoate i folosete metodele de programare. Este vorba de programarea Top-Down, Rafinarea n pai succesivi, Divide et impera , Bottom-up i mixt, programarea modular, etc. Aceste metode ncurajeaz reutilizarea, reducnd costul realizrii programelor. De asemenea, folosirea unor componente existente (deci testate) mrete gradul de fiabilitate a produselor soft realizate i scurteaz perioada de realizare a acestora. Evident, dac o parte din subalgoritmii necesari programului sunt deja scrii i verificai, viteza de lucru va crete prin Epilog - Sfaturi - 118 -
Proiectarea algoritmilor folosirea lor. Folosete deci bibliotecile de componente reutilizabile existente i construiete singur astfel de biblioteci, care s nglobeze experiena proprie. O bun programare modular elimin legturile ntre dou module prin variabile globale. Se recomand ca fiecare modul s realizeze o activitate bine definit i independent de alt modul. Comunicarea ntre dou module trebuie s se realizeze numai prin mecanismul parametrilor formali-actuali. 6. Amn pe mai trziu detaliile nesemnificative . Aceast regul stabilete prioritile de realizare a componentelor unui program; n primul rnd se acord atenie aspectelor eseniale, ncepnd cu modulul principal. n fiecare faz d atenie lucrurilor importante. De exemplu, este inutil s se piard timp cu scrierea unor pri de program pentru tiprirea rezultatelor i a constata ulterior c rezultatele nu sunt cele dorite, sau nu sunt corecte. Nu uita ns c pentru beneficiar "Detaliile nesemnificative sunt semnificative". Beneficiarii in foarte mult la forma rezultatelor i, adeseori, judec programatorii dup aceast form. E pcat de munca depus dac tiprirea rezultatelor las o impresie proast asupra beneficiarului. 7. Evit artificiile. Prin folosirea artificiilor n programare, a prescurtrilor i simplificrilor se pierde adesea din claritatea programului i, mult mai grav, uneori se ajunge chiar la introducerea unor erori. n plus se poate pierde portabilitatea programului. Exist ns situaii n care prin anumite artificii se ctig eficien n execuie sau se face economie de memorie. Dac acest fapt este important atunci artificiile sunt binevenite, n caz contrar nu se recomand folosirea lor. 8. Folosete constante simbolice. Folosirea intensiv a constantelor simbolice este recomandat oriunde n textul surs trebuie scris un numr (la declararea tablourilor, la precizarea limitelor de variaie a unor variabile, etc.). Prin utilizarea acestor constante se mrete gradul de generalitate a textului scris, iar n situaia n care valoarea unei constante trebuie schimbat, modificarea este mult mai uoar (doar la locul definiiei constantei) i nu duce la erori. Ea implic numai definiia constantei, nu modificarea valorii concrete n toate instruciunile programului. 9. Verific corectitudinea algoritmului i programului n fiecare etap a elaborrii lor. Detectarea i eliminarea unei erori imediat dup comiterea ei duce la creterea vitezei de realizare a produsului, evitndu-se activiti inutile de depanare. Se recomand demonstrarea corectitudinii fiecrui algoritm folosit, ntruct erorile semnalate n timpul testrii sunt adeseori greu de descoperit i, cteodat, imposibil de eliminat altfel dect prin rescrierea modulului sau programului respectiv. Urmeaz testarea fiecrui subprogram imediat Epilog - Sfaturi - 119 -
Proiectarea algoritmilor dup ce a fost scris (codificat). Acest lucru se potrivete codificrii bottom-up i sugereaz o abordare sistematic a activitii de codificare. Dac pentru proiectare se pot folosi oricare dintre metodele indicate, n codificare (i testarea aferent codificrii), abordarea de jos n sus este esenial. Sugerm ca aceast testare s se fac independent de programul n care se va folosi subprogramul testat. Este adevrat c activitatea de testare necesit un anumit timp, dar ea este util cel puin din trei puncte de vedere: - scoate n eviden erorile provocate de proiectarea algoritmului sau codificarea neadecvat a acestuia; - faciliteaz detectarea erorilor, deoarece dimensiunea problemei este mai mic; n fapt nu se pierde timp cu scrierea unui program de test, ci se ctig timp, deoarece la fiecare nivel de detaliere se vor folosi numai componente testate deja; ceea ce rmne de testat la nivelul respectiv este gestiunea corect a apelurilor respectivelor componente; - oblig implementatorul s gndeasc nc o utilizare (cel puin) a respectivului subprogram, independent de cea pentru care a fost iniial conceput. 10. Folosete denumiri sugestive pentru identificatorii utilizai n program. Fiecare identificator (nume de variabil, de tip de date, de constante, de subprograme) i are rolul i semnificaia lui ntr-un program. E bine ca denumirea s reflecte aceast semnificaie, mrind astfel claritatea textului programului. Unii programatori exagereaz ns, folosind identificatori lungi, obinui prin concatenarea mai multor cuvinte. E clar c denumirea ales red semnificaia variabilei, dar claritatea textului scade, lungimea programului crete i citirea lui devine greoaie. 13. Cunoate i respect semnificaia fiecrei variabile. Fiecare variabil are o semnificaie. n demonstrarea corectitudinii algoritmului aceast semnificaie se reflect, de cele mai multe ori, printr-un predicat invariant. O greeal frecvent fcut de unii programatori const n folosirea unei variabile n mai multe scopuri. 14. Folosete variabile auxiliare numai acolo unde este strict necesar. Fiecare variabil trebuie s aib o semnificaie proprie, iar n demonstrarea corectitudinii programului, acesteia i se ataeaz un invariant, care trebuie verificat. Folosirea necontrolat a mai multor variabile auxiliare, ruperea unor expresii chiar lungi n subexpresii cu diferite denumiri, pot duce la reducerea claritii programului. 15. Prin scriere red ct mai fidel structura programului. Importana indentrii i spaierii pentru claritatea programului au fost artate anterior. Fiecare programator trebuie s aib propriile reguli de scriere, care s scoat ct mai bine n eviden structura programului i funciile fiecrei pri a acestuia.
Epilog - Sfaturi - 120 -
Proiectarea algoritmilor 16. Nu uita s testezi programul chiar dac ai demonstrat corectitudinea lui. Sunt cunoscute demonstraii greite pentru unele teoreme celebre din matematic. i o demonstraie a corectitudinii unui program poate fi greit. Dar, chiar dac demonstrarea corectitudinii algoritmului este valid, programul poate conine greeli de codificare, de introducere (tastare) sau pot fi alte cauze care genereaz erori. 17. Nu recalcula limitele i nu modifica variabila de ciclare n interiorul unei structuri repetitive dat prin propoziia FOR O astfel de practic poate duce la erori greu de detectat i ncalc regulile programrii structurate. Atunci cnd este necesar schimbarea variabilei de ciclare sau a limitelor se recomand folosirea uneia din structurile repetitive REPEAT sau WHILE <condiie> DO. 18. Nu iei forat din corpul unei structuri repetitive redat prin propoziia FOR Instruciunea FOR corespunde unui numr cunoscut de execuii ale corpului ciclului. n situaia cnd corpul conine i testarea condiiei de continuare a ciclrii, recomandm a se folosi structurile REPEAT sau WHILE ... DO i nu FOR. 19. Elaboreaz documentaia programului n paralel cu realizarea lui. Aa cum s-a artat n mai multe locuri din acest material, pe durata de via a unui program se iau mai multe decizii. E bine ca aceste decizii s rmn consemnate mpreun cu rezultatul final al fiecrei faze din viaa programului (specificarea problemei, proiectarea algoritmilor, programul propriu-zis, datele de test folosite). Vor rezulta documentaii de analiz, proiectare, implementare i exploatare. Primele trei sunt necesare la ntreinerea aplicaiei, trebuind a fi actualizate ori de cte ori se produc modificri, iar ultima este necesar celor care exploateaz aplicaia. Pe lng acestea, un program bun va trebui s posede i o component de asisten on-line (funcie help), care contribuie la asigurarea a ceea ce am numit interfa prietenoas. 20. Folosete comentariile. Rolul comentariilor a fost explicat n seciunea 4.4. Este foarte greu s descifrm un program lipsit de comentarii, chiar dac este vorba de propriu; program scris n urm cu cteva luni sau ani de zile. Orice program sau modul trebuie s fie nsoit de comentarii explicative dac dorim s-l refolosim i nu trebuie s scriem programe care s nu poat fi refolosite. Minimum de comentarii ntr-un modul trebuie s conin specificarea acestui modul i semnificaia fiecrei variabile.
Epilog - Sfaturi - 121 -
Proiectarea algoritmilor EXERCIII SUPLIMENTARE 1. Stabilirea complexitii unui algoritm 1.1. Se consider algoritmul pentru calculul produsului scalar al doi vectori, de dimensiune n:
n r r v1 v2 = v1i v2i i =1
Funcia care genereaz produsul scalar, n pseudocod este: produs _ scalar (v1, v 2, n) 1 : ps 0 | stocare produs scalar
2 : FOR i = 1, n 3: || ps ps + v1i v 2i RETURN ps S se stabileasc complexitatea algoritmului, considernd toate operaiile cu cost egal.
Rezolvare Notnd instruciunile cu 1, 2, 3 vom avea numrul de operaii: 1: 1 2: 2(n+1) 3: 3n Pentru instruciunea FOR s-au considerat 2 operaii pentru fiecare valoare a lui i: incrementare i verificarea i n. Operaia se execut pn i=n+1. Pentru instruciunea 3-a s-a inut seama c avem 3 operaii pentru fiecare valoarea a lui i: o nmulire, o adunare i o atribuire. Sumnd obinem: T(n) = 5n+3 Rezult T(n) (n). 1.2. S se scrie i s se determine complexitatea pentru algoritmul de ortonormare r r r prin procedeul Gramm-Schmidt. Vectori de intrare: v1 , v2 ,.., vn . Vectorii r r r ortonormai de ieire: d1 , d 2 ,.., d n . Acetia au proprietatea: r r 1 daca i = j di d j = 0 daca i j Calculul vectorilor ortonormai se face iterativ cu relaiile:
Exerciii suplimentare
- 122 -
Proiectarea algoritmilor r r v1 d1 = r v1
r r i 1 r r r ui = vi vi d k d k , i = 2,.., n r r ui d i = r , i = 2,.., n ui
k =1
Rezolvare Folosim tehnica rafinrii unui algoritm n subalgoritmi. ntruct avem n vectori cu n componente vom folosi matrice ptrate pentru memorarea unui sistem de r vectori (v ,d ,u) notate cu [V], [D], [U]. Un vector oarecare vi va fi memorat n coloana i a matricei [V]. r Mai nti scrie funcia care determin modulul unui vector vi : valabs (v, n, i )
1: a 0 2 : FOR k = 1, n 3: 4:
2 || a a + vki
a a RETURN a
r r u Procedura de calcul a vectorului de lungime unitar: d i = ri ui norm(u, d , n, i ) 1 : mu valabs(u, n, i ) 2 : FOR k = 1, n u 3: || d ki ki mu RETURN d De remarcat c procedura de mai sus modific numai coloana i din matricea [D]. r r Procedura pentru produsul scalar, descris la problema 1, dintre vectorii ui , d k va fi: produs _ scalar (u, d , n, i, k ) 1 : ps 0 | stocare produs scalar
2 : FOR j = 1, n 3: || ps ps + u ji d jk RETURN ps
Exerciii suplimentare - 123 -
Proiectarea algoritmilor Algoritmul principal va fi: Ortonormare(v, d , n)

1 : d norm(v, d , n,1) 2 : FOR i = 2, n 3: 4: 5: 6: || FOR k = 1, n || || u ki vki || FOR k = 1, i 1 || || ps produs _ scalar (v, d , n, i, k )
r r v1 | d1 = r v1
r r | ui = vi r r | vi d k
i 1 r r r | ui vi d k d k
7: 8: 9:
|| || FOR j = 1, n || || || u ji u ji ps d jk || d norm(u , d , n, i ) RETURN d
r r ui | di = r ui
k =1
Scriem complexitatea pe module. Numrul de operaii: a. Procedura valabs 1: 1 2: 2(n+1) 3: 3n 4: 2 T1(n) = 5n + 5
| ridicare la ptrat, adunare i atribuire | radical i atribuire
b. Procedura produs_scalar T2(n)=5n+3 | a se vedea problema 1.1 c. Procedura norm 1: T1(n)+1 | modul+atribuire 2: 2(n+1) 3: 2n | mprire i atribuire T3(n)=5n+5+4n+3=9n+8 Algoritmul principal: 1: T3(n)+1=9n+9=9(n+1) 2: 2n 3: (n-1) 2(n+1) 4: (n-1) n
- 124 -
Proiectarea algoritmilor 5: 6: 7: 8: 9:
i=2
2 i = 2 (i + 1) = n (n 1) + 2 (n 1) = (n + 2) (n 1)
i =1 n n 1 i =1 i=2
n 1
[T 2(n) + 1] (i 1) = [T 2(n) + 1] i = n (n 1) (5 n + 4)
2
i = 2 k =1 n i 1 n
2 (n + 1) =2 (n + 1) (i 1) = 2 (n + 1) i = (n 1) n (n + 1)
i=2 i =1
i = 2 k =1 j =1
n i 1
n 1
3 = 3 n = 2 (n 1) n 2
i = 2 k =1
n i 1
(n 1) [T 3(n) + 1] = (n 1) (9 n + 9) = 9 (n 1) (n + 1)
T (n) = 5 n 3 + 11 n 2 + 8 n 4
Rezult T(n) (n3).
1.3. S se stabileasc complexitatea algoritmului pentru verificarea dac un numr este prim, dat mai jos:
prim(n) 1: r T 2: i 2 3: p n 4 : WHILE (i p ) and (r = T ) 5: || IF n mod i = 0 6: || || r F 7: || i i + 1 RETURN r
[ ]
Rezolvare Numrul de operaii pentru procedura prim: 1: 1 2: 1 3: 3 | radical, partea ntreag, atribuire 4: p3 | 3 operaii logice pentru n prim 23 | pentru n divizibil cu 2 5: 2(p-1) | calcul rest +testare rest=0, pentru n prim | pentru n divizibil cu 2 2 6: 1 | pentru n neprim 7: p-1 | pentru n prim | pentru n divizibil cu 2 1
- 125 -
Proiectarea algoritmilor Cazul cel mai favorabil n divizibil cu 2: T(n) = 15 Cazul cel mai nefavorabil n prim: T(n) = 5+3p+3(p-1) = 6p+2
15 T ( n) 6 n + 2
Rezult T (n) O n i T (n) (15) .

2. Sortare 2.1. S se scrie algoritmul pentru sortarea unor nregistrri care conin: marca, nume i prenume, salariu. Sortarea se va face n ordinea descresctoare a salariului i, pentru acelai salariu, n ordinea alfabetic a cmpului nume+prenume. Datele sunt memorate sub forma unor nregistrri avnd cele 3 cmpuri.
( )
Rezolvare Dac considerm irul care memoreaz nregistrrile xi, i=1,2,..,n, atunci accesarea informaiilor relative la o marc se va face sub forma x.marca, x.nume_prenume, x.salariu. Se va realiza mai nti sortarea dup salariu, iar apoi, pentru mrcile care au acelai salariu, se realizeaz sortarea, n ordine alfabetic, dup nume+prenume. Vom folosi metoda de sortare prin inserie. Vom folosi un fanion pe poziia x0. Algoritmul este prezentat mai jos:
sortare _ personal ( x, n) FOR i = 2, n || x0 xi || k i 1 || WHILE xk .salariu < x0 .salariu || || xk +1 xk || || k k 1 || xk +1 x0 k 1 | sortare dupa nume in ordine crescatoare WHILE k n 1 || i k + 1 || WHILE ( xi .salariu = xi 1.salariu ) and (i n ) | cat timp salariul este acelasi || || i i + 1 | sortare dupa salariu metoda insertiei
- 126 -
Proiectarea algoritmilor || IF i > k + 1 || || sort _ num( x, k , i 1) | sortare dupa nume la aceleasi salariu || k i RETURN x Sortare prin metoda inseriei, cresctor dup nume, pentru persoanele care au acelai salariu, variabile cu indice cuprins ntre k i i.
sort _ num( x, k , i ) FOR m = k + 1, i || x0 xm || n m 1 || WHILE ( xn .nume _ prenume > x0 .nume _ prenume ) and (n k ) || || x n +1 xn || || n n 1 || xn +1 x0 RETURN x
2.2. S se sorteze n ordine cresctoare un ir cu date referitoare la laturile ale unei reele electrice. irul de intrare este citit dintr-un fiier ASCII, secvenial, cu numele fsir. irul rezultant va fi memorat dinamic prin variabile nlnuite n memorie prin pointeri, sub forma:
p nod1 nod2 record 1 next nod1 nod2 record 2 next nod1 nod2 record n nil
unde nod1, nod2 reprezint marca nodurilor (valori numerice, cu maxim 5 cifre), iar record 1, record 2,.., record n, cmpuri compuse care conin informaii despre laturile delimitate de nodurile respective. Variabilele p i next sunt adrese ale nregistrrilor n memorie. Cheia de sortare va fi cmpul compus nod1 + nod2, adic nod1 cresctor i pentru acelai nod1, nod2 n ordine cresctoare. Nil indic c nu mai urmeaz nici o nregistrare. Rezolvare Avnd n vedere c sortarea se face cresctor n raport cu nod1 i nod2, avem 2 variante de sortare. Prima variant este de a genera irul memorat dinamic sortat n raport cu nod1 i apoi sortarea n raport cu nod2 pentru valorile multiple ale lui nod1, adic principiul utilizat la problema 2.1. O alt variant este de a genera direct cheia compus prin concatenarea, de exemplu, a irurilor de caractere aferente numerelor nod1 i nod2. Vom prezenta n continuare ce-a de-a doua variant. Vom nota cu x^.camp valoarea unui cmp (nod1, nod2, record) din nregistrarea dinamic x. Semnificaia notaiei este acceseaz cmpul camp de la adresa x. Exerciii suplimentare - 127 -
Proiectarea algoritmilor Procedura de generare a unei chei compuse denumit ntostr (numeric to string) este:
ntostr (nod1, nod 2) r str (nod1,5) + str (nod 2,5) RETURN r
Prin funcia str(n,5) se convertete cmpul numeric n ntr-un ir pe 5 caractere. irul generat are spaii n fa dac n<10000. De exemplu ntostr(17,35) = 17 35. Procedura sortlat este prezentat pe pagina urmtoare. De precizat c n procedura prezentat s-a considerat c funcia EOF(fisier) genereaz T la citirea ultimei nregistrri valide. Exist medii de dezvoltare (de exemplu FOX) n care funcia EOF (sau similar) genereaz T la ncercarea de citire a unei nregistrri aflat dup ultima nregistrare valid. n acest caz funcia READ aflat dup WHILE NOT EOF(fsir) trebuie amplasat naintea buclei, iar n interiorul buclei va fi amplasat o instruciune de citire la sfritul ei. sortlat | deschide fisier ASCII sursa OPEN fsir | aloca memorie pentru o inregistrare dinamica NEW x | memoreaza in p adresa primei inregistrari px | citeste o inregistrare din fisierul sursa READ fsir , nod1, nod 2, record | se memoreaza prima inregistrare citita x ^.nod1 nod1 | in x x ^.nod 2 nod 2 x ^.record record | marcheza ca ultima inregistrare x ^.next nil | cat timp nu s a ajuns la sfarsitul fsir WHILE NOT EOF ( fsir ) || READ fsir , nod1, nod 2, record || NEW x || x ^.nod1 nod1 | se memoreaza inregistrare citita || x ^.nod 2 nod 2 || x ^.record record
|| xs p || WHILE ( xs ^.next nil ) and ntostr ( xs ^.nod1, xs ^.nod 2) < ntostr ( nod1, nod 2) | pozitionare in sir int re xs si xm || || xm xs || || xs xs ^.next
- 128 -
Proiectarea algoritmilor || x ^.next xs || IF xs = p
| " agata" inregistrarea urmatoare | pozitionare la inceput | pozitionare in sir sau la sfarsit
|| ||
|| p x || xm^.next x
|| ELSE
3. Reducere i divizare 3.1. S se scrie o procedur pentru calcul xn , x R, n N, care aib clasa de complexitate (lgn).
Rezolvare Descompunem de n dup puterile lui 2:
n=
k =0
ak 2 k , unde
ak 2 k
m m m 1
m =[ lgn] (logaritm n baza 2), iar ak=0 sau 1.
x n = x k =0 = x a m 2 x a m1 2 x a1 2 x a 0 Avnd n vedere c descompunerea unui numr n baza 2 prin mprire repetat la 2 ne d mai nti puterile mici, rezult c va trebuie s reinem la un pas k, k=0,1,..,m
valoarea x 2 = x 2 x 2 pentru generarea succesiv a factorilor. Totodat, ntr-o alt variabil trebuie rezultatul curent al ridicrii la putere innd seama de coeficienii ak. Algoritmul este prezentat mai jos:
k k 1 k 1
putere( x, n) sx p 1 cn WHILE c > 0 || r c mod 2 c || c 2 || IF r > 0

|| || p p s || s s s | x ai 2 | x2
i =0 i =0 k +1 i k i
| factorul x 2 , initial k = 0 | factor ce retine x n , initial 1 | catul impartirii lui n la 2 k , initial n | coeficientul ak
RETURN p
Exerciii suplimentare - 129 -
Pentru a aprecia complexitatea, observm c ciclul WHILE se repet de m+1 ori (numrul de cifre ale lui n n baza 2). Toate instruciunile din ciclu se execut de m+1 ori, mai puin instruciunea p=ps care se execut de m+1 ori pentru n=2m+1-1 i se execut o dat pentru n=2m. Rezult: a (m + 1) + c + 1 T (n) (a + 1) (m + 1) + c
a (lg n + 1) + c + 1 T (n) (a + 1) (lg n + 1) + c T (n) (lg n ) a- numrul de operaii din ciclul WHILE care nu depind de valoarea lui n c- numrul de operaii din afara ciclului WHILE
3.2. S se stabileasc un algoritm pentru rezolvarea ecuaiei, f(x)=0, cunoscndu-se dou valori ale lui x, a i b, b > a, cu f(a)f(b) < 0, adic soluia se afl n intervalul [a,b]. Se va folosi metoda njumtirii intervalului, limitele noului interval se vor calcula astfel: a+b a+b a , daca f (b) f <0 2 2 a+b a+b b , daca f (a) f <0 2 2 Algoritmul se va opri atunci cnd |a-b| < . S se aprecieze complexitatea algoritmului (se vor considera numai iteraiile de baz).
Rezolvare Algoritmul de rezolvare a ecuaiei, prim metoda njumtirii intervalului este: rez _ ec( f , a, b) IF f (a) f (b) > 0 || WRITE " Interval de cautare eronat!" ELSE || WHILE b a >
a+b || || IF f f (a) > 0 2 a+b || || || a 2 || || ELSE a+b || || || b 2 a+b RETURN 2
- 130 -
Proiectarea algoritmilor Numrul de repetri ale ciclului WHILE, notat cu m, este dat de inegalitatea: a b a b a b < 2m > m > lg m 2 Rezult o complexitate logaritmic n raport cu precizia impus procesului de calcul.
3.3. S se gseasc un algoritm rapid pentru separarea elementelor unui ir de numere x1, x2, .., xn n dou subiruri n raport cu o valoare dat a. Valorile mai mici ca a sunt n primul subir, iar cele mai mari sau egale cu sunt n cel de-al doilea.
Rezolvare sep _ sir ( x, n, a ) i 1 jn WHILE i < j || WHILE ( xi < a ) AND (i < n )

|| || i i + 1 || WHILE x j a AND ( j > 1)
|| || j j 1 || IF i < j || || m xi || || xi x j IF (i = n ) AND (a > xn ) || i n + 1 RETURN i Vom folosi tehnica de partiionare a unui ir prezentat n cadrul metodei de sortare Quiksort. Algoritmul, adaptat, datorit faptului ca a poate fi oarecare, este prezentat mai sus. Algoritmul returneaz valoarea indicelui pentru care ncepe ce de-al doilea subir. Cele dou subiruri vor fi: x1, x2,...,xi-1 i xi, xi+1,..,xn. Dac a este mai mic ca orice element al irului atunci se returneaz 1, iar irul nu se modific. Dac a este mai mare ca orice element al irului atunci se returneaz n+1, iar irul nu se modific. || || x j m
4. Tehnica greedy 4.1. S se calculeze suma componentelor prime din irul de numere naturale x1, x2,..,xn. Atunci cnd un numr prim se repet, el va fi luat n consideraie o singur dat.
- 131 -
Proiectarea algoritmilor Rezolvare Deoarece trebuie eliminate dublurile, pentru a evita cutarea repetat n irul selectat, este mai bine s sortm irul de intrare. suma _ prime( x, n) sortare( x, n) IF prim( x1 ) || S x1 ELSE || S 0 i2 WHILE i n || IF ( xi xi 1 ) AND prim( xi ) || || S S + xi || i i + 1 RETURN S O procedur pentru verificarea unui numr c este prim sau nu a fost prezentat n exemplul de la pct. 1.3. De remarcat c sortarea se poate face n ordine cresctoare sau descresctoare, fiind indiferent ordinea n acest caz.
4.2. O singura staie de servire (de exemplu pompa de benzina) trebuie sa satisfac cererile a n clieni. Timpul de servire necesar fiecrui client este cunoscut n prealabil: pentru clientul i este necesar un timp ti, 1 i n. S se scrie un algoritm care s stabileasc timpul minim de ateptare i ordinea servirii n acest caz.
Rezolvare O prim variant de rezolvare este utilizarea forei brute: generarea tuturor variantelor de servire i alegerea variantei n care timpul total de ateptare este minim. Timpul total de ateptare, ntr-o variant de servire oarecare, va fi:
Ta = t ai = ti
i =1 i =1 k =1
Suma dup k n relaia de mai sus se face n ordinea servirii. Aplicarea metodei fora brut conduce la evaluarea timpilor de ateptare n n! situaii, rezultnd un timp de calcul factorial. ntruct timpii de ateptare pentru clienii servii la urm cuprind timpi de servire pentru clienii din fa, rezult imediat c servirea n ordinea cresctoare a timpilor de servire conduce la timpi totali de ateptare mai mici. Dac ar fi servii nti clienii cu timpi de servire mari, aceti timpi s-ar aduna la timpii de ateptare pentru toi clienii. Exerciii suplimentare - 132 -
Proiectarea algoritmilor Algoritmul care ine seama de ordinea de servire este prezentat mai jos: servire(t , n) sortare(t , n) | sortare crescatoare dupa timpii de servire Ta 0 | initializare timp total de asteptare
FOR i = 1, n || FOR k = 1, i || || Ta Ta + t k RETURN Ta
4.3. Se dau n numere ntregi nenule b , b , b i m numere ntregi nenule a ,a .
1 2 n 1 2
| calcul timp de asteptare
a . S se determine valoarea maxim a expresiei, E = a x + a x + . + a x

m 1 1 2 2
pentru valorile x din mulimea B= {b , b b }, unde n > m i x {b , b , ,b }

n i 1 2 n i 1 2
m m
Rezolvare ntruct produsele aixi sunt independente, vom obine maximul sumei ca suma maximelor produselor. Pentru fiecare valoare a lui a vom alege o valoare din mulimea B care s maximizeze produsul. sum _ prod (a, b, m, n) E 0
FOR i = 1, m || pm ai b1 || FOR k = 2, n || || IF pm < ai bk || || || pm = ai bk || E E + pm RETURN E De remarcat c dac toi ai > 0, i=1,2,..,m atunci va fi ales o singur valoare din B. Similar dac toi ai < 0, i=1,2,..,m.
- 133 -
Proiectarea algoritmilor 5. Tehnica programrii dinamice

5.1. S se stabileasc succesiunea optim de nmulire a matricelor A,B,C,D,E de dimensiuni 10 x 5, 5 x 90, 90 x 3, 3 x 40, 40 x 2.
Rezolvare Avem dou variante de rezolvare: a. Tehnica forei brute studierea tuturor combinaiilor de efectuare a nmulirilor i alegerea alelei variante n care numrul de nmuliri este mai mic b. Aplicarea tehnicii programrii dinamice i stabilirea succesiunii optime de efectuare a nmulirilor. n prima variant numrul de variante de grupare este dat de: 1 n 1 1 4 K (n) = C 2n 1) = C8 = 14 ( n 5 Rezult variantele: Nr. Parantezare Nr. nmuliri 1 ((((AB)C)D)E) 9200 2 ((AB)((CD)E)) 24300 3 ((AB)(C(DE))) 7080 3 (((AB)(CD))E) 52100 4 (((AB)C)(DE)) 7500 5 ((A(BC))(DE)) 1800 6 (((A(BC))D)E) 3500 7 (A(((BC)D)E)) 2450 8 ((A((BC)D))E) 4750 9 ((A(B(CD)))E) 31600 11 (A((B(CD))E)) 29300 12 (A(B((CD)E))) 19000 13 (A((BC)(DE))) 1720 14 (A(B(C(DE)))) 1780 Pentru calculul acestor variante au fost necesare 148=112 nmuliri +143=42 adunri. Valoarea optim este poz. 13, cu numrul minim de nmuliri 1720. n varianta b aplicm tehnica programrii dinamice i utilizm relaia de recuren pentru determinarea succesiunii optime a produsului de matrice. Numrul de nmuliri pentru produsul matricelor i..j. 0 daca i = j cij = min cik + ck +1, j + pi 1 pk p j daca i < j ik < j Rezultatele acestui calcul le trecem n matricea c:
- 134 -
0 4500 1500 2700 1720 0 1350 1950 1620 c= 0 10800 780 0 240 0 0 1 1 3 1 0 2 3 3 s= 0 3 3 0 4 0
Mrimile p0, p1, p2, p3, p4, p5 sunt date de dimensiunile matricelor: 10,5,90,3,40,2. Simultan vom completa i matricea s. Valorile lui s sunt valorile optime ale lui k din relaia de recuren i indic cum se mparte gruparea respectiv, adic dup care matrice, numrat din stnga, se pune paranteza. Calculul termenilor din matricea c: Se calculeaz direct termenii situai imediat deasupra diagonalei: s12=1 c12 = 10590=4500 s23=2 c23 = 5903 = 1350 s34=3 c34 = 90340=10800 s45=4 c45 = 3402= 240 Termenii urmtori se calculeaz utiliznd relaia de recuren: c13 = min{c11+c23+p0p1p3, c12+c33+ p0p2p3} = min{1350+1053,4500+10903} = = min{1500,7200}=1500 s13=1 c24 = min{c22+c34+p1p2p4, c23+c44+ p1p3p4} = min{10800+59040,1350+5340} = = min{28800,1950}=1950 s24=3 c14 = min{c11+c24+p0p1p4, c12+c34+ p0p2p4, c13+c44+ p0p3p4} = min{1950 + 10540, 4500+ 10800 + 109040,1500+10340} = min{3950,51300,2700}=2700 s14=3 c35 = min{c33+c45+p2p3p5, c34+c55+ p2p4p5} = min{240+9032,10800+90402} = = min{780,18000}=780 s35=3 c25 = min{c22+c35+p1p2p5, c23+c45+ p1p3p5, c24+c55+ p1p4p5} = min{780 + 5902, 1350+ 240 + 532,1950+5402} = min{1680,1620,2350}=1620 s25=3 c15 = min{c11+c25+p0p1p5, c12+c35+ p0p2p5, c13+c45+ p0p3p5, c14+c55+ p0p4p5} = min{1620 + 1052, 4500+ 780 + 10902,1500+240+1032,2700+10402} = = min{1720,7080,1800,3500}=1720 s15=1 Valoarea optim este c15 = 1720 nmuliri. Parantezarea optim se obine din matricea s: - pentru gruparea 1-5, paranteza este dup matricea 1 (s15=1) A(BCDE) - pentru gruparea 2-5, paranteza este dup matricea 3 (s25=3) A((BC)(DE)) Numrul de nmuliri efectuate pentru obinerea soluiei optime: 202=40
- 135 -
Proiectarea algoritmilor Numrul de adunri: 20 Se constat c soluia optim obinut prin cele dou metode este aceeai, ns volumul de calcule este semnificativ mai mic prin programarea dinamic (40+20=60 < < 112+42= 154 operaii).
5.2. Un ho ptrunde ntr-un magazin i poate fura n produse cu valorile vi , i=1,2,..,n i greutile gi, i=1,2,..,n. Numrul de produse de fiecare tip, xi, i=1,2,..,n afle n magazin sunt ai, i=1,2,..,n. S se stabileasc selecia optim de
produse astfel nct valoarea s fie maxim, iar greutatea total
g i xi s fie
i =1
cel mult egal cu greutatea maxim pe care o poate cra houl, G. Se va rezolva problema pentru n=5, v = (7 4 3 9 2) [mil. lei/buc], a=(2, 3, 1, 5, 3) [buc], g=(4 2 1 5 3) [kg/buc], G=10 kg. Rezolvare Modelul matematic al problemei de optimizare este:
f = vi xi = max!
i =1 n
g i xi G
i =1
0 xi ai , i = 1,2,.., n mprim greutatea total G n 10 coloane, fiecare coloan nsemnnd 1 kg, m=G/1=10. Vom construi matricea valorilor V i matricea deciziilor D de dimensiuni n x (m+1). Iniial Vik=-, Dik=0, i=1,2,..,n, k=0,1,2,..,m. Relaiile de recuren sunt: k V1, k = v1 g1
k k D1, k = g1 , a1 g1 g1 j Vi , k = max Vi 1, k j + vi , gi j
ai gi
j = 0,1,.., k
j Di , k = g i , gi i = 2,3,.., n
j pentru care se obtine mimiul pt. Vi , k
n relaiile de mai sus, [x] reprezint partea ntreag a valorii x. n final se obin valorile xi, i=n,n-1,..,1.
- 136 -
xn = 1 Dn, m gn
k =n
li 1 = xi =
xk g k ,
i = n 1, n 2,...,1
1 Di , l i gi
f max = Vn, m
Prin aplicarea relaiei iterative, rezult matricele V i D: 0 0 V = 0 0 0 0 0 D = 0 0 0 0 0 0 7 7 7 7 14 14 14 15 15 19 15 18 19 16 18 20 16 18 20 8 8 4 6 1 0 0 5 0 0
0 4 4 8 8 12 12 3 4 7 8 11 12 15 3 4 7 8 11 12 15 3 4 7 8 11 12 15
0 0 0 4 4 4 4 8 0 2 2 4 4 6 6 4 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 5 0 0 0 0 0 0 0 0
Detalierea calculului iterativ k k V1, k = v1 = 7, k = 0,1,2,.., m 4 g1 V1 = (0 0 0 0 7 7 7 7 14 14 14 )
k k k D1, k = g1 = 4, k = 0,1,2,..., m, 2 4 4 g1 D1 = (0 0 0 0 4 4 4 4 8 8 8)
V2, k =
j a2 g2
max V1, k j + v2 g 2 = max V1, k j + 4 2 ,

j 2 3
j = 0,1,.., k
0 V2,0 = V1,0 + 4 = 0 2 D2 , 0 = 0
- 137 -
j V2,1 = max V1,1 j + 4 , 2 j V2,1 = max{0 + 0,0 + 0} = 0 D2,1 = 0
2 3
j = 0,1
j V2, 2 = max V1,2 j + 4 , 2 j V2, 2 = max{0 + 0,0 + 0,0 + 4} = 4 2 D2 , 2 = 2 = 2 2 j V2,3 = max V1,3 j + 4 , 2 j
2 3
2 3
j = 0,1,2
j = 0,1,2,3
V2,3 = max{0 + 0,0 + 0,0 + 4,0 + 4} = 4 2 D2,3 = 2 = 2 2 j V2, 4 = max V1, 4 j + 4 , 2 j

2 3
j = 0,1,2,3,4
V2, 4 = max{7 + 0,0 + 0,0 + 4,0 + 4,0 + 8} = 8 4 D2, 4 = 2 = 4 2 j V2,5 = max V1,5 j + 4 , 2 j
2 3
j = 0,1,2,3,4,5
V2,5 = max{7 + 0,7 + 0,0 + 4,0 + 4,0 + 8,0 + 8} = 8 4 D2,5 = 2 = 4 2 j V2,6 = max V1,6 j + 4 , 2 j
2 3
j = 0,1,2,3,4,5,6
V2,6 = max{7 + 0,7 + 0,7 + 4,0 + 4,0 + 8,0 + 8,0 + 12} = 12 6 D2,6 = 2 = 6 2
- 138 -
j V2,7 = max V1,7 j + 4 , 2 j
2 3
j = 0,1,2,3,4,5,6
V2,7 = max{7 + 0,7 + 0,7 + 4,7 + 4,0 + 8,0 + 8,0 + 12} = 12 6 D2,7 = 2 = 6 2 j V2,8 = max V1,8 j + 4 , 2 j
2 3
j = 0,1,2,3,4,5,6
V2,8 = max{ + 0,7 + 0,7 + 4,7 + 4,7 + 8,0 + 8,0 + 12} = 15 14 4 D2,8 = 2 = 4 2 j V2,9 = max V1,9 j + 4 , 2 j
2 3
j = 0,1,2,3,4,5,6
V2,9 = max{ + 0,14 + 0,7 + 4,7 + 4,7 + 8,7 + 8,0 + 12} = 15 14 4 D2,9 = 2 = 4 2 j V2,10 = max V1,10 j + 4 , 2 j
2 3
j = 0,1,2,3,4,5,6
V2,10 = max{ + 0,14 + 0,14 + 4,7 + 4,7 + 8,7 + 8,7 + 12} = 19 14 6 D2,10 = 2 = 6 2 Se continu cu liniile urmtoare, n mod asemntor. Soluia optim se obine din tabloul D, innd seama de faptul c o coloan nseamn 1 kg. Dn, m D5,10 0 x5 = = = =0 3 3 g5 Pentru x4 ne deplasm pe linia 4 din D cu g5x5=0 coloane la stnga: D4,10 0 5 x4 = = =1 5 g4 Pentru x3 ne deplasm pe linia 3 din D cu g4x4=5 coloane la stnga: D3,10 5 1 x3 = = =1 1 g3 Pentru x2 ne deplasm pe linia 2 din D cu g3x3=1 coloane la stnga:
- 139 -
x2 =
D2,5 1 g2
4 =2 2
Pentru x1 ne deplasm pe linia 1 din D cu g2x2=4 coloane la stnga: D1, 4 4 0 x1 = = =0 4 g1 Vom avea n final: x5=0 x4=1 x3=1 x2=2 x1=0 Valoarea optim este dat de Vn,m=V5,10=fmax=20 Verificare Greutatea G=04+22+11+15+03=10 f=07+24+13+19+02=20 Obs. Dac aplicm tehnica greedy alegerea s-ar fi fcut n ordinea cresctoare a valorii raportat la greutate, vi/gi =(7/4 2 3 9/5 2/3) rezultnd: x3 = 1 (1 kg) x2=3 (23=6 kg), x4, x1 nu pot fi luate ntruct se depete greutatea total, x5=1 (3 kg). f=x3v3+ x2v2+ x5v5=13+34+12=17 < 20.
- 140 -
Proiectarea algoritmilor BIBLIOGRAFIE 1. Daniela Zaharie Algoritmic, Universitatea de Vest Timioara, 2005, http://web.info.uvt.ro 2. Razvan Andonie, Ilie Grbacea Algoritmi fundamentali. O perspectiv C++, Editura Libris, Cluj-Napoca, 1995 3. T. H. Cormen, C.E. Leiserson, R. L. Rivest, C. Stein - Introduction to Algorithms, Second Edition, McGraw-Hill Book Company, The Massachusetts Institute of Technology, 2001 4. David J.C. MacKay - Information Theory, Inference, and Learning Algorithms, Cambridge University Press 2003 5. R. Johnsonbaugh, M. Schaefer - Algorithms, Pearson Education, 2004
Bibliografie - 141 -

Proiectarea Algoritmilor

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Proiectarea Algoritmilor

Încărcat de

Drepturi de autor:

Formate disponibile

UNIVERSITATEA DIN BACU FACULTATEA DE INGINERIE

CURS PENTRU UZUL STUDENILOR

este minim. Cea mai simpl metod

Proiectarea algoritmilor O rutin n limbajul DELPHI este artat mai jos:

Figura 2.1 Structuri condiionale

Proiectarea algoritmilor v=v1 T

Figura 2 Structuri repetitive condiionate anterior

INTEGER S,i,n READ n S0 FOR i 1, n DO SS+i3 WRITE S

Proiectarea algoritmilor mediamedia+xi ii+1 mediamedia/n WRITE media

Verificrii corectitudinii algoritmilor - 26 -

A1: A2: A3: A4: A5: A6:

Verificrii corectitudinii algoritmilor

Verificrii corectitudinii algoritmilor - 30 -

Verificrii corectitudinii algoritmilor - 31 -

Proiectarea algoritmilor Operaie 1 2 3 4 5 Cost Nr. repetri c1 1 c2 1 c3 n+1 c4 n c5 n

2: FOR j= 1, p DO 3: cij 0 4: FOR k= 1, n DO 5: cij cij + aik bkj RETURN c

Cost Nr. repetri 2(m+1) 1 2(p+1) m 1 mp 2(n+1) mp 2 mpn

Figura 4.1 Reprezentarea funciilor f(n), c1g(n) i c2g(n), pentru n 10

Figura 4.2 Reprezentarea funciilor f(n), c1g(n) i c2g(n), pentru n 50

Analiza complexitii algoritmilor - 40 -

T (n) = (3i + 1) (3n ) .

Analiza complexitii algoritmilor - 41 -

Analiza complexitii algoritmilor - 44 -

Analiza complexitii algoritmilor - 45 -

RETURN x Algoritmi de sortare - 47 -

{ salvarea valorii lui xi pe poziia x0}

{nserarea valorii fanion pe poziia adecvat }

Figura 5.1 Sortarea prin inserie

n cazul cel mai defavorabil TC(i) = i, iar TM(i) = i - 1 + 2 = i + 1, obinndu-se c

Figura 5.2. Sortarea prin selecie

Figura 5.3 Sortarea prin interschibarea elementelor vecine (bubble sort)

{indicele ultimei interschimbri}

Figura 6.1 Structura de apel pentru algoritmul cmmdr1

Exemplul 1. S considerm h(n) = n 1 Prin metoda iteraiei se obine:

Proiectarea algoritmilor hanoi(n,s,d,i) IF n = 1 THEN sd ELSE Hanoi(n-1,s,i,d) sd Hanoi(n-1,i,d,s)

Figura 6.2 Turnurile din Hanoi

Figura 6.3 Structura de apel pentru algoritmul hanoi, n=3

21 22 ... 2n-2 2n-1 = 2n -1 adic algoritmul are

Figura 7.1. Sortarea prin interclasare

Aplicaii ale tehnicilor de reducere i divizare - 71 -

Aplicaii ale tehnicilor de reducere i divizare - 73 -

Aplicaii ale tehnicilor de reducere i divizare - 79 -

s fie ct mai mic. Se observ c aceast problem este similar cu

Tehnica alegerii local optimale greedy - 82 -

Tehnica alegerii local optimale greedy - 83 -

{dup profitul relativ Ai.p/ Ai.d}

Si di = C , astfel c n continuare considerm c restricia problemei este de

Tehnica alegerii local optimale greedy - 85 -

Proiectarea algoritmilor Calculm profiturile corespunztoare celor dou soluii:

diferena lor este

Tehnica alegerii local optimale greedy - 87 -

TObject); TObject); TObject); TObject); TObject);

Tehnica alegerii local optimale greedy - 89 -

Tehnica alegerii local optimale greedy - 90 -

Tehnica alegerii local optimale greedy - 91 -

Tehnica alegerii local optimale greedy - 92 -

dac k = 0 sau n = k altfel

Tehnica programrii dinamice - 96 -

Tehnica programrii dinamice - 102 -

Tehnica programrii dinamice - 103 -

Tehnica programrii dinamice - 105 -

Tehnica programrii dinamice - 106 -

Tehnica cutrii cu revenire - backtracking - 108 -

m . Un vector (s1,s2,...,sk) este