9.

METODA BACKTRACKING

Este una dintre cele mai cunoscute metode de elaborare a algoritmilor. Ea se aplic[ acelor
probleme @n care solu\ia se poate reprezenta sub forma unui vector x=(x1 ,. . . , xn )∈A1 x. . .xAn , unde Ai ,
i= 1, n sunt finite ( Ai =ni , i= 1, n ). #n plus, pentru fiecare problem[ @n parte este necesar ca solu\ia:
x1 ,...,xn sa satisfac[ anumite condi\ii interne ρ(x1 , . . . , xn ).
Mul\imea A=A1 x. . .xAn este spa\iul solu\iilor posibile. Elementele x∈A care satisfac condi\iile
interne se numesc solu\ii rezultat. Ne propunem determinarea tuturor solu\iilor rezultat, eventual pentru
a alege dintre ele pe cea care minimizeaz[ sau maximizeaz[ o func\ie obiectiv.
Metoda Backtracking evit[ generarea tuturor solu\iilor posibile (toate elementele produsului
cartezian A1 x...xAn ). Elementului xk ∈Ak , k= 1, n i se atribuie o valoare dup[ ce au fost atribuite valori
pentru componentele x1 ∈A1 ,..., xk-1∈Ak-1. Metoda trece la atribuirea unei valori pentru xk+1 ∈Ak+1 doar
dac[ xk @mpreun[ cu x1 ,...,xk-1 verific[ condi\iile de continuare, notate ρk (x1 ,...,xk ). Dac[ condi\iile
ρk (x1 ,...,xk ) sunt @ndeplinite se trece la atribuirea unei valori pentru elementul xk+1 ∈Ak+1 al solu\iei.
Neindeplinirea condi\iilor exprim[ faptul c[ oricum am alege xk+1 ∈Ak+1 ,...,xn ∈An nu vom putea ajunge
la o solu\ie rezultat @n care condi\iile interne s[ fie @ndeplinite. #n acest ultim caz va trebui s[ facem o
alt[ alegere pentru xk , iar acest lucru este posibil doar dac[ nu am epuizat toate valorile posibile din
mul\imea Ak . Dac[ mul\imea Ak a fost epuizat[ va trebui sa mic]or[m pe k, k←k-1 ]i s[ trecem la
alegerea unei alte valori pentru elementul xk-1∈Ak-1.

Backtracking
Intrare: -mul\imile A1 ,...,An
-condi\ia intern[ ρ(x1 , . . . , xn ) pentru solu\ia (x1 ,...,xn )∈A1 ,...,An , exprimat[ prin ρi (x1 ,...,xi ),
i= 1, n , condi\ii la pasul i.
Ie]ire: -solu\iile rezultat (x1 , . . . , xn ).

Procedure posibil (x,k;v)

x:vect. Solutiilor rezultat x=(x1,…,xn)
k:pasul curent. Semnifica cautarea unei noi valori α∈Ak care va fi atribuita
componentei xk a solutiei.
v:variabila booleana.
v= true ⇔ ∃ α∈Ak neatribuita pentru xk si ρ k(x1,…,xk-1,α)= true
false ⇔ caz contrar
w: variabila booleana auxiliara.

repeat
v←(„∃ α∈Ak neatribuita inca pentru xk”); w←true
1

if v then
2
xk←α
if not ρ k(x1,…,xk) then w←false endif
endif
until (not v) or (v and w)
v←(v and w)
end posibil

function este_sol (k):boolean

este_sol ← (k=n)
end este_sol
k←1; xk←3αk initial, α k initial ∉Ak
while (k>0)
posibil (x, k sol)
if not sol then k←k-1
else
if este_sol (k) then tipareste (x1,…,xn)
else
k←k+1; xk←3αk initial, α k initial ∉Ak
endif
endif
end while

Un caz particular al problemelor backtracking este acela @n care mul\imile Ai , i= 1, n con\in

elemente aflate @n progresie aritmetic[. Astfel, pentru mul\imea Ai avem:
ai1 : primul element
hi : ra\ia
bi : ultimul element
#n acest caz algoritmul se modifica astfel:
Instruc\iunea 1: v←(xk <bk )
Instruc\iunea 2: xk ←xk +hk
Instruc\iunea 3: xk ←ak1 -hk

Exemplul 1: Problema color[rii h[r\ilor:

S[ se coloreze o hart[ reprezent`nd n \[ri folosind m culori etichetate 1,...,m.
Rezolvare: Datele necesare pentru descrierea h[r\ii vor fi reprezentate de o matrice Anxn cu
semnifica\ia
aij = 1, \ara i are frontier[ comun[ cu \ara j
0 contrar (⇔aij =aji )
aii =0
Fie C={c1 ,...,cm } mul\imea culorilor cu ci =ν, ν=1, m .
Vectorul solu\iei rezultat x=(x1 ,...,xn )∈Cx...xC (de n ori), are semnifica\ia: \ara i are repartizat[
culoarea xi ∈C, i= 1, n . Ini\ial, fiec[rei \[ri i se va atribui culoarea O∈C.
La pasul k @ncerc[m s[ atribuim o nou[ culoare (xk +1) pentru \ara k (k= 1, n ), dac[ sunt
@ndeplinite condi\iile:
1. xk <m ⇔ se mai pot g[si alte culori pentru \ara k.
2. ∀i, 1≤i<k cu ai,k =1 avem xi ≠xk +1
Dac[ 1 ]i 2 sunt @ndeplinite, atunci noua culoare pentru \ara k va fi xk +1 ]i se poate trece la
stabilirea unei noi culori pentru \ara k+1. Astfel, \[rii k nu i se mai poate atribui alt[ culoare ]i ne
@ntoarcem la alegerea unei noi culori pentru \ara k-1. Algoritmul se termin[ c`nd nu se mai poate
atribui culoare pentru \ara 1.

Exemplul 2:Problema damelor

Pe o tabl[ de ]ah cu n×n p[trate, s[ se a]eze n dame a]a @nc`t s[ nu se atace reciproc.
Rezolvare: Dac[ vom considera matricea A=(ai,j )i,j= 1, n care s[ reprezinte tabla de ]ah ]i dou[ dame @n
pozi\iile aij si akl , atunci cele dou[ dame se atac[ reciproc dac[:
i=k sau j=l sau |i-k|=|j-l|
 Din prima rela\ie deducem faptul c[ fiecare dam[ trebuie s[ fie a]ezat[ pe o linie separat[. #n
continuare vom avea grij[ s[ nu fie @ndeplinite celelalte dou[ rela\ii.

Not[m N={1,...,n} mul\imea celor n coloane ale tablei de ]ah. Vectorul solu\iei rezultat
x=(x1 ,...,xn )∈N×...×N (de n ori) are semnifica\ia:
-componenta i a vectorului (i= 1, n ) reprezint[ linia i de pe tabla de ]ah. Valoarea xi a acestei
componente reprezint[ coloana @n care se a]eaz[ dama de pe linia i.
Ini\ial, toate damele sunt @n afara tablei de ]ah, deci xi =0, i= 1, n .
La pasul k vom @ncerca a]ezarea damei k pe linia k @n coloana x[k]+1. Ini\ial, dama k este @n
afara tablei (x[k]=0∉N). #n general, vom putea a]eza dama @ntr-o alt[ coloan[ dac[ vechea pozi\ie
satisface condi\ia xk <n (1). De fiecare dat[ noua pozi\ie va trebui s[ satisfac[ cond. Interne ρk :
(2) ∀i, 1≤i<k: xi ≠(xk +1) (nu sunt pe aceea]i coloan[), ]i
|i-k|≠|xi-(xk +1)| (nu sunt pe diagonal[)
Dac[ xk <n ]i ρk sunt adevarate, dama de pe linia k se a]eaz[ @n coloana xk +1 ]i se trece la
a]ezarea damei k+1. Astfel, dama k nu poate fi a]ezat[ pe tabla ]i va trebui s[ relu[m a]ezarea damei
k-1. Algoritmul se termin[ c`nd dama 1 nu mai poate fi a]ezat[ pe tabl[ (se @ncearc[ a]ezarea damei @n
coloana 0).

Exemplul 3:Problema comis-voiajorului

Un comis-voiajor trebuie sa viziteze n ora]e etichetate 1,...,n. Va pleca din ora]ul 1 ]i se va
@ntoarce tot @n 1, trec`nd prin fiecare ora] (@n afar[ de ora]ul 1, celelalte ora]e trebuie vizitate o singur[
dat[). Cunosc`nd leg[turile existente @ntre ora]e, s[ se tip[reasc[ toate drumurile posibile.
Rezolvare: Datele referitoare la drumurile dintre ora]e vor fi reprezentate @ntr-o matrice Anxn cu:
aij = 1 ∃ drum direct @ntre ora]ul i ]i ora]ul j
0 nu exist[ drum direct @ntre ora]ul i ]i ora]ul j
aii =0
Vectorul solu\iilor rezultat va fi x=(x1 , ... , xn , xn+1 ) cu x1 =xn+1 =1 ]i cu semnifica\ia: pe poz. i
(i= 1, n + 1 ) se viziteaz[ ora]ul xi ∈N.
La pasul k (2≤k≤n) se @ncearc[ vizitarea ora]ului x[k]+1 dac[:
(1) 1≤x[k]<n (ini\ial x[k]=1) ]i
a[x[k-1], x[k]+1]=1 (pt. k=n trebuie ]i a[1, x[k]+1]=1)
Dac[ (1) este adev[rat[ atunci x[k]←x[k]+1 ]i trebuie s[ fie satisf[cute condi\iile interne:
(2) ρk : ∀i, 1≤i<k ; xk ≠xi
Dac[ (1) ]i (2) sunt adev[rate se poate trece la vizitarea ora]ului k+1.
#n caz contrar cu ora]ul de pe pozi\ia xk nu ajungem la o solu\ie rezultat ]i va trebui s[ ne
@ntoarcem la o alt[ alegere pentru ora]ul de pe pozi\ia k-1.

Exemplul 4: S[ se descompun[ num[rul natural n @n toate modurile posibile ca sum[ de p

numere diferite (p≤n).
p
Rezolvare: Vectorul solu\iilor rezultat este x=(x1 , ..., xp ), ∑ x1 =n.
i =1
Obs.
1. Cel mai mare num[r ce poate fi atribuit compon. xi , i= 1, p este n-p+1 (pentru c[
n=n-p+1+(1+1+...+1) p-1 ori
 3. Trebuie s[ evit[m determinarea unor solu\ii care se deosebesc @ntre ele doar prin pozi\ia
numerelor din descompunere, ex.
5=2+3, 5=3+2, 5=1+4, 5=4+1
Pentru aceasta vom genera pe pozi\ia k (k= 1, p ) doar valori xk care satisfac: k≤xk ≤n-p+1
Astfel va ob\ine solu\ii @n care componentele sunt @n ordine cresc[toare.
Fie Nk ={k, ..., n-p+1} k= 1, p
Atunci x=(x1 ,...,xp )∈N1 xN2 x...xNp . Ini\ial xk =k-1, k= 1, p
La pasul k (k= 1, p ), val. de pe poz. k este xk . Vom putea schimba acea valoare cu xk +1 doar
dac[
(1) k-1≤xk <n-p+1 ⇔ ∃ α∈Nk neatrib. lui xk
(2) ρk : ∀i, 1≤i<k, xi ≠xk +1
Dac[ (1) ]i (2) sunt adevarate atunci xk ←xk +1 ]i se trece la poz. k+1. Altfel, orice valoare
pentru xk nu ne va conduce la o solu\ie rezultat ]i va trebui s[ ne @ntoarcem la atribuirea unei alte valori
pentru pozi\ia k-1.
Algoritmul se @ncheie c`nd epuiz[m toate valorile pentru pozi\ia k=1.

Backtracking recursiv

Algoritmul general backtracking prezentat la @nceputul cursului poate fi scris sub o form[
recursiv[. Astfel, partea principal[ a algoritmului notat[ cu (I) poate fi @nlocuit[ prin apelul unei
proceduri recursive Back (K: integer). Apelul se va face cu Back (1).
procedure Back (k)
k: pasul curent
if (k>0) then
posibil (x, k, sol)
if (not sol) then k←k-1
else
if este sol(k) then tipareste (x1,…,xn)
else
k←k+1, xk←αk, initial
end if
end if
Back (k)
end if
end Back.

#n cazul unor astfel de implement[ri este bine ca procedura Back() s[ nu con\in[ apelul unei alte
proceduri sau func\ii, dec`t apelul Back... Spre exemplu proced. posibil ar trebui @ntocmit[ cu corpul ei.

Alt exemplu de algoritm backtracking recursiv

Problema labirintului: Se d[ un labirint sub form[ de matrice cu n linii ]i m coloane. Fiecare

element al matricei este o camer[. Fiecare camer[ are 0 p`n[ la 3 u]i. Se d[ o pozi\ie ini\ial[ ]i s[ se
g[seasc[ toate posibilit[\ile de a ie]i din labirint.
Rezolvare: Fiec[rei camere @i vom ata]a un num[r ∈[0, 16]. Codul binar al ac. Num[r va reprezenta
configura\ia u]ilor din camer[.
VNSE , V, N, S, E∈{0, 1} → 0: nu este u][
1: este u][
 vest est

10. METODA GREEDY

Aceast[ metod[ se aplic[ problemelor @n care se d[ o mul\ime A cu n elemente ]i se cere s[ se

determine o submul\ime B⊆A care s[ @ndeplineasc[ anumite condi\ii pentru a putea fi acceptat[. Este
posibil ca sa existe mai multe mul\imi acceptabile (solu\ii posibile). De aceea se mai furnizeaz[ ]i un
criteriu prin care, din solu\iile posibile, se alege una singur[ numit[ solu\ie optim[.
Solu\iile posibile au proprietatea: dac[ B este solu\ie posibil[ ]i C⊂B, atunci ]i C este solu\ie
posibil[. Prin defini\ie Φ este solu\ie posibil[.

Algoritmul Greedy-1
Intrare: mul\imea A a elementelor de intrare; |A|=n.
Ie]ire: mul\imea B - solu\ia optim[.
Alege (A,i;x): alege la pasul i din mul\imea A, elementul x. Alegerea se face conform unui
criteriu care, @n final s[ conduc[ la solu\ia optim[.
Posibil (B,x;v): furnizeaz[ @n v∈{true, false} r[spunsul la @ntrebarea: „B∪{x} este sau nu
solu\ie posibil[?”
Adaug (x;B): x adaug[ la B elementul x: B←B∪{x}.

B←Φ
For i=1 to n do
Alege (A, i, X)
Posibil (B, x, v)
if (v) then Adaug (x, B)
end if
repeat

#n aceast[ versiune, criteriul de alegere este aplicat la fiecare pas. Algoritmul poate suferi o
modificare. Vom ordona elementele mul\imii A conform criteriului de alegere stabilit. Urmeaz[ ca apoi
elementele din A s[ fie extrase @n aceast[ ordine.

Algoritmul Greedy-2
Intrare: mul\imea A a elementelor de intrare; |A|=n, A={a1 ,...,an }.
Ie]ire: mul\imea B-solu\ie optim[.
Perm(;A): permut[ elementele lui A ordon`ndu-le conform criteriului de alegere stabilit.
Posibil (B,x,v)
Adaug (x,B)

B←Φ; Perm(A)
For i=1 to n do
Posibil (B, ai, v)
If (v) then Adaug(B, ai)
end if
repeat

Exemplul 1: Se d[ mul\imea X={x1 ,. . ., xn }⊂R. S[ se determine submul\imea Y a.@. ∑y

y∈Y
s[ fie

maxim[.
 Rez. Dac[ ∃ y0 ∈Y cu y0 ≤0, atunci ∑ y≤ ∑ y.
y∈Y y∈Y \{ y 0 }
Deci solu\ia posibil[ Y⊂X este

Y={yσx /y>0}⊂X.

Suma max
Intrare real array X[n]
Ie]ire real array Y[n]

k←0
for i=1 to n do
if (xi>0) then
k←k+1
yk←xi
end if
repeat

Obs. Ar fi mai costisitor (ca timp de execu\ie) s[ ordon[m mul\imea X.

Exemplul 2. Memorarea textelor pe benzi.

a) Fiind date ]i texte de lungimi diferite L1 , . . . ,Ln s[ se @nmagazineze aceste texte pe o band[
suficient de lung[. }tiindu-se ca citirea textului k se face dup[ citirea textelor 1, . . . , k-1 s[
se a]eze aceste texte a]a @nc`t timpul de citire pentru fiecare din ele s[ fie minim.
Rezolvare: Fie o pozi\ionare a textelor pe band[ dat[ de permutarea p(1, 2,..., n) = (p1 ,...pn ) @n
care textul k apare al pk -lea.
#n general, citirea unui text de lungime Lk necesit[ un timp direct propor\ional cu Lk : Tk ~Lk .
Atunci citirea textului k, care se afl[ pe pozi\ia pk , se va face dup[ textele p1 ,...,pk-1 ]i va avea
k
timpul ∑ Lpi .
i =1
Timpul mediu de reg[sire a unui text va fi:
1 n k
1 n
n∑ ∑ L pi =
n∑
( n − k + 1) Lpk
k =1 i =1 k =1
n
Consider[m func\ia: ρ(p)= ∑ (n − k + 1) L pk , p-permutare pentru {1,...,n} ]i s[ determin[m
k =1
permutarea p care o minimizeaz[.

Criteriul de alegere: Dac[ am ales textele p1 ,...,pk-1 ]i le-am a]ezat pe band[ @n aceea]i ordine,
atunci cea mai buna alegere pentru textul pk va fi textul cel mai scurt dintre textele {1, 2,..., n} /
{p1 ,...,pk-1}. Astfel suntem condu]i la alegerea textelor @n ordinea cresc[toare a lungimilor lor.

PROPOZI|IE. Fie p=(1, 2, ... , n) permutare dat[ de ordinea cresc. L1 ≤L2 ≤...≤Ln . Atunci
pozi\ionarea @n aceast[ ordine este optim[.
Demonstra\ie. Fie p=(p1 ,...,pn ) o pozi\ionare optim[. Presupunem, prin absurd, c[ ∃ i<j a.@.
Lpi ≥Lpj . Fie p’ ob\inut[ din p schimb`nd pi cu pj . Cele dou[ permut[ri difer[ doar cu dou[ pozi\ii.
Atunci:
 ρ(p’)-ρ(p)=(n-i+1)(L pj -Lpi )+(n-j+1)(L pi -Lpj )=(j-i)(L pj -Lpi )≤0
⇒ρ(p’)≤ρ(p) dar ρ(P) este minim[ ⇒ ρ(p’)=ρ(p) ⇒ p’ este pozi\ionare optim[.
Aplic`nd acest ra\ionament de mai multe ori, trecem din permutare @n permutare p`n[ ajungem
la permutarea identic[ p=(1, 2,..., n) dat[ de L1 ≤L2 ≤...≤Ln .

Rez. practic[. Un tablou de sting-uri care se va ordona cresc[tor.

b) Cele n texte se vor a]eza pe m benzi.
Rezolvare.
Pozi\ionarea celor n texte pe m benzi va corespunde unei partitii a mul\imii {1,...,n}=P1 ∪...∪Pm
1 m
m ∑
iar timpul mediu de reg[sire a unui text pe una din benzi este: ρ( Pk ) . Vom lua
k =1
m
ρ(P)= ∑ ρ( Pk ) , P=p ∪...∪p .
1 m
k =1

Dorim s[ g[sim parti\ia P care minimizeaz[ ρ(P).

Criteriu de alegere. Presupunem c[ am pozi\ionat k-1 texte. Vom alege din cele n-k+1 texte
r[mase pe cel mai scurt. #l vom a]eza pe banda cea mai liber[.
Vom considera textele @n ordinea cresc[toare a lungimilor L1 ≤...≤Ln ]i vom a]eza textul i pe
banda mod(i-1, m)+1 @n continuarea celor deja aflate pe aceast[ band[. Rezult[ c[ pe aceast[ band[ vor
fi a]ezate textele i+m, i+2m,... @n total mod(n-i, m) texte.
PROPOZI|IE:
Fie textele ordonate cresc[tor L1 ≤...≤Ln . A]ezarea textului i pe banda mod(i-1, m)+1, i= 1, n este
o pozi\ionare optim[.
Demonstra\ie: Aplic`nd metoda de mai sus rezult[ c[ pe fiecare band[ textele sunt a]ezate in
ordine cresc[toare (cele mai lungi m texte vor fi ultimele pe cele m benzi).
Fie ui ≡nr. de texte ce urmeaz[ textului i pe banda unde acesta se afl[. Fie P o parti\ionare
optim[.
Dac[ n≥m atunci nici o band[ nu este goal[ (am putea muta un text de pe o band[ cu minim
dou[ texte pe banda goal[ ]i am ob\ine o parti\ionare P’ mai bun[ dec`t P).
#n condi\ia n≥m cele mai lungi m texte apar pe ultima pozi\ie de pe cele m benzi. Valoarea n
corespunz[toare lor este 0. S[ dovedim acest lucru. Presupunem prin absurd ca exist[ un text i, ultimul
pe o band[ ]i mai exist[ pe o alt[ band[ textele j ]i k (ultimele @n aceast[ ordine) a.@.: Li <Lj ]i Li <Lk
(unde Lj <Lk ) ⇔ Li<Lj ]i ui =0 dar uj =1. Schimb`nd textele i ]i j @ntre ele am ob\ine o parti\ionare P’
strict mai bun[ dec`t P, contrazic`nd ipoteza.
Deci cele mai lungi m texte au u=0. Urm[toarele m texte ca lungime vor avea u=1. #n general,
textul i din ordinea L1 ≤...≤Ln va avea ui =mod(n-i, m).
Rezolvare practic[ : Cele m benzi vor fi m linii ale unui tablou bidimensional de ]iruri de
caractere (string-uri).

Exemplul 3: Problema rucsacului.

Cu ajutorul unui rucsac @n care se poate @nc[rca greutatea maxim[ G, trebuie transportate
obiectele O1 ,...,On . Obiectul i are greutatea gi ]i pentru transportul lui @n @ntregime se c`]tig[ Ci (i= 1, n ).
S[ se determine ce obiecte trebuie transportate pentru a se realiza c`]tigul maxim.
Rezolvare: Se disting dou[ cazuri:
1. Cazul continuu: Putem lua din ob. i orice parte xi ∈[0, 1].
 2. Cazul 0/1: Orice obiect i poate fi @ncadrat doar @n @ntregime sau deloc, xi ∈{0, 1}.
Fie x=(x1 ,...,xn ) vect. solu\ie @n ambele cazuri. Solu\ia optim[ va trebui s[ satisfac[:
n n
Cazul 1: ∑ gi xi =G ]i Cazul 2: ∑ gi xi ≤G
i =1 i =1
#n ambele cazuri solu\ia optim[ trebuie s[ maximizeze func\ia de c`]tig:

n
f(x)= ∑ ci xi (1)
i =1
Pentru a ajunge la solu\ia optim[ vom considera @n ambele cazuri obiectele @n ordinea
descresc[toare a c`]tigurilor unitare ci /gi , i= 1, n .

Cazul continuu
Presupunem ordinea c1 /g1 ≥c2 /g2 ≥...≥cn /gn ]i vom @ncerca s[ @nc[rc[m pe c`t posibil obiectele @n
@ntregime, In ordinea considerat[, p`n[ c`nd ajungem la greutatea G.
Vect. x=(x1 ,...,xn ) este solu\ie posibil[ dac[ xi ∈[0, 1], i= 1, n
n

∑ gi xi ≤G
i =1

Sol. posibil[ este optim[ dac[ maximizeaz[ func\ia de c`]tig (1).

Fie procedura RUCSAC, conform metodei Greedy.

RUCSAC (n, G, g, c, x, C)
n: nr. de obiecte
G: greutatea maxima ce poate fi dusa in rucsac
g: array[1...n] - vectorul greutatilor obiectelor
c: array[1...n] - vect. castigurilor corespunzatoare fiecarui obiect
x: array[1...n] - vect. sol. optime
C: castigul total
C←0, i=1
while (G>0) and (υ≤n)do
if gi<G then xi←1, G←G-gi, C←C+ci, i←i+1
else xi←G/gi, C←C+ci*xi, G←0
for j=i+1 to n do xj←0 repeat
end if
end while
Tipareste (x1,…,xn)
end RUCSAC

Observ[m c[ @n urma procedurii RUCSAC vect. sol. este x=(1,..., 1, xj , 0,..., 0) unde 1≤j≤n, j-
n
unic ]i xj ∈(0, 1]. Avem ∑ gi xi =G.
i =1

Ne propunem s[ ar[t[m c[ x este solu\ie optim[.

n
Dem.: Fie y=(y1 ,..., yn ) solu\ia optim[ ⇔ ∑ gi yi =G ]i presupunem y≠x.
i =1

Atunci, fie k≤n cel mai mic indice a.@. yk ≠xk (yi =xi , i= 1, k − 1 , yk ≠xk ). Pornind de la solu\ia y vom
construi o nou[ solu\ie optim[ y’ cu propr. y’i =xi , i= 1, n . Repet`nd procedeul p`n[ c`nd k=n vom
ajunge la o solu\ie optim[ care coincide cu x.
 Observa\ii:
n n n
1. k≤j. Daca k>j, atunci ∑ gi yi >G ( ∑ gi yi > ∑ gi xi =G) si y nu ar mai fi solu\ia posibil[.
i =1 i =1 i =1

2. yk <xk : Daca k<j, atunci xk =1 ⇒xk =1 ]i yk ≠xk ⇒yk <1=xk

n n
Dac[ k=j, putem presupune yk >xk ⇒ ∑ gi yi > ∑ gi xi =G (fals). ⇒yk <xk .
i =1 i =1

Fie y’=(y1 ,...,yk-1, xk , y’k+1 ,...,y’ n )=(1,…,1,xk , y’k+1 ,…,y’ n ) cu y’i=εyi , i= k + 1, n a.@. greutatea
maxim[ ob\inut[ in cazul lui y s[ fie men\inut[ ]i pentru y’. Not[m
ρ(ε)=[gk xk +ε ∑ gi yi ]-[gk yk + ∑ gi yi ]
i> k i> k

ρ(1)=gk (xk -yk )>0 ≤G =G

k −1 k −1 k n
ρ(0)=gk xk -gk yk - ∑ gi yi = ∑ gi xi +gk xk - ∑ gi yi -gk yk - ∑ gi yi = ∑ gi xi - ∑ gi yi ≤G-G=0
i> k i =1 i =1 i> k i =1 i =1

ρ(1)>0 ]i ρ(0)≤0 ⇒ ∃ ε∈[0, 1) a.@. ρ(ε)=0 ⇒gk xk + ∑ gi yi =gk yk + ∑ gi yi

i> k i> k
n n
⇒ ∑ gi y’i = ∑ gi yi ⇒y’ este solu\ia posibil[.
i =1 i =1
}tim c[ f(y)=maxim[.
f(y’) – f(y)=ck xk + ∑ ciyi′-ck yk - ∑ ciyi=ck (xk -yk )- ∑ ci(yi-yi′)=ck /gk [gk (xk -yk )-
i> k i> k i> k

∑ cigk /ck (yi-yi′)]

i> k

Dar, cum c1 /g1 ≥...≥cn /gn ⇒ g1 /c1 ≤…≤gn /cn ⇒ pentru i>k: gi /ci >gk /ck
#nlocuind gk /ck cu gi /ci ob\inem:
f(y’) – f(y)≥ck /gk [gk (xk -yk )- ∑ gi(yi- yi′)]=ck /gk [(gk xk + ∑ gi yi′)-(gk yk + ∑ gi yi )]=ck /gk ρ(ε)=0
i> k i> k i> k

⇒ f(y’) ≥ f(y) ]i f(y) maxim[ ⇒ f(y’) = f(y) ⇒y′ solu\ia optim[.

Caz practic: g=(4, 6, 2), C=(4, 3, 1), G=8 ⇒ m=(1, ½ , ½ )

Algoritmul RUCSAC determin[ solu\ia optim[ x=(1, 2/3, 0) ]i f(x)=6, dar exist[ ]i situa\ia
x=(1, 0, 2) ]i f(x)=6. Se propune ca exerci\iu modificarea algoritmului a.@. s[ afi]eze toate solu\iile
(vezi programul RUCSAC.CPP).
Cazul 0/1
n
Vectorul y=(y1 ,...,yn ) este solu\ie posibil[ dac[: yi ∈{0, 1} ]i ∑ gi yi ≤G. Solu\ia posibil[ y este
i =1
n n
optim[ dac[ f(y)= ∑ ci yi =maxim[ (∀ k= 1, n cu yk =0, dac[ yk <1 ⇒ ∑ gi yi +gk >G, i≠k)
i =1 i =1

Procedura RUCSAC 01
RUCSAC 01 (n, G, g, c; x, C)
G1←0, C←0
for i=1 to n do
if (G1+gi<G) then
xi←1
G1←G1+gi, C←C+ci
 else xi←0
end if
repeat
Tipareste (x 1,…, xn)
end RUCSAC 01

k −1 k −1
Din algoritmul RUCSAC 01 ⇒ ∀ k=1, n cu xk =0 ⇒ ∑ gi xi ≤ G ]i ∑ gi xi +gk > G
i =1 i =1
Ne propunem s[ ar[t[m c[ vectorul x=(x1 ,..., xn ) ob\inut de algoritmul RUCSAC 01 este solu\ia
optim[.
Fie y=(y1 ,..., yn ) solu\ie optim[. Presupunem y≠x.
Fie k primul indice a.@.: xk ≠yk ⇔ xi =yi , i= 1, k − 1 . Atunci sunt dou[ posibilit[\i:
k −1
1. xk =0 ⇒ ∑ gi xi +gk >G
i =1
k −1
yk =1 ⇒ ∑ gi yi +gk≤G Contradic\ie!!
i =1
n
Pentru c[ ∑ g ky k≤G ⇒ (x k≠yk ) (⇔False) ⇒
k =1
k −1
2. xk =1 ⇒ ∑ gi xi +gk≤G
i =1
k −1
yk =0 ⇒ ∑ gi yi +gk >G Contradic\ie!!
i =1

⇒ xk =yk ⇒ x=y ⇒ x solu\ie optim[.

Observa\ie: Algoritmul RUCSAC 01 furnizeaz[ o singur[ solu\ie optim[. A se modifica pentru

a da toate solu\iile (vezi RUCSAC 01 2.CPP).

11. METODA „DIVIDE ET IMPERA”

Metoda ″Divide et impera″ (″desparte ]i st[p`ne]te″) este o alt[ metod[ general[ de elaborare a
algoritmilor. Principiul metodei a fost enun\at de Iulius Cezar. Este o metod[ puternic recursiv[. Ea
const[ @n @mp[r\irea repetat[ a unei probleme de dimensiune mai mare @n dou[ sau mai multe
subprobleme de acela]i tip dar de dimensiuni mai mici. Descompunerea problemelor se repet[ p`n[
c`nd ultimele probleme pot fi rezolvate @n mod simplu. Apoi se merge pe cale invers[ combin`ndu-se
solu\iile de la fiecare pas p`n[ se ob\ine solu\ia problemei.
Altfel spus, fie un vector A={a1 , ... , an } reprezent`nd o mul\ime ale c[rei elemente trebuie
prelucrate conform unei anumite probleme. Presupunem c[ pentru ∀ p, q ∈ {1, ... , n} indici cu p<q ∃
m ∈ {p, p+1, ... , q} astfel @nc`t prelucrarea secven\ei {ap , ... ,aq } se poate face prelucr`nd separat
secven\ele {ap , ap+1 , ... ,am} ]i {am+1 , ... , aq }. Apoi, combin`nd solu\iile se determin[ solu\ia pentru cazul
secven\ei {ap , ... , aq }.

Procedure divide et impera (p, q, α)

p, q : indici din multimea {1, … , n}, p<q
 α : solutia problemei la pasul curent
prel (p, q, α) : procedura care obtine solutia problemei pentru sub-
multimea {ap, … , aq}
divizeaza (p, q, m) : procedura care determina indicele p≤m≤q nece-
sar pentru divizarea problemei
combina (β, γ, α) : combina solutiile β se γ obtinand solutia α
if (q-p≤eps) then prel (p, q, α)
else
divizeaza (p, q, m)
divide et impera (p, m, β)
divide et impera (m+1, q, γ)
continua (β, γ, α)
end if
end.

Problema 1: Fiind dat un tablou de elemente @ntregi sau reale A={a1 , ... , an } se cere s[ se
determine valoarea maxim[.
Obs. Problema este pur didactic[ pentru c[ ea are o solu\ie mai simpl[ dec`t cea oferit[ de
metoda ″Divide et impera″.
Rezolvare: Presupunem c[ trebuie s[ g[sim maximul elementelor din secven\a de elemente {ai ,
ai+1 , ... , aj }, i,j∈{1, ... , n} ]i i≤j. Ini\ial vom considera i=1, j=n. Dac[ i=j atunci max=ai . Altfel:
1. se determin[ k=(i+j) div 2
2. se determin[ a=max{ai , ... , ak } ]i b=max{ak+1 , ... , aj }
3. se determin[ max(a, b)
const N=...?

function max(v: array[1...N] of real; i, j : integer) : integer;

var a, b : real;
begin
if i=j then max:=v[i]
else
begin
a:= max (v, i, ((i+j) div 2));
b:= max (v, ((i+j) div 2) +1, j);
if (a>=b) then max:=a
else max:=b;
end;
end;

Problema 2: (C[utare binar[). Fiind dat[ o multime de elemente A={a1 , ... , an } ordonat[
(presupunem ordonarea cresc[toare a1 ≤a2 ≤...≤an ) s[ se determine dac[ valoarea c (de acela]i tip cu
elem. din A) se afl[ @n mul\ime.
Rezolvare: Presupunem c[ trebuie s[ r[spundem dac[ c se afl[ @n cadrul secven\ei {ai ,ai+1 ,...,aj },
i,j∈{1, ... ,n}. Ini\ial i=1, j=n.
Dac[ j<i algoritmul se termin[ f[r[ succes. Altfel:
1. se determin[ k=(i+j) div 2
2. dac[ c=ak algoritmul se termin[ cu succes
3. dac[ c≠ak atunci:
- dac[ c<ak atunci c[ut[m pe c @n cadrul secven\ei {ai , ... , ak-1} (j=k-1)
 - dac[ c>ak atunci c[ut[m pe c @n cadrul secven\ei {ak+1 , ... , aj } (i=k+1)

procedure caut bin (a: array [1...N] of real; c: real; i,j: integer;
var k: integer); var l integer;
{k=-1 insucces; 1≤k≤n : succes}
begin
if (j<i) then k:=-1
else
begin l:= (i+j) div 2;
if (c=a[l]) then k:=l
else
begin
if (c<a[l]) then cant bin (a, c, i, l-1, k)
else cant bin (a, c, l+1, j, k);
end;
end;
end;

Problema 3: (Problema turnurilor din Hanoi). Se dau trei tije numerotate cu 1, 2, 3 ]i n∈N
discuri perforate ]i de diametre diferite. Ini\ial toate discurile sunt a]ezate pe tija 1 @n ordinea
descresc[toare a diametrelor, consider`nd sensul de la baza tijei spre v`rful ei. S[ se mute toate
discurile pe tija 2 @n acceea]i ordine, folosind tija 3 ca tij[ intermediar[ ]i respect`nd regulile:
-la fiecare pas se mut[ un singur disc din v`rful unei tije.
-pe fiecare tij[, la orice pas, deasupra fiec[rui disc pot apare numai discuri de diametre mai
mici.
Rezolvare: Vom simboliza mutarea unui disc de pe tija i pe tija j , i,j∈{1, 2, 3}, prin perechea
(i, j), i≠j.

n=1 D1 ⇒ (1, 2)
1 2 3
T T T
P1

n=2 p2 p3
D2
D1 D2
T1 T2 T3

P1: D2 : T1→T3; p2 : D1 : T1→T2; p3 : D2 : T3→T2

(1, 3) (1, 2) (3, 2)

Observa\ie: Pentru a putea muta cele dou[ discuri de pe tija i=1 pe tija j=2 am utilizat ca tij[
intermediar[, tija k = 6 - i - j = 6 - 1 - 2 = 3, k = 3.

P1
n=3 p2
D3 p3
D2 D3
D1 D1 D2
T1 T2 T3
 Observ[m c[ putem, petru @nceput, s[ facem abstrac\ie de discul D1 ]i s[ @ncerc[m s[ mut[m
n=2 discuri (D2 ]i D3) de pe tija T1 pe tija T3, folosind tija k = 6 - 1 - 3 = 2 ca tij[ intermediar[.
Revenim la discul D1 mut`ndu-l pe tija T2. #n final proced[m din nou ca @n cazul n=2
pentru discurile D2 ]i D3 mut`ndu-le de aceast[ dat[ de pe tija T3 pe tija T2 ]i utiliz`nd tija
k=6-3-2=1 ca tij[ intermediar[.
#n general, dac[ not[m cu H(n, i, j) ]irul mut[rilor necesare pentru a a]eza n discuri (considerate
@n ordinea cresc[toare a diametrelor ]i sens v`rf-baz[ tij[) de pe tija i pe tija j folosind tija k=6-i-j ca
tij[ intermediar[, atunci,

(i, j) dac[ n=1

H(n, i, j) =
H(n-1, i, k), (i, j), H(n-1, k, j) dac[ n>1.

Astfel, reducem problema pentru n discuri la rezolvarea a dou[ probleme pentru n-1 discuri
@ncadr`ndu-ne @n metoda ″Divide et impera″. Vor fi 2n -1 mut[ri.
Pentru n=3 ]irul mut[rilor este:
(1, 2) (1, 3) (2, 3) (1, 2) (3, 1) (3, 2) (1, 2). Sunt 23 -1=7.

Procedure Hanoi (n, i, j : integer);

var k : integer
begin
if n=1 then write (`(`, i, `,`, j, `)`)
else
begin
k:=6-i-j;
Hanoi (n-1, i, k);
write (`(`, i, `,`, j, `)`);
Hanoi (n-1, k, j);
end;
end;

12. METODA PROGRAM{RII DINAMICE

Aceast[ metod[ se utilizeaz[ la rezolvarea unor probleme de optimizare care se refer[ la un

proces. Procesul parcurge st[rile s0 , s1 , ... , sn (sn - stare final[, s0 - stare ini\ial[). La fiecare trecere din
starea si-1 @n starea si se ia decizia di , i= 1, n pentru a se realiza acest lucru. La fiecare pas i, decizia di
poate fi aleas[ din mai multe decizii posibile, dar cea care se ia trebuie s[ fie optim[. #n general
deciziile d1 , ... , dn care conduc la solu\ia problemei trebuie s[ fie optime satisf[c`nd principiul
optimalit[\ii (R.Bellmann). Acest principiu spune c[, dac[ st[rilor s0 , s1 , ... , sn le corespund deciziile d1 ,
... , dn optime:
d1 d2 dn
s0 s1 s2 sn-1 sn

atunci, oricare ar fi i, la ]irul de st[ri s0 , s1 , ... , si le corespund acelea]i decizii optime d1 , d2 , ... , di iar la
]irul de st[ri si , si+1 , ... , sn corespund acelea]i decizii optime di+1 , ... , dn .
 Dac[ principiul optimalit[\ii este satisf[cut, metoda program[rii dinamice presupune
scrierea unei rela\ii de recuren\[ pentru decizia de la pasul i. #n general rela\iile de recuren\[ sunt de
dou[ tipuri:
• di =f(d1 , d2 , ... , di-1) : procedeul @napoi
• di =f(di+1 , dI+2 , ... , dn ) : procedeul @ninte
Func\ia f determin[ decizia de la pasul i \in`nd seama de trecutul procesului (@n primul caz) sau
de viitorul procesului (@n al doilea caz).

Procedeul @napoi
Problem[. Fie dou[ cuvinte s respectiv t cu m ]i respectiv n litere. S[ se transforme cuv`ntul s
@n cuv`ntul t utiliz`nd opera\iile:
′a′ : ad[ugarea unei litere
′m′ : modificarea unei litere
′s′ : ]tergerea unei litere
Transformarea s[ se fac[ prin utilizarea unui num[r minim de opera\ii. S[ se afi]eze costul
transform[rii (num[rul de opera\ii) ]i cuvintele intermediare.
Rezolvare: O solu\ie banal[, care bine@n\eles nu este optim[, este cea @n care la sf`r]itul
cuv`ntului s se adaug[ literele cuv`ntului t ]i apoi se ]terg primele m litere ale cuv`ntului s, ini\ial. O
alt[ solu\ie, care @n continuare nu este optim[ dar mai bun[ dec`t prima, s-ar aplica @n cazul @n care
m>n. #n acest caz primele n litere din s s-ar modifica prin literele din t ]i apoi s-ar ]terge ultimele m-n
litere.
Vom rezolva problema folosind procedeul @napoi al program[rii dinamice.
Consider[m o matrice cos t (m+1)x(n+1) ale c[rei elemente cos tij au semnifica\ia: (num[rul de
transform[ri) costul transform[rii primelor i caractere ale cuv`ntului s @n primele j caractere ale
cuv`ntului t. #n final ne intereseaz[ cos t (m, n), aceasta fiind valoarea minim[ de opera\ii cerut[ de
problem[.
S[ urm[rim modul de calcul al valorii cos tij :
-dac[ litera de pe pozi\ia i a cuv`ntului s este egal[ cu litera de pe pozi\ia j a cuv`ntului t (si =tj )
atunci cos tij =cos ti-1,j-1 (nu se face nici o opera\ie @n plus fa\[ de pasul anterior).
-dac[ si ≠tj atunci:
1.Transformarea primelor i litere din s @n primele j litere din t poate deriva din transformarea
primelor i-1 litere din s @n primele j-1 litere din t la care se adaug[ oper. de modificare a literei i din s,
si , cu litera j din t, tj .
Atunci: cos tij = cos ti-1, j-1+1 (si ←tj )
2.Transformarea primelor i litere din s @n primele j litere din t poate deriva din transformarea
primelor i-1 litere din s @n primele j litere din t la care se adaug[ opera\ia de ]tergere a literei si (litera
de pe pozi\ia i a cuv`ntului s).
Atunci: cos tij = cos ti-1,j +1 (si se ]terge)
3.Transformarea primelor i litere din s @n primele j litere din t poate deriva din transformarea
primelor i litere din s @n primele j-1 litere din t la care se adaug[ opera\ia de ″ad[ugare″ a unei litere.
Mai precis, la cuv`ntul intermediar ob\inut @n s la pasul anterior, se adaug[ pe pozi\ia j, litera tj .
Atunci: cos tij = cos ti,j-1+1
#n final:
cos ti-1,j-1 dac[ si =tj
cos tij =
1+min{cos ti-1,j-1, cos ti-1,j , cos ti,j-1} altfel
 Se observ[ c[ la fiecare pas se alege varianta care conduce la un num[r minim de transform[ri.
Altfel spus, la pasul curent valoarea cos tij este minim[ posibil[.
Pentru realizarea algoritmului vom considera liniile ]i coloanele matricei cos t numerotate
0,...,m respectiv o,...,n.
Coloana o va avea valorile:
cos t0,0 =0 costul transf. cuv. vid @n cuv. vid
cos t1,0 =1 costul transf. cuv. s1 @n cuv. vid (o ]tergere)
-------
cos tm,0 =m costul transf. cuv. s1 ...sm @n cuv. vid (m ]tergeri)
Linia 0 va avea valorile:
cos t0,0 =0
cos t0,1 =1 costul transf. cuv. vid @n cuv. t1 (o ad[ugare)
-------
cos t0,n =n costul transf. cuv. vid @n cuv. t1 ,...,tn (n ad[ugiri)

Exemplu: Transform[m cuv. ″corina″ @n cuv. ″cristina″.

Matricea cos t va fi:
CO
L0 0 1 2 3 4 5 6 7 8
1 0 1 2 3 4 5 6 7
2 1 1 2 3 4 5 6 7
3 2 1 2 3 4 5 6 7
4 3 2 1 2 3 4 5 6
5 4 3 2 2 3 4 4 5
6 5 4 3 3 3 4 5 4

cos t 6,8 =4 reprezint[ num[rul minim de transform[ri ale cuv`ntului ″corina″ @n cuv`ntul
″cristina″.
S[ urm[rim ]irul de transform[ri.

Observa\ie:
min.
(i-1, j-1) (i-1, j)
(i, j-1) (i, j)

Calculul se face astfel:

min=(i-1, j-1) ]i se compar[ pe r`nd cu pozi\ia (i-1, j) ]i (i, j-1).

Transf. primelor i car. din Transf. primelor i1 car. din

s @n primele j car. din t = s @n primele j1 car. din t Opera\ie
(6, 8) = (5, 7) `_`
(5, 7) = (4, 6) `_`
(4, 6) = 1+(4, 5) `a`←lit`i`=t6
(4, 5) = 1+(4, 4) `a`←lit`t`=t5
(4, 4) = 1+(4, 3) `a`←lit`s`=t4
(4, 3) = (3, 2) `_`
 (3, 2) = (2, 1) `_`
(2, 1) = 1+(1, 1) `s`←lit`o`=s2
(1, 1) = (0, 0) `_`

o +`s` +`t` +`i`

Deci corina → crina → crisna → cristna → cristina

Procedeul @nainte

Problem[: Fie ]irul A=(a1 , ... , an ). S[ se determine cel mai lung sub]ir cresc[tor al lui A,
(ai1 ,ai2 ,...,aik ) unde:
ai1 ≤ai2≤...≤aik , i1 <i2 <...<ik
Rezolvare: Pentru a respecta principiul program[rii dinamice facem urm[toarea presupunere:
-dac[ (ai1 , ... , aik ) este sub]ir cresc[tor de lungime maxim[, atunci ∀ j∈{1, 2, ... , k-1} sub]irul
(aij , aij+1 , ... , aik ) este sub]ir cresc[tor de lungime maxim[ care @ncepe @n aij .
Not[m cu li =nr. elementelor celui mai lung sub]ir cresc[tor care @ncepe cu ai .

Atunci: ln =1
li =1+max{lk / ai <ak , i+1≤k≤n}, i= n − 1,1 .

Prin conven\ie max{Φ}=0

Dac[ vom determina nr=max{li / 1≤i≤n} atunci problema este rezolvat[ pentru c[ li0 =nr. este
lungimea maxim[ a sub]irului cresc[tor iar acesta @ncepe cu ai0 . Determinarea efectiv[ a elem. ]irului
se face @ncep`nd cu ai0 ]i consider`nd toate elementele din A care respect[ ordinea cresc[toare.

procedure secvmax (n, a : array[1…n]; var nr, i0 : integer)

var i, k, max : integer;
l : array[1…n] of integer
ln=1, nr=0
for i=n-1 downto 1 do
max=0
for k=i+1 to n do
if (ai<ak) and (lk>max) then max=lk end of
next k
li=1+max
if li> nr then
nr=li, i0=i
endif
next i
end secvmax

Procedeul combinat

Problem[. S[ se calculeze produsul A1 xA2 x...xAn , unde ∀ i= 1, n . Ai este o matrice de ordin

di xdi+1 , astfel @nc`t s[ se efectueze un num[r minim de @nmul\iri.
Rezolvare. #n general, pentru dou[ matrici Bpxq ]i Cqxr, num[rul de @nmul\iri pt a calcula
produsul BxC este p.q.r. Produsul matricilor nu este comutativ dar este asociativ. #n cazul celor n
matrici exist[ (n-1)! posibilit[\i de a le asocia. Dintre toate aceste asocieri trebuie aleas[ cea @n care
num[rul total de @nmul\iri s[ fie minim. Iat[ un exemplu:
A1 (100, 1) x A2 (1, 100) x A3 (100, 1) x A4 (1, 100)
#n asocierea (A 1 xA2 ) x (A 3 xA4 ) se execut[ 1.020.000 @nmul\iri iar @n asocierea (A 1 x(A 2 xA3 ))xA4 ,
care este optim[, se execut[ 10.200 @nmul\iri.
Vom utiliza met. program[rii dinamice pentru a g[si asocierea optim[ dintre cele (n-1)!
posibile.
Pentru 1≤i≤j≤n introducem valoarea cost(i, j) = num[rul minim de @nmul\iri necesar pentru a
calcula produsul Ai xAi+1 x...xAj . Vom considera cost(i, j)=0. Observ[m c[ cost(i, i+1)=di .di+1 .di+2 , 1≤i≤n-
1.
#n general, cost(i, j)=min{cost(i, k)+cost(k+1, j)+di .dk+1 .dj+1 } (1)
i≤k≤j
Aceast[ ultim[ formul[ poate fi @n\eleas[ astfel:

Aik Ak+1, j

Aij =Ai xAi+1 x...xAj = (A i xAA i+1 x...xA k ) x (A k+1 x...xA j ) unde k este valoarea pentru care se
realizeaz[ minimul de mai sus. Primele dou[ valori din sum[ corespund factorilor (A i x...xAk ) respectiv
(A k+1 x ... x Aj ) iar di .dk+1 .dj+1 este num[rul de @nmul\iri pentru produsul Aik (di , dk+1 ) x
xAk+1, j (dk+1 , dj+1 ).
Formula (1) permite calculul valorilor cost(i, j) @n ordinea descresc[toare a diferen\ei j-i. Pentru
calculul tuturor valorilor cost (i, j) folosim procedura:

Prodmat (d:array[1…n+1] of integer; var cost:array[1…n, 1…n] of longint)

for i=1 to n do
cost(i, i)=0
next i
for k=1 to n-1 do
for i=1 to n-k do
j=i+k
cost(i, j)=min{cost(i, l)+cost(l+1, j)+di.dl+1.d j+1}
i≤l≤j
cost(j, i)=l, unde l este valoarea pentru care se realizeaza minimul
next i
next k

Observ[m c[ toate valorile cost(i, j) sunt scrise deasupra diagonalei principale, iar cost(1, n)
reprezint[ cost-ul minim cerut de problem[, adic[ num[rul minim de @nmul\iri @n cazul asocierii
optime.
Asocierea optim[ o vom g[si datorit[ valorilor cost(j, i) @nscrise sub diagonala principal[.
Astfel, pentru i<j, fie k=cost(j, i). Atunci ]tim sigur c[ Ai x...xAj =(A i x...xAk ) x (A k+1 x...xAj ). Vom
continua cu determinarea asocierilor din fiecare parantez[ cercet`nd cost(i, k) ]i cost(k+1, j). Ne vom
opri c`nd cost(i, j)=0, acest lucru desemn`nd un singur factor, matricea Ai (i, j). Formula complet[ a
asocierilor o vom determina @ncep`nd cu cost(n, 1). Iat[ o procedur[ care realizeaz[ acest lucru.
procedure asociere (i, j : longint), i≤j
var k:longint
k=cost(j, i)
if cost(i, k)≠0 then
 print (`(`), asociere (i, k), print (`)`)
else print (`A`, i)
end if
print (`x`)
if cost(k+1, j)≠0 then
print (`(`), asociere (k+1, j), print (`)`)
else print (`A`, j)
end if
end asociere
Apel : asociere (1, n)