TEHNICI DE ELABORARE A

ALGORITMILOR
Cuprins
 Metoda trierii
 Tehnica Greedy
 Metoda reluării (Backtracking)
 Probleme rezolvate
 Metoda trierii
 Se numeşte metoda trierii o metodă ce indentifică toate soluţiile unei probleme în
dependenţă de mulţimea soluţiilor posibile. Toate soluţiile se identifică prin valori, ce
aparţin tipurilor de date studiate: integer, boolean, enumerare, char, subdomeniu, tablouri
unidimensionale.
Fie P o problemă, soluţia căreia se află printre elementele mulţimii S cu un număr finit de
elemente. S={s1, s2 , s3 , ... , sn} . Soluţia se determină prin analiza fiecărui element si
din mulţimea S.
SCHEMA GENERALĂ
for i:=1 to k do
 if SolutiePosibila (si) then PrelucrareaSolutiei (si)
 (SolutiePosibila este o funcţie booleana care returneaza valoarea true dacă elementul si
satisface condiţiile problemei şi false în caz contrar, iar PrelucrareaSolutiei este o
procedură care efectuează prelucrarea elementului selectat. De obicei, în această
procedură soluţia si este afişată la ecran.)
Generarea soluţiilor posibile necesită elaborarea unor algoritmi speciali. În general,aceşti
algoritmi realizează operaţiile legate de prelucrarea unor mulţimi:
• - reuniunea;
• - intersecţia;
• - diferenţa;
• - generarea tuturor submulţimilor;
• - generarea elementelor unui produs cartezian;
• - generarea permutărilor, aranjamentelor sau combinărilor de obiecte etc.
 Metoda Greedy
 Metoda Greedy este una dintre cele mai directe tehnici de proiectare a
algoritmilor care poate fi aplicată la o gamă largă de probleme.
Această metodă se aplică problemelor de optimizare, care constau în
determinarea unei submultimi B, a unei mulţimi A cu n elemente care să
îndeplinească anumite condiţii pentru a fi acceptate. Orice submulţime de acest
fel, care respectă aceste condiţii se numeşte soluţie posibilă. Din mulţimea
tuturor soluţiilor posibile se doreştedeterminarea unei soluţii care maximizează
sau minimizează o funcţie de cost. O soluţie posibilă care realizează acest lucru
se numeşte soluţie optimă.
Descrierea metodei
Exemplu:
Se dă o mulţime A cu n elemente şi se cere să se determine o submulţime B
care satisface anumite restricţii. Această soluţie se numeşte soluţie posibilă. Se
cere să se determine o soluţie posibilă care să maximizeze sau să minimizeze o
anumită funcţie obiectiv dată. Această soluţie se numeşte soluţie optimă.
Specificul acestei metode constă în faptul că se construieşte soluţia optimă pas
cu pas , la fiecare pas fiind selectat (sau "înghiţit") în soluţie elementul care
pare "cel mai bun" la momentul respectiv, în speranţa că va duce la soluţia
optimă globală.
 Metoda reluării (Backtracking)
 Este o tehnica de programare aplicabila algoritmilor care ofera mai multe solutii si are ca
rezultat obtinerea tuturor solutiilor problemei. Fiecare solutie se memoreaza într-o
structura de date de tip stiva implementata cu ajutorul unui vector. Deci fiecare solutie
poate fi pusa sub forma unui vector. Toate configuratiile stivei ce reprezinta solutii finale
sunt alcatuite din elementele aceleiasi multimi bine definite pe care o numim multimea
solutiilor. Fiecare noua solutie partiala se obtine prin completarea solutiei partiale
precedente cu înca o nivel pe stiva. La fiecare nivel se pun valori din multimea solutiilor
care nu au fost încercate pâna când se obtine o solutie valida. În acest moment se trece la
nivelul urmator în stiva pentru a completa mai departe solutia reluând încercarile pe
noul nivel.
 La un moment dat pe un anumit nivel nu mai exista nici o valoare neîncercata din
multimea valorilor problemei. În acest caz se face un pas înapoi în stiva la nivelul
anterior si se reia cautarea cu valorile ramase neîncercate pe acest nivel anterior.
 Respectivul nivel a mai fost vizitat dar l-am abandonat dupa ce am pus o valoare
care a generat o solutie valida. Deci este posibil sa fi ramas aici valori neîncercate. Daca
nici pe acest nivel nu mai avem valori neîncercate mai facem un pas înapoi în stiva.
Mecanismul revenirilor a determinat denumirea de metoda backtracking.
 Probleme rezolvate
Metoda trierii
-suma cifrelor
-distanta maxima
Tehnica Greedy
-Suma elementelor maxime
-Rucsac
Backtracking
-Permutari
-Aranjamente
-Combinari
 Se consideră numerele naturale din mulţimea {0, 1, 2, …, n}. Elaboraţi un program care determină pentru
cîte numere K din această mulţime suma cifrelor fiecărui număr este egală cu
m.
În particular, pentru n=100 si m=2, în mulţimea{0, 1, 2, …, 100} există 3 numere care satisfac condiţiile
problemei: 2, 11 si 20.Prin urmare, K=3.
Program Triere; Procedure PrelucrareaSolutiei(i:Natural);BeginWriteln(‘i=’, i);
K:=k+1;
Type Natural=0..MaxInt;
End;
Var I, k, m, n : Natural; BeginWrite(‘Dati n=’);
Function SumaCifrelor(i:Natural): Natural; readln(n);
Write(‘Dati m=’);
Var suma: Natural; readln(m);
BeginSuma:=0; K:=0;
For i:=0 to n do If SolutiePosibila(i) then PrelucrareaSolutiei(i);
RepeatSuma:=suma+(I mod 10);
Writeln(‘K=’, K);
i:=i div 10; Readln;
until End.

i=0;
SumaCifrelor:=suma;
End;
Function SolutiePosibila(i:Natural):Boolean;
Begin
If SumaCifrelor(i)=mthen SolutiaPosibila:=trueElseSolutiePosibila:=false;
End;
 Se consideră mulţimea P={ P1, P2, …, Pn} formată din n puncte (2 ≤ n ≤30) pe un plan
Euclidian. Fiecare punct Pj este definit prin coordonatele sale Xj,Yj.Elaboraţi un program
care afişează la ecran coordonatele punctelor Pa, Pb distanţa dintre care este maximă.

Program Triere2;
Const nmax=30; PA:=A;
Type Punct = record PB:=B;
Dmax:=Distanta(A,B);
X, y: real; End;
End; End;
Begin
Indice = 1..nmax; Write(‘Dati n=’);
Var P:array[Indice] of Punct; readln(n);
Writeln(‘Dati coordonatele x, y ale punctelor’);
J, m, n:Indice; For j:=1 to n do
Dmax:real; Begin
Write(‘P[‘, j,’]: ‘);
PA, PA: Punct; readln(P[j].x, P[j].y);
Function Distanta(A, B: Punct): real; End;
Dmax:=0;
BeginDitanta:=sqrt(sqr(A.x-B.x)+sqr(A.y-B.y)); For j:=1 to n do
End; For m:=1 to n do
If SolutiePosibila(j, m) thenPrelucrareaSolutiei(P[j], P[m]);
Function SolutiePosibila(j, m:Indice):Boolean; Writeln(‘Solutia: PA=(‘, PA.x:5:2, ‘,’, PA.y:5:2, ‘)’);
Begin Wtieln(‘Solutia: PB=(‘, PB.x:5:2, ‘,’, PB.y:5:2, ’)’);
Readln;
If j<>m then SolutiePosibila:=true Else SolutiePosibila:=false; End.
End;
Procedure PrelucrareaSolutiei(A, B: Punct);
Begin
If Distanta(A,B)>dmax then
Begin
 Se consideră mulţimea
A = {a1, a2,…,ai, …, an}
elementele căreia sînt numerereale, iar cel puţin unul din ele satisface condiţia ai>0.
Elaboraţi un program care determină o submulţime
B, B∈A, astfel încît suma elementelor din B să fie maximă.

 Program P153;
 Const nmax=1000;
Procedure IncudeElementul (x:real);
 Var A : array [1..nmax] of real; Begin
 N : 1..nmax;B : array [1..nmax] of real; M:=m+1;
 M : 0..nmax; B[m]:=x;
 X : real; End;
Begin
 I : 1..nmax; Write(‘Dati n=’);
 Function ExistaElemente : Boolean; readln(n);
 Var i: integer; Writeln(‘Dati elementele multimii A:’);
 BeginExistaElemente:=false; For i:=1 to n do
read(a[i]);
 For i:=1 to n do If A[i]>0 then ExistaElemente:=true;
Writeln;
 End; M:=0;
 Procedure AlegeUnElement(var x:real); While ExistaElemente do
 Var i: integer; Begin
 BeginI:=1; AlegeUnElement (x);
IncludeElementul (x);
 While A[i]<=0 do i:=i+1;
End;
 X:=A[i]; Writeln(‘Elementele multimii B:’);
 A[i]:=0; For i:=1 to m do writeln(B[i]);
 End; Readln;
End.
 Rucsac Tehnica Greedy
Program Rucsac; For i:=1 to n do if x[i]=1 then CC:=CC+C[i];
Const max=10; If CC>=Cmax then
Var CMax, CC, GG: integer; Begin
CMax:=CC;
C, G, X, Iau: array [1..max] ofinteger; for i:=1 to n do Iau[i]:=x[i] end;End;
N, k, i: integer; Else
cont: Boolean; begin k:=k+1;
x[k]:=-1
Function PotContinua( k: integer): Boolean;
end;
Var i: 1..max; Else k:=k-1
Greut: integer; End;End;
Begin
BeginGreut:=0;
Write(‘n=’);
For i:=1 to k do if x[i[=1 then Greut:=Greut+G[i]; readln(n);
PotContinua:=Greut<=GGEnd; For i:=1 to n do
Procedure BackTrack; Begin
Write(‘C[‘,i,’]=’);
BeginK:=1; readln(C[i]);
x[k]:=-1; write(‘G[‘,i,’]=’); Readln(G[i]);
CMax:=0; End;
Write(‘GG=’);
While k>0 doBeginCont:=False;
readln(GG);
While (x[k]<1) and (not cont) doBegin x[k]:=x[k]+1; BackTrack;
cont:=PotContinua(k)End; Writeln(‘O sol. Cu cistig maxim:’);
For i:=1 to n do
If cont thenIf k=n then
if Iau[i]=1 then writeln(‘Se ia obiectul ‘,i);
Begin Writeln(‘Cistig = ‘,Cmax);
CC:=0; readln;
End.
 Backtracking permutari procedure valid (var ev:boolean; st:stiva; k:integer);
 program permutari;
var i:integer;
 type stiva=array[1..20] of integer; begin
ev:=true;
 var st:stiva;
for i:=1 to k-1 do if st[k]=st[i] then ev:=false
 n,k:integer; end;
function solutie (k:integer): boolean;
 as,ev:boolean;
begin
 procedure init (k:integer;var st:stiva); solutie:=(k=n)
end;
 begin
procedure tipar;
 st[k]:=0; var i:integer;
begin
 end;
for i:=1 to n do write (st[i]);
 procedure succesor (var as: boolean; var st: stiva; k:integer); writeln;
end;
 begin
Begin
 if st[k]<n then write ('n='); readln(n);
k:=1; init (k,st);
 begin
while (k>0) do
 st[k]:=st[k]+1; begin
repeat
 as:=true;
succesor (as, st, k);
 end if as then valid (ev,st,k);
until (not as) or (as and ev);
 else as:=false
if as then
 end; if solutie (k) then tipar
else begin
 procedure valid (var ev:boolean; st:stiva; k:integer);
k:=k+1;
 var i:integer; init (k,st)
end
 begin
else k:=k-1
 ev:=true; end
readln;
 for i:=1 to k-1 do if st[k]=st[i] then ev:=false
End.
 end;
 Backtracking aranjamente
program aranjamente;
type stiva=array[1..20] of integer; begin
var st:stiva; solutie:=(k=p)
n,k:integer; end;
procedure tipar;
as,ev:boolean; var i:integer;
procedure init (k:integer;var st:stiva); begin
begin for i:=1 to p do write (st[i]);
writeln;
st[k]:=0;
end;
end; Begin
procedure succesor (var as: boolean; var st: stiva; k:integer); write ('n='); readln(n); write('p=');readln(p);
k:=1; init (k,st);
begin
while (k>0) do
if st[k]<n then begin
begin repeat;
st[k]:=st[k]+1; succesor (as, st, k);
if as then valid (ev,st,k);
as:=true; until (not as) or (as and ev);
End; if as then
else as:=false; if solutie (k) then tipar
else
end;
begin
procedure valid (var ev:boolean; st:stiva; k:integer); k:=k+1;
var i:integer; init (k,st);
End;
begin
else k:=k-1;
ev:=true; End;
for i:=1 to k-1 do if st[k]=st[i] then ev:=false; readln;
end; End.
function solutie (k:integer): boolean;
Backtracking combinari
 program combinari;
 type stiva=array[1..20] of integer;
 var st:stiva;
function solutie (k:integer): boolean;
 n,k:integer; begin
solutie:=(k=p)
 as,ev:boolean;
end;
 procedure init (k:integer;var st:stiva); procedure tipar;
var i:integer;
 begin
begin
 st[k]:=0; for i:=1 to p do write (st[i]);
writeln;
 end; end;
 procedure succesor (var as: boolean; var st: stiva; k:integer); Begin
write ('n='); readln(n);write('p='); readln(p);
 begin k:=1; init (k,st);
 if st[k]<n-p+k then while (k>0) do
begin
 begin repeat
 st[k]:=st[k]+1; succesor (as, st, k);
if as then valid (ev,st,k);
 as:=true; until (not as) or (as and ev);
if as then
 end
if solutie (k) then tipar
 else as:=false else begin
k:=k+1;
 end; init (k,st)
 procedure valid (var ev:boolean; st:stiva; k:integer); end
else k:=k-1
 var i:integer; end
 begin readln;
End.
 ev:=true;
 for i:=1 to k-1 do if st[k]=st[i] then ev:=false
 if k>1 then st[k]<st[k-1] then ev:=false
 end;