1

Metoda Divide et Impera

Metoda Divide et Impera ("desparte i stpnete") const n mprirea repetat a

unei probleme de dimensiuni mari n mai multe subprobleme de acelai tip, urmat de
rezolvarea acestora i combinarea rezultatelor obinute pentre a determina rezultatul
corespunztor problemei iniiale. Pentru fiecare subproblem procedm n acelai mod,
cu excepia cazului n care dimensiunea ei este suficient de mic pentru a fi rezolvat
direct.
Este evident caracterul recursiv al acestei metode.

Schema general

Descriem schema general pentru cazul n care aplicm metoda pentru o

prelucrare oarecare asupra elementelor unui vector. Funcia DivImp, care ntoarce
rezultatul prelucrrii asupra unei subsecvene ap,...au, va fi apelat prin DivImp(1,n).

function DivImp(p,u)
if up< p u
then r Prel(p,u)
else m Interm(p,u);
r1 DivImp(p,m);
r2 DivImp(m+1,u);
r Combin(r1,r2)
return r
end;

unde:
- funcia Interm ntoarce un indice n intervalul p..u (de obicei m= (p+u)/2 ).
- funcia Prel este capabil s ntoarc rezultatul subsecvenei p..u, dac aceasta este
suficient de mic;
- funcia Combin ntoarce rezultatul asamblrii rezultatelor pariale r1 i r2.

Exemple:
Calculul maximului elementelor unui vector;
Parcurgerile n preordine, inordine i postordine ale unui arbore binar;
Sortarea folosind arbori de sortare.

Mai pe scurt, putem spune:

Metoda Divide et Impera const n:

- construirea dinamic a unui arbore (prin mprirea n subprobleme) urmat de
- parcurgerea n postordine a arborelui (prin asamblarea rezultatelor pariale).

1
 2

Cutarea binar

Se consider vectorul a=(a1,...,an) ordonat cresctor i o valoare x. Se cere s

se determine dac x apare printre componentele vectorului.

Problema enunat constituie un exemplu pentru cazul n care problema se reduce

la o singur subproblem.
innd cont de faptul c a este ordonat cresctor, vom compara pe x cu elementul
din "mijlocul" vectorului. Dac avem egalitate, algoritmul se ncheie; n caz contrar vom
cuta fie n "jumtatea" din stnga, fie n cea din dreapta.

Vom aduga a0=-, an+1=+. Cutm perechea (b,i) dat de:

(true,i) dac ai=x;
(false,i) dac ai-1<x<ai.

Deoarece problema se reduce la o singur subproblem, nu mai este necesar s

folosim recursivitatea.
Algoritmul este urmtorul:

procedure CautBin
p u; u n
while pu
i (p+u)/2
case ai>x : u i-1
ai=x : write(true,i); stop
ai<x : p i+1
write(false,p)
end

Algoritmul necesit o mic analiz, legat de corectitudinea sa parial. Mai

precis, ne ntrebm: cnd se ajunge la p>u?
pentru cel puin 3 elemente : nu se poate ajunge la p>u;
pentru 2 elemente, adic pentru u=p+1: se alege i=p. Dac x<ai, atunci up-1. Se
observ c se iese din ciclul while i ai-1<x<ai=ap;
pentru un element, adic p=u: se alege i=p=u. Dac x<ai atunci up-1, iar dac
x>ai atunci pu+1; n ambele cazuri se prsete ciclul while i tiprete un
rezultat corect.

Problema turnurilor din Hanoi

Se consider 3 tije. Iniial pe tija 1 se afl n discuri cu diametrele decresctoare

privind de la baz ctre vrf, iar pe tijele 2 i 3 nu se afl nici un disc. Se cere s se mute
aceste discuri pe tija 2, ajutndu-ne i de tija 3, respectnd condiia ca n permanen pe
orice tij sub orice disc s se afle baza tijei sau un disc de diametru mai mare.

2
 3

O mutare este notat prin (i,j) i semnific deplasarea discului din vrful tijei i
deasupra discurilor aflate pe tija j. Se presupune c mutarea este corect (vezi condiia de
mai sus).

Fie H(m;i,j) irul de mutri prin care cele m discuri din vrful tijei i sunt
mutate peste cele de pe tija j, folosind i a treia tij, al crei numr este k=6-i-j.
Problema const n a determina H(n;1,2).
Se observ c este satisfcut relaia:
H(m;i,j) = H(m-1;i,k) (i,j) H(m-1;k,j) (*)
respectndu-se condiia din enun. Deci problema pentru m discuri a fost redus la dou
probleme pentru m-1 discuri, al cror rezultat este asamblat conform (*).

Corespunztor, vom executa apelul Hanoi(n,1,2), unde procedura Hanoi are

forma:

procedure Hanoi(n,i,j)
if n=1
then write(i,j)
else k6-i-j;
Hanoi(n-1,i,k); Hanoi(1,i,j); Hanoi(n-1,k,j)
end

Observaie. Numrul de mutri este 2n-1.

Sortare prin interclasare

Fie a=(a1,...,an) vectorul care trebuie ordonat cresctor.

Ideea este urmtoarea: mprim vectorul n doi subvectori, ordonm cresctor
fiecare subvector i asamblm rezultatele prin interclasare. Se observ c este aplicat
tocmai metoda Divide et Impera.

ncepem cu procedura de interclasare. Fie secvena de indici p..u i fie m un

indice intermediar. Presupunnd c (ap,...,am) i (am+1,...,au) sunt ordonai
cresctor, procedura Inter va ordona cresctor ntreaga secven (ap,...,au).
Mai precis, vom folosi notaiile:
k1 = indicele curent din prima secven;
k2 = indicele curent din a doua secven;
k3 = poziia pe care va fi plasat cel mai mic dintre ak1 i ak2 ntr-un vector auxiliar b.

procedure Inter(p,m,u)
k1p; k2m+1; k3p;
while k1m & k2u
if ak1<ak2 then bk3ak1; k1k1+1;
else bk3ak2 ;k2k2+1
k3k3+1

3
 4

if k1>m { au fost epuizate elementelei primei subsecvene }

then for i=k2,u
bk3ai; k3k3+1
else { au fost epuizate elementelei primei subsecvene }
for i=k1,m
bk3ai; k3k3+1
for i=p,u
aibi
end
Timpul de calcul este de ordinul O(u-p), adic liniar n lungimea secvenei
analizate.

Programul principal urmeaz ntocmai strategia Divide et Impera, deci se face

apelul SortInter(1,n), unde procedura recursiv SortInter are forma:

procedure SortInter(p,u)
if p=u
then
else m (p+u)/2 ;
SortInter(p,m); SortInter(m+1,u);
Inter(p,m,u)
end

Calculm n continuare timpul de executare T(n), unde T(n) se poate scrie:

t0 (constant), pentru n=1;
2T(n/2)+an, pentru n>1, unde a este o constant: problema de dimensiune n s-a
descompus n dou subprobleme de dimensiune n/2, iar combinarea rezultatelor s-a
fcut n timp liniar (prin interclasare).

Presupunem c n=2k. Atunci:

T(n) = T(2k) =2 T(2k-1) + a 2k =

=2[2T(2k-2) + a 2k-1] + a 2k = 22T(2k-2) + 2 a 2k =
=22[T(2k-3) + a 2k-2] + 2 a 2k = 23T(2k-3) + 3 a 2k =
. . .
= 2iT(2k-i) + i a 2k =
. . .
=2kT(1) + k a 2k = nt0 + a. n .log2n.

Rezult c T(n)=0(n.log n).

Se observ c s-a obinut acelai timp ca i pentru sortarea cu ansamble.
Meniune. Se poate demonstra c acest timp este optim.

4
 5

Metoda Quicksort

Prezentm nc o metod de sortare a unui vector a=(a1,...,an). Va fi aplicat

tot metoda Divide et Impera. i de aceast dat fiecare problem va fi descompus n
dou subprobleme mai mici de aceeai natur, dar nu va mai fi necesar combinarea
(asamblarea) rezultatelor rezolvrii subproblemelor.
Fie (ap,...,au) secvena curent care trebuie sortat. Vom poziiona pe ap n
secvena (ap,...,au), adic printr-o permutare a elementelor secvenei:
x=ap va trece pe o poziie k;
toate elementele aflate la stnga poziiei k vor fi mai mici dect x;
toate elementele aflate la dreapta poziiei k vor fi mai mari dect x.
n acest mod ap va aprea pe poziia sa final, rmnnd apoi s ordonm
cresctor elementele aflate la stnga sa, precum i pe cele aflate la dreapta sa.

Fie poz funcia cu parametrii p,u care ntoarce indicele k pe care va fi poziionat
ap n cadrul secvenei (ap,...,au).
Atunci sortarea se realizeaz prin apelul QuickSort(1,n), unde procedura
QuickSort are forma:
procedure QuickSort(p,u)
if p=u
then
else k poz(p,u); QuickSort(p,k-1); QuickSort(k+1,n)
end

Funcia poz lucreaz astfel:

function poz(p,u)
ip; ju; ii0; jj-1
while i<j
if ai<aj
then
else aiaj; (ii,jj)(-jj,-ii) (*)
ii+ii; jj+jj
poz i
end

S urmrim cum decurg calculele pentru secvena:

(a4,...,a11)=(6,3,2,5,8,1,9,7)
se compar 6 cu a11,a10,... pn cnd gsim un element mai mic. Acesta este a9=1.
Se interschimb 6 cu 1. Acum secvena este (1,3,2,5,8,6,9,7) i vom lucra n
continuare pe subsecvena (3,2,5,8,6), schimbnd direcia de comparare conform
(*);
6 va fi comparat succesiv cu 3,2,... pn cnd gsim un element mai mare. Acesta
este a8=8. Se interschimb 6 cu 8.

5
 6

Se obine astfel (1,3,2,5,6,8,9,7), n care la stnga lui 6 apar valori mai

mici, iar la dreapta lui 6 apar valori mai mari, deci l-am poziionat pe 6 pe poziia 8,
valoare ntoars de funcia poz.

Observaie. Cazul cel mai defavorabil pentru metoda Quicksort este cel n care
vectorul este deja ordonat cresctor: se compar a1 cu a2,...,an rezultnd c el se afl
pe poziia final, apoi se compar a2 cu a3,...,an rezultnd c el se afl pe poziia
final etc.

Trecem la calculul timpul mediu de executare al algoritmului Quicksort. Vom

numra cte comparri se efectueaz (componentele vectorului nu sunt neaprat numere,
ci elemente dintr-o mulime ordonat oarecare). Timpul mediu este dat de formulele:

1n


T(n) n 1 [T(k 1) T(n k)]
n k 1
T(1) T 0 0

deoarece:
n cazul cel mai defavorabil a1 se compar cu celelalte n-1 elemente;
a1 poate fi poziionat pe oricare dintre poziiile k=1,2,...,n; considerm aceste
cazuri echiprobabile;
T(k-1) este timpul (numrul de comparri) necesar ordonrii elementelor aflate la
stnga poziiei k, iar T(n-k) este timpul necesar ordonrii elementelor aflate la
dreapta poziiei k.

nT(n) = n(n-1)+2[T(0)+T(1)+...+T(n-1)]
(n-1)T(n-1) = (n-1)(n-2)+2[T(0)+...+T(n-2)]
Scznd cele dou relaii obinem:
nT(n)(n-1)T(n-1) = 2(n-1)+ 2T(n-1), deci:
nT(n) = (n+1)T(n-1)+2(n-1).
mpart cu n(n+1):

T(n) T(n 1) 2(n 1)

n 1 n n(n 1)
T(n) T(n 1) 2 1
2
n 1 T(n) n 1 n
T(n 1) T(n 2) 2 1
2
n T(n 1) n n 1
...........................
T(2) T(1) 2 1
2
3 2 3 2 f(x)=ln x

Prin adunarea relaiilor de mai sus obinem:

2 3 n n+1
 7

T(n) 1 1 1 2
2 ..... 1
n 1 n 1 n 3 n 1
Cum suma ultimilor doi termeni este negativ, rezult:
T(n) n 1 1
dx 2lnx|2n 1 2.ln(n+1)
n 1 2 x
(am folosit o inegalitate bazat pe sumele Rieman pentru funcia f(x)=ln x).
Deci T(n)=O(n.log n).

Arbori de decizie

Arborii de decizie sunt arbori binari strici ce reprezint o vizualizare a

algoritmilor de sortare bazai pe comparri.
Pentru fiecare nod intern:
- eticheta sa este i?j, semnificnd compararea lui ai cu aj;
- descendentul su stng corespunde situaiei aiaj;
- descendentul su drept corespunde situaiei ai>aj.
Fiecare frunz corespunde unei permutri a lui {1,2,...,n}, cu semnificaia:
a(1) a(2) . . . a(n),
relaii deduse din semnificaia muchiilor ce leag rdcina de frunz.
Deducem c numrul maxim de comparri necesare pentru sortare este egal cu
nlimea arborelui.

Teorem. Orice algoritm de sortare bazat pe comparri are timpul de executare de

un ordin cel puin egal cu O(n.log n).
Este suficient s demonstrm c orice arbore de decizie are nlimea de ordinul
O(n log n).
.

Considerm un arbore de decizie oarecare i fie h nlimea sa.

Cum un arbore binar strict de nlime h are cel mult 2h frunze i cum numrul
frunzelor este n!, rezult c n!2h.
Folosind inegalitatea n!>(n/e)n, obinem:
2h>(n/e)n
adic h>n.log2(n/e)
de unde rezult h=O(n.log n).

Incheiem cu meniunea c metoda Divide et Impera are o larg aplicativitate n

calculul paralel.