METODA DIVIDE ET IMPERA

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Sign up to vote on this title
UsefulNot useful