Grup Scolar Industrial Sarmasag

1. GrupScolar Industrial Sarmasag Disciplina. Informatica Clasa a XI-a B Grupa 3: Kocsis-Feri Robert, SzaszZsolt, Solyom Robert, UszkaiBotond, MilicuBrigitta Metoda divide et impera. Profesorcoordonator: BotiSandor

2. Desparte si Stapaneste(Divide et impera)

3. Tehnica divide et impera • Divide et impera este o tehnica de elaborare a algoritmilor care consta in: • · Descompunerea cazului ce trebuie rezolvat intr-un numar de subcazuri mai mici ale aceleiasi probleme.· Rezolvarea succesiva si independenta a fiecaruia din aceste subcazuri.· Recompunerea subsolutiilor astfel obtinute pentru a gasi solutia cazului initial. • Sa presupunem ca avem un algoritm A cu timp patratic. Fie c o constanta, astfel incat timpul pentru a rezolva un caz de marime n este tA(n) £ cn2. Sa presupunem ca este posibil sa rezolvam un astfel de caz prin descompunerea in trei subcazuri, fiecare de marime én/2ù. Fie d o constanta, astfel incat timpul necesar pentru descompunere si recompunere este t(n) £ dn. Folosind vechiul algoritm si ideea de descompunere-recompunere a subcazurilor, obtinem un nou algoritm B, pentru care: • tB(n) = 3tA(én/2ù)+t(n) £ 3c((n+1)/2)2+dn = 3/4cn2+(3/2+d)n+3/4c

4. Termenul 3/4cn2 domina pe ceilalti cand n este suficient de mare, ceea ce inseamna ca algoritmul B este in esenta cu 25% mai rapid decat algoritmul A. Nu am reusit insa sa schimbam ordinul timpului, care ramane patratic. Putem sa continuam in mod recursiv acest procedeu, impartind subcazurile in subsubcazuri etc. Pentru subcazurile care nu sunt mai mari decat un anumit prag n0, vom folosi tot algoritmul A. Obtinem astfel algoritmul C, cu timpul Conform rezultatelor din Sectiunea 5.3.5, tC(n) este in ordinul lui nlg 3. Deoarece lg 3 @ 1,59, inseamna ca de aceasta data am reusit sa imbunatatim ordinul timpului. Iata o descriere generala a metodei divide et impera: functiondivimp(x){returneaza o solutie pentru cazul x}ifx este suficient de mic thenreturnadhoc(x){descompune x in subcazurile x1, x2, …, xk}fori ¬ 1 to kdoyi ¬ divimp(xi){recompune y1, y2, …, yk in scopul obtinerii solutiei y pentru x}returny unde adhoc este subalgoritmul de baza folosit pentru rezolvarea micilor subcazuri ale problemei in cauza (in exemplul nostru, acest subalgoritm este A).

5. Un algoritm divide et impera trebuie sa evite descompunerea recursiva a subcazurilor “suficient de mici”, deoarece, pentru acestea, este mai eficienta aplicarea directa a subalgoritmului de baza. Ce inseamna insa “suficient de mic”? • In exemplul precedent, cu toate ca valoarea lui n0 nu influenteaza ordinul timpului, este influentata insa constanta multiplicativa a lui nlg 3, ceea ce poate avea un rol considerabil in eficienta algoritmului. Pentru un algoritm divide et impera oarecare, chiar daca ordinul timpului nu poate fi imbunatatit, se doreste optimizarea acestui prag in sensul obtinerii unui algoritm cat mai eficient. Nu exista o metoda teoretica generala pentru aceasta, pragul optim depinzand nu numai de algoritmul in cauza, dar si de particularitatea implementarii. Considerand o implementare data, pragul optim poate fi determinat empiric, prin masurarea timpului de executie pentru diferite valori ale lui n0 si cazuri de marimi diferite. • In general, se recomanda o metoda hibrida care consta in: i) determinarea teoretica a formei ecuatiilor recurente; ii) gasirea empirica a valorilor constantelor folosite de aceste ecuatii, in functie de implementare. • Revenind la exemplul nostru, pragul optim poate fi gasit rezolvand ecuatia • tA(n) = 3tA(én/2ù) + t(n)

6. Exemple: • a) Problema turnurilor din Hanoi. • Având n discuri aşezate (descrescător după dimensiune) pe una din cele trei tije • (numerotate cu 1,2,3), se cere să le mutăm pe altă tijă luând căte un singur disc • (cel de deasupra) de pe o tijă şi mutându-l pe o alta respectând ordinea (nu se • poate depune un disc mai greu peste unul mai uşor). • Pentru a rezolva problema vom utiliza un subalgoritm care mută primele n-1 • discuri de pe tija a pe tija b. Dacă mutăm primele n, înseamnă că le mutăm pe • toate şi problema este rezolvată. • Primele n discuri se mută astfel: se mută primele n-1 discuri de pe tija a pe tija • c=6-a-b, apoi se mută discul n (baza) pe tija destinaţie (b), iar în final se mută • din nou primele primele n-1 discuri de pe tija c=6-a-b pe tija b.

7. b) Merge Sort (sortare prin interclasare) . • Să se ordoneze un vector X cu n componente. Se va apela subalgoritmul • MergeSort (X,1,n): • Subalgoritmul MergeSort (X,i,j) este: { Ordonează subşirul xi,…,xj } • Dacă j-i>ε Atunci m:=(i+j)/2; • MergeSort (X,i,m); • MergeSort (X,m+1,j); • Interclasare (X,i,m, X,m+1,j, X,i,j) • c) QuickSort (sortare rapidă). • Să se ordoneze un vector X cu n componente. Se va apela subalgoritmul • QuickSort (X,1,n) : • Subalgoritmul QuickSort (X,i,j) este: { Ordonează subşirul xi,…,xj } • Dacă j-i>ε Atunci m:=Split (X,i,j); • QuickSort (X,i,m); • QuickSort (X,m+1,j);

8. Paradigma divide-et-impera: algoritm • procedure DivideEtImpera(P, n, S) • begin • if (n <= n0) • then determina S prin metode elementare • else imparte P in P1, ..., Pa • DivideEtImpera(P1, n1, S1) • ... • DivideEtImpera(Pa, na, Sa) • Asambleaza(S1, ..., Sa, S) • end

9. Tăierea pe verticală

10. Prin metoda Divide et impera se împarte sirul de lungime n în doua subsiruri de lungime n/2, • apoi acestea în alte dous subsiruri de lungime n/4, s.a.m.d. pîna cînd obtinem subsiruri de • lungime mai mica sau egal cu 2. Dac n este o putere a lui 2 atunci se va ajunge la subsiruri • elementare de lungime 2. • procedura MAX_MIN(S,n,xmin,xmax) este • daca nd2 atunci • xmin=MIN(a,b) • xmax=MAX(a,b) • altfel • *) determina S1 si S2 de lungime n/2 • MAX_MIN(S1,n/2,x1,x2) • MAX_MIN(S2,n/2,y1,y2) • xmin=MIN(x1,y1) • xmax=MAX(x2,y2) • . • sfîrsit

11. procedure DesparteSiStapineste(a, b, c, d : real); var i : integer; begin if SolutieDirecta(a, b, c, d, i) then PrelucrareaSolutiei(a, b, c, d) else begin DesparteSiStapineste(a, b, X[i], d); DesparteSiStapineste(X[i], b, c, d); DesparteSiStapineste(a, Y[i], c, d); DesparteSiStapineste(a, b, c, Y[i]); end; end; { DesparteSiStapineste } Procedura DesparteSiStapineste

12. Schema generală a algoritmului bazat pe metoda desparte şi stăpîneşte • procedure DesparteSiStapineste(i,j : integer; var x : tip); • var m : integer; • x1, x2 : tip; • begin • if SolutieDirecta(i, j) then Prelucrare(i, j, x) • else • begin • m:=(j-i)div 2; • DesparteSiStapineste(i, i+m, x1); • DesparteSiStapineste(i+m+1, j, x2); • Combina(x1, x2, x); • end; • end;

13. Maximum keresese:program sor_maximum;type tomb=array[1..100] of integer;varet:tomb; n:Byte;Procedure beolvas (varet:tomb; var n:byte);var i:Integer;begin Write(‘n=‘); Readln(n); for i:=1 to n do begin write(‘et[‘,i,’]=‘); Readln(et[i]) endend;Function maximum(a,b:Integer):Integer;begin if a<b then maximum:=b else maximum:=aend;

14. Funvtion max(e,v:Byte): integer;var k:byte;begin if v=e then max:=et[e]else begin k:=(e+v)div 2; max:=maximum(max(e,k),max(k+1,v))endend;beginbeolvas(et,n);writeln(max(1,n))end.