MI - Modulul V - Varzopov Silvia II

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
MODUU !"""
#itlul $odulului% #E&'"(" ()S"(E DE PRO*R)M)RE
Material de n+,are - partea a ""-a
Do$eniul% "nfor$atic,
(alificarea% )nali.t pro/ra$ator
'i+el% 3 a+an.at
2000
)U#OR%
S"!") !)R1OPO! - Profesor grad didactic
(OORDO')#OR%
M)R")') !"OE#) ("O2)'U - Profesor grad didactic
(O'SU#)'34%
"O)') (5RS#E) expert CNDPT
*)2R"E) ("O2)'U expert CNDPT
)'*E) POPES(U expert CNDPT
D)') S#RO"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........................................................................................................................7
II. Resurse..........................................................................................................................13
Tema 7. Algoritmi de sortare.................................................................................................14
Fia de documentare 7.1 Sortarea prin selecie..................................................................14
Activitatea de nvare 7.1.1 !"ecuia pas cu pas a algoritmului.......................................1#
Activitatea de nvare 7.1.$ Sortarea prin selecia ma"imului........................................1#
Activitatea de nvare 7.1.3 %ro&leme..............................................................................1'
Tema 7. Algoritmi de sortare.................................................................................................17
Fia de documentare 7.$ Sortarea prin inserare.................................................................17
Activitatea de nvare 7.$.1 !"ecuia pas cu pas a algoritmului.......................................1(
Activitatea de nvare 7.$.$ %ro&leme.............................................................................1(
Tema 7. Algoritmi de sortare.................................................................................................1)
Fia de documentare 7.3 Sortarea prin numrare..............................................................1)
Activitatea de nvare 7.3.1 !"ecuia pas cu pas a algoritmului.......................................$*
Activitatea de nvare 7.3.$ %ro&leme.............................................................................$*
Tema 7. Algoritmi de sortare.................................................................................................$1
Fia de documentare 7.4 Sortarea prin intersc+im&are,-u&&leSort..................................$1
Activitatea de nvare 7.4.1 !"ecuia pas cu pas a algoritmului.......................................$$
Activitatea de nvare 7.4.$ Implementare.......................................................................$$
Tema 7. Algoritmi de sortare.................................................................................................$4
Fia de documentare 7.# Sortarea rapid ,/uic0sort..........................................................$4
Activitatea de nvare 7.#.1 !"ecuia pas cu pas a algoritmului.......................................$#
Activitatea de nvare 7.#.$ %ro&leme.............................................................................$'
Activitatea de nvare 7.#.3 Anali1.................................................................................$'
Activitatea de nvare 7.#.4 Anali1.................................................................................$7
Tema 7. Algoritmi de sortare.................................................................................................$(
Fia de documentare 7.' Sortarea prin inserie cu pas varia&il2S+ellSort..........................$(
Activitatea de nvare 7.'.1 !"ecuia pas cu pas a algoritmului.......................................3*
Activitatea de nvare 7.'.$ Implementare.......................................................................3*
Activitatea de nvare 7.'.3 3uic0Sort vs S+ellSort........................................................31
Tema 7. Algoritmi de sortare.................................................................................................3$
Fia de documentare 7.7 Sortarea prin interclasare 2 4ergeSort.......................................3$
Activitatea de nvare 7.7.1 !"ecuia pas cu pas a algoritmului.......................................33
Activitatea de nvare 7.7.$ Implementare......................................................................34
Activitatea de nvare 7.7.3 %ro&leme..............................................................................34
Activitatea de nvare 7.7.4 3uic0Sort vs 4ergeSort...................................................3#
Tema 7. Algoritmi de sortare.................................................................................................3'
Fia de documentare 7.( Sortarea prin asam&lare ,5eapSort............................................3'
Activitatea de nvare 7.(.1 !"ecuia pas cu pas a algoritmului.......................................37
Activitatea de nvare 7.(.$ implementare.......................................................................3(
Tema (. Algoritmi generali de cutare...................................................................................3)
Fia de documentare (.1 6utarea secvenial...................................................................3)
Activitatea de nvare (.1.1 Implementare.......................................................................4*
Activitatea de nvare (.1.$ %ro&leme..............................................................................4*
Tema (. Algoritmi generali de cutare...................................................................................4$
Fia de documentare (.$ 6utarea &inar..........................................................................4$
Activitatea de nvare (.$.1 !"ecuia pas cu pas a algoritmului.......................................43
Activitatea de nvare (.$.$ Implementare......................................................................44
Activitatea de nvare (.$.3 Anali1.................................................................................44
Activitatea de nvare (.$.4 Trans7ormare iterativ n recursiv..........................................4#
Tema (. Algoritmi generali de cutare...................................................................................4'
Fia de documentare (.3 6utarea prin interpolare............................................................4'
Activitatea de nvare (.3.1 !"ecuia pas cu pas a algoritmului ......................................47
Activitatea de nvare (.3.$ Implementare......................................................................4(
Activitatea de nvare (.3.3 Studiu de ca1........................................................................4(
Tema ). 6riterii de per7orman.............................................................................................4)
Fia de documentare ).1 6omple"itatea metodei..............................................................4)
Activitatea de nvare ).1 Anali1a timpului de e"ecuie..................................................#*
Tema ). 6riterii de per7orman.............................................................................................#1
Fia de documentare ).$ 8tili1area spaiului de memorie.................................................#1
Activitatea de nvare ).$ Anali1a timpului de e"ecuie...................................................#$
Tema 1*. 6omple"itatea algoritmilor....................................................................................#3
Fia de documentare 1*.1 9umrul de operaii. :ite1a de e"ecuie..................................#3
4surarea timpului de e"ecuie a unei pri de program n 6;;.......................................#(
4surarea timpului de e"ecuie a unei pri de program n %ascal<..................................#(
Activitatea de nvare 1*.1.1 =eterminarea comple"itii................................................#)
Activitatea de nvare 1*.1.$ =eterminarea timpului de e"ecuie....................................#)
Activitatea de nvare 1*.1.3 Asemnri i di7erene.......................................................'*
Tema 1*. 6omple"itatea algoritmilor....................................................................................'1
Fia de documentare 1*.$ 4rimea datelor. 8tili1area memoriei....................................'1
Activitatea de nvare 1*.$ =omeniul de valori...............................................................'3
Tema 1*. 6omple"itatea algoritmilor....................................................................................'4
Fia de documentare 1*.3 Algoritmi polinomiali i e"poneniali......................................'4
Activitatea de nvare 1*.3 %olinomial vs e"ponenial.....................................................''
Tema 11. %rogramare dinamic..............................................................................................'7
Fia de documentare 11.1 >ir de deci1ii. %rincipiul de optim. Relaii de recuren..........'7
Activitatea de nvare 11.1 >ir de deci1ii..........................................................................'(
Tema 11. %rogramare dinamic..............................................................................................')
Fia de documentare 11.$ 4etoda nainte..........................................................................')
Activitatea de nvare 11.$.1 Implementare.....................................................................7*
Activitatea de nvare 11.$.$ %ro&leme...........................................................................71
Tema 11. %rogramare dinamic..............................................................................................7$
Fia de documentare 11.3 4etoda napoi...........................................................................7$
Activitatea de nvare 11.3.1 implementare......................................................................74
Activitatea de nvare 11.3.$ %ro&leme...........................................................................74
Tema 11. %rogramare dinamic..............................................................................................7#
Fia de documentare 11.4 4etoda mi"t..........................................................................7#
Activitatea de nvare 11.4.1 Implementare.....................................................................7(
Activitatea de nvare 11.4.$ %ro&lem............................................................................7(
Tema 11. %rogramare dinamic..............................................................................................7)
Fia de documentare 11.# 4etoda simple".......................................................................7)
Activitatea de nvare 11.#.1 %ro&lem de minim............................................................(3
Activitatea de nvare 11.#.$ %ro&lem de ma"im...........................................................(3
Tema 1$. Te+nici de programare care conduc la soluii optime.............................................(#
Fia de documentare 1$. ?reed@. 4etode euristice...........................................................(#
Activitatea de nvare 1$.1 Implementare.......................................................................((
Activitatea de nvare 1$.$ %ro&lema rucsacului..............................................................()
Activitatea de nvare 1$.3 Anali1..................................................................................()
III. ?losar...........................................................................................................................)1
I:. -i&liogra7ie...................................................................................................................)3
"6 "ntroducere
Materialul de nvare are rolul de a conduce elevul la dobndirea competenelor 3
i 4 ale modulului V - Tehnici clasice de programare .
Do$eniul: nformatic
(alificarea: Analist programator
'i+elul de calificare: 3 avansat
Materialul cuprinde:
- fie de documentare
- activiti de nvare
- glosar
Prezentul material de nvare se adreseaz elevilor din cadrul colilor postliceale,
domeniul "nfor$atic,, calificarea )nali.t pro/ra$ator
El a fost elaborat pentru modulul #e7nici cla.ice de pro/ra$are
ce se desfoar n 120 ore, n urmtoarea structur:
Laborator tehnologic: 60 ore
Tabelul de mai jos cuprinde corelaiile i subordonarea dintre competene,
teme,fie de documentare i activiti de nvare
(o$peten
a 8 Re9ultatul
n+,,rii
#e$e Ele$ente co$ponent
3.mplement
eaz algoritmii
de sortare i
cutare
Tema 7. Algoritmi de sortare Fia de documentare 7.1
Sortarea prin selecie
Activitatea de nvare 7.1.1
Execuia pas cu pas a
algoritmului de sortare prin
selecie
Sortarea prin selecia
maximului
Probleme
Fia de documentare 7.2
Sortarea prin inserare
(o$peten
a 8 Re9ultatul
n+,,rii
inserie
Probleme
Sortarea prin numrare
numrare
Probleme
Sortarea prin
interschimbare(BubbleSort)
interschimbare (BubbleSort)
mplementare
Sortarea rapid (quicksort)
algoritmului quicksor
Probleme
Analiz
Analiz
(o$peten
a 8 Re9ultatul
n+,,rii
Sortarea prin inserie cu pas
variabil-ShellSort
algoritmului ShellSort
mplementare
QuickSort vs ShellSort
Sortarea prin interclasare -
MergeSort
algoritmului MergeSort
mplementare
Probleme
QuickSort vs MergeSort
Sortarea prin asamblare
(HeapSort)
algoritmului HeapSort
implementare
Tema 8. Algoritmi generali de
cutare
Cutarea secvenial
mplementare
(o$peten
a 8 Re9ultatul
n+,,rii
Probleme
Cutarea binar
algoritmului de cutare binar
mplementare
Analiz
Transformare iterativ n
recursiv
Cutarea prin interpolare
algoritmului de cutare binar
i interpolare
mplementare
Studiu de caz
3.mplement
eaz algoritmii
de sortare i
cutare..
Tema 9. Criterii de
performan
Complexitatea metodei
Activitatea de nvare 9.1
Analiza timpului de execuie
Utilizarea spaiului de
memorie
(o$peten
a 8 Re9ultatul
n+,,rii
Analiza timpului de execuie
4. Utilizeaz
metode de
optimizare
Tema 10. Complexitatea
algoritmilor
Numrul de operaii. Viteza de
execuie
Determinarea complexitii
Determinarea timpului de
execuie
Asemnri i diferene
Mrimea datelor. Utilizarea
memoriei
Domeniul de valori
Algoritmi polinomiali i
exponeniali
Polinomial vs exponenial
4. Utilizeaz
metode de
optimizare
Tema 11. Programare
dinamic
Fia de documentare 11.1 Sir
de decizii. Principiul de optim.
Relaii de recuren
Activitatea de nvare 11.1 Sir
de decizii
Metoda nainte
mplementare
Probleme
(o$peten
a 8 Re9ultatul
n+,,rii
Metoda napoi
implementare
Probleme
Metoda mixt
mplementare
Problem
Metoda simplex
Problem de minim
Problem de maxim
4. Utilizeaz
metode de
optimizare
Tema 12. Tehnici de
programare care conduc la
soluii optime
Fia de documentare 12.
Greedy. Metode euristice.
mplementare
Problema rucsacului
Absolvenii nivelului 3 avansat, coal postliceal, calificarea Analist programator,
trebuie s fie capabili s utilizeze tehnicile clasice de programare, s implementeze
algoritmii de sortare i cutare, s optimizeze algoritmii de rezolvare a problemelor.
""6 Re.ur.e
Prezentul material de nvaare cuprinde diferite tipuri de resurse care pot fi folosite
de elevi:
- fie de documentare
- activiti de nvaare
Alte surse pot fi:
Crile de specialitate;
Reviste de specialitate;
Surse web
Elevii pot folosi att materialul prezent (n forma printat) ct i varianta
echivalent online.
Tema 7. Algoritmi de sortare
Fi:a de docu$entare 761 Sortarea prin .elecie
De.criere
deea algoritmului este urmatoarea: tabloul unidimensional este mprit n 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> 0> -2> 1?> 2> 0>@ 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
)cti+itatea de n+,are 76161 E;ecuia pa. cu pa. a al/orit$ului
(o$petena% mplementeaz algoritmii de sortare i cutare
OAiecti+ul8oAiecti+e +i9ate%
S descrie pas cu pas algoritmul pe un exemplu concret
S neleag care este ideea algoritmului de sortare prin selecie
S determine algoritmul folosind descrierea n pseudocod
Durata% 15 minute
#ipul acti+it,ii% Observarea sistematic i independent
Su/e.tii% Elevii se pot organiza n grupe mici ( 2-3 elevi) sau pot lucra individual
Sarcina de lucru% Urmnd exemplul de mai sus s se descrie pas cu pas
algoritmul de sortare prin selecie pentru irul 89, 10, 11, 23, -1, 78, 4. Cte operaii de
comparaie se fac? Apoi vei trece la determinarea algoritmului, folosind descrierea n
pseudocod.
)cti+itatea de n+,are 76162 Sortarea prin selecia maximului
"$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[], i
nt 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;
}
}
}
OAiecti+ul8oAiecti+e +i9ate% S simuleze algoritmul pentru cazul cnd pentru
selecie se alege elementul maxim
Durata% 15 minute
#ipul acti+it,ii% Modelarea
Sarcina de lucru% Urmnd exemplul din activitatea de nvare 1.1 s se descrie
pas cu pas algoritmul de sortare prin selecie pentru irul 89, 10, 11, 23, -1, 78, 4
folosind selecia maximului. Elevii sunt solicitai s descrie algoritmul folosit pentru
sortarea prin selecia maximului, dup care se trece la modificarea algoritmului descris
iniial, folosind descrierea n pseudocod
)cti+itatea de n+,are 76163 ProAle$e
S compare rezultatele obinute n cazul problemei date i a altora
asemntoare
S interpreteze rezultatele
S realizeze relaia ntre modul de reprezentare a datelor i problem
precum i ntre datele de ieire i ceea ce reprezint aceste date
Durata% 90 minute
#ipul acti+it,ii% Exerciiu
Su/e.tii% Elevii vor lucra individual fiecare la un calculator
Sarcina de lucru% Se vor rezolva probleme n care elevii vor folosi noiunile
nvate la sortarea prin selecie. Exemplu: dndu-se un vector de elemente ntregi s
se sorteze crescator i apoi descresctor folosind att sortarea prin selecia minimului
ct i sortarea prin selecia maximului.
Fi:a de docu$entare 762 Sortarea prin in.erare
Descriere
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.
Exemplu
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
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
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--;
}
}}
"$ple$entare Pa.cal
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;
Elevii vor ti:
Care sunt paii algoritmului de sortare prin inserie
Ce tehnic folosete acest algoritm
Durata% 20 minute
Sarcina de lucru% Urmnd exemplul din fia de documentare 7.2 s se
descrie pas cu pas algoritmul de sortare prin inserie pentru irul 5 6 8 9 10 15 4 7 3 -1,
trecndu-se, apoi la determinarea algoritmului, folosind descrierea n pseudocod.
)cti+itatea de n+,are 76262 Probleme
Elevii vor ti:
s compare rezultatele obinute n cazul problemei date i a altora
asemntoare
Durata% 45 minute
Sarcina de lucru% Se vor rezolva probleme n care elevii vor folosi noiunile
nvate la sortarea prin inserie. Exemplu: dndu-se un vector de elemente ntregi s
se sorteze cresctor i apoi descresctor folosind sortarea prin inserie
ia de documentare 7.! "ortarea prin numrare
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)
Dezavantajul metodei const n utilizarea a doi vectori de lucru, deci utilizarea unui
spaiu de memorie suplimentar
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
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];
}
Elevii vor ti:
S neleag care este ideea algoritmului de sortare prin numrare
Durata: 10 minute
Sarcina de lucru% Urmnd exemplul din fia de documentare 7.3 descriei pas cu
pas algoritmul de sortare prin numrare pentru irul 4 9 1 6 7 2 , dup care trecei la
determinarea algoritmului, folosind descrierea n pseudocod.
)cti+itatea de n+,are 76362 Probleme
Elevii vor ti:
asemntoare
Durata% 30 minute
Sarcina de lucru% Dndu-se un vector de elemente ntregi s se sorteze cresctor
i apoi descresctor folosind sortarea prin numrare. Rulai programele pentru mai
multe exemple.
Fi:a de docu$entare 76? Sortarea prin inter.c7i$AareC2uAAleSortD
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
S 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
okAtrue
jA0
ct timp ok execut
okAfalse
jAj+1
pentru i A1,n-j execut
dac v[i]>v[i+1] atunci
vBiC D vBEC
sfdac
sfpentru
sfct timp
)cti+itatea de n+,are 76?61 E;ecuia pa. cu pa. a al/orit$ului
Elevii vor ti:
S neleag care este ideea algoritmului de sortare prin interschimbare
Durata% 20 minute
pas algoritmul de sortare prin interschimbare pentru irul 4 6 7 2 9 1. De cte ori se
parcurge irul? Algoritmul v-a sesiza c vectorul este ordonat? Cum? Trecei, apoi, la
determinarea algoritmului, folosind descrierea n pseudocod.
)cti+itatea de n+,are 76?62 "$ple$entare
Elevii vor ti:
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;
S rezolve probleme clasice prin modelare apoi algoritmizare
asemntoare
S genereze idei, soluii de rezolvare a problemelor propuse i s le
argumenteze
Durata% 50 minute
Sarcina de lucru% Dndu-se un vector de elemente ntregi s se sorteze cresctor
i apoi descresctor toate elementele nenule folosind sortarea prin interschimbare
(BubbleSort).
Rulai programele pentru mai multe exemple.
Fi:a de docu$entare 76= Sortarea rapid, CEuicF.ortD
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 .ortea9, a$Gndou, 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.
E;e$plu: 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
)cti+itatea de n+,are 76=61 E;ecuia pa. cu pa. a al/orit$ului
OAiecti+ul8oAiecti+e +i9ate% Elevii vor ti:
S neleag care este ideea algoritmului quicksort.
Durata% 20 minute
"$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);
}
Sarcina de lucru% Urmnd exemplul din fia de documentare 7.5 s se descrie
pas cu pas algoritmul de sortare quicksort pentru irul -3.1, 2, 1.5, 4.9, 3, 6.
Numrai comparaiile i interschimbrile de elemente pe care le-ai efectuat. dup care
trecei la determinarea algoritmului, folosind descrierea n pseudocod.
)cti+itatea de n+,are 76=62 ProAle$e
OAiecti+ul8oAiecti+e +i9ate% Elevii vor ti:
asemntoare
Durata% 100 minute
Sarcina de lucru% Dndu-se un vector cu maxim 100 de numere naturale, s se
localizeze elementul maxim i toate elementele dinaintea lui s se ordoneze cresctor
iar cele de dup el decresctor folosind quicksort.
Sarcina de lucru% Dndu-se un vector cu n numere naturale s se separe n prima
lui parte elementele pare iar n a doua parte cele impare folosind principiul algoritmului
de sortare quicksort, dup care s se sorteze cresctor numerele pare i descresctor
cele impare folosind algoritmul quicksort.
)cti+itatea de n+,are 76=63 )nali9,
Elevii vor ti:
S aplice metoda iterativ
S realizeze conexiuni ntre problemele rezolvate i noul tip de probleme
argumenteze
Durata% 50 minute
#ipul acti+it,ii% Studiu de caz
Sarcina de lucru% Analizai algoritmul de sortare quicksort i nlocuii varianta
prezentat ce folosete recursivitatea, cu o variant nerecursiv. Ce variabile trebuiesc
iniializate, cu ce valori i unde are loc saltul n program pentru a se elimina apelul
recursiv?
)cti+itatea de n+,are 76=6? )nali9,
Elevii vor ti:
argumenteze
S aplice metoda n cazul unor probleme mai dificile
Durata% 30 minute
Sarcina de lucru% Adaptai algoritmul quicksort pentru a determina ntr-un ir de
lungime n cu elemente ntregi, al m-lea mai mic element .
Fi:a de docu$entare 76H Sortarea prin in.erie cu pa. +ariaAil-S7ellSort
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
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;
}
} }
)cti+itatea de n+,are 76H61 E;ecuia pa. cu pa. a al/orit$ului
Elevii vor ti:
S neleag care este ideea algoritmului ShellSort.
Durata% 20 minute
Sarcina de lucru% Urmnd exemplul din fia de documentare 7.6 s se descrie
pas cu pas algoritmul de sortare ShellSort pentru irul 1 11 8 10 12 4 7 3 1 13.
Numrai comparaiile i mutrile de elemente pe care le-ai efectuat. dup care trecei
la determinarea algoritmului, folosind descrierea n pseudocod.
)cti+itatea de n+,are 76H62 "$ple$entare
Elevii vor ti:
S depisteze i s elimine erorile
asemntoare
Durata% 30 minute
Sarcina de lucru% mplementai pe calculator n limbajul C++ sau Pascal
algoritmul descris n pseudocod. Rulai programul pentru mai multe exemple.
)cti+itatea de n+,are 76H63 IuicFSort +. S7ellSort
Elevii vor ti:
asemntoare
Durata% 40 minute
#ipul acti+it,ii% Asemnri i diferene
Sarcina de lucru%Pentru vectorul de elemente reale: -3.1, 0.1, 1.2, 5.7, -0.3, 6,
aplicai metodele de sortare ShellSort i QuickSort, pentru fiecare pas reprezentnd
noua configuraie a vectorului. Numrai comparaiile i mutrile de elemente pe care le-
ai efectuat. Care algoritm este mai eficient pentru acest tablou?
Fi:a de docu$entare 767 Sortarea prin intercla.are - Mer/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.
3( $7 43 3 ($ ) 1*
Divizare
Sortare
nterclasare
$7 3( 3 43 ) ($ 1*
3 $7 3( 43 ) 1* ($
3 ) 1* $7 3( 43 ($
3( $7 43 3 ($ ) 1*
3( $7 3 3 ($ ) 1*
)l/orit$ de.cri. n p.eudocod%
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
.f"nterc
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
Elevii vor ti:
S neleag care este ideea algoritmului MergeSort.
S anticipeze unele rezultate precum i ncheierea algoritmului
S remarce sub-programele ce trebuie s apar n cadrul algoritmului
"$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); } }
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;
Durata% 30 minute
pas algoritmul de sortare MergeSort pentru irul 1 11 8 10 12 4 7 3 1 13, dup care
)cti+itatea de n+,are 76762 "$ple$entare
Elevii vor ti:
asemntoare
Durata% 30 minute
Elevii vor ti:
argumenteze
Durata% 35 minute
Sarcina de lucru% Se dau n persoane care au participat la un concurs memorate
n vectorul V. Ordonai persoanele n ordinea descresctoare a punctajului obinut
folosind algoritmul de sortare prin interclasare. Pentru fiecare persoan se va afia
numele i punctajul obinut. Afiai numele persoanelor cu punctaj maxim.
)cti+itatea de n+,are 7676? IuicFSort +. Mer/eSort
Elevii vor ti:
asemntoare
Durata% 40 minute
Sarcina de lucru% Comparai algoritmii bazai pe ,divide et impera MergeSort si
QuickSort prin implementarea pe un ir format din 3500 elemente.( acestea se pot da
prin folosirea funciei ,random())
Fi:a de docu$entare 76J Sortarea prin a.a$Alare C&eapSortD
De.criere
Se numete ansamblu (heap) o 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
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=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
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
)cti+itatea de n+,are 76J61 E;ecuia pa. cu pa. a al/orit$ului
Elevii vor ti:
S neleag care este ideea algoritmului HeapSort.
S remarce sub-programele ce trebuie s apar n cadrul algoritmului
Durata% 30 minute
"$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}
Sarcina de lucru% Urmnd exemplul din fia de documentare 7.8 descriei pas
cu pas algoritmul de sortare HeapSort pentru irul (6, 9, 10, 4, 7, -1), dup care
)cti+itatea de n+,are 76J62 i$ple$entare
Elevii vor ti:
asemntoare
Durata% 30 minute
#e$a J6 )l/orit$i /enerali de c,utare
Fi:a de docu$entare J61 (,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.
gsit A*
pentru iA 0,n-1 execut
dac x=v[i] atunci
gsit A1
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
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;
}
"$ple$entare (BB
{
for(int i=0;i<n;i++)
if(x==v[i])
return 1;
return 0;
}
"$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
{
if(x==v[i])
return 1;
return 0;
}
"$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[],intn)
{
if(x==v[i])
return 1;
return 0;
}
)cti+itatea de n+,are J6161 "$ple$entare
Elevii vor ti:
S defineasc corect noiunea de cutare
S descrie particularitile operaiei de cutare
S recunoasc algoritmii prezentai
S implementeze i s corecteze erorile de sintax care apar.
Durata% 40 minute
Su/e.tii% Elevii pot lucra n grupe mici ( 2-3 elevi) sau pot lucra individual
fiecare la un calculator.
Sarcina de lucru% - mplementai pe calculator n limbajul C++ sau Pascal
algoritmii descrii n pseudocod. Rulai programele pentru mai multe exemple.
- Cum se modific algoritmii n cazul cnd se va afia i poziia elementului cutat
- Cum se modific algoritmii n cazul cnd se determin toate apariiile elementului
cutat? Dar pentru aflarea primei i ultimei apariii ale elementului?
)cti+itatea de n+,are J6162 ProAle$e
Elevii vor ti:
Particularitile operaiei de cutare
S foloseasc algoritmii de cutare n rezolvri de probleme.
Durata% 90 minute
Sarcina de lucru%
1. Se citesc 2 vectori A i B cu n respectiv m elemente ntregi. Folosind
cutarea secvenial s se determine reuniunea, intersecia i diferena lor.
Exemplu: A=(2,4,1,6,7) i B=(3,4,8,9) se va afia: A U B=(2,4,1,6,7,3,8,9), A
i B=(4) i A-B=(2,1,6,7)
2. Se citete un vector A cu n elemente ntregi. Folosind algoritmul de cutare
secvenial s se determine dac vectorul are proprietatea de mulime (este
alctuit numai din elemente distincte)
Fi:a de docu$entare J62 (,utarea Ainar,
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
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
sfdac
sfdac
sfct timp sfCautBin
17 19
5 6
19
6
)cti+itatea de n+,are J6261 E;ecuia pa. cu pa. a al/orit$ului
Elevii vor ti:
Care este ideea algoritmului de cutare binar
Durata% 30 minute
pas algoritmul de cutare a elementului x=36 n vectorul V=(8,15,20,31,36,41,48,50).
Cte comparaii se fac? Trecei apoi la determinarea algoritmului folosind descrierea n
pseudocod.
Cum se modific algoritmul dac vectorul este ordonat descresctor?
"$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;
Elevii vor ti:
S defineasc corect noiunea de cutare
Particularitile operaiei de cutare
S descrie algoritmii prezentai
Durata% 20 minute
Su/e.tii% Elevii vor lucra individual fiecare la un calculator.
Sarcina de lucru% - mplementai pe calculator n limbajul C++ sau Pascal
algoritmul descris n pseudocod. Rulai programul pentru mai multe exemple. Modificai
programul astfel nct s se afieze poziia elementultui cutat sau un mesaj
corespunztor dac elementul cutat nu se afl n vector.
)cti+itatea de n+,are J6263 )nali9,
Elevii vor ti:
Particularitile operaiei de cutare binar i secvenial
S analizeze eficiena algoritmililor
Durata% 30 minute
Sarcina de lucru% Considerai un vector cu n=7 elemente ordonate cresctor. Cte
comparaii execut algoritmul de cutare binar n cazul cel mai defavorabil ( cnd
elementul cutat nu se afl n vector sau este depistat abia la ultima comparaie)? Dar
pentru n= 10 elemente? Putei estima n general (n funcie de n) numrul de comparaii
necesare n cazul cel mai defavorabil? Ce concluzie tragei, comparnd algoritmul de
cutare binar cu algoritmul de cutare secvenial?
)cti+itatea de n+,are J626? #ran.for$are iterati+ n recur.i+
Elevii vor ti:
S aplice metoda recursiv folosind Divide et mpera
S genereze idei, soluii de rezolvare a noului tip de probleme i s le
argumenteze
Durata% 50 minute
#ipul acti+it,ii% Modelare
Su/e.tii% Elevii se pot organiza n grupe mici ( 2-3 elevi) sau pot lucra
individual
Sarcina de lucru% Analizai algoritmul de cutare binar prezentat n variant
iterativ i nlocuii-l cu varianta recursiv folosind Divide et mpera. Care este condiia
de oprire? Cu ce trebuie iniializat funcia la condiia de oprire dac dorii s aflai
poziia pe care se afl elementul cutat?
Fi:a de docu$entare J63 (,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 s
depaeasc n.
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;
}
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).
)cti+itatea de n+,are J6361 E;ecuia pa. cu pa. a al/orit$ului
Elevii vor ti:
S compare ce doi algoritmi
S analizeze eficiena algoritmililor
Durata% 30 minute
Sarcina de lucru% Urmnd exemplul din fia de documentare 8.2 ilustrai pas cu
pas, etapele necesare algoritmilor de cutare binar i cutare prin interpolare pentru
urmtoarele date: se caut elementul 7, n vectorul V=(1,3,4,7,9,11,13,14,17,18,
20,23,24,26,29,31,32). Cte comparaii se fac n cazul cutrii binare? Dar n cazul
cutrii prin interpolare? Care este mai eficient?
Elevii vor ti:
S defineasc corect noiunea de cutare prin interpolare
Particularitile operaiei de cutare prin interpolare
S descrie algoritmul prezentat
Durata% 20 minute
algoritmul de cutare prin interpolare. Rulai programul pentru mai multe exemple.
)cti+itatea de n+,are J6363 Studiu de ca9
Elevii vor ti:
Particularitile operaiei de cutare prin interpolare
S genereze idei, soluii de rezolvare a noului tip de problem i s le
argumenteze
Durata% 20 minute
Su/e.tii% Elevii pot lucra n grupe mici ( 2-3 elevi) sau pot lucra individual fiecare la un
calculator.
Sarcina de lucru% Cum se modific algoritmul pentru cutarea unui element ntr-
un vector ordonat descresctor?
#e$a 06 (riterii de perfor$an,
Fi:a de docu$entare 061 (o$ple;itatea $etodei
(o$ple;itatea al/orit$ilor de .ortare
!ortarea 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.
!ortarea 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##le!ort. 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.
!ortarea 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.
!ortarea 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 (nKlg nK - 2
Klg nK
+ 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.
)cti+itatea de n+,are 061 )nali9a ti$pului de e;ecuie
Elevii vor ti:
S analizeze timpul de execuie al algoritmilor de sortare i cutare
S genereze idei, soluii de rezolvare n cele 3 cazuri: favorabil, mediu i
nefavorabil
Durata% 50 minute
calculator.
Sarcina de lucru%
16 Demonstrai c timpul de execuie al algoritmului quicksort, n cazul unui
vector A cu toate elementele egale ntre ele, este O(n log n).
26 Demonstrai c pentru a interclasa doi vectori ordonai ce conin fiecare cte
n elemente, sunt necesare 2n-1 comparaii n cazul cel mai defavorabil.
36 Analizati algoritmul heapsort pentru cel mai favorabil caz. Care este cel mai
favorabil caz?
#e$a 06 (riterii de perfor$an,
Fi:a de docu$entare 062 Utili9area .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 stn&a 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 stn&a 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:
)cti+itatea de n+,are 062 )nali9a ti$pului de e;ecuie
Elevii vor ti:
S analizeze algoritmi echivaleni de rezolvare a unei probleme n
vederea alegerii algoritmului optim
S foloseasc metode sistematice de rezolvare pentru probleme de
generare;
Durata% 30 minute
calculator.
Sarcina de lucru% Descriei algoritmul de sortare prin inserare, la care s
modificai cutarea liniar cu o cutare binar.Calculai 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?
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
#e$a 106 (o$ple;itatea al/orit$ilor
Fi:a de docu$entare 1061 'u$,rul de operaii6 !ite9a de e;ecuie6
De.criere
Vom nota cu T(n' 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 analiz 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
Sfritct timp
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:
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
Timpul de execuie este n acest caz: T(m, n,p) = 4mnp + 5mp + 4m + 2.
n
i
i
1
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:
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. 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 0. 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
deci 1 > r
1
(n) > n
deci 0 > r
3
(n) > n
Tabelul costurilor este:
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+oraAil ca96 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).
#i$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
v(n' reprezint numrul variantelor posibile, 1
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 . , F . , . ,
. ,
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
v
(n'/n%+
(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/(n+1). 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 , $
. $ # , #
.. 1 , # . 1 , # ,
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:

4
. # 3 , #
. . 1 , # . 1 , #
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:
G *
. ,lg
lim

k
b
n
n
n
G * lim

n
k
n
a
n
G * lim

n
n
n
n
a
G *
H
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
M,.urarea ti$pului de e;ecuie a unei p,ri de pro/ra$ n (BB
M,.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.
Utilizarea operaiilor starton si startoff.
Msurarea duratei se poate face astfel:
8L 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:
8L fiierul ti$er67
#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;
}
)cti+itatea de n+,are 106161 Deter$inarea co$ple;it,ii
(o$petena% Utilizeaz metode de optimizare
Elevii vor ti:
S analizeze algoritmi prin urmrirea evoluiei valorilor variabilelor
prelucrate de algoritmii respectivi
S organizeze etapele de prelucrare ce formeaz un algoritm utiliznd
structuri de control i module de program
Durata% 20 minute
calculator.
Sarcina de lucru%
S se determine complexitatea timp a algoritmului urmtor:
x a
y b
s 0
ct timp x<>0 execut
ct timp x%2=0 execut
y 2*y
x x div 2
sfct timp
s s+y
x x-1
sfct timp
)cti+itatea de n+,are 106162 Deter$inarea ti$pului de e;ecuie
Elevii vor ti:
S analizeze algorimi echivaleni de rezolvare a unei probleme n
S foloseasc metode sistematice de rezolvare pentru probleme de
generare;
Durata% 40 minute
calculator.
Sarcina de lucru%
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
)cti+itatea de n+,are 106163 ).e$,n,ri :i diferene
Elevii vor ti:
S analizeze algorimi echivaleni de rezolvare a unei probleme n
Durata% 120 minute
calculator.
Sarcina de lucru%
Folosind variantele C++ sau Pascal,descrise n fia de documentare 10.1
pentru calcularea timpului de execuie a unei pri de program, s se calculeze timpul
de execuie pentru aceleai date de intrare astfel:
- sortarea prin interclasare vs quicksort
- cutarea secvenial vs cutarea binar
- cutarea binar vs cutarea prin interpolare
Rezultatele nregistrate n urma testelor efectuate se nregistreaz i se fac prelucrri
statistice.
Fi:a de docu$entare 1062 M,ri$ea datelor6 Utili9area $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 #ii din repre$entarea #inar 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)
#ip Di$MAii Se$nificaie Do$eniu de +alori
nt 16 ntreg [-32768..32767]
Short 16 ntreg [-32768..32767]
Long 32 ntreg [-2147483648..2147483647]
Unsigned
int
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^492]
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.
)cti+itatea de n+,are 1062 Do$eniul de +alori
Elevii vor ti:
S stabilesc proprietile datelor de intrare n raport cu o problem dat
Durata% 20 minute
Su/e.tii% Elevii pot lucra n grupe mici ( 2-3 elevi) sau pot lucra individual.
Sarcina de lucru% Cum se calculeaz domeniile de valori pentru tipurile int i
unsingned char?
Fi:a de docu$entare 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
#i$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.
OA.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
#i$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
3
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.
OA.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.
)cti+itatea de n+,are 1063 Polino$ial +. e;ponenial
Elevii vor ti:
S deosebeasc un algoritm polinomial de unul exponenial
S analizeze algoritmi prin urmrirea timpului de execuie al algoritmilor
respectivi
Durata% 120 minute
Sarcina de lucru% Plata unei sume ntr-un numr minim de bancnote.
Se dau n tipuri de bancnote de valori b
1,
b
2,

. . .
b
n
(numere naturale strict mai mari ca 0).
Din fiecare tip se dispune de un numr nelimitat de bancnote. De asemenea, se tie c
vom avea ntotdeauna bancnota cu valoarea 1. Fiind dat o suma S, numr natural, se
cere ca aceasta s fie pltit prin utilizarea unui numr minim de bancnote.
Rezolvai problema folosind strategia Greedy (timp de prelucrare polinomial) i folosind
strategia Backtracking (timp de execuie polinomial). Rulai programele pentru mai
multe exemple i folosind variantele C++ sau Pascal,descrise n fia de documentare
10.1 pentru calcularea timpului de execuie completai un tabel cu timpul de execuie a
celor dou programe pentru diverse valori ale datelor de intrare.

#e$a 116 Pro/ra$are dina$ic,
Fi:a de docu$entare 1161 Nir de deci9ii6 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
k-1
n S
n
.
(2) Dac irul D
1
,.,D
n
0
n S
n
1<=k<=n, irul D
1
,...,D
k
0
n S
k
.
(3) Dac irul D
1
,.,D
k
0
n S
n
1<=k<=n, irul D
1
,...,D
k
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.
Mai 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.
)cti+itatea de n+,are 1161 Nir de deci9ii
Elevii vor ti:
S deosebeasc un algoritm recursiv de relaiile de recuren rezolvate
iterativ n cazul programrii dinamice
S analizeze algoritmii prin urmrirea timpului de execuie al algoritmilor
respective
S fac analiza unor algoritmi echivaleni de rezolvare a unei probleme n
Durata% 30 minute
#ipul acti+it,ii% Problematizarea
Sarcina de lucru% La capitolul ,Recursivitate ai rezolvat recursiv ce-l de-al n-lea
termen al irului Fibonacci i ai observat c este ineficient din cauza faptului c
subproblemele se suprapun i acelei valori se calculeaz de mai multe ori.
Rezolvarea iterativ presupune luarea unui ir de decizii plecnd de la starea iniial a
problemei. Rezolvati problema iterativ. n care din cele 3 metode ale programrii
dinamice se ncadreaz?
Fi:a de docu$entare 1162 Metoda nainte
ProAle$,%
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 sau 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 C1D 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 :
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.
)cti+itatea de n+,are 116261 "$ple$entare
Elevii vor ti:
Particularitile algoritmului de programare dinamic, metoda nainte
Durata% 30 minute
algoritmul descris n pseudocod.
Elevii vor ti:
S aplice algoritmul de programare dinamic, metoda nainte, n rezolvri
de probleme
Durata% 100 minute
Sarcina de lucru%
1. Dintr-un element (a
i,j
)al unei matrice A
n,n
se poate ajunge n elementele a
i+1,j,
a
i+1,j+1,
a
i+1,j-1
. Stiind c fiecare element al matricei reine un numr natural, se cere
un drum care ndeplinete condiiile problemei i unete un element de pe linia
1 cu unul de pe linia n astfel nct suma numerelor reinute de elementele pe
unde trece drumul s fie maxim.

Exemplu: Pentru n=3 i matricea A=
iar suma este 3+4+7=14
drumul este: a
1,1,
a
2,1,
a
3,2
iar
suma este: 3+4+7=14
Indicaie:Rezolvarea este asemntoare cu rezolvarea din, problema triunghiului
descris n fia de documentare.
2. 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
I A
i$
I. . .A
i0
i 1 I
i1Ji$. . . Ji0 I n.

Exemplu: pentru n=5 i vectorul A= (4, 1, 7, 6, 7) subirul obinut
va fi: 4, 7, 7.
Fi:a de docu$entare 1163 Metoda napoi
ProAle$,%
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:
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);
)cti+itatea de n+,are 116361 i$ple$entare
Elevii vor ti:
Particularitile algoritmului de programare dinamic, metoda npoi
Durata% 30 minute
Elevii vor ti:
S aplice algoritmul de programare dinamic, metoda npoi, n rezolvri
de probleme
Durata% 50 minute
Sarcina de lucru% 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 I 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.
Se poate rezolva problema prin metoda nainte?
Fi:a de docu$entare 116? Metoda $i;t,
ProAle$,%
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 /-
+
* -
,
* ... * -
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 !
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:
6,1G4.
6,1G1. 6,$G4. 6,1G$. 6,3G4. 6,1G3. 6,4G4.
6,$G$. 6,3G4. 6,1G1. 6,$G3. 6,$G3. 6,4G4. 6,1G$. 6,3G3.
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 / +, ..., n>
;7e(ultatele sunt matricele C i ! descrise mai sus.>
Pentru i 1, n execut
C
ij
0
sfpentru
Pentru l 2, n execut ;dia&onala superioar l din matrice>
Pentru i 1, n-l+1 execut ;linia de pe acea dia&onala>
Fie j i + l -1 ;)lementul C
i:
, i /+,...,n$l%+>
C
ij
nfinit ;C
i,:
/ 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 ! se calculeaz n ordinea diagonalelor, dup cum indic figura
urmtoare:
1 $ 3 4
1
$
3
4
lK$
lK3
lK4
Ciclul cu contorul l calculeaz diagonalele superioare ale matricelor C i !. 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 ! care indic parantezarea, construirea unei soluii optime
7 -
+
-
,
...-
n
se efectueaz apelnd 1rodus!ir4atrice(7, -, !, 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 / !
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 1rodus!ir4atrice folosete matricea ! calculat. Deoarece valoarea
lui 2/!
+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.
(onclu9ii
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.
)cti+itatea de n+,are 116?61 "$ple$entare
Elevii vor ti:
Particularitile algoritmului de programare dinamic, metoda mixt
Durata% 30 minute
)cti+itatea de n+,are 116?62 ProAle$,
Elevii vor ti:
S aplice algoritmul de programare dinamic, metoda mixt, n rezolvri
de probleme
Durata% 50 minute
Sarcina de lucru 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.
Fi:a de docu$entare 116= Metoda .i$ple;
ProAle$,%
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 G...G G
$ 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
G
+ i G
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 G in7
*

'
>
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 G G G
$ 1

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

G G G
$ 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 G
. 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 E G *
B
j j
z c
Observaie: pentru o problem de maxim, inegalitatea se schimb.
Criteriul de intrare n baz:
Dac
S G * < 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 G * <
B
k k
z c intr n baz vectorul V
k
pentru care
{ } in7
B
j j
B
k k
z c z c
La o problem de maxim, avem:

,Dac G * >
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
{ } in7
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"MPEO
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
G 1 G
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
G 1 G
;
B j z c
B
j j
G *
Datele se introduc ntr-un tabel SMPLEX:
1
c
$
c
..........
n
c
2 (
2
D
2
!
1
!
2
P666666666 !
n
e
V
1

e
V
$
P666

e
m
V
e
V
1
1
i
c
1
i
x 1 G
1
i
a
$ G
1
i
a
...............
n i
a
G
1
e
V
$
$
i
c
$
i
x 1 G
$
i
a
$ G
$
i
a
...............
n i
a
G
$
.
.
.
.
.
.
.
.
. .
. .
e
m
V
m
i
c
m
i
x 1 G
m
i
a
$ G
m
i
a
...............
n i
m
a
G
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
G 1 G *
, atunci programul
B
x
este optim i STOP.
Dac nu, adic S G * < 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
{ } in7
B
j j
B
k k
z c z c
(testul de optim infinit) Dac n i a
B
ik
G 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 G in7
*

'
>
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.
)cti+itatea de n+,are 116=61 ProAle$, de $ini$
Elevii vor ti s aplice algoritmul de programare liniar, metoda simplex,
n rezolvri de probleme
Dezvoltarea abilitii de a formula modelul matematic al unei probleme de
optimizare i de a aplica metoda potrivit de rezolvare pentru stabilirea
soluiei optime.
Durata% 50 minute
Sarcina de lucru% S se rezolve cu algoritmul simplex urmtoarea problem
* G
)* # 4
3' $ 3
' 3 min
$ 1
$ 1
$ 1
$ 1
'
+
+
+
x x
x x
x x
x x z
)cti+itatea de n+,are 116=62 ProAle$, de $a;i$
Elevii vor ti s aplice algoritmul de programare liniar, metoda simplex,
n rezolvri de probleme
Dezvoltarea abilitii de a formula modelul matematic al unei probleme de
optimizare i de a aplica metoda potrivit de rezolvare pentru stabilirea
soluiei optime.
Durata% 50 minute
#ipul acti+it,ii% Exerciiu practic
Sarcina de lucru%
n fiecare lun, mainile M1, M2, M3 , ce lucreaz ntr-o secie a unei ntreprinderi
nu sunt folosite 8 ore, 24 de ore i respectiv 18 ore. Se ia hotrrea s se foloseasc i
acest timp, punndu-le s lucreze la fabricarea a 2 produse suplimentare, P1 i P2 , ca
produse anexe ale seciei, care aduc un profit la unitatea de produs fabricat de 4 i
respectiv 3 u. m. Timpul necesar de lucru la fiecare main este, pe fiecare produs, dat
de Tabelul urmtor:
Maina P1 P2
M1 2 1
M2 3 2
M3 1 3
S se determine planul de producie al seciei pentru produsele 11 i 12 care s dea
un profit maxim.
Indicaie
4odelarea pro#lemei. Fie *1, *2 cantitile din produsele 11 i 12 ce trebuie
fabricate. Formularea matematic a problemei este:
( $
* G
1( 3
$4 $ 3
. 3 4 ma", ma"
$ 1
$ 1
$ 1
$ 1
$ 1
+
'
+
+
+
x x
x x
x x
x x
x x z
#e$a 126 #e7nici de pro/ra$are care conduc la .oluii opti$e
Fi:a de docu$entare 126 *reedQ6 Metode euri.tice6
De.ciere%
Metode 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.
*reedQ 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 Aancnote

Enun.Se dau n tipuri de bancnote de valori A
1>
A
2
>666>A
$
(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
SuAal/orit$% Selecie-Greedy():
Ord_desc(n,b)
i0
cGt ti$p (S>0) si (i<n) e;ecut,
ii+1
x
i
[S / b
i
]
nrbnrb+x
i

SS-x
i
*nrb
SfGr:it cGt ti$p
Dac, S=0 atunci
Scrie x
1
,...,x
i
)ltfel
Scrie RNu s-a gsit soluie.`
SfGr:it dac,
SfGr:it .uAal/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.
ProAle$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 #ac2trac2in&.
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).
SuA)l/orit$ Selecie-Greedy(gr, val, n, G):
{ordonm obiectele descresctor dup valoarea ctigului}
Ordonare(n, gr, val)
i 0
cGt ti$p (G>0) :i (i<n) e;ecut,:
i i+1
dac, gr
i
>G atunci
G G gr
i

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
ctig ctig + val
i
k k + 1
x
k
i
.fGr:it dac,
.fGr:it cGt ti$p
.crie x
1
, ..., x
k
.fGr:it SuA)l/orit$
ProAle$a color,rii 7,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.
)cti+itatea de n+,are 1261 mplementare
Elevii vor ti:
Particularitile algoritmilor euristici
S descrie algoritmii prezentai
Durata% 100 minute
algoritmul descris n pseudocod. Rulai programele pentru mai multe exemple.
)cti+itatea de n+,are 1262 ProAle$a ruc.acului
Elevii vor ti:
S aplice algoritmi euristici n rezolvri de probleme
Durata% 50 minute
Sarcina de lucru% Cum se modific problema rucsacului n ca(ul continuu(cnd
o#iectele pot fi tiate n #uci'D
)cti+itatea de n+,are 1263 )nali9,
Elevii vor ti:
S aplice algoritmi euristici n rezolvri de problem
S compare algoritmii euristici cu strategia backtracking.
Durata% 100 minute
Sarcina de lucru% S se rezolve problema plata .u$ei cu nu$,r $ini$ de
Aancnote prin metoda backtracking i cu ajutorul programelor de calculare a timpului
de execuie din fia de documentare 10.1 se va calcula timpul pentru aceleai date de
intrare n cazul: *reedQ euri.tic +. 2acFtracFin/6 Timpii de execuie pentru mai multe
date de intrare se vor completa ntr-un tabel.
"""6 *lo.ar
) contori9a
A numra
) e.ti$a
A evalua (cu aproximaie) a aprecia mrimea, valoarea....
)cce. aleator
Acces ntmpltor
)daptat
Corespunztor anumitor cerine
)dec+at
Potrivit, care corespunde situaiei
)diacente
-lturate,nvecinate
)leator
ntmpltor
)l/orit$
Succesiune de operaii necesare n rezolvarea unei probleme
)r/u$entele procedurii
Parametrii procedurii
2it
Cea mai mica unitate de date utilizata in informatica, cu valoare egala cu 1 sau 0
2uAAleSort
Sortarea prin metoda bulelor
(,utare .ec+enial,
Cutare element cu element
(od )S(""
Standard de Cod American pentru nterschimbarea de nformaii. Conform ASC toate
literele, cifrele arabe i simbolurile speciale au drept corespondent un cod numeric intre
32 i 127 (sau 255 pentru codul extins)
(o$ple;itate
ndicator al dependenei dintre dimensiunea datelor de intrare i numrul de instruciuni
execute de un algoritm.
Depanarea al/orit$ului
Rularea pas cu pas a algoritmului
Ele$ent c7eie
Element principal
Funcia Srando$CDT
Funcie care are rolul de a genera, ntmpltor, numere ntregi cuprinse ntre 0 i
32767
*li.area ntr-un +ector
Deplasarea de la un element la altul
$ple$entare
Transpunerea unui algoritm din pseudocod ntr-un limbaj de programare
"ndici
Numere, litere care indic poziia unui element ntr un tablou
"nterpolare
A intercala ntr-un ir de valori cunoscute una sau mai multe mrimi determinate sau
estimate
"terati+
Care se repet de mai multe ori ( repetitiv)
i.t,
Elemente scrise ntr - o anumit ordine (ir de elemente)
ocaie de $e$orie
Zon a memoriei unui calculator electronic al crei coninut poate fi folosit n timpul
rulrii unui program
Mer/eSort
Sortarea prin interclasare
Metode de opti$i9are
Metode de alegere i aplicare a soluiei optime (dintre mai multe posibile).
Operan9i
Nume de date, constante, funcii care impreun cu operatorii formeaz expresii
Partiionare
mprire n subansamble
Pi+ot
Element, punct de sprijin esenial care asigur desfurarea unei activiti
Pointer
Element reprezentnd o adres, pe baza creia pot fi legate componentele unei
structuri
P.eudocod
Limbaj n proiectarea i documentarea programelor, prin grefarea unor reguli sintactice
pe limbaj natural
IuicFSort
Sortarea rapid
Relaie de recuren,
Relaie care exprim un termen dintr-un ir n funcie de valorile unor anumii termeni
precedeni
Repre9entare Ainar,
Reprezentarea n baza doi
Repre9entarea n +ir/ul, $oAil,
Metod de reprezentare a numerelor reale
Selecie
Alegere
Sortare
Aranjare ntr-o anumit ordine, ordonare
Sortare )rAitrar,
Sortare ntmpltoare
SuA:ir
Parte dintr -un ir
SuAtaAlou
Parte dintr un tablou
#aAlou unidi$en.ional
List (ir de elemente)
#a.F acti+
Program n timp de execuie
"!6 2iAlio/rafie
1. Cormen, Thomas.Leiserson, Charkes.Rivest, Ronald (1990). Introducere in
al&oritmi Bucureti: Editura Agora
2. Cerchez, Emanuela. Serban, Marinel (2005). 1ro&ramarea 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 &rupele de performan, Cluj-Napoca Editura Dacia
Educaional
5. Lic, Dana. Paoi Mircea (2005). Fundamentele pro&ramrii, Bucureti : Editura
L&S nfo-mat
6. Odgescu, . Furtun, F.(1998). 4etode i tehnici de pro&ramare, Bucureti:
Editura Computer Libris Agora
7. Sorin, Tudor (1996).Tehnici de pro&ramare, Bucureti : Editura L&S nfo-mat
8. Neculai Andrei (1999). 1ro&ramarea matematic avansat, Bucureti Editura
Tehnic
9. D.Lucanu, (1996). "a(ele proiectrii pro&ramelor i al&oritmilor, ai: Editura
Universitii "Al. . Cuza
10. C.Croitou, (1992). Tehnici de #a( n optimi(area com#inatorie, ai: Editura
Universitii "Al. . Cuza
11. A. Gica, L. Panaitopol, (2006). -ritmetica si Teoria Gumerelor.1ro#leme.
Bucureti: Editura Universitatii
12. Trandafir, Romic (2004). 4odele i al&oritmi de optimi(are. Bucureti: Editura
AGR.

MI - Modulul V - Varzopov Silvia II

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

MI - Modulul V - Varzopov Silvia II

Încărcat de

Drepturi de autor:

Formate disponibile

nvmntul profesional i tehnic n domeniul TIC

La o problem de maxim, avem:

Criteriul de optim infinit

S-ar putea să vă placă și