Sunteți pe pagina 1din 65

nvmntul profesional i tehnic n domeniul TIC

Proiect cofinanat din Fondul Social European n cadrul POS DRU 2007-2013
Beneficiar Centrul Naional de Dezvoltare a nvmntului Profesional i Tehnic
str. Spiru Haret nr. 10-12, sector 1, Bucureti-010176, tel. 021-3111162, fax. 021-3125498, vet @ tvet.ro
Tenici cla!ice de pro"ra#are
$aterial de predare % partea a &&-a
Do#eniul' &nfor#atic(
)alificarea' *nali!t pro"ra#ator
+i,el 3 a,an!at
200-
*UTOR'
S&./&* /*R0OPO/ % profesor grad didactic
)OORDO+*TOR'
$*R&*+* /&O.ET* )&O1*+U % profesor grad didactic
)O+SU.T*+23'
&O*+* )4RSTE* expert CNDPT
0O&)* /.3DU2 expert CNDPT
*+5E.* POPES)U expert CNDPT
D*+* STRO&E expert CNDPT
Acest material a fost elaborat n cadrul proiectului nvmntul profesional i tehnic n
domeniul TIC, proiect cofinanat din Fondul Social European n cadrul POS DRU 2007-
2013
)uprin!
I. Introducere...................................................................................................................................5
II. Documente necesare pentru activitatea de predare.....................................................................7
III. Resurse.......................................................................................................................................8
Tema 7. Algoritmi de sortare.......................................................................................................8
Fia suport 7.1. Sortarea prin selecie......................................................................................8
Tema 7. Algoritmi de sortare.....................................................................................................1
Fia suport 7.!. Sortarea prin inserare...................................................................................1
Tema 7. Algoritmi de sortare.....................................................................................................1!
Fia suport 7.". Sortarea prin num#rare.................................................................................1!
Tema 7. Algoritmi de sortare.....................................................................................................1$
Fia suport 7.$. Sortarea prin intersc%im&are'(u&&leSort)...................................................1$
Tema 7. Algoritmi de sortare.....................................................................................................1*
Fia suport 7.5. Sortarea rapid# '+uic,sort)...........................................................................1*
Fia suport 7.*. Sortarea prin inserie cu pas varia&il............................................................18
Tema 7. Algoritmi de sortare.....................................................................................................!
Fia suport 7.7. Sortarea prin interclasare - .ergeSort.........................................................!
Tema 7. Algoritmi de sortare.....................................................................................................!!
Fia suport 7.8. Sortarea prin asam&lare '%eapsort)..............................................................!!
Tema 8. Algoritmi generali de c#utare.......................................................................................!$
Fia suport 8.1. /#utarea secvenial#.....................................................................................!$
Tema 8. Algoritmi generali de c#utare.......................................................................................!*
Fia suport 8.!. /#utarea &inar#............................................................................................!*
Tema 8. Algoritmi generali de c#utare.......................................................................................!8
Fia suport 8.". /#utarea prin interpolare..............................................................................!8
Tema 0. /riterii de per1orman#................................................................................................."
Fia suport 0.1. /omple2itatea metodei................................................................................"
Tema 0. /riterii de per1orman#................................................................................................."!
Fia suport 0.!. 3tili4area spaiului de memorie..................................................................."!
Tema 1. /omple2itatea algoritmilor........................................................................................"$
Fia suport 1.1. 5um#rul de operaii. 6ite4a de e2ecuie...................................................."$
.asurarea timpului de e2ecuie a unei p#ri de program 7n /88.............................................."0
.asurarea timpului de e2ecuie a unei p#ri de program 7n 9ascal:.........................................."0
Tema 1. /omple2itatea algoritmilor........................................................................................$1
Fia suport 1.!. .#rimea datelor. 3tili4area memoriei.......................................................$1
Tema 1. /omple2itatea algoritmilor........................................................................................$$
Fia suport 1.". Algoritmi polinomiali i e2poneniali........................................................$$
Tema 11. 9rogramare dinamic#.................................................................................................$*
Fia suport 11.1. ;ir de deci4ii. 9rincipiul de optim. Relaii de recuren#............................$*
Tema 11. 9rogramare dinamic#.................................................................................................$8
Fia suport 11.!. .etoda 7nainte............................................................................................$8
Tema 11. 9rogramare dinamic#.................................................................................................5
Fia suport 11.". .etoda 7napoi.............................................................................................5
Tema 11. 9rogramare dinamic#.................................................................................................5!
Fia suport 11.$. .etoda mi2t#.............................................................................................5!
Tema 11. 9rogramare dinamic#.................................................................................................5*
Fia suport 11.5. .etoda simple2..........................................................................................5*
Tema 1!. Te%nici de programare care conduc la soluii optime................................................*
Fia suport 1! <reed=. .etode euristice...............................................................................*
6. (i&liogra1ie................................................................................................................................**
&6 &ntroducere
Materialele de predare reprezint o resurs suport pentru activitatea de predare,
instrumente auxiliare care includ un mesaj sau o informaie didactic.
Prezentul material de predare, se adreseaz cadrelor didactice care predau n cadrul
colilor postliceale, domeniul &nfor#atic(, calificarea *nali!t pro"ra#ator6
El a fost elaborat pentru modulul Tenici cla!ice de pro"ra#are
ce se desfoar n 120 ore, n urmtoarea structur:
Laborator tehnologic 60 ore
)o#petene
7re8ultate ale
in,((rii9
Te#e Fi:e !uport
3.mplementeaz
algoritmii de
sortare i
cutare
Tema 7- Algoritmi de sortare Fia 7.1 - Sortarea prin
selecie
Fia 7.2- Sortarea prin
inserare
Fia 7.3 -Sortarea prin
numrare
Fia 7.4 - Sortarea prin
interschimbare
Fia 7.5 - Sortarea rapid
(quiksort)
Fia 7.6 - Sortarea prin
inserie cu pas variabil
Fia 7.7 - Sortarea prin
interclasare
Fia 7.8 - Sortarea prin
asamblare (heapsort)
Tema 8 - Algoritmi generali de
cutare
Fia 8.1 - Cutarea
secvenial
Fia 8.2 Cutarea binar
Fia 8.3 - Cutarea prin
interpolare
)o#petene
7re8ultate ale
in,((rii9
Te#e Fi:e !uport
Tema 9 - Criterii de
performan
Fia 9.1 - Complexitatea
metodei
Fia 9.2- Utilizarea spaiului
de memorie
4.Utilizeaz
metode de
optimizare
Tema 10 - Complexitatea
algoritmilor
Fia 10.1 - Numrul de
operaii. Viteza de execuie
Fia 10.2. - Mrimea datelor.
Utilizarea memoriei
Fia 10.3. - Algoritmi
polinomiali i exponeniali
Tema 11 - Programare
dinamic
Fia suport 11.1- Sir de
decizii. Principiul de optim.
Relaii de recuren.
Fia suport 11.2 - Metoda
nainte
Fia suport 11.3 - Metoda
napoi
Fia suport 11.4 - Metoda
mixt
Fia suport 11.5 - Metoda
simplex
Tema 12. Tehnici de
programare care conduc la
soluii optime
Fia suport 12 - Greedy.
Metode euristice
Absolvenii nivelului 3 avansat, coal postliceal, calificarea Analist programator, vor fi
capabili s utilizeze tehnicile clasice de programare, s implementeze algoritmii de
sortare i cutare s optimizeze algoritmii de rezolvare a problemelor.
&&6 Docu#ente nece!are pentru acti,itatea de predare
Pentru predarea coninuturilor abordate n cadrul materialului de predare cadrul
didactic are obligaia de a studia urmtoarele documente:
Standardul de Pregtire Profesional pentru calificarea Tehnician echipamente
de calcul, nivelul 3 avansat www.tvet.ro, seciunea SPP sau www.edu.ro ,
seciunea nvmnt preuniversitar
Curriculum pentru calificarea Tehnician echipamente de calcul, nivelul 3 avansat
www.tvet.ro, seciunea Curriculum sau www.edu.ro , seciunea nvmnt
preuniversitar
Alte surse pot fi:
Crile de specialitate;
Reviste de specialitate;
Surse web
&&&6 Re!ur!e
Te#a 76 *l"orit#i de !ortare
Fi:a !uport 761 Sortarea prin !elecie
De!criere
deea algoritmului este urmatoarea: tabloul unidimensional este imprit in dou
pri imaginare o parte sortat i o parte nesortat. La nceput, partea sortat este
goal, n timp ce partea nesortat conine ntreg tabloul. La fiecare pas, algoritmul
gsete elementul minim din partea nesortat i l adaug la finalul prii sortate. Cnd
partea nesortat rmne goal, algoritmul se oprete.
Cnd algoritmul sorteaz un tablou unidimensional, interschimb primul element
al prii nesortate cu elementul minim i dup aceea el este inclus n partea sortat.
Aceast implementare a sortrii prin selecie nu este stabil. n cazul cnd sortm o
list, i, n loc de interschimbri, elementul minim este legat de partea nesortat,
sortarea prin selecie este stabil.
E;e#plu
Dorim s sortm irul <=> 1> -> -2> 1?> 2> ->@ utiliznd sortarea prin selecie.
Legend:
Partea nesortat;
Partea sortat;
Elementele care vor fi interschimbate.
5, 1, 9, -2, 14, 2, 9; nesortat
5, 1, 9, -2, 14, 2, 9; interschimbm 5 cu -2
-2, 1, 9, 5, 14, 2, 9; 1 rmne pe poziie
-2, 1, 9, 5, 14, 2, 9; interschimbm 2 cu 9
-2, 1, 2, 5, 14, 9, 9; 5 ramne pe poziie
-2, 1, 2, 5, 14, 9, 9; interschimbm 14 cu 9
-2, 1, 2, 5, 9, 9 14; vector sortat
*l"orit# de!cri! n p!eudocod
pentru i 0,n-1 execut
min i ;
pentru j i+1,n execut
dac v[j]<v[i] atunci
min j ;
sfdac
sfpentru
dac min = i atunci
aux v[i] ;
v[i] v[min] ;
v[min] aux ;
sfdac
sfpentru
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A
Clasa poate fi organizat frontal sau pe grupe.
Ca metode de predare se vor folosi:
Explicaia n etapa de comunicare a cunotintelor;
Demonstraia prin descrierea pas cu pas a algoritmului;
nvarea prin descoperire propunnd elevilor nc un exemplu pe care s-l rezolve ei
pas cu pas;
Conversaia euristic n etapa de fixare a cunotinelor;
Exerciiul propunnd elevilor s modifice algoritmul, astfel nct s realizeze sortarea
descrescatoare a elementelor vectorului sau ordonarea prin selecia maximului.
Ca materiale suport se pot folosi:
- Lecia interactiv AEL;
- Prezentarea PowerPoint ataat materialului.
Acest coninut poate fi evaluat oral sau prin lucrare scris.
&#ple#entare Pa!cal
Type vector=array[1..1000] of integer;
procedure sortareSelecie(var v:vector; n:integer);
var i,j,min,aux:integer;
begin
for i:=1 to n do
begin
min:=i;
for j;=i+1 to n do
if v[j]<v[min] then
min:=j;
f min<>i then
begin
aux:=v[i];
v[i]:=v[min];
v[min]:=aux;
end;
end;
end;
mplementare C++
void sortareSelecie(int v[], int n)
{
int i, j, min, aux;
for (i = 0; i < n - 1; i++)
{
min = i;
for (j = i + 1; j < n; j++)
if (v[j] < v[min])
min = j;
if (min != i)
{
aux = v[i];
v[i] = v[min];
v[min] = aux;
}
}
}
Te#a 76 *l"orit#i de !ortare
Fi:a !uport 762 Sortarea prin in!erare
De!criere
Sortarea prin inserare seaman oarecum cu sortarea prin selecie. Tabloul este mprit
imaginar n dou pari - o parte sortat i o parte nesortat. La nceput, partea sortat
conine primul element al tabloului i partea nesortat conine restul tabloului. La fiecare
pas, algoritmul ia primul element din partea nesortat i l insereaz n locul potrivit al
prii sortate. Cnd partea nesortat nu mai are nici un element, algoritmul se oprete.
E;e#plu
S sortm irul {9, -5, 2, 12, 4} folosind sortarea prin inserie.
9, -5, 2, 12, 4 nesortat
9, -5, 2, 12, 4 -5 va fi inserat 9 > -5 , interschimbm
-5, 9, 2, 12, 4 2 va fi inserat 9 > 2, interschimbm
-5, 2, 9, 12, 4 -5 < 2 , 2 nu se face interschimbare
-5, 2, 9, 12, 4 12 va fi inserat 9 < 12 nu se face interschimbare
-5, 2, 9, 12, 4 4 va fi inserat, 4 < 12, interschimbm
-5, 2, 9, 4, 12 4 < 9 , interschimbm
-5, 2, 4, 9, 12 sortat
*l"orit# de!cri! n p!eudocod
pentru i 1,n execut
j i ;
ct timp j>0 si v[j-1]>v[j] execut
aux v[j] ;
v[j] v[j-1] ;
v[j-1] aux ;
j j-1 ;
sfct timp
sfpentru
&#ple#entare Pa!cal
Type vector=array[1..1000] of integer;
procedure sortarenserie(var v:vector;
n:integer);
var i,j,aux:integer;
begin
for i:=2 to n do
begin
j:=i;
while (j>1)and(v[j-1]>v[j]) do
begin
aux:=v[j];v[j]:=v[j-1];v[j-1]:=aux;
end;
end;
end;
mplementare C++
void sortarenserie(int v[ ], int n)
{
int i,j,aux;
for ( i=1;i<n;i++)
{
j=i;
while (j>0 && v[j-1]>v[j])
{
aux=v[j];
v[j]=v[j-1];
v[j-1]=aux;
j--;
}
}}
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A
Clasa poate fi organizat frontal sau pe grupe.
Ca metode de predare se vor folosi:
Explicaia n etapa de comunicare a cunotintelor;
Demonstraia prin descrierea pas cu pas a algoritmului;
nvarea prin descoperire propunnd elevilor nc un exemplu pe care s-l rezolve ei
pas cu pas;
Conversaia euristic n etapa de fixare a cunostinelor;
Exerciiul propunnd elevilor s modifice algoritmul, astfel nct s realizeze sortarea
descrescatoare a elementelor vectorului.
Ca materiale suport se pot folosi:
- Lecia interactiv AEL;
- Prezentarea PowerPoint ataat materialului.
Acest coninut poate fi evaluat oral sau prin lucrare scris.
Te#a 76 *l"orit#i de !ortare
Fi:a !uport 763 Sortarea prin nu#(rare
De!criere
Metoda sortrii prin numrare const n gsirea pentru fiecare element A[i], a
numrului de elemente din vector, mai mici ca el. Numerele obinute sunt memorate
ntr-un vector C; elementele vectorului de sortat A, sunt iniial atribuite vectorului B. Pe
baza vectorului C, elementele lui B vor fi aranjate n vectorul A.
E;e#plu
Vrem s sortm urmatorul ir:
A= (9, -5, 2, 12, 4)
Elementele lui A le atribuim lui B:
B= (9, -5, 2, 12, 4)
Pentru fiecare element A[j] numrm cte elemente sunt mai mici ca el, aceste
numere reinndu-le n vectorul C:
C=(3, 0, 1, 4, 2) se reconstitue vect A astfel: A[c[1]+1]=B[1];A[c[2]+1]=B[2]...
obinndu-se vectorul A sortat (-5, 2, 4, 9, 12)
*l"orit# de!cri! n p!eudocod
Pentru i 1,n execut
b[i] a[i];
sfpentru
pentru j 2,n execut
pentru i 1,j-1 execut
dac a[i]<a[j] atunci
c[j] c[j]+1
altfel c[i] c[i]+1;
sfdac
sfpentru
sfpentru
pentru i 1,n execut
a[c[i]+1] b[i]
sfpentru
&#ple#entare Pa!cal
Type vector=array[1..10] of integer;
Procedure sortNumait pe poziia 6. rt pe poziia 6. are(var
a:vector;n:integer);
var i,j:integer;b,c:vector;
begin
for i:=1 to n do
begin
c[i]:=0;b[i]:=a[i];
end;
for j:=2 to n do
for i:=1 to j-1 do
if a[i]<a[j] then c[j]:=c[j]+1
else c[i]:=c[i]+1;
for i:=1 to n do
a[c[i]]:=b[i];
end;
&#ple#entare )BB
void sortNumrare(int a[ ],int n)
{
int i,j;
int b[100],c[100];
for(i=0;i<n;i++)
{
c[i]=0;
b[i]=a[i];
}
for(j=1;j<n;j++)
for(i=0;i<=j-1;i++)
if(a[i]<a[j]) c[j]++;
else c[i]++;
for(i=0;i<n;i++)
a[c[i]]=b[i];
}
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A Clasa poate fi organizat frontal sau pe grupe.
Ca metode de predare se vor folosi:
Explicaia n etapa de comunicare a cunotintelor;
Demonstraia prin descrierea pas cu pas a algoritmului;
Exerciiul propunnd elevilor un set de aplicaii (exemplu: sortarea descrescatoare a
unui vector)
Ca materiale suport se pot folosi:
- Lecia interactiv AEL;
- Prezentarea PowerPoint ataat materialului.
Acest coninut poate fi evaluat oral sau prin lucrare scris.
Te#a 76 *l"orit#i de !ortare
Fi:a !uport 76? Sortarea prin inter!ci#Care71uCCleSort9
De!criere
1. Se compar fiecare pereche de elemente adiacente de la nceputul tabloului
unidimensional i dac elementele nu sunt n ordinea dorit, le interschimbm.
2. Dac cel puin o interschimbare a fost facut, repetm pasul 1. Algoritmul se ncheie
cnd la o nou parcurgere nu se mai face nicio interschimbare (deci vectorul este
sortat).
E;e#plu
Sa sortm irul {8, 1, 11, -3, 15} folosind metoda bulelor
8, 1, 11, -3, 15; nesortat
8, 1, 11, -3, 15; 8>1 interschimbm
1, 8, 11, -3, 15; 8<11 nu se face interschimbare
1, 8, 11, -3, 15; 11>-3 interschimbm
1, 8, -3 11, 15; 11<15nu se face interschimbare
1, 8, -3 11, 15; 1<8 nu se face interschimbare
1, 8, -3 11, 15; 8>-3 interschimbm
1, -3, 8, 11, 15; 8<11 nu se face interschimbare
1, -3, 8, 11, 15; 1>-3 interschimbm
-3, 1, 8, 11, 15; 1<8 nu se face interschimbare
-3, 1, 8, 11, 15; -3<1 nu se face interschimbare
-3, 1, 8, 11, 15; vector sortat
*l"orit# de!cri! n p!eudocod
ok>true
j>0
ct timp ok execut
ok>false
j>j+1
pentru i >1,n-j execut
dac v[i]>v[i+1] atunci
v?i@ A v?B@
sfdac
sfpentru
sfct timp
mplementare n C++
void bubbleSort(int v[], int n)
{
int ok = 1;
int j = 0;
int aux;
while (ok)
{
ok = 0;
j++;
for (int i = 0; i < n - j; i++)
if (v[i] > v[i + 1]) {
aux = v[i]; v[i] = v[i + 1];
v[i + 1] = aux;
ok =1;}
}}
mplementare Pascal
procedure bubbleSort(var v:vector; n:integer);
var ok:Boolean;i,j,aux:integer;
begin
ok:=true;
j:=0;
while ok do begin
ok:=false;
j:=j+1;
for i:=1 to n-j do
if v[i]>v[i+1] then begin
aux = v[i];
v[i] = v[i + 1];
v[i + 1] = aux;
ok =true;
end;
end;
end;
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A
Clasa poate fi organizat frontal sau pe grupe.
Ca metode de predare se vor folosi:
Explicaia n etapa de comunicare a cunotintelor;
Demonstraia prin descrierea pas cu pas a algoritmului;
Conversaia euristic n etapa de fixare a cunostinelor;
Exerciiul propunnd elevilor un set de aplicaii (exemplu: sortarea descrescatoare a
unui vector, sortarea elementelor de poziii impare,sortarea elementelor nenule)
Ca materiale suport se pot folosi:
- Lecia interactiv AEL;
- Prezentarea PowerPoint ataat materialului.
Acest coninut poate fi evaluat oral sau prin lucrare scris.
Te#a 76 *l"orit#i de !ortare
Fi:a !uport 76= Sortarea rapid( 7DuicE!ort9
De!criere
Metoda divide et impera este utilizat n sortarea rapid. Mai jos este explicat varianta
recursiv:
1. Se ale"e o ,aloare pi,ot. Se ia valoarea elementului din mijloc ca valoare pivot, dar
poate fi oricare alt valoare, care este n intervalul valorilor sortate, chiar dac nu este
prezent n tablou.
2. Partiionare> Se rearanjeaz elementele n aa fel nct, toate elementele care sunt
mai mari dect pivotul merg n partea dreapt a tabloului. Valorile egale cu pivotul pot
sta n orice parte a tabloului. n plus, tabloul poate fi mprit n pri care nu au aceeai
dimensiune (nu sunt egale).
3. Se !ortea8( a#Fndou( p(rile.se aplic recursiv algoritmul de sortare rapid n
partea stng i n partea dreapt.
*l"orit#ul de partiie n detaliu6
Exist 2 indici i i j, i la nceputul algoritmului de partiionare i indic primul element al
tabloului iar j indic ultimul element din tablou. La pasul urmtor algoritmul mut i
nainte, pn cnd un element cu o valoare mai mare sau egal cu pivotul este gsit.
ndicele j este mutat napoi, pna cnd un element cu valoare mai mic sau egal cu
pivotul este gsit. Dac i<=j atunci i merge pe poziia i+1 iar j merge pe poziia j-1.
Algoritmul se oprete, cnd i devine mai mare dect j.
Exemplu: dorim s sortm irul {1, 13, 7, 28, 10, 16, 3, 10, 2} folosind sortarea rapid.
1, 13, 7, 28, 10, 16, 3, 10, 2 - nesortat
1, 13, 7, 28, 10, 16, 3, 10, 2 - valoarea pivot = 10
1, 13, 7, 28, 10, 16, 3, 10, 2 - 13 >= 10 >= 2, interschimbm 13 cu 2
1, 2, 7, 28, 10, 16, 3, 10, 13 - 28 >= 10 >= 10 , interschimbm 28 cu 10
1, 2, 7, 10, 10, 16, 3, 28, 13 - 10 >= 10 >= 3, interschimbm 10 cu 3
1, 2, 7, 10, 3, 16, 10, 28, 13 - i > j, se oprete partiionarea
se aplic din nou algoritmul pentru 1, 2, 7, 10, 3 si 16, 10, 28, 13
Se obine: 1, 2, 3, 7, 10, 10, 13, 16, 28 ir sortat
Algoritm descris n pseudocod:
QuickSort(V,st,dr);
pivotv[(st+dr) div 2)];
ct timp i<=j execut
ct timp v[i] <pivot execut ii+1;
sfct timp
ct timp v[j] >pivot execut jj-1;
sfct timp
dac i<=j atunci
auxv[i];v[i]v[j];v[j]aux;ii+1;jj-1;
sfdac
sfct timp
dac st<j atunci quikSort(v,st,j);
sfdac
dac i<dr atunci quikSort(v,i,dr);
sfdac
sfQuickSort
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A Clasa poate fi organizat frontal sau pe grupe.
Se vor reactualiza cunostinele metodei Divide et mpera;
Ca metode de predare se vor folosi:explicaia n etapa de comunicare a cunotintelor;
demonstraia prin descrierea pas cu pas a algoritmului;conversaia euristic n etapa de
fixare a cunostinelor;
Exerciiul propunnd elevilor un set de aplicaii (exemplu: sortarea descrescatoare a
unui vector, s se localizeze elementul maxim i toate elementele dinaintea lui se
sorteaz descresctor iar cele dup el cresctor)
Ca materiale suport se pot folosi:
- Lecia interactiv AEL;
- Prezentarea PowerPoint ataat materialului.
Acest coninut poate fi evaluat oral sau prin lucrare scris.
&#ple#entare n Pa!cal
Procedure quickSort(var v:vector;
st,dr:integer);
Var pivot, i,j,aux,m:integer;
begin
i:=st;j:=dr;m:=(st+dr) div 2;
pivot:=v[m];
while i<=j do
begin
while v[i] <pivot do
i:=i+1;
while v[j]>pivot do
j:=j-1;
if i<=j then
begin
aux :=v[i];
v[i] :=v[j];
v[j] :=aux;
i:=i+1;
j:=j-1;
end;
end;
if st<j then
quikSort(v,st,j);
if i<dr then
quikSort(v,i,dr);
end
&#ple#entare n )BB
void quickSort(int v[],int st, int dr)
{
int i=st,j=dr;int aux; int pivot=v[(st+dr)/2];
while(i<=j)
{ while (v[i]<pivot)
i++;
while(v[j]>pivot)
j--;
if (i<=j)
{ aux=v[i];
v[i]=v[j];
v[j]=aux;
i++;
j--;
}
}
if (st<j)
quickSort(v,st,j);
if (i<dr)
quickSort(v,i,dr);
}
Te#a 76 *l"orit#i de !ortare
Fi:a !uport 76G Sortarea prin in!erie cu pa! ,ariaCil
De!criere
Unul dintre dezavantajele sortrii prin inserie este faptul c la fiecare etap un element
al irului se deplaseaz cu o singur poziie. O variant de reducere a numrului de
operaii efectuate este de a compara elemente aflate la o distan mai mare h ! 1) i
de a realiza deplasarea acestor elemente peste mai multe poziii. Un ir x[1..n] este
considerat h -sortat dac orice subir x[ i
0
] , x[ i
0
+ h] , x[ i
0
+ 2h]... este sortat (i
0

{1,...,h}). Aceasta este ideea algoritmului propus de Donald Shell n 1959 cunoscut sub
numele shell sort.
Elementul cheie al algoritmului l reprezint alegerea valorilor pasului h" Pentru
alegeri adecvate ale secvenei h
k
se poate obine un algoritm de complexitate
#(n
3/2
) n loc de #(n
2
) cum este n cazul algoritmului clasic de sortare prin inserie.
E;e#plu
Fie un ir cu 15 elemente. Pentru urmtoarele valori ale pasului: h=13, h=4, h=1 (care
corespund unui ir h
k
dat prin relaia h
k
=3h
k-1
+1, h
1
=1):
Etapa 1: pentru h=13 se aplic algoritmul sortrii prin inserie subirurilor x[1], x[14] i
x[2], x[15], singurele subiruri cu elemente aflate la distana h care au mai mult de
un element:
Tabloul: 14 8 10 7 9 12 5 15 2 13 6 1 4 3 11
ndici: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Si se obine:
Tabloul: 3 8 10 7 9 12 5 15 2 13 6 1 4 14 11
ndici: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Etapa 2: pentru h=4 se aplic algoritmul sortrii prin inserie succesiv subirurilor: x[1],
x[5], x[9], x[13], x[2],x[6],x[10],x[ 14],x[3],x[7],x[11],x[15],x[4],x[8],x[12].
Dup prima subetap (prelucrarea primului subir) prin care se ordoneaz subirul constituit
din elementele marcate:
Tabloul: 3 8 10 7 9 12 5 15 2 13 6 1 4 14 11
se obine:
Tabloul: 2 8 10 7 3 12 5 15 4 13 6 1 9 14 11
La a doua subetap se aplic sortarea prin inserie asupra subirului constituit din
elementele marcate
Tabloul: 2 8 10 7 3 12 5 15 4 13 6 1 9 14 11
obinndu-se aceeai configuraie (subirul este deja ordonat cresctor) din care se
prelucreaz acum subirul constituit din elementele marcate:
Tabloul: 2 8 10 7 3 12 5 15 4 13 6 1 9 14 11
Obtinandu-se:
Tabloul: 2 8 5 7 3 12 6 15 4 13 10 1 9 14 11
Se aplic acum sortarea prin inserie asupra subirului constituit din elementele
marcate:
Tabloul: 2 8 5 7 3 12 6 15 4 13 10 1 9 14 11
obinndu-se:
Tabloul: 2 8 5 1 3 12 6 7 4 13 10 15 9 14 11
Se aplic acum sortarea prin inserie asupra ntregului ir.
Algoritm descris n pseudocod
h1
ct timp h<n execut
hh*3 + 1;
sfct timp
ct timp h<1execut
h[h / 3]
pentru ih,n xecut xv[i] ji
ct timp v[j-h]>x execut
v[j]v[j-h] jj-h
sfct timp
v[j]x
sfpentru
sfct timp
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A Se vor reactualiza cunostinele din fia suport 1.2
Ca metode de predare se vor folosi: Demonstraia prin descrierea pas cu pas a
algoritmului; explicaia n etapa de comunicare a cunotinelor.
&#ple#entare n Pa!cal
Procedure shellSort(var v:vector;n:integer);
var i,j,h,x:integer;
begin
h:=1;
while h<n do
h:=h*3+1;
while h>=1 do
begin
h:=h div 3;
for i:=h to n do
begin
x:=v[i];j:=i;
while v[j-h]>x do
begin
v[j]:=v[j-h];
j:=j-h;
if j<h then break;
end;
v[j]:=aux;
end;
end;
end;
&#ple#entare n )BB
void shellSort(int v[],int n)
{
int i,j,h,x;
h=1;
while(h<n)
h=h*3 + 1;
while(h>=1)
{
h=h / 3;
for(i=h;i<n;i++)
{
x=v[i];j=i;
while(v[j-h]>x)
{
v[j]=v[j-h];
j=j-h;
if(j<h) break;
};
v[j]=x;
}
}
}
Te#a 76 *l"orit#i de !ortare
Fi:a !uport 767 Sortarea prin intercla!are - $er"eSort
De!criere
Algoritmul de sortare prin interclasare se bazeaz pe urmtoarea idee: pentru a sorta
un vector cu n elemente l mpim n doi vectori care, odat sortai, se interclaseaz.
Conform strategiei Divide et mpera, problema este descompus n alte dou
subprobleme de acelai tip i, dup rezolvarea lor, rezultatele se combin (n particular
se interclaseaz). Descompunerea unui vector n ali doi vectori care urmeaz a fi
sortai are loc pn cnd avem de sortat vectori de una sau dou componente.
E;e#plu Sortarea unui ir de apte valori de tip ntreg.
"8 !7 $" " 8! 0 1
Divizare
Sortare
nterclasare
!7 "8 " $" 0 8! 1
" !7 "8 $" 0 1 8!
" 0 1 !7 "8 $" 8!
"8 !7 $" " 8! 0 1
"8 !7 $" " 8! 0 1
Algoritm descris n pseudocod:
Sort(p,q,A);
dac A[p]>A[q] atunci
interschimba A[p]A[q]
!fSort
&nterc(p,q,m,A)
ip;jm+1;k0;
ct timp i<=m si j<=q execut
dac A[i]<A[j] atunci
kk+1;B[k] A[i];ii+1
altfel
kk+1;B[k] A[j];jj+1;
sfdac
sfct timp


ct timp i<=m execut
kk+1 B[k] A[i] ii+1
sfct timp
ct timp j<=q execut
kk+1 B[k] A[j];jj+1
sfct timp
pentru ip,q execut
A[i] B[i]
Sfpentru
Di,i#p(p,q,A)
dac q-p<=1 atunci Sort(p,q,A)
altfel Divimp(p,m,A) Divimp(m+1,q,A)
nterc(p,q,m,A)
sfdac
!fDi,i#p
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A Clasa poate fi organizat frontal sau pe grupe.
Se vor reactualiza cunotinele despre interclasarea a 2 vectori sortai i a metodei
Divide et mpera. Ca metode de predare se vor folosi:
Explicaia n etapa de comunicare a cunotintelor;
Demonstraia prin descrierea pas cu pas a algoritmului;
Exerciiul propunnd elevilor un set de aplicaii (exemplu: sortarea descresctoare a
primei jumati din vector i cresctoare a celei de-a doua,sortarea elementelor pare)
Ca materiale suport se pot folosi:
- Lecia interactiv AEL, prezentarea PowerPoint ataat materialului.
&#ple#entare n )BB
void sort (int p,int q, int a[100] )
{ int m;
if (a[p]>a[q])
{m=a[p];a[p]=a[q];a[q]=m;}
}
void interc (int p,int q, int m, int a[100])
{
int b[100],i,j,k;
i=p; j=m+1; k=0;
while ((i<=m) && (j<=q))
if (a[i]<=a[j]) b[++k]=a[i++];
else b[++k]=a[j++];
while(i<=m)
b[++k]=a[i++];
while(j<=q)
b[++k]=a[j++];
for(i=p;i<=q;i++)
a[i]=b[i];
}
void divimp (int p, int q, int a[100])
{
int m;
if ((q-p)<=1) sort (p,q,a);
else
{ m=(p+q)/2;
divimp(p,m,a);
divimp(m+1,q,a);
interc(p,q,m,a);
}
}
&#ple#entare n Pa!cal
Proceduresort(p,q:integer;var
a:vector);
var m:integer;
begin
if a[p]>a[q] then begin
m:=a[p];a[p]:=a[q];a[q]:=m;end;
end;
procedure interc(p,q,m:integer;var
a:vector);
var b:vector;i,j,k:integer;
begin
i:=p;j:=m+1;k:=0;
while(i<=m)and(j<=q) do
if a[i]<=a[j] then begin
inc(k);b[k]:=a[i];inc(i); end
else begin
inc(k);b[k]:=a[j];inc(j); end;
while i<=m do begin
inc(k);b[k]:=a[i];inc(i); end;
while j<=q do begin
inc(k);b[k]:=a[j];inc(j);end;
for i:=p to q do a[i]:=b[i];
end;
procedure divimp(p,q:integer;var
a:vector);
var m:integer;
begin
if q-p<=1 then sort(p,q,a)
else begin m:=(p+q) div 2;
divimp(p,m,a);divimp(m+1,q,a);
interc(p,q,m,a);end;
end;
Te#a 76 *l"orit#i de !ortare
Fi:a !uport 76H Sortarea prin a!a#Clare 7eap!ort9
De!criere
Se numete ansamblu (heap) a secven de chei h1, h2,..., hn care satisfac condiiile: hi
<= h2i si hi <= h2i+1 i=1,N/2.
Se aduce tabloul la forma unui ansamblu, adic pentru orice i,j, k din intervalul [1,N],
unde j=2*i si k=2*i+1, s avem a[i]<=a[j] si a[i]<=a[k] (*). Se observ c n acest caz a[1]
este elementul cu cheia minim n tablou. Se interschimb elementele a[1] i a[N] i se
aduce subtabloul a[1],...,a[N-1] la forma de ansamblu, apoi se interschimb elementele
a[1] si a[N-1] i se aduce subtabloul a[1],...,a[N-2] la forma de ansamblu .a.m.d. n final
rezult tabloul ordonat invers. Dac se schimb sensul relaiilor n condiiile (*) atunci se
obine o ordonare direct a tabloului (a[1] va fi elementul cu cheia maxim).
Aducerea unui tablou la forma de ansamblu se bazeaz pe faptul c subtabloul
a[N/2+1],...,a[N] este deja un ansamblu (nu exist indicii j si k definii ca mai sus). Acest
subtablou se va extinde mereu spre stnga cu cte un element al tabloului, pna cnd
se ajunge la a[1]. Elementul adugat va fi glisat astfel nct subtabloul extins s devin
ansamblu.
Procedura Deplasare(s,d) realizeaz glisarea elementului a[s] astfel c subtabloul
a[s],...,a[d] (s<d) s devin ansamblu. Aceast procedur este folosit mai nti pentru
aducerea ntregului tablou la structura de ansamblu i apoi pentru ordonarea tabloului
conform metodei enunate mai sus.
Timpul de execuie al sortrii este O(N*log N).
E;e#plu
Dorim s sortm un ir de cinci valori de tip ntreg:
Tablou: 9 1 7 0 3
ndici: 1 2 3 4 5
s=3 d=5 deplasare(2,5) rezult tabloul: 9 3 7 0 1
s=1 d=5 deplasare(1,5) nu se efectueaz deplasarea
s=1 d=4 deplasare(1,4) rezult tabloul: 7 3 1 0 9
s=1 d=3 deplasare(1,3) rezult tabloul: 3 0 1 7 9
s=1 d=2 deplasare(1,2) rezult tabloul: 1 0 3 7 9
s=1 d=1 deplasare(1,1) rezult tabloul: 0 1 3 7 9 vector sortat
HeapSort
s [n/2]+1 d n
ct timp s>1 execut
s s-1
Apel
Deplasare(s,n)
Sfrit ct timp
Ct timp d>1 execut
x a[1] a[1] a[d]
a[d] x d d-1
Apel Deplasare(s,n)
Sfrit ct timp
Sfrit subalgoritm
Algoritm descris n pseudocod
Deplasare(s,n)
i s j 2*i x a[i] ok adevrat
ct timp j>d i ok=0 execut
dac j<d atunci
dac a[j]<a[j+1] atunci
j j+1
sfrit dac
sfrit dac
dac x< a[j] atunci
a[i] a[j] i j j 2*i
altfel ok 1
sfrit dac
sfrit ct timp
a[i] x
Sfrit subalgoritm
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A Clasa poate fi organizat frontal sau pe grupe.
Ca metode de predare se vor folosi:
Explicaia n etapa de comunicare a cunotintelor;
Demonstraia prin descrierea pas cu pas a algoritmului;
Conversaia euristic n etapa de fixare a cunostinelor;
Acest coninut poate fi evaluat oral sau prin lucrare scris.
&#ple#entare n )BB
void Deplasare(int s,int n)
{
int i,j,ok; i=s; j=2*i; x=a[i];ok=0;
while((j<=d)&&(!ok))
{
if(j<d)
if(a[j]<a[j+1])
j=j+1;
if(x<a[j])
{ a[i]=a[j];i=j;j=2*i; }
else ok=1;
}
a[i]=x;
}
void HeapSort()
{
s=(n/2)+1;d=n;
while(s>1) {
s-=1;
Deplasare(s,n);}
while(d>1)
{ x=a[1];a[1]=a[d]; a[d]=x;d-=1;
Deplasare(1,d);
}
}
&#ple#entare Pa!cal
procedure HeapSort;
var s,d : nteger; x : nteger;
procedure Deplasare(s,d : nteger);
var i,j : nteger; ok : boolean;
begin {Deplasare}
i:=s; j:=2*i; x:=a[i]; ok:=false;
while (j<=d) and (not ok) do begin
if j<d then
if a[j]< a[j+1]then j:=j+1;
if x < a[j]then begin
a[i]:=a[j]; i:=j; j:=2*;end
else ok:=true;end;
a[i]:=x
end; {Deplasare}
begin {HeapSort}
{constructie ansamblu}
s:=(N div 2) +1; d:=N;
while s > 1 do begin
s:=s-1;
Deplasare(s,N);
end;
{sortare}
while d > 1 do begin
x:=a[1]; a[1]:=a[d]; a[d]:=x;
d:=d-1;
Deplasare(1,d); end
end; {HeapSort}
Te#a H6 *l"orit#i "enerali de c(utare
Fi:a !uport H61 )(utarea !ec,enial(
De!criere
S presupunem c dorim s determinm dac un element aparine sau nu unui vector
de elemente. Dac nu tim nimic despre elementele vectorului avem soluia cutrii
secveniale, pn gsim elementul cutat sau pn testm toate elementele.
Algoritm descris n pseudocod
gsit >
pentru i> 0,n-1 execut
dac x=v[i] atunci
gsit >1
sfrit dac
sfrit pentru
n cazul cel mai favorabil cnd elementul se gsete pe prima poziie se efectueaz
dou comparaii. n cazul cel mai nefavorabil, cnd elementul nu se gsete deloc n
vector, se efectueaz 2n+1 comparaii. n continuare este prezentat o implementare
ceva mai rapid:
Cu aceast implementare, n cazul cel mai favorabil avem dou comparaii, iar n cazul
cel mai nefavorabil avem n+2 comparaii.
&#ple#entare Pa!cal
FunctionCautSecv
(x:integer;v:vector;n:integer):boolean;
var gsit:boolean;
begin
gsit:=false;
for i:=1 to n do
if x=v[i] then
gsit:=true;
CautSecv:=gsit;
end;
&#ple#entare )BB
int CautSecv(int x,int v[],int n)
{
for(int i=0;i<n;i++)
if(x==v[i])
return 1;
return 0;
}
&#ple#entare Pa!cal
Function CautSecv
(x:integer;v:vector;n:integer):boolean;
var i:integer;gasit:boolean;
begin
i:=1; gasit:=false;
while (v[i]<>x)and(i<=n)then
i:=i+1;
if i<=n then
gasit:=true;
CautSecv:=gasit;
end;
&#ple#entare )BB
int CautSecv(int x,int v[],int n)
{int i=0;
while ((v[i]!=x)&&(i<n))
i++;
if(i<n)
return 1;
else
return 0;
}
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A
Clasa poate fi organizat frontal sau pe grupe.
Ca metode de predare se vor folosi:
Explicaia n etapa de comunicare a cunotintelor;
Conversaia euristic n etapa de fixare a cunostinelor;
Exerciiul propunnd elevilor o aplicaie (dac maximul dintr-un ir se gsete n al
doilea ir).
Studiu de caz: S exemplifice modul n care se aplic algoritmul pentru cutarea unui
element ntr-un vector pentru aflarea poziiei pe care se afl acesta.
Acest coninut poate fi evaluat oral sau prin lucrare scris.
Te#a H6 *l"orit#i "enerali de c(utare
Fi:a !uport H62 )(utarea Cinar(
De!criere
Dac elementele vectorului sunt ordonate cresctor, putem s ne dm seama dac
elementul nu exist n vector fr a fi nevoie s parcurgem toate elementele vectorului.
Unul dintre algoritmii folosii n acest caz este algoritmul de cutare binar. Acest
algoritm are la baz principiul njumtirii repetate a domeniului n care se caut
elementul, prin mprirea vectorului n doi subvectori. Notm cu !t primul indice al
vectorului i cu dr ultimul indice al vectorului, iar # este indicele elementului din mijloc
al vectorului m=(st+dr)/2. Se compar valoarea cutat cu valoarea elementului din
mijloc. Dac cele dou valori sunt egale nseamn c s-a gsit elementul. Dac nu sunt
egale vectorul v-a fi mprit n doi subvectori. Operaia de cutare const n
identificarea subvectorului n care se poate gsi elementul, prin compararea valorii
cutate cu cea din mijloc, dup care se divizeaz acest subvector n doi subvectori
.a.m.d. pn cnd se gsete elementul, sau pn cnd nu se mai poate face
mparirea n subvectori, ceea ce nseamn c nu s-a gsit elementul.
E;e#plu' Dorim s cutm elementul x=19 ntr-un vector cu 9 elemente:
5 8 11 15 17 19 20 23 26
1 2 3 4 5 6 7 8 9
st=1 dr=9 m=5
elementul cutat este x=19
se caut n subvectorul din dreapta st=m+1=6
19 20 23 26
6 7 8 9
19<20 se caut n subvectorul din stnga dr=m-1=6
st=m=5
19>17 se caut n subvectorul din dreapta st=m+1=6
st=dr=m=6 Elementul a fost gsit
Algoritm descris n pseudocod
Funcia CautBin(n,A,x)
p1 qn
ct timp p>q execut
m [(p+q)/2]
dac x=A[m] atunci
CautBin m p q+1
altfel
dac x<A[m] atunci q m-1
altfel p m+1
sdac
sfdac
sfct timp
sfCautBin
17 19
5 6
19
6
&#ple#entare )BB
int CautBinar(int n, int a[], int x)
{
int p, q, m;
p = 0; q = n - 1;
while(p <= q)
{
m = (p + q) / 2;
if (x == a[m])
{return m;
p=q+1;}
else
if (x < a[m]) q = m - 1;
else p = m + 1;
}
return -1;
}
&#ple#entare Pa!cal
FunctionCautBinar(n:integer;
a:vector):integer;
var p,q,m:integer;
begin
p:=1;q:=n;
while p<=q do
begin
m:=(p+q) div 2;
if x=a[m] then
begin
CautBinar:=m;
p:=q+1;
end
else
if x<a[m] then q:=m-1
else p:=m+1;
end;
end;
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A Ca metode de predare se vor folosi:
Explicaia n etapa de comunicare a cunotintelor;
Demonstraia prin descrierea pas cu pas a algoritmului;
Conversaia euristic n etapa de fixare a cunostinelor;
Problematizarea: Cum se modific algoritmul pentru cutarea unui element ntr-un
vector ordonat descresctor?
Acest coninut poate fi evaluat oral sau prin lucrare scris.
Te#a H6 *l"orit#i "enerali de c(utare
Fi:a !uport H63 )(utarea prin interpolare
De!criere
Este similar cu cutarea binar, dar folosete o alt formul pentru calculul lui m i
anume: m=st+(x-v[st])*(dr-st)/(v[dr]-v[st] ceea ce conduce la o delimitare mai rapid a
zonei din tablou n care s-ar putea gsi x. Ca principiu, metoda este inspirat dup
procedeul cutarii ntr-o carte de telefon.
Aplicarea cutrii prin interpolare necesit ca elementul de cutat, x, s se afle n
interiorul intervalului v[1],...,v[n], astfel apare riscul ca valoarea calculat a lui m sa
depaeasc n.
Algoritm descris n pseudocod
Cutarenterpolare(V,n,x)
st 0 dr n-1 gasit fals
dac ((x<=v[dr]) i (x>=v[st])) execut
repet
m st +(x-v[st])*[(dr-st)/(v[dr]-v[st])]
dac x < v[m] atunci
st m+ 1
altfel dr m-1
sfrit dac
pn cnd ((v[m]=x) i (st<dr)i (v[st]=v[dr]) i(x<v[st]) i (x>v[dr]))
sfrit dac
dac v[m]=x atunci
gasit adevarat
sfrit dac
sfrit subalgoritm
&#ple#entare n )BB
int Cutarenterpolare(int v[], int n, int x)
{
int st,dr,m;
st=0;dr=n-1;
if ((x<=v[dr]) && (x>=v[st]))
do
{
m=st+(x-v[st])*(dr-st)/(v[dr]-v[st]);
if(x>v[m])
st=m+1;
else
dr=m-1;
} while((v[m]!=x) && (st<dr) && (v[st]==v[dr]) && (x>=v[st]) && (x<=v[dr]));
if(v[m]==x)
return 1;
else
return 0;
}
&#ple#entare n Pa!cal
function Cutarenterpolare(v:vector;n,x:integer):Boolean;
var st,dr,m:integer;
begin
st:=1;dr:=n;gsit:=false;
if (x<=v[dr]) and (x>=v[st]) then begin
repeat
m:=st+(x-v[st]*(dr-st) div (v[dr)-v[st]);
if x>v[m] then st:=m+1
else
dr:=m-1;
until ((v[m]<>x) and (st<dr) and (v[st]=v[dr]) and (x>=v[st]) and (x<=v[dr]));
if v[m]=x then gsit:=true;end.
Cutarenterpolare:= gsit;
End;
Aceast metod este eficient n cazul n care n este foarte mare i valorile elementelor
tabloului au o distribuie uniform n intervalul v[1],...,v[n]. Numrul de cutri n acest
caz este de ordinul lg(lgn).
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A
Clasa poate fi organizat frontal sau pe grupe.
Ca metode de predare se vor folosi:
Explicaia n etapa de comunicare a cunotintelor;
Conversaia euristic n etapa de fixare a cunostinelor;
Problematizarea: Cum se modific algoritmul pentru cutarea unui element ntr-un
vector ordonat descresctor?
Acest coninut poate fi evaluat oral sau prin lucrare scris.
Te#a -6 )riterii de perfor#an(
Fi:a !uport -61 )o#ple;itatea #etodei
)o#ple;itatea al"orit#ilor de !ortare
Sortarea prin selecie este un algoritm de sortare a crui principiu de funcionare este
specific algoritmilor de sortare prin comparare care se fac pe loc Acest tip de sortare are
complexitatea O(n
2
), i se comport eficient dac lucreaz cu liste mari de date, iar n
cazul n care se comport ineficient algoritmul are o rapiditate de sortare asemntoare
cu rapiditatea algoritmului de sortare al metodei de sortare prin inserie. Sortarea prin
selecie este preferat n practic deoarece reprezint un algoritm simplu, avnd i alte
avantaje performante rezultnd astfel c sortarea prin selecie se situeaz deasupra
altor algoritmi de sortare chiar dac se sorteaz structuri de date de aceeai
complexitate.
Sortarea prin inserare este un algoritm simplu de sortare prin compararea unor
elemente aflate n tablouri de date sortate, construind cte o intrare la un anumit timp.
Acest tip de algoritm este mai puin eficient n lucrul cu liste mari de date, i nu are
performana algoritmilor de sortare avansai cum sunt algoritmul de sortare rapid quick
sort sau merge sort.
$u%%leSort" Dei sortarea prin interschimbare este unul dintre cei mai simpli algoritmi,
putnd fi uor ntelei sau implementai, totui are o complexitate de O(n
2
) care l face
prea ineficient pentru a sorta liste de dimensiuni mari.Dei este simplu comparativ cu
ali algoritmi,sortarea prin inserie este mult mai eficient dect sortarea prin
interschimbare.
Sortarea prin inserie cu pas varia%il este un algoritm de sortare, care n implementarea
original necesit un numr de O(n
2
) comparaii i nlocuiri de elemente, n cazul n
care algoritmul se comport ineficient. Algoritmul de sortare prin inserie cu pas variabil
este uor de depanat dac se dorete a se vedea cum funcionez acest algoritm, ns
este mai dificil s se examineze timpul de execuie al algoritmului.
Sortarea prin interclasare" Pentru a sorta un numar de n elemente sortarea prin
interclasare prezint o comportare mulumitoare reprezentat prin relaia O(n log n).
Dac se aplic sortarea prin interclasare n cadrul unei liste de lungime n atunci timpul
de sortare a acesteia va fi de T(n), unde relaia T(n)= 2T(n/2) + n provine de la ideea de
baz a algoritmului . Adic, perioada de sortare T(n) a unei liste de dimensiune n
depinde i de perioada de sortare a celor dou sub-liste: T(n)= 2T(n/2) + n, plus numr
de treceri pentru a sorta cele dou sub-liste rezultate.
n cazul n care sortarea prin interclasare se comport ineficient aceasta va efectua un
numr de (nIlg nI - 2
Ilg nI
+ 1) comparaii, care se cuprind in intervalul (n lg n& n+1) i (n lg
n ' n + O(lgn)). Astfel c n cazul n care sortarea prin interclasare se comport
ineficient, se efectueaz cu 39% mai puine comparaii ale elementelor dect n cazul
comportrii mulumitoare a sortrii rapide, deoreace sortarea prin interclasare va
efectua ntotdeauna mai puine comparaii dect cel mai rapid algoritm de sortare -
sortarea rapid (quicksort), excepie facnd cazurile extrem de rare cnd comportarea
ineficient a sortrii prin interclasare este mai performant dect comportarea eficient
a sortrii rapide.Sortarea prin interclasare ct i sortarea rapid pot sorta i cazuri mai
complexe, ambele finaliznd sortarea intr-un timp definit prin relaia O(n log n).
mplementrile recursive ale algoritmului de sortare prin interclasare efectueaz printr-
un numr de 2n-1 treceri n cazul cnd acesta se comport ineficient, care n
comparaie cu sortarea rapid care efectueaz un numr de n treceri, aceasta
nsemnnd c sortarea prin interclasare este mult mai recursiv dect sortarea rapid.
mplementrile acestei sortri ocolesc metoda de efectuare a mai multor treceri dect
este necesar, astfel fiind uor de implementat.
Cele mai multe implementri ale sortrii prin interclasare nu efectueaz sortri "pe loc",
astfel, capacitatea memoriei alocat la nceputul procedeului de sortare are aceeai
dimensiune ca i capacitatea memoriei folosit pentru a stoca datele i dup terminarea
procesului de sortare.Deasemeni este permis utilizarea conceptului de sortare pe loc
n cadrul algoritmului de sortare prin interclasare, ns va rezulta un algoritm foarte
complicat care va avea o performan foarte scazut din puncrt de vedere practic, astfel
c algoritmul nu va mai rula ntr-un timp de O(n logn).n acest caz metoda de sortare
prin ansamble (heapsort) are o comportare mult mai eficient, deoarece prezint un
algoritm mai uor de implemetat.
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A Clasa poate fi organizat frontal sau pe grupe.
Ca metode de predare se vor folosi:
Explicaia n etapa de comunicare a cunotintelor;
Conversaia euristic n etapa de fixare a cunostinelor;
Studiu de caz: -S se demonstreze c timpul de execuie al algoritmului quicksort, n
cazul unui vector A cu toate elementele egale ntre ele, este O(n log n).
- S se demonstreze c pentru a interclasa doi vectori ordonai ce conin fiecare
cte n elemente, sunt necesare 2n-1 comparaii n cazul cel mai defavorabil.
Acest coninut poate fi evaluat oral sau prin lucrare scris.
Te#a -6 )riterii de perfor#an(
Fi:a !uport -62 Utili8area !paiului de #e#orie
Pentru a aloca un spaiu de memorie sortarea rapid utilizeaz o metod care are o
complexitate de O(log n), care este valabil i n situaia n care algoritmul folosit se
comport ineficient.ns pentru a ocoli o comportare ineficient trebuie s se aib n
vedere urmatoarele aspecte:
- Se utilizeaz metoda partiionrii pe loc.Aceasta neceist O(1) timp de sortare.
- Dup partiionarea listei iniiale va rezulta c partiia care deine cele mai puine
elemente este sortat (prin procedee recursive) prima, necesitnd un spaiu de
memorie de O(log n) locaii.Astfel dac se ncepe sortarea unei alte partiii atunci se va
utliza metoda iteraiilor.
Versiunea sortrii rapide care utilizeaz procedura de partiionare pe loc utilizeaz un
spaiu de memorie de dimensiune constant chiar i naintea metodei de
recursivitate.Oricum, se execut un numr de O(log n) de nlocuiri prin operaii
recursive, astfel rezultnd c sortarea rapid trebuie s memoreze indicii de dimensiuni
fixe pentru a furniza informaii referitoare la fiecare termen din list.Cnd algoritmul se
comport eficient vor fi necesare un numar de O(log n) de nlocuiri care vor utiliza un
spaiu de memorie de O(log n) locaii.Cnd algoritmul se comport ineficient atunci
nlocuirea elementelor de sortare se va executa ntr-un timp de O(n), necesitnd astfel
i un spaiu de memorie O(n) locaii.
Dac se presupune c se sorteaz arbitrar liste de dimensiuni mari atunci utilizarea
unui concept de sortare care s foloseasc variabile cum ar fi stnga sau dreapta este
indicat spre a fi utlizat, deoarece aceste variabile au dimensiuni reduse i nu vor depi
limita constant a spaiului de memorie alocat la nceputul sortrii; astfel fiind necesare
un numr de O(log n) bii pentru a localiza poziia celor n termeni din list.Dac se
utliziteaz acest concept bazat pe variabilele de stnga i dreapta n fiecare partiie
(sub-lista) a listei iniiale atunci vor fi necesari un numr de O(log
2
n) de bii pentru a
memora locaiile poziiilor elementelor din list n cazul n care algoritmul de sortare se
comport eficient, i n caz contrar vor fi necesari un numr de O(n logn).
Dac se folosete un algoritm de sortare diferit de algoritmul de sortare "pe loc", atunci
sortarea rapid va executa un numar de O(n) locaii de memorie nainte de a se ncepe
nlocuirea termenilor.Un astfel de algoritm execut sortarea complet a listei ntr-un timp
definit prin metoda O(n), deoarece fiecare nivel la care se aplic operaia de
recursivitate utilizeaz mai mult spaiu de memorie.Dac elementele listei au dimensiuni
diferite atunci rezolvarea devine mai complex, cci de exemplu dac cele mai multe
elemente ale unei liste ce trebuie sortat sunt distincte, atunci pentru a stoca informaii
despre acestea este necesar un numar de O(log n) bii, iar numarul de bii necesari
pentru a memeora informaii despre aceste elemente va fi necesar un spaiu de
memorie de O(n log n) locaii, iar n cazul n care algoritmul care trebuie s sorteze
aceste elemente este ineficient atunci va fi necesar un spaiu de memorie de O(n
2
log n)
locaii.
Comportarea algoritmilor de sortare din punct de vedere al eficienei i al utilizrii
memoriei este exprimat n urmtorul tabel:
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A
Clasa poate fi organizat frontal sau pe grupe.
Ca metode de predare se vor folosi:
Explicaia n etapa de comunicare a cunotintelor;
Conversaia euristic n etapa de fixare a cunostinelor;
Studiu de caz: S se descrie algoritmul de sortare prin inserare, la care s se modifice
cutarea liniar cu o cutare binar.S se calculeze pentru acest nou algoritm numrul
de comparaii i mutri ale elementelor din list pentru exemplul: 5 9 1 7 4 3 2 0. Devine
acest algoritm mai performant?
Acest coninut poate fi evaluat oral sau prin lucrare scris.
Numele sortrii Comportare
eficient
Comportare
medie
Comportare
ineficient
Nr.
accese la
memorie
Stabilitate
Sortare
interschimbare
O(n) -- O(n
2
) O(1) Da
Sortare selecie O(n
2
) O(n
2
) O(n
2
) O(1) Nu
Sortare inserie O(n) O(n + d) O(n
2
) O(1) Da
Sortare inserie
cu pas variabil
-- -- O(n
1.5
) O(1) Nu
Sortare
interclasare
O(n log n) O(n log n) O(n log n) O(n) Da
HeapSort O(n log n) O(n log n) O(n log n) O(1) Nu
QuickSort O(n log n) O(n log n) O(n
2
) O(log n) Nu
Te#a 106 )o#ple;itatea al"orit#ilor
Fi:a !uport 1061 +u#(rul de operaii6 /ite8a de e;ecuie6
De!criere
Vom nota cu Tn( timpul de execuie al unui algoritm destinat rezolvrii unei probleme
de dimensiune n. Pentru a estima timpul de execuie trebuie stabilit un model de calcul
i o unitate de msur. Vom considera un model de calcul (numit i main de calcul cu
acces aleator) caracterizat prin:
Prelucrrile se efectueaz n mod secvenial
Operaiile elementare sunt efectuate n timp constant indiferent de valoarea
operanzilor
Timpul de acces la informaie nu depinde de poziia acesteia (nu sunt diferene
ntre prelucrarea primului element i cea a ultimului element al unui tablou)
A stabili o unitate de msur nseamn a stabili care sunt operaiile elementare i a
considera ca unitate de msur timpul de execuie a acestora. n acest fel timpul de
execuie va fi exprimat prin numrul de operaii elementare executate. Operaiile
elementare sunt cele aritmetice (adunare, scdere, nmulire, mprire), comparaiile i
cele logice (negaie, conjuncie i disjuncie). Cum scopul calculului timpului de execuie
este de a permite compararea algoritmilor uneori este suficient s se contorizeze doar
anumite tipuri de operaii elementare, numite operaii de %a) (de exemplu n cazul unui
algoritm de cutare sau de sortare se pot contoriza doar operaiile de comparare) i/sau
s se considere c timpul de execuie a acestora este unitar (dei operaiile de nmulire
i mprire sunt mai costisitoare dect cele de adunare i scdere n analiza se poate
considera c ele au acelai cost).
Cteva reguli generale pentru evaluarea timpului de execuie, funcie de mrimea n a
datelor de intrare, snt:
(1) timpul de execuie a unei instruciuni de asignare, citire sau scriere, este O(1);
(2) timpul de rulare a unei secvene de instruciuni e determinat de regula de
nsumare, fiind proporional cu cel mai lung timp din cei ai instruciunilor secvenei;
(3) timpul de execuie a unei instruciuni if-then-else este suma dintre timpul de
evaluare a condiiei (O(1)) si cel mai mare dintre timpii de execuie ai instruciunilor
pentru condiie adevarat sau fals;
(4) timpul de execuie a unei instruciuni de ciclare este suma, pentru toate iteraiile,
dintre timpul de execuie al corpului instruciunii i cel de evaluare a condiiei de
terminare (O(1));
(5) pentru evaluarea timpului de execuie a unei proceduri recursive, se asociaz
fiecrei proceduri recursive un timp necunoscut T(n), unde n msoar argumentele
procedurii; se poate obine o relaie recurent pentru T(n), adic o ecuaie pentru T(n),
n termeni T(k), pentru diferite valori ale lui k;
(6) timpul de execuie poate fi analizat chiar pentru programele scrise n pseudocod;
pentru secvenele care cuprind operaii asupra unor date, se pot alege cteva
implementri i astfel se poate face comparaie ntre performanele implementrilor, n
contextul aplicaiei respective.
Timpul de execuie al ntregului algoritm se obine nsumnd timpii de execuie a
prelucrrilor componente.
*+emplul," Considerm problema calculului Dimensiunea acestei probleme
este n"
Algoritmul de rezolvare poate fi descris prin:
suma(n)
1: S 0
2: i 1
3:ct timp i<=n execut
4: s s+i
5: i i+1
Sfritcttimp
Unde operaiile ce sunt contorizate sunt numerotate. Timpul de execuie al algoritmului
poate fi determinat folosind tabelul de costuri:
Operaie Cost Nr. repetri
1 C1 1
2 C2 1
3 C3 n+1
4 C4 n
5 C5 n
nsumnd timpii de execuie ai prelucrrilor elementare se obine: T(n) = n{c3 + c4 +
c5) + c1 + c2 + c3 = k
1n
+k
2
, adic timpul de execuie depinde liniar de dimensiunea
problemei. Costurile operaiilor elementare influeneaz doar constantele ce intervin n
funcia T(n).
*+emplul -" Considerm problema determinrii produsului a dou matrici: . de
dimensiuni m*n i $ de dimensiuni n*p. n acest caz dimensiunea problemei este
determinat de trei valori: (m,n,p). Algoritmul poate fi descris prin:
produs(a[1..m,1..n],b[1..n,1..p])
1: pentru i 1,m execut
2: pentru j 1,p execut
3: c[i,j] 0
4: pentru k 1,n execut
5: c[i,j] c[i,j]+a[i,k]*b[k,j]
sfritpentru
sfritpentru
sfritpentru
Costul prelucrrilor de pe liniile 1, 2 i 4 reprezint costul gestiunii contorului i va fi
tratat global. Presupunnd c toate operaiile aritmetice i de comparare au cost unitar
tabelul costurilor devine:
Operaie Cost Nr. repetri
1 2(m+1) 1
2 2(p+1) m
3 1 m*p
4 2(n+1) m*p
5 2 m*p*n

n
i
i
1
Timpul de execuie este n acest caz: T(m, n,p) = 4mnp + 5mp + 4m + 2.
n practic nu este necesar o analiz att de detaliat ci este suficient s se
identifice operaia de baz i s se estimeze numrul de repetri ale acesteia. Prin
operaie de baz se nelege operaia care contribuie cel mai mult la timpul de execuie
al algoritmului i este operaia ce apare n ciclul cel mai interior.
n exemplul de mai sus ar putea fi considerat ca operaie de baz, operaia de
nmulire. n acest caz costul execuiei algoritmului ar fi T(m,n,p) = m*n*p.
*+emplul /" Considerm problema determinrii valorii minime dintr-un tablou x[1..n].
Dimensiunea problemei este dat de numrul n de elemente ale tabloului. Algoritmul
este:
Minim(x[1..n])
1: m x[1]
2: pentru i 2,n execut
3: dac m > x[i] atunci
4: m x[i]
Sfritdac
Sfrit pentru
Tabelul costurilor prelucrrilor este:
Operaie Cost Nr. repetri
1 1 1
2 2n 1
3 1 n-1
4 1 r(n)
Spre deosebire de exemplele anterioare timpul de execuie nu poate fi calculat
explicit ntruct numrul de repetri ale prelucrrii numerotate cu 4 depinde de valorile
aflate n tablou.
Dac cea mai mic valoare din tablou se afl chiar pe prima poziie atunci prelucrarea 4
nu se efectueaz nici o dat iar r(n) 0 0. Acesta este considerat cazul cel mai favorabil"
Dac, n schimb, elementele tabloului sunt n ordine strict descresctoare atunci
prelucrarea 4 se efectueaz la fiecare iteraie adic r(n) = n - l" Acesta este cazul cel
mai defavorabil.
Timpul de execuie poate fi astfel ncadrat ntre dou limite: 3n < T(n) < 4n -1.
n acest caz este uor de observat c se poate considera ca operaie de baz cea a
comparrii dintre valoarea variabilei m i elementele tabloului n n acest caz costul
algoritmului ar fi T(n) = n -1
*+emplul 1" Considerm problema cutrii unei valori v ntr-un tablou x[1..n].
Dimensiunea problemei este din nou n iar o variant a algoritmului este:
cutare (x[1..n], v)
1: gsit fals
2: i 1
3: ct timp (gsit=fals) si (i > n) execut
4: dac v=x[i] atunci
5: gsit adevarat
6: altfel i i+1
sfritdac
sfritcttimp
Tabelul costurilor este:
deci 1 > r
1
(n) > n
deci 0 > r
3
(n) > n
Operaie Cost Nr. repetri
1 1 1
2 1 1
3 3 r
1
(n) + 1
4 1 r
1
(n)
5 1 r
2
(n)
6 1 r
3
(n)
n cazul n care valoarea v se afl n ir notm cu k prima poziie pe care se afl.
Se obine:
k valoarea se afl n ir
r
1
(n)= n valoarea nu se afl n ir
1 valoarea se afl n ir
r
2
(n)= 0 valoarea nu se afl n ir
k+1 valoarea se afl n ir
r
3
(n)= n valoarea nu se afl n ir
Cazul cel mai favorabil este cel n care valoarea se afl pe prima poziie n tablou,
caz n care T(n) = 3(n(n) + 1) + n(n) + r
2
{n) + n(n) + 2 = 6 + 1 + 1 + 0 + 2 = 10.
Cazul cel mai defavorabil este cel n care valoarea nu se afl n tablou:
T(n)=3(n+1)+n+0+2=5(n+1)
&#portana celui #ai defa,oraCil ca86 n aprecierea i compararea algoritmilor
intereseaz n special cel mai defavorabil caz deoarece furnizeaz cel mai mare timp
de execuie relativ la orice date de intrare de dimensiune fix. Pe de alt parte pentru
anumii algoritmi cazul cel mai defavorabil este relativ frecvent.
n ceea ce privete analiza celui mai favorabil caz, aceasta furnizeaz o margine
inferioar a timpului de execuie i poate fi util pentru a identifica algoritmi ineficieni
(dac un algoritm are un cost mare n cel mai favorabil caz, atunci el nu poate fi
considerat o soluie acceptabil).
Ti#p #ediu de e;ecuie6 Uneori, cazurile extreme (cel mai defavorabil i cel mai
favorabil) se ntlnesc rar, astfel c analiza acestor cazuri nu furnizeaz suficient
informaie despre algoritm.
n aceste situaii este util o alt msur a complexitii algoritmilor i anume timpul
mediu de e+ecuie" Acesta reprezint o valoare medie a timpilor de execuie calculat n
raport cu distribuia de probabilitate corespunztoare spaiului datelor de intrare. Dac
vn( reprezint numrul variantelor posibile, P
2
este probabilitatea de apariie a cazului
2 iar T
k
(n) este timpul de execuie corespunztor cazului 2 atunci timpul mediu este dat
de relaia:

) '
1
. ) ' ) '
n v
k
k k m
P n T n T
Dac toate cazurile sunt echiprobabile (P
k
=1/v(n)) se obine ) ' C ) ' ) '
) '
1
n v n T n T
n v
k
k m

.
*+emplu"Considerm din nou problema cutrii unei valori
v
ntr-un tablou
x
[1..n]
(exemplul 4).
Pentru a simplifica analiza vom considera c elementele tabloului sunt distincte. Pentru
a calcula timpul mediu de execuie trebuie s facem ipoteze asupra distribuiei datelor
de intrare.
S considerm c valoarea
v
se poate afla pe oricare dintre poziiile din tablou sau n
afara acestuia cu aceeai probabilitate. Cum numrul cazurilor posibile este
1 ) ' + n n v
(n cazuri n care valoarea se afl n cadrul tabloului i unul n care
v
nu se afl n
tablou) rezult c probabilitatea fiecrui caz este de
) 1 C' 1 + n
. Cum timpul
corespunztor cazului n care
v
se afl pe poziia k este T
k
=5(k+1) iar cel
corespunztor cazului n care valoarea nu se afl n tablou este T
n+1
=5(n+1) rezult c
timpul mediu de execuie este:

+
+ +
+ + +
+

n
k
m
n
n n
n k
n
n T
1
!
) 1 ' !
) ! 5 ' 5
)) 1 ' 5 ) 1 ' 5 '
1
1
) '
Dificultatea principal n stabilirea timpului mediu const n stabilirea distribuiei
corespunztoare spaiului datelor de intrare. Pentru exemplul n discuie s-ar putea lua
n considerare i ipoteza:
P(
v
se afl n tablou)=P(
v
nu se afl n tablou)=0.5 iar n cazul n care se afl n
tablou el se gsete cu aceeai probabilitate pe oricare dintre cele n poziii: P(
v
se afl
pe poziia k)=1/n. n acest caz timpul mediu este:

$
) 5 " ' 5
) ) 1 ' 5 ) 1 ' 5
1
'
!
1
) '
1
+
+ + +

n
n k
n
n T
n
k
m
Se observ c timpul mediu de execuie depinde de ipotezele fcute asupra
distribuiei datelor de intrare i c aceasta nu este o simpl medie aritmetic a timpilor
corespunztori cazurilor extreme(cel mai favorabil respectiv cel mai defavorabil).
Datorit dificultilor ce pot interveni n estimarea timpului mediu i datorit faptului
c n multe situaii acesta difer de timpul n cazul cel mai defavorabil doar prin valori
ale constantelor implicate, de regul analiza se refer la estimarea timpului n cazul cel
mai defavorabil.Timpul mediu are semnificaie atunci cnd pentru problema n studiu
cazul cel mai defavorabil apare rar.
)la!e de co#ple;itate
n ierarhizarea algoritmilor dup ordinul de complexitate se ine cont de urmtoarele
proprieti ale funciilor ce intervin cel mai frecvent n analiz:
D
) 'lg
lim

k
b
n
n
n
D lim

n
k
n
a
n
D lim

n
n
n
n
a
D
E
lim

n
a
n
n
(a3,)
Clase de complexitate
Ordin
(cazul cel mai defavorabil)
Exemplu
logaritmic O(lgn) cutare binar
liniar
O(n)
O(nlgn)
cutare secvenial
sortare prin interclasare
ptratic O(n
2
) sortare prin inserie
cubic O(n
3
)
produsul a dou matrici
ptratice de ordin n
exponenial O(2
n
)
prelucrarea tuturor submulimilor
unei mulimi cu n elemente
factorial O(n!)
prelucrarea tuturor permutrilor
unei mulimi cu n elemente
Majoritatea limbajelor de programare ofer funcii care calculeaz timpul scurs ntre
dou momente. Este important ca n sistem s nu fie mai multe taskuri active sau s fie
contorizat numai timpul afectat execuiei programului analizat. Se recomand s fie
executat programul de mai multe ori i s se fac media timpului de execuie.
La generarea seturilor de date de intrare scopul urmrit este acela de a se obine
date tipice rulrilor uzuale (s nu fie cazuri extreme sau excepii). n acest scop datele
se genereaz n manier aleatoare
$(!urarea ti#pului de e;ecuie a unei p(ri de pro"ra# n )BB
$(!urarea ti#pului de e;ecuie a unei p(ri de pro"ra# n Pa!cal'
Var i,j,h,m,s,h1,m1,s1,s100,s1001,durata,x:word;
begin
gettime(h,m,s,s100);
for i:=1 to 2000 do
for j:=1 to 2000 do
if i mod 2=0 then
i:=i;
gettime(h1,m1,s1,s1001);
writeln('Ora de inceput: ',h,':',m,':',s,':',s100);
writeln('Ora exacta: ',h1,':',m1,':',s1,':',s1001);
writeln('Timpul de executie necesar este :');
durata:=((h1-h)*3600+(m1-m)*60+(s1-s))*100+s1001-s100;
writeln(durata,' sutimi de secunde');
writeln(durata div 100,' secunde ',durata mod 100,' sutimi de secunde');
end.
Su"e!tii #etodolo"ice
Utilizarea operaiilor starton si startoff.
Msurarea duratei se poate face astfel:
JK fiierul pti#er6cpp
#include <iostream.h>
#include <conio.h>
#include "timer.h"
void main()
{
clrscr();
float timp;
int i,j;
starton();
for(i=1;i<=2000;i++)
for(j=1;j<=2000;j++)
if(i%2)
i=i;
timp=startoff();
cout<<timp;
getch();
}
Se definete modulul timer.h, cu operaiile
starton i startoff ca n exemplul urmtor:
JK fiierul ti#er6
#include <time.h>
void starton(void);
float startoff(void);
static clock_t aux;
void starton(void)
{
aux=clock();
}
float startoff(void)
{
return(clock()-aux)/CLK_TCK;
}
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic.
)U$ PRED3$A Clasa poate fi organizat frontal sau pe grupe.
Ca metode de predare se vor folosi:
Explicaia n etapa de comunicare a cunotintelor;
Conversaia euristic n etapa de fixare a cunostinelor;
Studiu de caz: 1. S se demonstreze c timpul de execuie al algoritmului quicksort, n
cazul unui vector A cu toate elementele egale ntre ele, este O(n log n).
2. S se demonstreze c pentru a interclasa doi vectori ordonai ce conin
fiecare cte n elemente, sunt necesare 2n-1 comparaii n cazul cel mai defavorabil.
3.Folosind variantele C++ sau Pascal,descrise n aceast fi pentru calcularea
timpului de execuie a unei pri de program, se poate propune elevilor urmtorul test:
Calcularea timpului de execuie pentru aceleai date de intrare astfel:
- sortarea prin interclasare vs quicksort
- cutarea secvenial vs cutarea binar
- cutarea binar vs cutarea prin interpolare
Acest coninut poate fi evaluat oral sau prin lucrare scris.
Te#a 106 )o#ple;itatea al"orit#ilor
Fi:a !uport 1062 $(ri#ea datelor6 Utili8area #e#oriei6
De!criere
Comportarea aceluiai algoritm poate fi diferit n funcie de datele de intrare. De
aceea se impune o mare atenie asupra acestora din urm. O variabil prezent n
intrarea unui algoritm poate identifica un tablou sau un obiect al unei date compuse i
va fi tratat ca un pointer la elementele tabloului, respectiv la cmpurile (atributele)
obiectului corespunztor.
Modul n care se definete dimensiunea datelor de intrare depinde de problema de
calcul analizat. Ea poate fi exprimat prin:
a) numrul de elemente cuprinse n datele de intrare (de exemplu, de
dimensiunea unui tablou de numere intregi);
b) numrul total de bii din reprezentarea binar a datelor de intrare;
c) dou numere naturale;
d) valoarea numeric a intrrii (pentru algoritmi numerici).
Pentru fiecare algoritm care rezolv o anumit problem P este necesar a se preciza
modul de exprimare a dimensiunii datelor de intrare.
n tabelul de mai jos sunt prezentate tipurile de date cu domeniile lor de
reprezentare (pentru BorlandC 3.1)
Tip Di#LCii Se#nificaie Do#eniu de ,alori
nt 16 ntreg [-32768..32767]
Short 16 ntreg [-32768..32767]
Long 32 ntreg [-2147483648..2147483647]
Unsigned 16 ntreg fr semn [0..65535]
Unsigned
long
32 ntreg fr semn [0..4294967295]
Unsigned
char
8 Cod ASC caracter [0..255]
Signed char 8 Cod ASC caracter [-128,127]
Float 32
Flotant
simpl precizie
[3.4x10^(-38)..3.4x10^38]
Double 64 Flotant dubl precizie [1.7x10^(-308).. 1.7x10^308]
Long double 80 Flotant dubl precizie
[3.4x10^(-
4932)..3.4x10^4932]
Observaii:
Pentru tipul char, implicit se consider "signed char". Variabilele de tip ntreg folosesc
pentru memorarea datelor codul complementar fa de 2 (dac se rein date cu semn)
sau baza 2 (pentru date fr semn). Caracterele se memoreaz prin codul ASC, care
este tot un numr ntreg. Pentru tipurile flotante (reale) se folosete reprezentarea n
virgul mobil.
Dac exist un algoritm care rezolv problema P nu nseamn c el este unic.
De exemplu, exist algoritmi ca: QuickSort (sortare rapid), MergeSort (sortare prin
interclasare), sortarea prin selecie i inserie etc. care sunt utilizai n acelai scop.
Prin urmare, apare necesitatea alegerii unui algoritm din clasa de algoritmi care
rezolv problema P care s corespund unor cerine. Algoritmul depinde de aplicaie,
implementare, mediu, frecvena utilizrii etc. Compararea algoritmilor este un proces
subtil care are n vedere mai multe aspecte. n continuare, vom cuta s analizm
cteva din aceste aspecte care joac un rol important n elaborarea unui algoritm.
Un program necesit un spaiu de memorie constant, independent de datele de
intrare, pentru memorarea codului su, a constantelor, a variabilelor simple i a
structurilor de date de dimensiune constant alocate static i un spaiu de memorie
variabil, a crui dimensiune depinde adesea de datele de intrare, constnd din spaiul
necesar pentru structurile de date alocate dinamic, a cror dimensiune depinde de
instana problemei de rezolvat i din spaiul de memorie necesar apelurilor de proceduri
i funcii.
De exemplu, s considerm urmtoarea problem:
Fie A o mulime cu n elemente i x o valoare de tipul elementelor mulimii A. S se
decid dac x aparine sau nu mulimii.
Vom scrie o funcie iterativ care va cuta secvenial valoarea x n vectorul folosit
pentru memorarea mulimii A, funcie care ntoarce valoarea true dac x se gsete n
vector i false n caz contrar.
function Caut : boolean;
var i: integer; gasit: boolean;
begin
i := 1; gasit := false;
while (i < n) and not gasit do
if a[i] = x then gasit := true
else i := i+1;
Caut := gasit;
end;
Funcia Caut va fi apelat o singur dat. Neavnd parametri, va necesita spaiu de
memorie doar pentru variabilele locale i pentru adresa de revenire. Deci nu este
necesar spaiu de memorie variabil. Aceeai problem o putem rezolva cu ajutorul unei
funcii recursive Rcaut.
Funcia are un parametru ntreg care indic poziia de la care ncepe cutarea n
vectorul a. Evident, iniial apelm rcauta(1).

function Rcaut (poz: integer): boolean;
begin
if poz > n then rcauta := false
else if a[poz] = x then Rcaut := true
else Rcaut := Rcaut(poz+1);
end;
Spaiul de memorie utilizat pentru un apel al funciei este cel necesar pentru
memorarea parametrului (2 octei) i pentru adresa de revenire (2 octei). Dac x nu se
gsete n vector se fac n apeluri recursive, deci spaiul de memorie variabil este de 4n
octei. Dac x se gsete n vector, dimensiunea spaiului de memorie variabil depinde
de poziia pe care x se gsete n vectorul a. Deci, varianta recursiv necesit un spaiu
de memorie mult mai mare dect varianta iterativ.
Progresele tehnologice fac ca importana criteriului spaiu de memorie utilizat s
scad, prioritar devenind criteriul timp.
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A Clasa poate fi organizat frontal sau pe grupe.
Ca metode i procedee de predare se vor folosi:
Explicaia n etapa de comunicare a cunotintelor;
Conversaia euristic n etapa de fixare a cunostinelor;
Studiu de caz: Se poate propune elevilor s explice pentru tipurile int i unsigned char
cum se calculeaz domeniile de valori.
Acest coninut poate fi evaluat oral sau prin lucrare scris.
Te#a 106 )o#ple;itatea al"orit#ilor
Fi:a !uport 1063 *l"orit#i polino#iali :i e;poneniali6
Definiia 1: Un algoritm se numete polino#ial dac are o complexitate temporal
Of(n)), unde f(n) este o funcie polinomial n n, lungimea intrrilor.
Definiia 2: Dac un algoritm nu este de complexitate polinomial, atunci el se numete
e;ponenial; tot exponeniali sunt considerai algoritmii de complexitate n
log n
, cu toate
c ei nu sunt polinomiali, dar nici exponeniali n sens strict matematic.
De menionat c:
practica a impus ca acceptabili numai algoritmii cu comportare n timp polinomial
deoarece, chiar pentru valori nu prea mari ale lui n, algoritmii exponeniali devin
inutilizabili;
n acelai timp, pentru valori mici ale lui n, un algoritm exponenial poate fi mai bun
dect unul polinomial;
n calculul timpului de execuie necesar algoritmului, putem considera c toate
operaiile elementare ce intervin n algoritm necesit acelai timp.
Pentru a justifica aceste afirmaii vom considera c o operaie necesit 10
-6
secunde
pentru a se executa. Tabelul de mai jos furnizeaz timpul de calcul pentru algoritmii
polinomiali cu f(n) egal cu n, n
2
, n
3
, n
5
si exponeniali cu f(n) egal cu 2
n
,3
n
, pentru diferite
valori ale lungimii n a intrrilor.
N 10 20 30 40 50
N 0,0001 0,0002 0,0003 0,0004 0,0005
N
2
0,0001 0,0004 0,0009 0,0016 0,0025
N
3
0,001 0,008 0,027 0,064 0,125
N
5
0,1 3,2 24,3 1,7' 5,2'
2
n
0,001 1 17,9 12,7 yile 38,7 ani
3
n
0,059 38' 6,5 ani 38,5 secol 2*10
8
secol
Ti#pi de calcul pentru al"orit#i polino#iali :i e;poneniali
Din tabel se observ c:
- comparnd viteza de cretere n funcie de n a timpului de execuie pentru funciile f(n)
considerate, constatm c pentru valori ale lui n nu prea mari, timpul de execuie este
inacceptabil n cazul algoritmilor exponeniali care devin astfel inutilizabili;
- pentru valori mici ale lui n, un algoritm exponenial poate fi mai bun dect unul
polinomial; astfel, functia f(n)=2
n
ne conduce la o valoare a timpului de execuie mai
mic dect n cazul f(n)=n5 pentru n>20.
- exist algorimi exponeniali care se comport acceptabil pentru rezolvarea majoritii
problemelor particulare, cum este metoda simplex pentru rezolvarea problemelor de
programare liniara (metoda este de complexitate exponenial, dar este eficient n
rezolvarea problemelor concrete). Astfel de exemple sunt rare i nu exist o metod
care s prevad c un algoritm de complexitate exponenial este practic acceptabil.
OC!er,aia 1: pentru a justifica faptul c am considerat toate operaiile care intervin
ntr-un algoritm cu acelai timp de execuie, vom lua urmtorul exemplu:
Presupunem c un algoritm prelucreaz un vector A=(a1, a2, .,an) i c n algoritm
intervin dou tipuri de operaii notate prin (*) si (+). Considerm,de asemenea, c timpul
de execuie al operaiei (*) este de 10.000 mai mare ca al operaiei (+), i c n timp ce
operaia (*) se execut de n ori, operaia (+) se executa de n
3
ori.
N (+) (*)
Nr operaii n*10000 N
3
N=1 10.000 1
N=10 10.000 1.000
N=100 1.000.000 1.000.000
N=200 2.000.000 8.000.000
N=500 5.000.000 125.000.000
Ti#pi de prelucrare pentru operaii
Din acest tabel se observ c pentru n 100 avem n*10.000 n
3
, dar pentru n>100
obtinem n*10.000<n
3
sau c.
+

n
n
n
1
lim
"
Rezult deci c, mai ales pentru valori mari ale intrrilor n algoritm, adic ale lui n, este
mai important numrul de calcule, de operaii efectuate, i nu diferenierea lor pe tipuri,
chiar dac timpii de execuie pentru diferite operaii difer.
OC!er,aia 2: Nu exist o metod general de deteminare a numrului de operaii,
asfel nct problema complexitii trebuie rezolvat pentru fiecare program n parte. De
exemplu, fie produsul a patru matrice A
1
, A
2
, A
3
si A
4
, care au respectiv dimensiunile:
(10,20), (20,50), (50,1), (1,100). nmulirea matricelor se poate efectua n mai multe
moduri:
- Fie ordinea (A
1
* (A
2
*( A
3
* A
4
))) care necesit 125000 operaii, deoarece:
50*1*100+20*50*100+10*20*100=125000.
- Fie ordinea ((A
1
* (A
2
* A
3
)) *A
4
) care necesit 2200 operaii, deoarece:
20*50*1+10*20*1+10*1*100=2200.
Rezult deci c timpul de execuie n cel de-al doilea caz este de aproximativ 60 de ori
mai mic dect primul caz.
Majoritatea algoritmilor exponeniali constituie variante ale unei enumerri totale a
cilor de identificare a soluiilor unei probleme, pe cnd cei polinomiali reprezint
rezultatul unei cunoateri detaliate a problemei studiate (de exemplu, metoda
backtracking conduce la algoritmi exponeniali n cazul n care sunt enumerate toate
cile de identificare a soluiei unei probleme).
Din acest motiv se spune c o problema este uor rezolvabil sau u:oar( numai
dac s-a elaborat un algoritm polinomial pentru rezolvarea ei. O problem pentru care
nu exist un algoritm polinomial se numete dificil(.
)alitatea algoritmului depinde de polinomialitatea sa i de gradul ct mai mic al
polinomului.
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A Clasa poate fi organizat frontal sau pe grupe.
Ca metode de predare se vor folosi:
Explicaia n etapa de comunicare a cunotintelor;
Conversaia euristic n etapa de fixare a cunostinelor;
Acest coninut poate fi evaluat oral sau prin lucrare scris.
Te#a 116 Pro"ra#are dina#ic(
Fi:a !uport 1161 Mir de deci8ii6 Principiul de opti#6 Relaii de recuren(6
De!criere
Metoda progamrii dinamice se poate aplica problemelor n care soluia este
rezultatul unui ir finit de decizii optim dintr-un anumit punct de vedere. Se presupune
c avem un sistem care se poate afla n mai multe stri posibile i n urma fiecrei
decizii trece dintr-o stare n alta.
Se presupune, n plus, c problema verific una din urmtoarele condiii, numite
principii de opti#alitate (vom nota cu S
i
strile i D
i
deciziile):
(1) Dac irul D
1
,...,D
n
duce sistemul n mod optim din S
0
n S
n
, atunci: pentru orice
1<=k<=n, irul D
k
,...,D
n
duce sistemul n mod optim din S
k-1
n S
n
.
(2) Dac irul D
1
,.,D
n
duce sistemul n mod optim din S
0
n S
n
, atunci: pentru orice
1<=k<=n, irul D
1
,...,D
k
duce sistemul n mod optim din S
0
n S
k
.
(3) Dac irul D
1
,.,D
k
duce sistemul n mod optim din S
0
n S
n
, atunci: pentru orice
1<=k<=n, irul D
1
,...,D
k
duce sistemul n mod optim din S
0
n S
k
, iar irul D
(k+1)
,...,D
n
duce
sistemul n mod optim din S
k
n S
n
(evident, ultima cerin se pune doar pentru k<n).
n notaiile de mai sus S
0
,...,S
n
sunt nite stri oarecare din mulimea strilor posibile,
iar cu D
i
sistemul trece din S
(i-1)
n S
i
.
Oricare din principiile de optimalitate de mai sus exprim faptul c optimul total
implic optimul parial.
Evident, optimul parial nu implic neaprat optimul total; de exemplu e clar c
oricum am alege dou orae X i Y, dac cel mai scurt drum dintre ele trece printr-un
anumit ora Z, atunci poriunile din acest drum cuprinse ntre X i Z, respectiv Z i Y,
sunt cele mai scurte drumuri ntre oraele respective; asta nseamn c dac
compunem cel mai scurt drum ntre Bucureti i Cluj cu cel mai scurt drum ntre Cluj i
Suceava obinem cel mai scurt drum ntre Bucureti i Suceava (poate exista un drum
mai scurt ntre Bucureti i Suceava care nu trece prin Cluj).
Deci oricare din principiile de optimalitate afirm doar c optimul total poate fi gsit
printre optimele pariale, nu indic ns i care din ele e. Totui asta nseamn c putem
cuta optimul total doar printre optimele pariale, ceea ce reduce considerabil cutarea.
Modul de cutare a optimului total printre optimele pariale depinde de forma n care
este ndeplinit principiul de optimalitate i se face pe baza unor relaii de recuren(
deduse din structura problemei.
$ai e;act'
* dac este ndeplinit n forma (1), spunem c se aplic #etoda nainte; n acest
caz, pe baza unor relaii de recuren se calculeaz optimurile de la strile mai
deprtate de final n funcie de optimurile de la strile mai apropiate de final i se
determin deciziile ce leag aceste optime ntre ele (se merge deci de la sfrsit ctre
nceput); n final se afl optimul total, apoi se determin irul de decizii care l realizeaz
compunnd deciziile calculate anterior mergnd de la nceput ctre sfrit.
* dac este ndeplinit n forma (2), spunem c se aplic #etoda napoi; n acest caz
calculele recurente se fac de la nceput ctre sfrit, iar n final se afl optimul total i se
determin irul de decizii care l realizeaz compunnd deciziile de la sfrit ctre
nceput.
* dac este ndeplinit n forma (3), spunem c se aplic #etoda #i;t(; n acest caz
pe baza unor relaii de recuren se calculeaz optimurile ntre strile mai ndeprtate
ntre ele n funcie de cele ntre stri mai apropiate ntre ele i se determin deciziile
care interconecteaz aceste optimuri; n final se afl optimul total, apoi se determin
irul de decizii care l realizeaz mergnd de la capete spre interior (se determin prima
si ultima decizie, apoi o decizie intermediar, apoi cte o decizie intermediar ntre cele
dou perechi succesive, etc.).
Deci metoda programrii dinamice se poate aplica cu urmtoarele abordri:
4etoda nainte pentru rezolvare se pleac de la starea final;
4etoda napoi - pentru rezolvare se pleac de la starea iniial;
4etoda mi+t o combinaie a primelor dou.
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A Clasa poate fi organizat frontal sau pe grupe.
Ca metode de predare se vor folosi:
Explicaia n etapa de comunicare a cunotintelor;
Conversaia euristic n etapa de fixare a cunostinelor;
Acest coninut poate fi evaluat oral sau prin lucrare scris.
Te#a 116 Pro"ra#are dina#ic(
Fi:a !uport 1162 $etoda nainte
ProCle#('
Se consider un triunghi de numere naturale cu n linii; prima linie conine un numr a
doua linie dou,..., ultima linie n numere, liniile ncepnd din aceeai coloan stng, de
exemplu (n=4):
2
3 5
6 3 4
5 6 1 4
Dorim s aflm cea mai mare sum care se poate obine astfel: plecm de la
numrul din linia 1, apoi la fiecare pas urmtorul numr adunat se afl pe linia
urmtoare, dedesubtul su imediat n dreapta numrului anterior.
Exemple de sume corect construite:
2 + 3 + 6 + 5 = 16
2 + 5 + 4 + 1 = 12
2+3+6+6=17(care este i suma maxim)
Constatm c se pot forma 2 la puterea n-1 sume de acest fel i deci un algoritm
care s le determine pe toate pentru a o afla pe cea maxim ar fi de complexitate
exponenial(deci ineficient).
Observm ns c dac x
1
,x
2
,...,x
n
este un ir de numere ce respect enunul i
produce suma maxim, atunci pentru orice 1<= i <=n irul pornind cu numarul x
i
(fixat).
Astfel se verific principiul de opti#alitate in for#a 719 i putem aplica
programarea dinamic,#etoda nainte.
Pentru relaiile de recuren aferente notm:
-x[i][j] numrul aflat n triunghi pe linia i si coloana j (1<= i<=n ,1<=j<=i);
-s[i][j] cea mai mare sum care se poate obine cu un ir ca n enun ce ncepe cu
numrul din linia i si coloana j;
-u[i][j] coloana (j sau j+1) a numrului de pe linia i+1 care urmeaz numrului din
linia i si coloana j ntr-un ir ca n enun de sum maxim ce ncepe cu
acesta;convenim c u[n][j]=0,1<=j<=n.
Ne putem imagina c avem un sistem n care strile sunt pozitii (i,j) n triunghi iar u[i][j]
o decizie cu care ajungem din starea (i,j) n starea (i+1,u[i][j]).
Relaiile de recuren sunt urmtoarele :
s[n][j] = x[n][j] (1<=j<=n)
u[n][j] = 0 (1<=j<=n)
s[i][j] = x[i][j] + max {s[i+1][k] | j<=k<=j+1} (1<=j<=n,1<=j<=i)
u[i][j]= acel k pentru care se atinge maximul mai sus (1<=j<=n,1<=j<=i)
Matricile inferior triunghiulare ! si u se vor calcula pe baza relaiilor de recuren
anterioare de jos n sus :
Algoritm descris n pseudocod
pentru j1,n-1 execu
s[n][j]x[n][j]
u[n][j]0
sfpentru
pentru in-1,1 -1 execut
pentru j1,i-1 execut
dac s[i+1][j] < s[i+1][j+1] atunci
s[i][j]x[i][j]+s[i+1][j]
u[i][j]j
altfel
s[i][j]x[i][j]+s[i+1][j+1]
u[i][j]j+1
sfdac
sfpentru
sfpentru
n final s[1][1] d suma maxim posibil pentru iruri de n numere ca n enun iar un
ir de sum maxim se obine astfel :
j 1
pentru i 1,n
scrie x[i][j]
j u[i][j]
sfpentru
Complexitatea algoritmului de mai sus este O(n
2
),deci polinomial.
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A Clasa poate fi organizat frontal sau pe grupe.
Ca metode i procedee de predare se vor folosi:
Explicaia n etapa de comunicare a cunotintelor;
Conversaia euristic n etapa de fixare a cunostinelor;
Studiu de caz: Se poate propune elevilor urmtoarea problem: Se consider un vector
cu n elemente ntregi. S se afle cel mai lung subir al acestuia. Un subir cresctor al
lui A se poate descie astfel: A
i1
F A
i!
F. . .A
i,
i 1 F i1Gi!. . . Gi, F n.

Exemplu: pentru n=5 i
vectorul A= (4, 1, 7, 6, 7) subirul obinut va fi: 4, 7, 7.
Acest coninut poate fi eva luat oral sau prin lucrare scris.
Te#a 116 Pro"ra#are dina#ic(
Fi:a !uport 1163 $etoda napoi
ProCle#('
Se d un ir (vector) de numere naturale x
1
,.,x
n
; se cere s se determine un subir
al su x
i1
,.,x
ik
(1 <= i
1
<.<i
k
<= n) astfel nct x
i1
+.+x
ik
se divide cu n i este maxim cu
aceast proprietate; se cere i determinarea sumei respective.
E;e#plu'
Dac irul dat este 2,3,4,9,3 (n=5),
Atunci suma maxim este 15 iar un subir care o realizeaz este 2, 4, 9.
Observm c ntodeauna exist subiruri pentru care suma elementelor se divide cu n.
ntr-adevar,dac calculm sumele x
1
,x
1
+x
2
,...,x
1
+...+x
n
,obtinem n numere naturale;dac
vreunul se divide cu n,atunci subirul corespunztor satisface cerina; dac niciunul nu
se divide cu n,atunci resturile lor la n sunt n numere de la 1 la n+1,deci exista printre ele
dou care dau acelai rest la n; dac acestea sunt x
1
+...+x
i
i x
1
+.+x
j
,i<j,atunci
x
(i+1)
,x
(i+2)
,.,x
j
este un subir a crui sum a elementelor se divide cu n.
Totui numrul total al subirurilor nevide ale lui x
1
,...,x
n
este (2
n
)-1 (ele se asimileaz
cu submulimile nevide ale mulimii indicilor 1,...,n) iar un algoritm care s le genereze
pe toate pentru a-l alege pe cel optim ar fi de complexitate exponenial (deci ineficient).
Observm ns c dac x
i1
,...,x
ik
(1 <=i1<.<ik <=n)

este un subir de sum maxim
divizibil cu n (care d prin mpartire la n restul 0) atunci avem urmtoarele posibiliti:
- i1 = ik = n (adic subirul se reduce la ultimul numr,xn);atunci xn % n = 0;
- i1<ik = n;atunci dac notam p= (x
i1
+.+x
i(k+1)
) % n, va rezulta c x
i1
,...,x
i(k+1)
este un
subir al irului x
1
,...,x
(n+1)
(chiar al irului x
1
,...,x
i(k+1)
) de sum maxim care d prin
mparire la n restul p;
- ik<n;atunci x
i1
,.,x
ik
este un subir al irului x
1
,...,x
(n-1)
de sum maxim care d prin
mparire la n restul 0.
Deci se verific principiul de optimalitate n forma (2),dar condiiile nu sunt ndeplinite
ntocmai,deoarece a doua variant de mai sus arat c subirul lui x
1
,...,x
n
de sum
maxim care prin mprire la n d restul 0 depinde de un subir al irului x
1
,...,x
n+1
de
suma maxim care prin mprire la n d un rest p, 0<= p <= n-1,nu neaprat p =0.
Totui, dac considerm o problem mai general,aceea de a determina pentru orice
0<=p<=n-1 cte un subir al lui x
1
,...,x
n
de sum maxim care prin mprire la n d
restul p,atunci ansamblul optimelor pentru subiruri ale lui x
1
,...,x
n
(p variind de la 0 la
n-1) depinde de ansamblul optimelor pentru subiruri ale lui x
1
,...,x
(n-1)
(iari p variind
de la 0 la n-1), ceea ce justific aplicarea metodei napoi.n continuare vom rezolva
problema general.Menionm c pentru anumii p de la 0 la n-1 s-ar putea s nu existe
subiruri ale lui x
1
,...,x
n
a cror sum modulo n s dea p (de exemplu n=2, x
1
=4, x
2
=6,
p=1).
Pentru a stabili relaiile de recuren aferente notm:
-s[i][k] - suma maxima care mparit la n d restul k i care se poate realiza cu un
subir al irului x
1
,..., x
i
(1<=i<=n, 0<=k<=n-1);
dac nu exist nuci un subir cu aceast proprietate convenim s punem s[i][k]=0;
-m[i][k] - mulimea indicilor unui subir care realizeaz s[i][k].
Relaiile de recuren sunt urmatoarele:
s[1][k]=x
1
, m[1][k]={1} (k=x
1
% n)
s[1][k]=0, m[1][k]={} (k=x
1
% n)
s[i][k]= maximul ntre urmtoarele valori, fiecare lundu-se n consideraie doar
pentru acei k ce verific condiiile din paranteze:
x
i
(dac x
i
% n=k)
s[i-1][k] (pentru orice k)
s[i-1][p]+x
i
(dac 0<=p<=n-1 i (s[i-1][p]+x
i
) % n=k) (2<= i<=n, 0<=k<=n-1)
m[i][k]={i} sau m[i-1][k] sau m[i-1][p]U{i}, n funcie de varianta care a dat maximul de
mai sus (dac sunt mai multe, se face o alegere) (2<=i<=n, 0<=k<=n-1)
Observm c valoarea s[j][k]=0 convenit n cazul cnd nu exist subiruri ale lui
x
1
,..., x
j
a cror sum s dea prin mprire la n restul k nu altereaz calculele de mai
sus; ntr-adevr, dac s[i-1][k]=0, el nu afecteaz maximul de mai sus ntruct acesta
oricum trebuie s fie >=0 (e maximul unor sume de numere naturale); de asemenea,
dac s[i-1][p]=0, a treia variant pentru maximul de mai sus se reduce la prima; n fine,
dac nu exist subiruri ale lui x
1
, ..., x
i
a cror sum s dea prin mprire la n restul k,
din calculul de mai sus va rezulta s[i][k]=0 (la calcularea maximului va participa doar
varianta a doua).
n final suma maxim divizibil cu n cutat este s[n][0] iar un subir al lui x
1
, ..., x
n
care o realizeaz este x
i1
, ..., x
ik
, unde m[n][0]={i
1
, ., i
k
} (i
1
<.<i
k
).
Putem organiza eficient calculele folosind doi vectori de numere s, s
1
i doi vectori de
mulimi (codificate de exemplu ca vectori caracteristici) m si m
1
astfel:
Algoritm descris n pseudocod
pentru k0,n-1 execut
s[k]0 m[k]{}
sfpentru
s[x[1]%n]x[1] m[x[1]%n]{1};
pentru i2,n-1 execut
s
1
s m
1
m 55s
,
, m
,
rein strile vechi6 s, m vor fi cele noi
dac s[x[i]%n]<x[i] atunci
s[x[i]%n]x[i]; m[x[i]%n]{i}
sfdac
pentru p0,n+1 execut
dac(s[(s
1
[p]+x[i])%n]<s
1
[p]+x[i]) atunci
s[(s
1
[p]+x[i])%n]s
1
[p]+x[i]; m[(s
1
[p]+x[i])%n]m
1
[p]U{i}
sfdac
sfpentru
sfpentru
Complexitatea algoritmului de mai sus este O(n
2
) sau O(n
3
) dac inem cont c o
atribuire ntre submulimi ale lui {1, ...,n} este O(n);
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A Clasa poate fi organizat frontal sau pe grupe.
Ca metode i procedee de predare se vor folosi:Explicaia n etapa de comunicare a
cunotintelor; Conversaia euristic n etapa de fixare a cunostinelor; Problematizarea:
Se poate rezolva problema prin metoda nainte? Studiu de caz: Se d un ir A cresctor
i o valoare x. S se determine un subir de lungime maxim, n care diferena dintre
oricare doua elemente alturate este < cu x (A
ik+1
A
ik
) < x, 1 F ik <n. Exemplu: pentru
n=6, x=4 i irul 5 7 9 10 14 15 se va afia 5 9 14, 5 10 15 sau 5 10 14.
Acest coninut poate fi evaluat oral sau prin lucrare scris.
Te#a 116 Pro"ra#are dina#ic(
Fi:a !uport 116? $etoda #i;t(
ProCle#('
Se consider problema nmulirii optimale a unui ir de matrice. Fie matricele .
,
, .
-
, """,
.
n
, unde .
i
are dimensiunile d
i&,
, d
i
(, pentru i = 1, 2, ..., n". S se calculeze produsul 7 0.
,
+ .
-
+ """ + .
n
prin nmuliri repetate a cte dou matrice i efectund un numr minim de
operaii.
Deoarece nmulirea matricelor este asociativ, matricea produs .
,
.
-
.
/
poate fi
calculat prin ((.
,
.
-
).
/
), sau (.
,
(.
-
.
/
)). Dac matricele au dimensiunile 5x3, 3x2 i
respectiv 2x7, atunci calculnd n ordinea ((.
,
.
-
).
/
) efectum 100 nmuliri, iar n ordinea
(.
,
(.
-
.
/
)) efectum 147 nmuliri. (Numrul operaiilor de nmulire pentru a calcula
produsul $ + C este p898r, dac dimensiunile matricelor $ i C sunt (p, 9) respectiv (9, r).
Considerm aici aplicarea algoritmului uzual de nmulire a dou matrice.)
Problema pus se reduce la gsirea acelei ordini de asociere pentru care numrul
nmulirilor s fie minim.
Vom determina varianta optim de asociere a irului de matrice fr a calcula toate
posibilitile de asociere (deoarece numrul lor este mare). Pentru aceasta notm cu C
i,:
numrul minim de nmuliri (elementare) necesare calculrii produsului .
i
.
i',
""" .
:
, pentru 1
i : n.
Se observ c:
a) C
i,i
= 0;
b) C
i,i',
= d
i&,
" d
i
" d
i',
;
c) C
,,n
este valoarea minim cutat;
d) Este verificat principiul optimalitii:
C
i,:
= min {C
i,2
+C
2',,:
+ d
i&,
"d
2
"d
:
| i 2 < : }
pentru c asocierile sunt de forma (.
i
.
i',
""".
2
)(.
2',
.
2'-
""".
:
). (Relaia este adevrat
deoarece parantezarea (.
i
.
i',
""".
2
) trebuie s fie optim pentru ca (.
i
.
i',
""".
:
) s fie la
rndu-i optim). Deci pentru rezolvare se aplic principiul (3) #etoda #i;t(6
Costul optimal C
,,n
poate fi calculat apelnd funcia recursiv:
Funcia C(i, j) este:
Dac i = j atunci C 0
altfel
Dac i = j-1 atunci C d
i-1
. d
i
. d
i+1
altfel
min C(i, i) + C(i+1, j) + d
i-1
. d
i
. d
j
Pentru k i+1, j-1 execut
val C(i, k) + C(k+1, j) + d
i-1
. d
k
. d
j
Dac val < min atunci
min val
sfdac
sfpentru
C min
sfdac
sfdac
sf-C
funcie care interpreteaz relaia C
i,:
= min {C
i,2
+C
2',,:
+ d
i&,
"d
2
"d
:
| i 2 < : }.
S observm n primul rnd c n urma acestui calcul nu obinem dect costul minim
pentru nmulire. Dac notm cu S
i:
valoarea 2 pentru care se obine minimul (C
i:
=
C
i,2
+C
2',,:
+ d
i&,
"d
2
"d
:
) n calculul de mai sus, atunci vom ti c pentru produsul .
i
.
i',
""".
:
este
optim s efectum (.
i
.
i',
""".
2
)(.
2',
.
2'-
""".
:
).
n al doilea rnd s remarcm c funcia recursiv efectueaz calcule redundante. De
exemplu, pentru calcularea lui C(1, 4) se efectueaz calcule dup cum indic figura
urmtoare:
/'1D$)
/'1D1) /'!D$) /'1D!) /'"D$) /'1D") /'$D$)
/'!D!) /'"D$) /'1D1) /'!D") /'!D") /'$D$) /'1D!) /'"D")
Pentru evitarea calculrii de mai multe ori a acestor valori ale funciei C, putem proceda
dup cum urmeaz:
Subalgoritmul nmulireOptim(n, d, C, S) este:
;<imensiunile matricelor sunt= d
i&,
+ d
i
, i 0 ,, """, n>
;7e)ultatele sunt matricele C i S descrise mai sus">
Pentru i 1, n execut
C
ij
0
sfpentru
Pentru l 2, n execut ;diagonala superioar l din matrice>
Pentru i 1, n-l+1 execut ;linia de pe acea diagonala>
Fie j i + l -1 ;*lementul C
i:
, i 0,,""",n&l',>
C
ij
nfinit ;C
i,:
0 min ;C
i,2
'C
2',,:
' d
i&,
"d
2
"d
:
| i 2 ? : >
Pentru k i, j-1 execut
cost C
ik
+ C
k+1
,
j
+ d
i-1
.d
k
.d
j
Dac cost < C
ij
atunci
C
ij
cost ;@aloarea pentru costul minim>
S
ij
k ;Indic po)iia parante)rii>
sfdac
sfpentru
sfpentru
sfpentru
Matricele C i S se calculeaz n ordinea diagonalelor, dup cum indic figura
urmtoare:
1 ! " $
1
!
"
$
lH!
lH"
lH$
Ciclul cu contorul l calculeaz diagonalele superioare ale matricelor C i S. Pentru un l
dat, ciclul cu contorul i fixeaz liniile i care au elemente pe acea diagonal. ndicele :
fixeaz coloana corespunztoare liniei fixate, iar ciclul cu contorul 2 corespunde formulei
C
i,:
= min {C
i,2
+C
2',,:
+ d
i&,
"d
2
"d
:
| i 2 < : }.
Odat calculat matricea S care indic parantezarea, construirea unei soluii optime
7 .
,
.
-
""".
n
se efectueaz apelnd ProdusSir4atrice(7, ., S, 1, n), unde:
Subalgoritmul ProdusSirMatrice(A, S, i, j) este: ;Calculea) optim 7 A .
i
.
i',
""".
:
>
Dac j > i atunci
ProdusSirMatrice(X, A, S, i, S
ij
) ;B A .
i
.
i',
""".
2
, cu 2 0 S
i:
>
ProdusSirMatrice(Y, A, S, S
ij
+1, j) ;C A .
2',
.
2'-
""".
:
>
Fie R Produs(X, Y) ; 7 A B C>
altfel
Fie R A
i
sfdac
sfSubalgoritm
Subalgoritmul ProdusSir4atrice folosete matricea S calculat. Deoarece valoarea lui
20S
,n
indic unde este parantezarea optim pentru .
,
.
-
""".
n
, aplicm metoda divizrii
calculnd produsele .
,
.
-
""".
2
i .
2',
.
2'-
""".
n
i combinm rezultatele (nmulind matricele
rezultate).
Complexitatea algoritmului este o(n
3
) deoarece sunt trei cicluri for imbricate.
)onclu8ii
Am vzut deci c pentru a rezolva o problem prin programare dinamic trebuie pus
n eviden principiul de optimalitate ((1),(2) sau (3)) pe care aceasta l verific i
releiile de recuren care cuantific modul de obinere a optimurilor ,mai generale din
optimuri "mai particulare (i prin ce decizii).
n general maniera de a demonstra verificarea unui principiu de optimalitate si
determinarea relaiilor de recuren aferente se face foarte diferit de la o problema la
alta (nu se pot da nite prescripii generale) i de multe ori e foarte dificil.
Rezolvarea problemelor prin programare dinamic (folosind acele calcule recurente)
se face ns n timp polinomial, deoarece fiecare optim ,mai general se calculeaz din
optimele ,mai particulare fcnd o cutare n timp polinomial, iar aceste optime odat
calculate nu se mai recalculeaz ulterior ci se trece la calcularea optimelor ,i mai
generale.
De aceea metodele de programare dinamic se doresc a fi o alternativ la metoda
backtracking: este clar c problemele abordabile prin backtracking se ncadreaz n
tiparul problemelor abordabile prin programare dinamic strile sunt poziiile 0<= i <=
n pn la care s-a completat o soluie, starea iniial este vectorul vid (i=0), starea final
este vectorul complet (i=n), iar o decizie const n alegerea unei valori v pentru poziia i
(ea duce sistemul din starea de completare pan la poziia i-1 n starea de completare
pan la pozitia i). Dac pentru o astfel de problem se reuete demonstrarea unui
principiu de optimalitate(i determinarea relaiilor de recuren aferente), problema se
va rezolva prin metoda de programare dinamic corespunzatoare(nainte, napoi sau
mixt) folosind relaiile de recuren evideniate, n timp polinomial. Dac nu se reueste
acest lucru, problema se va rezolva prin backtraking (care este o metod universal),
oinnd un algoritm ce poate ajunge (n cazul cel mai nefavorabil) exponenial.
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A Clasa poate fi organizat frontal sau pe grupe.
Ca metode i procedee de predare se vor folosi:
Explicaia n etapa de comunicare a cunotintelor;
Conversaia euristic n etapa de fixare a cunostinelor;
Studiu de caz: Se poate propune elevilor urmtoarea problem: Se consider o matrice
n care se afl numai litere mici distincte ale alfabetului englezesc i un cuvnt format
din litere distincte ale alfabetului englezesc. S se gseasc numrul total de apariii ale
acestui cuvnt n cadrul matricei, tiind c acesta poate s apar sub orice form ( de la
stnga la dreapta, de jos n sus, n form de spiral etc.
Acest coninut poate fi evaluat oral sau prin lucrare scris.
Te#a 116 Pro"ra#are dina#ic(
Fi:a !uport 116= $etoda !i#ple;
ProCle#('
S se determine soluiile primal admisibile, de baz ale problemei de programare
liniara (PPL)
Fie problema PPL standard:

min
X
D AX
X C
T
Considerm sistemul compatibil AX=D,
( )
mxn
ij
a A
,n>m ,rang A=m, A=(V
1
, V
2
,. V
n
),
m
i
R V
; ( )
T
n
x x x X D...D D
! 1
este soluia
sistemului ,dac:
D V x V x V x
n n
+ + + ...
! ! 1 1
Definiie: Vectorul X este o soluie de baz a sistemului,dac vectorii
i
V
corespunztori coordonatelor nenule ale sale sunt liniari independeni.
Soluia de baz se numete nedegenerat dac are chiar m coordonate nenule, n caz
contrar soluia se numete degenerat.
Dac B baz a matricii A ,deci a spaiului R
m
,notm:
S- matricea format din vectorii coloan ale lui A care nu fac parte din baz.
X
B
variabilele principale (bazice) care nsoesc vectorii din baza B
X
S
- variabilele secundare (nebazice)
Sistemul se poate scrie: BX
B
+SX
S
=D i nmulind la stnga cu B
-1
se obine soluia
sistemului : X
B
= B
-1
D-(B
-1
S)X
S
. Pentru X
S
=0

X
B
= B
-1
D=D
B
( coordonate vectorului D
n baza B)
B
i
x =

'

B i daca
B i daca d
B
i
. .
.
Soluia particular obinuta din D
B
completat cu 0 pentru variabilele secundare este o
soluie de baz a sistemului i se numete soluie de baz corespunzatoare bazei B.
Aceasta este nedegenerat pentru componentele D
B
nenule i degenerat n caz
contrar.
Deci fiecrei baze din A i corespunde o soluie de baz. Reciproc nu este adevrat. O
soluie de baz poate corespunde mai multor baze. Numrul maxim de soluii de baz
ale unui sistem este combinri de n luate cte ( )
m
n
C m .
Exprimnd vectorii coloan i
V
ai matricei A n funcie de vectorii bazei B, se obine o
nou matrice A
B
,numit matricea redus a matricii A corespunzatoare bazei B.
m
R B
.
Astfel , coloanele lui A
B
sunt coordonatele vectorilor
i
V
n baza B, dai de relaia : B
-1
i
V
= A B A V
B
B
i
1

Forma redus conine o matrice unitate U
m
format din coloanele corespunztoare
vectorilor care formeaz baza B. Pentru determinarea formei reduse se folosete
metoda eliminrii complete prin eliminarea succesiv a cte unui singur vector din baz.
Pentru calcule se aranjeaz totul ntr-un singur tabel:
B D
V
1
V
2
. V
k
.....V
n
E
1
E
2
. E
k
....E
n
E
1
E
2
.
.
.
E
h
.
.
.
E
m
d
1
d
2
.
.
.
d
h
.
.
.
d
m
a
11
a
12
. a
1k
.....a
1n
a
21
a
22
. a
2k
.....a
2n
.
.
.
a
h1
a
h2
. a
hk
.....a
hn
.
.
.
a
m1
a
m2
. a
mk
.....a
mn
1 0 0 0
0 1.......0...............0
.
.
.
0 0 1 0
.
.
.
0 0 0 1
Apar astfel calculate coordonatele lui D n bazele succesive obinute prin nlocuirea n
baz a cte unui vector din A. n final se obine soluia de baz a sistemului restriciilor
PPL, X=B
-1
D=D
B
.
Dac vectorul V
k
intr n baz i vectorul E
h
iese, se obine o nou baz B
1
i, cu
transformrile de coordonate la schimbarea bazei datorate aplicrii regulei pivotului
a
hk
0 se obin relaiile:

'

h i
a
a d a d
a
d
d
B
hk
B
ik
B
h
B
hk
B
i
B
hk
B
h
B
i
D
% i D
1
Se pune problema determinrii pentru sistemul compatibil AX=D,
( )
mxn
ij
a A
,n>m rang
A=m, a acelor soluii de baz pentru care
B
X .
Cum
B
i
x =

'

B i daca
B i daca d
B
i
. .
.
atunci
B
X
B
D
Deci, se poate formula criteriul de ieire din baz:
Dac n baz intr vectorul V
k
, atunci din baz se scoate vectorul care ndeplinete
condiia:
( i D in1

'

>
B
ik
B
i
a
B
hk
B
h
a
d
a
d
B
ik
Avem descompunerea: A=(B,S), unde
( )
m
i i i
V V V B D D D
! 1

,
( )
m n
j j j
V V V S

D D D
! 1

i
corespunztor descompunerea vectorului

,
_

S
B
X
X
X
n variabile bazice i nebazice,

,
_

S
B
C
C
C
; Sistemul de restricii devine: D AX
( ) D
X
X
S B
S
B

,
_

D SX BX
S B
+ .
Dac notm
B
j
V S B
1
atunci soluia sistemului devine:


S j
j
B
j
B B
X V D X
sau, scris
pe componente,


S j
j
B
ij
B
i
B
i
x a d x ( i D
. nlocuind n funcia obiectiv se obine


,
_

+ +
S j
j
B
ij
B i
i j
B i
B
i i
S j
j j
B i
i i
t
x a c c d c x c x c X C z
.
Notm:

B i
B
i i
B
d c z
valoarea funciei obiectiv corespunztoare programului de baz
B
x
B
ij
B i
i
B
j
a c z

i avem:
( )
j
S j
B
j j
B
x z c z z

+
Se pot enuna deci urmtoarele criterii
folosite de algoritmul de optimizare
Criteriul de optim pentru PPL:
Programul de baz
B
x este optim pentru problema de minim dac
S B D
B
j j
z c
Observaie: pentru o problem de maxim, inegalitatea se schimb.
Criteriul de intrare n baz:
Dac
S D < k z c
B
k k
, atunci programul
B
x nu este optim i programul se
mbuntete dac vectorul V
k
intr n baz.
Observaii:
Dac indicele k pentru care se verific relaia a criteriului de intrare n baz, nu este
unic determinat, atunci pentru o valoare a funciei obiectiv ct mai apropiat de valoarea
minim, se adopt regula:
,Dac D <
B
k k
z c intr n baz vectorul V
k
pentru care
{ } in1
B
j j
B
k k
z c z c

La o problem de maxim, avem:


,Dac D >
B
k k
z c intr n baz vectorul V
k
pentru care
{ } sup
B
j j
B
k k
z c z c

Criteriul de optim infinit


Dac
<
B
j j
z c
i
{ } in1
B
j j
B
k k
z c z c
,
B i a
B
ik

, atunci spunem c PPL
admite un optim infinit i algoritmul de optimizare se oprete.
Enunarea al"orit#ului S&$P.EN
Algoritmul SMPLEX ofer soluia optim a PPL. Algoritmul descris pentru problema de
minim:
Se determin o baz admisibil B i se calculeaz :
- programul de baz corespunztor
B
x
B
D D B
1
n j V B S B V
j
B
j
D 1 D
1 1


- valoarea funciei obiectiv


B i
B
i i
T
B
B
T
B
B
d c D B C x C z
1

B
ij
B i
i
B
j
a c z

- diferenele
B
j j
z c
=
n j V C c
B
j
T
B j
D 1 D
;
B j z c
B
j j
D
Datele se introduc ntr-un tabel SMPLEX:
1
c
!
c
..........
n
c
B C
B
D
B
V
1
V
2
.......... V
n
e
V
1

e
V
!
....
e
m
V
e
V
1
1
i
c
1
i
x 1 D
1
i
a
! D
1
i
a
.................
n i
a
D
1
e
V
!
!
i
c
!
i
x 1 D
!
i
a
! D
!
i
a
.................
n i
a
D
!
.
.
.
.
.
.
.
.
.
.
.
.
. .
. .
. .
e
m
V
m
i
c
m
i
x 1 D
m
i
a
! D
m
i
a
...............
n i
m
a
D
B
z
B
z
1
B
z
!
.............
B
n
z
B
j j
z c
B
z c
1 1

B
z c
! !
...
B
n n
z c
(testul de optim) Dac
n j z c
B
j j
D 1 D
, atunci programul
B
x
este optim i STOP.
Dac nu, adic S D < k z c
B
k k
atunci programul
B
x
nu este optim i se aplic
criteriul de intrare n baz: intr n baz vectorul V
k
pentru care
{ } in1
B
j j
B
k k
z c z c
(testul de optim infinit) Dac n i a
B
ik
D 1 atunci problema admite un optim infinit i
STOP.
Dac >
B
ik
a atunci se aplic criteriul de ieire din baz, adic iese din baz vectorul
V
h
pentru care
( i D in1

'

>
B
ik
B
i
a
B
hk
B
h
a
d
a
d
B
ik
.
Se obine o nou baz B
1
i se reia algoritmul de la punctul b), iar ieirea din el are loc
fie la punctul b) (testul de optimalitate), fie la punctul c) (testul de optim infinit).
Deci: algoritmul SMPLEX va testa condiia de optim pentru programul de baz gsit i,
n caz c aceasta nu este satisfcut, va determina un alt program de baz care va
apropia funcia obiectiv de valoarea optim, iar n final va determina valoarea optim a
sa.
Observaie:
a)Pentru o problem de maxim se schimb semnul inegalitii n criteriul de optim i inf
devine sup la criteriul de intrare n baz.
b)Dac criteriile decid c
B
hk
a
este pivot, atunci tabelul SMPLEX se transform dup
regulile:
i) linia pivotului se mparte cu pivotul.
ii) coloana pivotului se completeaz cu 0 pn se obine vectorul unitar al bazei
canonice.
iii) orice alt element din tabel se transform dup regula dreptunghiului (pivotului)
introdus la metoda eliminrii complete.
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A Clasa poate fi organizat frontal sau pe grupe.
Ca metode i procedee de predare se vor folosi:Explicaia n etapa de comunicare a
cunotintelor; Conversaia euristic n etapa de fixare a cunostinelor;Studiu de caz:
Se poate propune elevilor s rezolve cu algoritmul simplex urmtoarea problem
D
0 5 $
"* ! "
* " min
! 1
! 1
! 1
! 1

'

+
+
+
x x
x x
x x
x x f
Acest coninut poate fi evaluat oral sau prin lucrare scris.
Te#a 126 Tenici de pro"ra#are care conduc la !oluii opti#e
Fi:a !uport 12 5reedO6 $etode euri!tice6
De!ciere'
$etode euri!tice
Algoritmii i metodele prezentate anterior sunt neeficieni pentru probleme grele,
combinatoriale si de dimensiuni mari. Aceasta deoarece timpul de rezolvare i/sau
memoria intern necesar este exponenial n raport cu dimensiunile problemei.
n aceste situaii, pentru astfel de probleme, se accept utilizarea unor algoritmi
despre care nu se tie sau nu s-a demonstrat deocamdat c sunt optimali, dar care
furnzeaz rezultate ,acceptabile ntr-un timp mai scurt i cu un consum mai redus de
memorie. Datorit importanei mari a criteriului timp n raport cu spaiul de memorie
necesar, se va avea n vedere criteriul timp.
Un algoritm se numete euristic dac are urmtoarele proprieti:
- furnizeaz, de obicei, soluii bune dar nu neaprat optime
- poate fi implementat mai uor i permite obinerea rezultatelor n timp rezonabil,
n orice caz mai scurt dect cel cerut de orice algoritm exact cunoscut.
O idee frecvent utilizat n elaborarea algoritmilor euristici, const n descompunerea
procesului de cutare a soluiei n mai multe subprocese (etape) succesive i cutarea
soluiei optime a fiecreia n parte (presupunnd c fiecare subproces este suboptimal).
Aceast strategie nu conduce ns ntotdeauna la o soluie optimal, deoarece
optimizarea local nu mpiedic, n general, optimizarea total (sau optimul parial nu
coincide cu optimul general). Deoarece un algoritm elaborat pe baza metodei Greedy
care furnizeaz o soluie care nu este optim (sau nu i se poate demonstra
optimalitatea) este un algoritm euristic.
Pentru elaborarea unui algoritm euristic se pun n eviden toate condiiile pe care le
satisface o soluie exact i se mpart condiiile n dou sau mai multe clase conform
unor criterii. Aceste criterii pot fi facilitarea satisfacerii condiiilor i necesitatea
satisfacerii lor. Din aceste puncte de verede condiiile pot fi:
- condiii uor de ndeplinit
- condiii dificil de ndeplinit (se poate accepta ndeplinirii primelor)
- condiii necesare (nendeplinirea lor mpiedic obinerea unei soluii
posibile)
- condiii pentru care se poate accepta un compromis, n sensul c ele pot fi
nlocuite cu alte condiii care permit apropierea de o soluie optimal (eventual optim)
n aceast situaie satisfacerea condiiilor necesare e obligatorie iar n calitatea
soluiei depinde n mare msur de compromisul adoptat pentru condiiile din a doua
categorie.
Este de menionat c:
- algoritmii euristici sunt utili pentru utilizri sporadice, unice, deoarece efortul
determinrii soluiei optime este prea mare fa de ctigul obinut
- algoritmii euristici furnizeaz soluii aproximative dar i algoritmii analizei
numerice au soluii aproximative, fr a lua n considerare propagarea erorilor de
rotunjire, greu controlabile, care pot transforma un proces convergent ntr-unul
divergent.
5reedO euri!tic
Un algoritm care conduce la o soluie acceptabil, dar nu optim, de tip Greedy , se
numete Greedy euristic.Exemplele care urmeaz v vor lmuri.
Plata unei !u#e cu un nu#(r #ini# de Cancnote

Enun.Se dau n tipuri de bancnote de valori C
1>
C
2
>666>C
#
(numere naturale strict mai mari
ca 0). Din fiecare tip se dispune un numr nelimitat de bancnote. De asemenea,se tie
c vom avea ntotdeauna bancnota cu valoarea 1. Fiind dat o sum !,numr
natural,se cere ca aceasta s fie pltit prin ultilizarea unui numr minim de bancnote.
Avnd n vedere cerina problemei de a folosi bancnote ct mai puine,vom ncerca
s alegem pentru nceput bancnota cea mai mare.n acest fel se acoper din sum o
cantitate mai mare, cu bancnote puine. Pentru suma rmas de pltit vom proceda la
fel,la fiecare pas alegnd bancnota cea mai mare posibil, n numr maxim. Dac S
este suma rmas de descompus la un moment dat i cea mai mare bancnot
disponibil(mai mic sau egal cu S) este b
i
, atunci se vor alege [S / b
i
] bancnote de
acest fel.
n aceast problem este mai util forma modificat a algoritmului Greedy. Vom
ordona descresctor irul bancotelor, dup care vom face selecia lor.Vom memora
soluia irului x
i
,i=1,2,...,n, unde x
i
reprezint numrul bancnotelor avnd valoarea
b
i
,i=1,2,...,n astfel nct s avem : S=b
1
*x
1
+b
2
*x
2
+.+b
n
*x
n
SuCal"orit#' Selecie-Greedy():
Ord_desc(n,b)
i0
cFt ti#p (S>0) si (i<n) e;ecut(
ii+1
x
i
[S / b
i
]
nrbnrb+x
i

SS-x
i
*nrb
SfFr:it cFt ti#p
Dac( S=0 atunci
Scrie x
1
,...,x
i
*ltfel
Scrie PNu s-a gsit soluie.`
SfFr:it dac(
SfFr:it !uCal"orit#
Acest algoritm nu furnizeaz ntotdeauna o soluie. De exemplu,dac avem la
dispoziie bancnote de 10, 5 i 3 lei i S=39, coninutul irului x va fi (3,1,1) dar acesta
constituie soluie a problemei, deoarce mai rmne de descompus suma 1 pentru care
nu sunt bancnote.
Analiznd exemplul, observm c problema, totui are soluie. Aceasta corespunde
urmtoarei descompuneri: 310+5+33=39.
Rezolvarea exact a problemei se poate face ncercnd toate combinrile posibile de
bancnote, folosind metoda backtracking.
ProCle#a di!cret( a ruc!acului
Enun' O persoan are un rucsac cu ajutorul cruia poate transporta o greutate
maxim G. Persoana are la dispoziie n obiecte i cunoate pentru fiecare obiect
greutatea i ctigul care se obine n urma transportului su la destinaie.
Se cere s se precizeze ce obiecte trebuie s transporte persoana n aa fel nct
ctigul s fie maxim.
E;e#ple'
1. Fie n=5 si G=10.
Vom calcula, pentru fiecare obiect, valoarea pe unitatea de greutate.
Vom selecta obiecte n ordine descresctoare a raportului valoare-greutate. Se
obine soluia 1, 2, 4 care este soluie optim a problemei.
2. Fie n=3, G=8
1 2 3
Greutate 5 4 4
Valoare 6 4 3
n acest caz soluia optim este format din obiectele 2 i 3, dar algoritmul
construiete doar soluia format din primul obiect.
Algoritmul nu asigur obinerea soluiei optime, dar este foarte rapid.
Deoarece obiectele nu pot fi luate dect ntregi (nu se pot tia n buci), problema se
mai numete i pro%lema 0-1 a rucsacului pro%lema discret(.
Aceast problem o vom rezolva folosind o metod euristic. Soluia gsit nu va fi
ntotdeauna optim, dar va fi apropiat de aceasta. Se va calcula rapid i va fi uor de
implementat. O soluie exact se poate afla pentru seturi de date relativ mici dac se
folosete metoda %ac2trac2ing.
Vom sorta obiectele descresctor dup valoarea ctigului unitar i vom alege
obiecte pn se ntlnete una din urmtoarele situaii:
- obiectele alese au o greutate total egal cu capacitatea rucsacului (soluie
optim);
- mai exist loc n rucsac, dar nu se mai pot selecta obiecte care s acopere
greutatea rmas (n unele situaii soluia poate fi optim , iar n altele, nu).
*l"orit# Selecie-Greedy(gr, val, n, G):
{ordonm obiectele descresctor dup valoarea ctigului}
Ordonare(n, gr, val)
i 0
cFt ti#p (G>0) :i (i<n) e;ecut(:
i i+1
dac( gr
i
>G atunci
G G gr
i

ctig ctig + val
i
k k + 1
x
k
i
!fFr:it dac(
!fFr:it cFt ti#p
!crie x
1
, ..., x
k
sfrit subalgoritm
1 2 3 4 5
Greutate 2 4 5 2 6
Valoare 4 20 1 3 3
Valoare/greutate 2 5 0.2 1.5 1.5
ProCle#a color(rii (rilor
Enun' Se d o hart nu n ri precizndu-se relaiile de vecintate ntre ele (printr-o
matrice de adiacen). Se cere s se coloreze harta astfel nct dou ri vecine s nu
fie colorate cu aceiai culoare. Se tie c sunt suficiente patru culori pentru a colora
orice hart, dar nu se cunoate nici un algoritm n timp polinomial care s produc o
soluie folosind doar patru culori. Algoritmul greedy prezentat n continuare rezolv
problema dar nu cu un numr minim de culori.
Funcia Hari(n, A) este:
S[1] 1
pentru i 2,n execut
culoare1
gsittrue
ct timp gsit execut
gsitfalse
pentru j1,i-1 execut
dac A[i][j] = 1 and S[j] = culoare atunci
gsittrue
dac gsit= fals atunci S[i]culoare
altfel culoare culoare + 1
sfct timp
sfpentru
Hari S
Sf- Hari
Algoritmul pleac de la o ar i o coloreaz cu culoarea 1. Pentru a colora ara i
(presupunnd c sunt colorate trile pn la i-1), se ncearc colorarea cu cea mai mic
culoare dac nu exist un vecin deja colorat cu culoarea respectiv. Dac nu este
ndeplinit aceast condiie se trece la culoarea urmtore i se verific din nou toi
vecinii.
Su"e!tii #etodolo"ice
U+DE PRED3$A Coninutul poate fi predat n laboratorul de informatic .
)U$ PRED3$A Clasa poate fi organizat frontal sau pe grupe.
Se vor reactualiza cunostinele despre tehnica de programare Greedy.
Ca metode i procedee de predare se vor folosi: Explicaia n etapa de comunicare a
cunotintelor; Conversaia euristic n etapa de fixare a cunostinelor;
Problematizarea: Cum se modific problema rucsacului n ca)ul continuucnd
o%iectele pot fi tiate n %uci(D
Studiu de caz: Se poate propune elevilor s rezolve problema plata !u#ei cu nu#(r
#ini# de Cancnote prin metoda backtracking i cu ajutorul programelor de calculare a
timpului de execuie din fia suport 10.1 se va calcula timpul pentru aceleai date de
intrare n cazul:
Greedy euristic vs Backtracking
Acest coninut poate fi evaluat oral sau prin lucrare scris.
Unitatea de n,((#Fnt __________________
Fi:a re8u#at
)la!a ________________ Profe!or______________________
Nr.
Crt.
Nume i
prenume
elev
Competena 1 Competena 2 Competena 3
Observaii
A 1 A 2 A X A 1 A 2 A 3 A 1 A 2 A 3
1 ))"ll"aaaa
,
2
3
4
...
Y

1
zz.ll.aaaa reprezint data la care elevul a demonstrat c a dobndit cunotinele, abilitile i atitudinile vizate prin activitatea respectiv
)o#petene care treCuie doCFndite
Aceast fi de nregistrare este fcut pentru a evalua, n mod separat, evoluia
legat de diferite competene. Acest lucru nseamn specificarea competenelor tehnice
generale i competenelor pentru abiliti cheie, care trebuie dezvoltate i evaluate.
Profesorul poate utiliza fiele de lucru prezentate n auxiliar i/sau poate elabora alte
lucrri n conformitate cu criteriile de performan ale competenei vizate i de
specializarea clasei.
*cti,it(i efectuate :i co#entarii
Aici ar trebui s se poat nregistra tipurile de activiti efectuate de elev,
materialele utilizate i orice alte comentarii suplimentare care ar putea fi relevante
pentru planificare sau feed-back.
Priorit(i pentru de8,oltare
Partea inferioar a fiei este conceput pentru a meniona activitile pe care
elevul trebuie s le efectueze n perioada urmtoare ca parte a viitoarelor module.
Aceste informaii ar trebui s permit profesorilor implicai s pregteasc elevul pentru
ceea ce va urma.
)o#petenele care ur#ea8( !( fie doCFndite
n aceast csu, profesorii trebuie s nscrie competenele care urmeaz a fi
dobndite. Acest lucru poate implica continuarea lucrului pentru aceleai competene
sau identificarea altora care trebuie avute in vedere.
Re!ur!e nece!are
Aici se pot nscrie orice fel de resurse speciale solicitate:manuale tehnice, reete,
seturi de instruciuni i orice fel de fie de lucru care ar putea reprezenta o surs de
informare suplimentar pentru un elev care nu a dobndit competenele cerute.
Not: acest format de fi este un instrument detaliat de nreistrare a proresului
elevilor! "entru fiecare elev se pot realiza mai multe astfel de fie pe durata
derulrii modulului# aceasta permind evaluarea precis a evoluiei elevului# n
acelai timp furniznd informaii relevante pentru analiz!

/6 1iClio"rafie
1. Cormen, Thomas.Leiserson, Charkes.Rivest, Ronald (1990). Introducere in
algoritmi Bucureti: Editura Agora
2. Cerchez, Emanuela. Serban, Marinel (2005). Programarea n lim%a:ul C5C''
pentru liceu vol" II, ai: Editura Polirom
3. Sorin, Tudor (2006). 4anual de informatica intensiv clasa a BI Ea Bucureti:
Editura L&S nfo-mat
4. Blan, Gabriela. onescu, Clara. Giurgea, Mihaela. Soroiu,Claudiu (2004).
Informatic pentru grupele de performan, Cluj-Napoca Editura Dacia
Educaional
5. Lic, Dana. Paoi Mircea (2005). Fundamentele programrii, Bucureti : Editura
L&S nfo-mat
6. Odgescu, . Furtun, F.(1998). 4etode i tehnici de programare, Bucureti:
Editura Computer Libris Agora
7. Sorin, Tudor (1996).Tehnici de programare, Bucureti : Editura L&S nfo-mat
8. Neculai Andrei (1999). Programarea matematic avansat, Bucureti Editura
Tehnic