METODA DIVIDE ET IMPERA

.................4 Sortare prin insertie binara....................... 8 2.. 14 3 CONCLUZII................................ 17 2 .....1“Turnurile din Hanoi”...................................................................................... 3 2 APLICATII DIVIDE ET IMPERA......................................... 16 4 BIBLIOGRAFIE.................2 Sortare rapida ............................... 11 2.....3 Sortare prin interclasare............................... 6 2... 6 2....................................................................................................................Cuprins 1 NOTIUNI INTRODUCTIVE................................................

smilare problemei de baza . Dupa cum sugereaza si numele "desparte si stapaneste" etapele rezolvarii unei probleme (numita problema initiala) in DIVIDE ET IMPERA sunt : descompunerea problemei initiale in subprobleme independente . aceste subprobleme sunt similare cu problema initiala. aceste suprobleme sunt independente una fata de alta (o subproblema nu se rezolva pe baza alteia si nu se foloseste rezultate celeilalte).aplicarea metodei este destul de rara.pana cand se pot rezolva imediata .NOTIUNI INTRODUCTIVE Metoda de programare DIVIDE ET IMPERA consta in impartirea problemei initiale de dimensiuni [n] in doua sau mai multe probleme de dimensiuni reduse . descompunerea treptata a subproblemelor in alte subprobleme din ce in ce mai simple .  la randul lor subproblemele se pot descompune (daca este necesar) in alte subprobleme mai simple. Deoarece putine probleme indeplinesc conditiile de mai sus .In general se executa impartirea in doua subprobleme de dimensiuni aproximativ egale si anume [n/2] .de dimensiuni mai mici .Dupa rezolvarea celor doua subprobleme se executa faza de combinare a rezultatelor in vederea rezolvarii intregii probleme . aceste subprobleme simple se pot solutiona imediat prin algoritmul simplificat.prin algoritmul simplificat . Metoda DIVIDE ET IMPERA se poate aplica in rezolvarea unei probleme care indeplineste urmatoarele conditii : se poate descompune in ( doua sau mai multe) suprobleme . 3 . Impartirea in subprobleme are loc pana cand dimensiunea acestora devine suficient de mica pentru a fi rezolvate in mod direct(cazul de baza).

de dimensiuni mai mari).k executa DIVIMP(PROB) si se obtine SOL1. deorece subproblemele sunt similare problemei initiale.s-a ajuns la o (sub)problema care nu admite o rezolvare imediata . Se combina solutiile SOL 1.se intampla la orice nivel . Daca PROBLEMA PROB este simpla Atunci se rezolva si se obtine solutia SOL Altfel pentru i=1.rezolvarea subproblemelor simple .caz in care o descompunem in doua sau mai multe subprobleme si pentru fiecare din ele se continua apelurile recursive(ale procedurii sau functiei). 4 de dimensiuni . combinarea solutiilor gasite pentru construirea solutiilor subproblemelor de dimensiuni din ce in ce mai mari . ..ceea ce se intampla la un nivel .. dar mai mici .  combinarea ultimelor solutii determina obtinerea solutiei problemei initiale .Asemanator se intampla si in cazul metodei DIVITE ET IMPERA.s-a ajuns la o (sub)problema simpla ce admite o rezolvare imediata caz in care se rezolva (sub)problema si se revine din apel (la subproblema anterioara..SOL K si se obtine SOL.avand grija sa asiguram conditia de terminare ale apelurilor repetate . Principiul fundamental al recursivitatii este autoapelarea unui subprogram cand acesta este activ. Etapele metodei DIVIDE ET IMPERA (prezentate anterior) se pot reprezenta prin urmatorul subprogram general (procedura sau functie ) recursiv exprimat in limbaj natural: Subprogram DIVIMP (PROB). In etapa finala a metodei DIVIDE ET IMPERA se produce combinarea subproblemelor (rezolvate deja) prin secventele de revenire din apelurile recursive. La un anumit nivel sunt doua posibilitati : . . Metoda DIVIDE ET IMPERA admite o implementare recursiva.

atunci procedura DIVIDE o imparte in doua subprobleme .ls. DIVIMP(m. Pentru acestea se reapeleaza recursiv subprogramul.ls.daca (sub)problema este (inca) complexa .pentru fiecare din cele doua subprobleme se reapeleaza recursiv procedura DIVIMP. DIVIMP(li.atunci procedura REZOLVA ii afla solutia imediat si se produce intoarcerea din apelul recursiv.sol). De obicei problema initiala se descompune in doua subprobleme mai simple.m. in final .msol1). In acest caz etapele generale ale metodei DIVIDE ET IMPERA se pot reprezenta concret. printr-o procedura recursiva astfel : Procedura DIVIMP(li. Procedura DIVIMP se apeleaza pentru problema initiala care are dimensiunea intre limita inferioara (li) si limita inferioara(ls).alegand pozitia m intre limitele li si ls .ls).la intoarcerile din apeluri se produce combinarea celor doua solutii sol1 si sol2 prin apelul procedurii COMBINA. 5 . subprogramul DIVIMP se apeleaza pentru problema initiala PROB.sol2. in limbaj pseudocod. Altfel DIVIDE (li. COMBINA(sol1.aceasta admite descompunerea in K subprobleme simple.sol).ls.Sfarsit _subprogram. In final se combina solutiile acestor K subprobleme. Daca ((ls-li)<=eps) Atunci REZOLVA (li.sol).sol2). Deci.daca (sub)problema este simpla (ls-li<=eps). Sfarsit_ procedura.

B. Rezolvarea acestei probleme se bazeaza pe urmatoarele considerente logice : daca n=1. un disc se poate aseza numai peste un disc cu diametrul mai mare .Pe tija A se gasesc asezate n discuri de diametre diferite . Observam ca problema initiala se descompune in trei subprobleme mai simple .C .B. -mut un disc AàB .AàB.1. -mut cele (n-1)discuri CàB. daca n>2 procedam astfel : -mut (n-1)discuri AàC. Initial .Notam .n-1.mut cele (n-1)discuri CàB. folosind C. PENTRU n=1 AàB 6 care sunt dispuse discurile ). Aceste subprobleme sunt independente .mut ultimul disc pe B . Dimensiunile acestor subprobleme sunt : n-1.Sa se afiseze toate mutarile prin care discurile de pe tija A se muta pe tija B . in aceeasi ordine .similare problemei initiale: mut (n-1)discuri AàC .C)=sirul mutarilor a n discuri de pe A pe B. atunci sirul mutarilor este : AàC. daca n=2.tijele finale si tijele intermediare sunt diferite.A.tijele B si C sunt goale . atunci mutarea este imediata AàB(mut discul de pe A pe B).folosind ca tija de manevra C si resspectand urmatoarele reguli: la fiecare pas se muta un singur disc.in ordinea crescatoare a diametrelor.APLICATII Problema turnurilor din Hanoi Prezentarea rezolvarii algoritmului Fie trei tije verticale notate A.CàB.privind de sus in jos .deoarece tijele initial (pe H(n.

hanoi(n.’à’. begin if n=1 then writeln(a.A.B.C.C.’A’.A) program turnurile_hanoi. begin write(‘nr discuri pe tija A =’).c. end.b) else begin hanoi(n-1.readln(n).c.’C’).B).b).’B’. writeln(‘mutarile sunt urmatoarele :’). end. hanoi(n-1. procedure hanoi(n:byte.B.a. var n:byte. readln.b. 7 .C)= H(n-1.’à’. writeln(a.AB.A.readln. H(n-1. end.b).a.c:char).n>1 H(n.b.a).

Sa se ordoneze crescator folosind metoda de sortare rapida .vectorul V se imparte in doua parti : li …k-1 si k+1…ls. in acest fel . 8 .astfel .cu limitele modificate corespunzator .deci vectorul este ordonat . Solutia problemei se bazeaza pe urmatoarele etape implementate in programul principal: se apeleaza procedura “quick” cu limita inferioara li=1 si limita superioara ls=n.inpartita in alte doua parti .primul element din fiecare parte va fi pozitionat exact pe pozitia finala ce o va ocupa in vectorul final ordonat (functia“poz”).procesul continua pana cand limitele partilor ajung sa se suprapuna . fiecare din cele doua parti va fi . in acest moment se produc intoarcerile din apelurile recursive si programul isi termina executia .Sortarea rapida(quicksort) Un tablou V se completeaza cu n elemente numere reale . functia”poz” realizeaza mutarea elementului v[i] exact pe functia”poz” intoarce pozitia ce o va ocupa acesta in vectorul final ordonat . in acest fel . (in k ) pozitia ocupata de acest element. pentru fiecare din aceste parti se reapeleaza procedura“quick”.ceea ce indica ca toate elementele vectorului au fost mutate exact pe pozitiile ce le vor ocupa in vectorul final .

var v:vector. i:=i+modi. while i<j do begin if v[i]>v[j] then begin man:=v[i].modj. function poz(li. 9 . modj:=-m. type vector= array [1. modi:=0. end. v[i]:=v[j]. j:=j+modj.program quicksort. procedure quick(li.m:integer.modi.ls:integer).j. end. v[j]:=man. modj:=-1.n. man:real. j:=ls. var i. i.50] of real .. end.ls:integer):integer.k:integer. begin i:=li. poz:=i. m:=modi . modi:=-modj.

readln. end. 10 .ls). quick(k+1. OBSERVATII daca elementul se afla in stanga . daca elementul se afla in dreapta .k-1). end. end.n).ls). for i:=1 to n do begin write(‘tastati elementul ‘.readln(n). quick(li.i.’=’). quick(1. writeln(‘vectorul ordonat este :’). for i:=1 to n do writeln(v[i]). begin write(‘cate elemente are vectorul ?=’).atunci se compara cu elementele din dreapta lui si se sar (j:=j-1)elementele mai mari decat el . readln(v[i]).atunci se compara cu elemente din stanga lui si se sar (i:=i+1)elementele mai mici decat el.begin if li<ls then begin k::=poz(li. end.

procedure interclas(li. k:=0. a[li]:=a[ls]. end.var a:vector).p.Sortarea prin interclasare(mergesort) Tabloul unidimensional V se completeaza cu n numere reale.cate doi astfel de mini. program mergesort.50] of real .fiecare dintre acestia se ordoneaza printr-o simpla comparare a elementelor . while (i<=m)and(j<=ls) do begin 11 .k. Sortarea prin interclasare se bazeaza pe urmatoarea logica : vectorul V se imparte . begin i:=li.cand se ating vectorii de maxim doua elemente .var a:vector).m. j:=m+1.ls:word. var man:real. a[ls]:=man.j:word.vectori ordonati se interclaseaza succesiv pana se ajunge iar la vectorul V. var v:vector . var b:vector:i. end.n.. begin if a[li]>a[ls] then begin man:=a[li].ls:word.prin injumatatiri succesive . Sa se ordoneze crescator folosind sortare prin interclasare.i:word.in vectori din ce in ce mai mici . type vector=array[1. procedure schimba(li.

end. end. end. end. else begin m:=(li+ls)div 2.m. divi(li. inc(j).b[k]:=a[p]. end else begin b[k]:=a[j]. if i<=m then for p:=i to m do begin1 inc(k). procedure divi(li. if j<=ls then for p:=j to ls do begin inc(k) . inc(i). end. if a[i] <a[j] then begin b[k]:=a[i]. for p:=li to ls do begin inc(k).inc(k). end.b[k]:=a[p].a).ls.ls:word. a[p]:=b[k]. 12 . var a:vector). begin if (ls-li)<=1 then schimba(li. var m:word. k:=0.a).

a).’=’).iar ordonarea independenta celor doua jumatati(mini.readln(n). end. OBSERVATII mecanismul general de tip Divide et Impera se gaseste implementat in procedura “divi” . 13 .vectori) consuma in total aproximativ a doua parte din timpul care ar fi necesar ordonarii vectorului luat ca intreg . for i:=1 to n do begin write(‘tastati elementul’. interclas(li. begin write(‘cate elemente are vectorul?=’). for i:=1 to n do writeln(v[i]). divi(1. end. writeln(‘vectorul sortat este:’).n.ls.a).deoarece operatia de interclasare a doi vectori deja ordonati este foarte rapida .m. readln(v[i]). end.ls.v).divi(m+1.i. o astfel de abordare a problemei sortarii unii vector conduce la economie de timp de calcul . end.

…. Pentru fiecare element v[i] se procedeaza in patru pasi:  se considera ordonate elementele v[1].ls. program sortare _binara.…. begin if li=ls then if v[i]<v[j] then poz:=li else poz:=i else if ls-li=1 then if v[i]<v[ls] then if v[i]>=v[li] then poz:=ls else poz:=li else poz:=i else begin m:=(li+ls)div 2.v[i-1].folosind sortarea prin insertie binara . v:vector.v[2].k.i:integer. type vector =array[1.50] of real .n(procedura “deplasare”). insereaza elementul v[i] in pozitia k (procedura”deplasare”).i:integer):integer. var n. function poz(li. se obtine o succesiune de k+1 elemente ordonate crescator. var m:integer.v[2].v[i-1](procedura “poz” prin cautare binara)..Sortarea prin insertie binara Sa se ordoneze crescator un tablou unidimensional V de n numere reale . 14 .k+1. se deplaseaza spre dreapta elementele din pozitiile k. se cauta pozitia k pe care urmeaza s-o ocupe v[i] intre elementele v[1].…..

if v[i]<v[m] then poz:=poz(li.’=’). for i:=1 to n do writeln(v[i]). deplasare(k.i:integer). var man:real. j:integer. for i:=2 to n do begin k:=poz(1.readln(v[i]). procedure deplasare(k. v[k]:=man.readln(n).i). for i:=1 to n do begin write(‘tastati elementul ‘. end. for j:=I downto k+1 do v[j]:=v[j-1]. begin write(‘cate elemente are vectorul?=’). end.ls. end.i. 15 . readln. writeln(‘vectorul ordonat este :’). end.i-1.m. end.i).i) else poz :=poz(m.i). begin if k<i then begin man:=v[i]. end.

lipsesc fazele de combinare a solutiilor subproblemelor(cautare binara).end. CONCLUZII Analiza complexitatii timp pentru algoritmii Divide et Impera Algoritmii de tip Divide et Impera au buna comportare in timp .daca se indeplinesc urmatoarele conditii:  dimensiunile subprogramelor(in care se imparte problema initiala )sunt aproximativ egale(“principiul balansarii”). 16 .

Sign up to vote on this title
UsefulNot useful