Disciplina. InformaticaDisciplina. Informatica

Clasa a XI-a BClasa a XI-a B

Grupa 3: Kocsis-Feri Robert, Szasz Zsolt, Grupa 3: Kocsis-Feri Robert, Szasz Zsolt, Solyom Robert, Uszkai Botond, Milicu Solyom Robert, Uszkai Botond, Milicu BrigittaBrigitta

Metoda divide et impera.Metoda divide et impera.

Profesor coordonator: Boti SandorProfesor coordonator: Boti Sandor

Grup Scolar Industrial SarmasagGrup Scolar Industrial Sarmasag

Desparte si Desparte si StapanesteStapaneste

(Divide et impera)(Divide et impera)

Tehnica divide et imperaTehnica divide et impera Divide et imperaDivide et impera este o tehnica de elaborare a algoritmilor care este o tehnica de elaborare a algoritmilor care

consta in:consta in: · Descompunerea cazului ce trebuie rezolvat intr-un numar de · Descompunerea cazului ce trebuie rezolvat intr-un numar de

subcazuri mai mici ale aceleiasi probleme.subcazuri mai mici ale aceleiasi probleme.· Rezolvarea succesiva si independenta a fiecaruia din aceste · Rezolvarea succesiva si independenta a fiecaruia din aceste subcazuri.subcazuri.· Recompunerea subsolutiilor astfel obtinute pentru a gasi · Recompunerea subsolutiilor astfel obtinute pentru a gasi solutia cazului initial.solutia cazului initial.

Sa presupunem ca avem un algoritm Sa presupunem ca avem un algoritm AA cu timp patratic. Fie cu timp patratic. Fie cc o o constanta, astfel incat timpul pentru a rezolva un caz de constanta, astfel incat timpul pentru a rezolva un caz de marime marime nn este este tAtA((nn) £ ) £ cncn2. Sa presupunem ca este posibil sa 2. Sa presupunem ca este posibil sa rezolvam un astfel de caz prin descompunerea in trei rezolvam un astfel de caz prin descompunerea in trei subcazuri, fiecare de marime ésubcazuri, fiecare de marime énn/2ù. Fie /2ù. Fie dd o constanta, astfel o constanta, astfel incat timpul necesar pentru descompunere si recompunere incat timpul necesar pentru descompunere si recompunere este este tt((nn) £ ) £ dndn. Folosind vechiul algoritm si ideea de . Folosind vechiul algoritm si ideea de descompunere-recompunere a subcazurilor, obtinem un nou descompunere-recompunere a subcazurilor, obtinem un nou algoritm algoritm BB, pentru care:, pentru care:

tBtB((nn) = 3) = 3tAtA(é(énn/2ù)+/2ù)+tt((nn) £ 3) £ 3cc((((nn+1)/2)2++1)/2)2+dndn = = 3/43/4cncn2+(3/2+2+(3/2+dd))nn+3/4+3/4cc

Termenul 3/4Termenul 3/4cncn2 domina pe ceilalti cand 2 domina pe ceilalti cand nn este suficient de mare, este suficient de mare, ceea ce inseamna ca algoritmul ceea ce inseamna ca algoritmul BB este in esenta cu 25% mai rapid este in esenta cu 25% mai rapid

decat algoritmul decat algoritmul AA. Nu am reusit insa sa schimbam ordinul . Nu am reusit insa sa schimbam ordinul timpului, care ramane patratic.timpului, care ramane patratic.

Putem sa continuam in mod recursiv acest procedeu, impartind Putem sa continuam in mod recursiv acest procedeu, impartind subcazurile in subsubcazuri etc. Pentru subcazurile care nu sunt subcazurile in subsubcazuri etc. Pentru subcazurile care nu sunt mai mari decat un anumit prag mai mari decat un anumit prag nn0, vom folosi tot algoritmul 0, vom folosi tot algoritmul AA. .

Obtinem astfel algoritmul Obtinem astfel algoritmul CC, cu timpul, cu timpulConform rezultatelor din Sectiunea 5.3.5, Conform rezultatelor din Sectiunea 5.3.5, tCtC((nn) este in ordinul lui ) este in ordinul lui nnlg 3. Deoarece lg 3 @ 1,59, inseamna ca de aceasta data am lg 3. Deoarece lg 3 @ 1,59, inseamna ca de aceasta data am

reusit sa imbunatatim ordinul timpului.reusit sa imbunatatim ordinul timpului.Iata o descriere generala a metodei divide et impera:Iata o descriere generala a metodei divide et impera:

functionfunction divimpdivimp((xx)){returneaza o solutie pentru cazul {returneaza o solutie pentru cazul xx}}

ifif xx este suficient de mic este suficient de mic thenthen returnreturn adhocadhoc((xx)){descompune {descompune xx in subcazurile in subcazurile xx1, 1, xx2, …, 2, …, xkxk}}

forfor ii ¬ 1 ¬ 1 to to kk dodo yiyi ¬ ¬ divimpdivimp((xixi)){recompune {recompune yy1, 1, yy2, …, 2, …, ykyk in scopul obtinerii solutiei in scopul obtinerii solutiei yy pentru pentru xx}}

returnreturn yyunde unde adhocadhoc este subalgoritmul de baza folosit pentru rezolvarea este subalgoritmul de baza folosit pentru rezolvarea

micilor subcazuri ale problemei in cauza (in exemplul nostru, acest micilor subcazuri ale problemei in cauza (in exemplul nostru, acest subalgoritm este subalgoritm este AA).).

Un algoritm divide et impera trebuie sa evite descompunerea Un algoritm divide et impera trebuie sa evite descompunerea recursiva a subcazurilor “suficient de mici”, deoarece, pentru recursiva a subcazurilor “suficient de mici”, deoarece, pentru acestea, este mai eficienta aplicarea directa a subalgoritmului de acestea, este mai eficienta aplicarea directa a subalgoritmului de baza. Ce inseamna insa “suficient de mic”?baza. Ce inseamna insa “suficient de mic”?

In exemplul precedent, cu toate ca valoarea lui In exemplul precedent, cu toate ca valoarea lui nn0 nu 0 nu influenteaza ordinul timpului, este influentata insa constanta influenteaza ordinul timpului, este influentata insa constanta multiplicativa a lui multiplicativa a lui nnlg 3, ceea ce poate avea un rol considerabil lg 3, ceea ce poate avea un rol considerabil in eficienta algoritmului. Pentru un algoritm divide et impera in eficienta algoritmului. Pentru un algoritm divide et impera oarecare, chiar daca ordinul timpului nu poate fi imbunatatit, se oarecare, chiar daca ordinul timpului nu poate fi imbunatatit, se doreste optimizarea acestui prag in sensul obtinerii unui algoritm doreste optimizarea acestui prag in sensul obtinerii unui algoritm cat mai eficient. Nu exista o metoda teoretica generala pentru cat mai eficient. Nu exista o metoda teoretica generala pentru aceasta, pragul optim depinzand nu numai de algoritmul in aceasta, pragul optim depinzand nu numai de algoritmul in cauza, dar si de particularitatea implementarii. Considerand o cauza, dar si de particularitatea implementarii. Considerand o implementare data, pragul optim poate fi determinat empiric, implementare data, pragul optim poate fi determinat empiric, prin masurarea timpului de executie pentru diferite valori ale lui prin masurarea timpului de executie pentru diferite valori ale lui nn0 si cazuri de marimi diferite.0 si cazuri de marimi diferite.

In general, se recomanda o metoda hibrida care consta in: In general, se recomanda o metoda hibrida care consta in: i)i) determinarea teoretica a formei ecuatiilor recurente; determinarea teoretica a formei ecuatiilor recurente; ii)ii) gasirea gasirea empirica a valorilor constantelor folosite de aceste ecuatii, in empirica a valorilor constantelor folosite de aceste ecuatii, in functie de implementare.functie de implementare.

Revenind la exemplul nostru, pragul optim poate fi gasit Revenind la exemplul nostru, pragul optim poate fi gasit rezolvand ecuatiarezolvand ecuatia

tAtA((nn) = 3) = 3tAtA(é(énn/2ù) + /2ù) + tt((nn))

Exemple:Exemple: a) Problema turnurilor din Hanoia) Problema turnurilor din Hanoi.. Având n discuri aşezate (descrescător după dimensiune) pe una Având n discuri aşezate (descrescător după dimensiune) pe una

din cele trei tijedin cele trei tije (numerotate cu 1,2,3), se cere să le mutăm pe altă tijă luând căte (numerotate cu 1,2,3), se cere să le mutăm pe altă tijă luând căte

un singur discun singur disc (cel de deasupra) de pe o tijă şi mutându-l pe o alta respectând (cel de deasupra) de pe o tijă şi mutându-l pe o alta respectând

ordinea (nu seordinea (nu se poate depune un disc mai greu peste unul mai uşor).poate depune un disc mai greu peste unul mai uşor). Pentru a rezolva problema vom utiliza un subalgoritm care mută Pentru a rezolva problema vom utiliza un subalgoritm care mută

primele n-1primele n-1 discuri de pe tija a pe tija b. Dacă mutăm primele n, înseamnă că discuri de pe tija a pe tija b. Dacă mutăm primele n, înseamnă că

le mutăm pele mutăm pe toate şi problema este rezolvată.toate şi problema este rezolvată. Primele n discuri se mută astfel: se mută primele n-1 discuri de pe Primele n discuri se mută astfel: se mută primele n-1 discuri de pe

tija a pe tijatija a pe tija c=6-a-b, apoi se mută discul n (baza) pe tija destinaţie (b), iar în c=6-a-b, apoi se mută discul n (baza) pe tija destinaţie (b), iar în

final se mutăfinal se mută din nou primele primele n-1 discuri de pe tija c=6-a-b pe tija b.din nou primele primele n-1 discuri de pe tija c=6-a-b pe tija b.

b) Merge Sort (sortare prin interclasare) b) Merge Sort (sortare prin interclasare) .. Să se ordoneze un vector X cu Să se ordoneze un vector X cu n n componente. Se va apela componente. Se va apela

subalgoritmulsubalgoritmul MergeSort MergeSort (X,1,n):(X,1,n): Subalgoritmul Subalgoritmul MergeSort MergeSort ((X,i,jX,i,j) este: { Ordonează subşirul x) este: { Ordonează subşirul xii,,

…,x…,xj j }} Dacă Dacă j-i>j-i>ε Atunci ε Atunci mm:=(:=(i+ji+j)/2;)/2; MergeSort MergeSort ((X,i,mX,i,m);); MergeSort MergeSort ((X,m+1,jX,m+1,j);); Interclasare Interclasare ((X,i,m, X,m+1,j, X,i,jX,i,m, X,m+1,j, X,i,j))

c) QuickSort (sortare rapidă)c) QuickSort (sortare rapidă).. Să se ordoneze un vector X cu Să se ordoneze un vector X cu n n componente. Se va apela componente. Se va apela

subalgoritmulsubalgoritmul QuickSort QuickSort (X,1,n) :(X,1,n) : Subalgoritmul Subalgoritmul QuickSort QuickSort ((X,i,jX,i,j) este: { Ordonează subşirul x) este: { Ordonează subşirul xii,,

…,x…,xj j }} Dacă Dacă j-i>j-i>ε Atunci ε Atunci mm:=:=Split Split ((X,i,jX,i,j);); QuickSort QuickSort ((X,i,mX,i,m);); QuickSort QuickSort ((X,m+1,jX,m+1,j););

Paradigma divide-et-impera: algoritmParadigma divide-et-impera: algoritm procedure DivideEtImpera(P, n, S)procedure DivideEtImpera(P, n, S) beginbegin if (n <= n0)if (n <= n0) then determina S prin metode then determina S prin metode

elementareelementare else imparte P in P1, ..., Paelse imparte P in P1, ..., Pa DivideEtImpera(P1, n1, S1)DivideEtImpera(P1, n1, S1) ...... DivideEtImpera(Pa, na, Sa)DivideEtImpera(Pa, na, Sa) Asambleaza(S1, ..., Sa, S)Asambleaza(S1, ..., Sa, S) endend

Tăierea pe verticalăTăierea pe verticală

Prin metoda Prin metoda Divide et impera Divide et impera se împarte sirul de lungime se împarte sirul de lungime n în doua subsiruri de lungime n/2,n în doua subsiruri de lungime n/2,

apoi acestea în alte dous subsiruri de lungime n/4, s.a.m.d. apoi acestea în alte dous subsiruri de lungime n/4, s.a.m.d. pîna cînd obtinem subsiruri depîna cînd obtinem subsiruri de

lungime mai mica sau egal cu 2. Dac n este o putere a lui 2 lungime mai mica sau egal cu 2. Dac n este o putere a lui 2 atunci se va ajunge la subsiruriatunci se va ajunge la subsiruri

elementare de lungime 2.elementare de lungime 2.

procedura procedura MAX_MIN(S,n,xmin,xmax) MAX_MIN(S,n,xmin,xmax) esteeste daca daca nd2 nd2 atunciatunci xmin=MIN(a,b)xmin=MIN(a,b) xmax=MAX(a,b)xmax=MAX(a,b) altfelaltfel *) determina S1 si S2 de lungime n/2*) determina S1 si S2 de lungime n/2 MAX_MIN(S1,n/2,x1,x2)MAX_MIN(S1,n/2,x1,x2) MAX_MIN(S2,n/2,y1,y2)MAX_MIN(S2,n/2,y1,y2) xmin=MIN(x1,y1)xmin=MIN(x1,y1) xmax=MAX(x2,y2)xmax=MAX(x2,y2) .. sfîrsitsfîrsit

PProcedura rocedura DesparteSiStapinesteDesparteSiStapineste

procedureprocedure DesparteSiStapineste(a, b, c, d : DesparteSiStapineste(a, b, c, d : real);real);

varvar i : integer; i : integer; beginbegin ifif SolutieDirecta(a, b, c, d, i) SolutieDirecta(a, b, c, d, i) thenthen PrelucrareaSolutiei(a, b, c, d) PrelucrareaSolutiei(a, b, c, d) elseelse begin begin DesparteSiStapineste(a, b, X[i], d);DesparteSiStapineste(a, b, X[i], d); DesparteSiStapineste(X[i], b, c, d);DesparteSiStapineste(X[i], b, c, d); DesparteSiStapineste(a, Y[i], c, d);DesparteSiStapineste(a, Y[i], c, d); DesparteSiStapineste(a, b, c, Y[i]);DesparteSiStapineste(a, b, c, Y[i]); endend;; endend; { DesparteSiStapineste }; { DesparteSiStapineste }

ScSchhema generalema generală a algoritmului bazat pe metoda ă a algoritmului bazat pe metoda desparte şi stăpîneştedesparte şi stăpîneşte

procedureprocedure DesparteSiStapineste( DesparteSiStapineste(i,i, j : integer;j : integer; var var x : tip); x : tip);

varvar m : integer; m : integer; x1, x2 : tip;x1, x2 : tip; beginbegin ifif SolutieDirecta(i, j) SolutieDirecta(i, j) thenthen Prelucrare(i, j, x) Prelucrare(i, j, x) elseelse beginbegin m:=(j-im:=(j-i)) divdiv 2; 2; DesparteSiStapineste(i, i+m, x1);DesparteSiStapineste(i, i+m, x1); DesparteSiStapineste(i+m+1, j, x2);DesparteSiStapineste(i+m+1, j, x2); Combina(x1, x2, x);Combina(x1, x2, x); endend;; endend;;

Maximum keresese:Maximum keresese:

program sor_maximum;program sor_maximum;type tomb=array[1..100] of integer;type tomb=array[1..100] of integer;var et:tomb;var et:tomb; n:Byte; n:Byte;

Procedure beolvas (var et:tomb; var n:byte);Procedure beolvas (var et:tomb; var n:byte);var i:Integer;var i:Integer;beginbegin Write(‘n=‘); Readln(n); Write(‘n=‘); Readln(n); for i:=1 to n do begin for i:=1 to n do begin write(‘et[‘,i,’]=‘); Readln(et[i]) write(‘et[‘,i,’]=‘); Readln(et[i]) end endend;end;

Function maximum(a,b:Integer):Integer;Function maximum(a,b:Integer):Integer;beginbegin if a<b then if a<b then maximum:=b maximum:=b else else maximum:=a maximum:=aend;end;

Funvtion max(e,v:Byte): integer;Funvtion max(e,v:Byte): integer;var k:byte;var k:byte;beginbegin if v=e then if v=e then max:=et[e] max:=et[e]else beginelse begin k:=(e+v)div 2; k:=(e+v)div 2; max:=maximum(max(e,k),max(k+1,v)) max:=maximum(max(e,k),max(k+1,v))endendend;end;

beginbegin beolvas(et,n); beolvas(et,n);writeln(max(1,n))writeln(max(1,n))end.end.