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

METODE I TEHNICI CLASICE DE PROGRAMARE Material de predare partea I

Domeniul: Informatic Calificarea: Analist programator Nivel 3 avansat

2009

AUTOR: ROMANA SLJAN profesor grad didactic I

COORDONATOR: MARIANA VIOLETA CIOBANU - Profesor, grad didactic I, Colegiul Tehnic Media Bucureti

CONSULTAN: IOANA CRSTEA expert CNDIPT ZOICA VLDU expert CNDIPT ANGELA POPESCU expert CNDIPT DANA STROIE expert CNDIPT

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 20072013

Cuprins
I.Introducere.................................................................................................4 Documente necesare pentru activitatea de predare.....................................6 III. Resurse...................................................................................................7
Tema 1. Noiunea de recursivitate......................................................................7
Fia suport 1.1...................................................................................................................7 Tema 2. Recursivitate i iterativitate...............................................................................12 Fia suport 2.1 Algoritmi care implementeaz definiii recursive....................................12 Fia suport 2.2 Tipuri de algoritmi de traversare i inversare a unei structuri................15 Fia suport 2.3 Tipuri de algoritmi de divizare................................................................20 Fia suport 2.4 Tipuri de algoritmi recursivi cu revenire..................................................23 Fia suport 2.5 Algoritmi recursivi i iterativi...................................................................26

Tema 3. Avantajele i dezavantajele utilizrii recursivitii...............................29

Fia suport 3.1 Eliminarea recursivitii...........................................................................29

Tema 4. Tehnica de programare Divide et Impera........................................33

Fia suport 4.1 Descriere general ................................................................................33

Tema 5. Tehnica de programare Backtracking ................................................36

Fia suport 5.1 Descrierea tehnicii ................................................................................36 Fia suport 5.2 Backtracking recursiv.............................................................................43

Tema 6. Tehnica de programare Greedy ........................................................49

Fia suport 6.1 Descrierea tehnicii.................................................................................49

IV. Fia rezumat.........................................................................................55 V. Bibliografie.............................................................................................57

I.

Introducere

Materialele de predare reprezint o resurs suport pentru activitatea de predare, respectiv instrumente auxiliare care includ un mesaj sau o informaie didactic. Prezentul material de predare, se adreseaz cadrelor didactice care predau n cadrul colilor postliceale, domeniul Informatic, calificarea Analist programator. Modulul Tehnici clasice de programare cuprinde competenele din unitatea de competen tehnic specializat Utilizarea metodelor i tehnicilor clasice de programare din cadrul structurii programului pentru nivel 3 avansat. Coninuturile ce trebuie parcurse pentru a putea construi aceste competene, apar n programa modulului i sunt corelate cu Criteriile de Performan i Condiiile de Aplicabilitate din Standardul de Pregtire Profesional pentru unitile de competen corespunztoare modulului. Modulul Tehnici clasice de programare se studiaz n anul I i are o durat de 8 sptmni totaliznd un numar de 120 de ore din care 60 de teorie i 60 de laborator tehnologic. n primele dou sptmni se studiaz cte 12 ore pe sptmn (parte teoretic i practic) iar n restul de ase sptmni se studiaz cte 6 ore pe sptmn (parte teoretic si practic) n paralel cu modulul Baze de date. Astfel: n primele dou sptmni se studiaz 12 ore pe sptmn activiti teoretice, respectiv 12 ore laborator tehnologic, iar urmtoarele 6 sptmni se studiaz cte 6 ore activiti teoretice, respectiv 6 ore laborator n paralel cu activitile teoretice i aplicative din modulul Baze de date. Coninuturile au fost ntocmite corelnd Criteriile de Performan, precum i Condiiile de Aplicabilitate. Cadrele didactice au posibilitatea de a decide asupra numrului de ore alocat fiecrei teme, n funcie de dificultatea acesteia, de nivelul de cunotine anterioare ale grupului instruit, de complexitatea materialului didactic implicat n strategia didactic i ritmul de asimilare a cunotinelor, i de formare a deprinderilor, proprii grupului instruit. ntre competene i coninuturi exist o relaie bine determinat: atingerea competenelor implic coninuturile tematice, iar parcurgerea acestora asigur dobndirea de ctre elevi a competenelor dorite. Pentru construirea competenelor dorite, activitile de predare vor avea un caracter activ, interactiv , cu pondere sporit pe activitile practice (mai puin pe cele teoretice) i pe activitile ce privesc exersarea abilitilor cheie. Ordinea de parcurgere a temelor aferente coninuturilor din curriculum rmne la alegerea cadrelor didactice, cu condiia respectrii succesiunii logice n abordarea acestora.

Tabelul de corelare a competenelor cu temele i fiele suport corespunztoare coninuturilor

Competene Aplic principiile recursivitii i iterativitii n rezolvarea problemelor Utilizeaz

Teme Tema 1 Noiumea de recursivitate Tema 2 Recursivitate i iterativitate Tema 3 Avantajele i dezavantajele utilizrii recursivitii Tema 4 Tehnica de programare " Divide et Impera "

Fise suport Fia 1.1 Elementele recursivitii Fia 2.1 Tipuri de algoritmi recursivi

Fia 3.1 Eliminarea recursivitii Fia 4.1 Descrierea general Fia 4.2 Aplicaii practice

tehnicile clasice Tema 5 Tehnica de programare Backtracking de programare

Fia 5.1 Descrierea metodei Fia 5.2 Backtracking recursiv

Tema 6 Tehnica de programare Greedy

Fia 6.1 Descriera metodei

Absolvenii nivelului 3 avansat, coal postliceal, calificarea Analist programator , vor fi capabili s aplice principiile recursivitii i iterativitii n rezolvarea problemelor i s utilizeze tehnicile clasice de programare.

Documente necesare pentru activitatea de predare

Pentru predarea coninuturilor abordate n cadrul materialului de predare, cadrul didactic are obligaia de a studia urmtoarele documente: Standardul de Pregtire Profesional pentru calificarea Analist programator, nivelul 3 avansat www.tvet.ro, seciunea SPP sau www.edu.ro , seciunea nvmnt preuniversitar Curriculum pentru calificareaAnalist programator, nivelul 3 avansat www.tvet.ro, seciunea Curriculum sau www.edu.ro , seciunea nvmnt preuniversitar

Alte surse pot fi: Informatic. Metodica predrii informaticii i tehnologiei informaiei. Craiova. Editura Arves; Cri de specialitate; Reviste de specialitate; Ghiduri de redactare, de exemplu: Chelcea, Septimiu[1999].(2007). Cum s redactm. Bucureti. Editura: Comunicare.ro

III. Resurse
Tema 1. Noiunea de recursivitate
Fia suport 1.1
Noiunea de recursivitate este fundamental n informatic. Utilizarea frecvent a ei s-a fcut dup anii 80. Multe din limbajele de programare evoluate i mult utilizate Fortran, Cobol nu permiteau scrierea programelor recursive.

Definiie Procesul recursiv este procesul care, n timpul execuiei, genereaz apariia unor procese identice, aflate n legtur direct cu procesul ce le genereaz.Un proces poate fi descris printr- un subprogram. Aadar recursivitatea este un mecanism general de elaborare a programelor, care const n posibilitatea ca un subprogram s se autoapeleze. Recursivitatea a aparut din necesiti practice date de transcrierea direct a formulelor matematice recursive. n timp acest mecanism a fost extins, fiind utilizat n elaborarea multor algoritmi.

Sugestii metodologice Pentru predarea acestor coninuturi este necesar s se dea cteva exemple intuitive de procese recursive din realitatea cotidian. 1. O camer de luat vederi are n obiectiv un televizor care transmite imaginile primite de la camer. n televizor se va vedea un televizor, iar n acesta, un televizor,.a.m.d. Pe scurt, n orice telvizor se vede un televizor 2. n anumite localuri ntlnim anunul Azi nu se fumeaz. Cerem elevilor s gseasc exemple de procese recursive din mediul nconjurtor. Atunci cnd scriem un algoritm recursiv, este suficient s gndim exact ce se ntmpl la un anumit nivel, pentru c la orice nivel se ntmpl exact acelai lucru. Exemplele prezentate sunt procese recursive infinite, prezentnd un ir infinit de televizoare, respectiv anunul este perpetuu. Un algoritm recursiv corect trebuie s se termine, contrar programul se va termina cu eroare i nu vom primi rezultatul ateptat. Procesele descrise prin subprogram sunt procese finite. Condiia de terminare va fi pus de ctre programator. Elementele recursivitii sunt: Procesul care se repet; Motorul; Condiia de terminare. A nu se uita condiia de terminare, de oprire a autoapelului procesului.

Sugestii metodologice Se atrage atenia elevilor ca recursivitatea s fie definit corect. Prin urmare este obligatoriu s avem cazuri elementare care se pot rezolva direct, adic o condiie de oprire. O greeal frecvent este nclcarea acestui principiu. Se recomand identificarea acestor elemente in exemplele prezentate.

Care este mecanismul intern al limbajului care permite ca un algoritm recursiv s poat fi implementat? Pentru a putea implementa recursivitatea, se folosete structura de date numit stiv care nu este gestionat de programator, ci chiar de limbaj. O parte din memoria intern rezervat programului este alocat stivei ( segmentului de stiv). Un registru al microprocesorului reine n permanen adresa bazei stivei, altul adresa vrfului ei. La apelul unui subprogram care are x parametri efectivi, acetia se rein n stiv. Astfel, pentru parametrii transmii prin valoare se reine valoarea lor (din aceast cauz nu putem ntoarce valori utiliznd variabile transmise astfel- la revenire nu mai avem acces la stiv), iar pentru parametrii transmii prin referin se reine adresa lor (n stiv se rezerv spaiu pentru adres, iar coninutul va fi obinut prin utilizarea acesteia). Mecanismul prezentat mai sus poate fi generalizat cu uurint pentru obinerea recursivitaii. Atunci cnd o funcie se autoapeleaz se depun n stiv: valorile parametrilor transmii prin valoare; adresele parametrilor transmii prin referin; valorile tuturor variabilelor locale (declarate la nivelul procedurii sau funciei); adresa de revenire. Revenind la autoapel, s presupunem c funcia s-a autoapelat. Instruciunile rmn nemodificate. Funcia va lucra asupra datelor transmise pe stiv. n cazul unui nou autoapel, se creeaz un alt nivel pentru stiv, n care se depun noile valori. Odat ndeplinit condiia de terminare, urmeaz s se revin din autoapelri. Funcia care s-a autoapelat se reia de la instruciunea care urmeaz autoapelului. Ea va lucra cu variabilele (valorile) reinute pe stiv n momentul autoapelului, la care se adaug valorile returnate .

Sugestii metodologice Evocarea Elevii fac brainstorming individual in legatur cu noiunea de recursivitate i folosesc o modalitate de organizare grafic pentru a ilustra relaiile dintre idei (Ciorchinele iniial). n perechi, elevii coreleaz informaiile gsite i completeaz ciorchinele inceput de ei pe caiet. Profesorul adun informaiile (reprezentarea grafic a brainstormingului) i le trece pe tabl indiferent dac au legatur sau nu cu lecia. Se activizeaza cunotinele oferite de elevi pentru ai stimula s pun intrebri. 8

Reflexia Se ncearc provocarea la o discuie prin care elevii s exprime cu propriile lor cuvinte ideile i informaiile gsite n material. Se mobilizeaz elevii ntr-o discuie n care se ntlnesc mai multe modele de gndire pentru ca fiecare din ei s-i construiasc o schem personal de gndire pentru a aplica n practic ceea ce au nvat. Elevii care doresc citesc ceea ce au scris i argumenteaz de ce au ales acest acest mod de structurare a informaiilor pe recursivitate. Se completeaz ciorchinele de pe tabl pentru ca in final s avem un ciorchine revizuit, cu completrile i corectarea informaiilor. Se organizeaz informaiile i se fixeaz mai bine prin vizualizare.

Exemplificare S se calculeze n!, n natural. Pentru a scrie o functie recursiv prelum din matematic relaia:

1, n = 0 n! =fact(n)= n, N n * (n 1) !, a lt fe l
Pentru n=3, avem 3!=f(3)=3*f(2)=3*2*f(1)=3*2*1*f(0)= 3*2*1*1=6 Funcia recursiv fact transcrie in C++ definiia de mai sus. int fact(int n){ if(n==0) -condiie de terminare a apelului return 1; return n*fact(n-1); -apel recursiv } Observaie: tipul funciei trebuie s devin long pentru n>=8 ( 8!>32767 ). Funcionarea subprogramului de mai sus, pentru n=3 este: se apeleaz funcia fact pentru n=3; n este diferit de 0 i se apeleaz fact pentru n=2 (calculatorul va reine n stiva proprie valoarea 3, apoi, la apel, va creea un nou nivel pentru stiv n care depune valoarea 2); n este diferit de 0 i se apeleaz fact pentru n=1 (calculatorul va crea un nou nivel n care depune valoarea 1); n este diferit de 0 (n=1) se apeleaz fact pentru n=0 (calculatorul depune 0 n stiv); cum n este 0,fact va lua valoarea 1 i se revine din apel; n urma apelului trebuie nmulit 1 (valoarea gsit pe stiv la nivelul corespunztor) cu 1 (valoarea cu care s-a revenit din apel), rezultat 1 i se revine din apel; se face nmulirea cu 2 (valoarea gsit pe nivel) cu 1 (valoarea ntoars) rezultat 2 i se revine din apel;

 se nmulete 3 (valoarea gsit pe stiv) cu 2 (valoarea cu care s-a revenit, rezultatul este 6 i se revine din apel (de data asta revenirea se face n programul principal,ntrucat stiva este vid); valoarea returnata va fi 6. S observ c, n acest exemplu, calculele se efectueaz la revenirea din apel. Valorile au fost reinute n stiv, iar la revenire au fost folosite pentru nmulire.

Condiia de oprire Apelul recursiv al unei funcii trebuie s fie condiionat de o decizie care s mpiedice apelul n cascad ( la infinit ); aceasta ar duce la o eroare de program - depirea stivei. Un program recursiv poate fi exprimat: P=M(Ik,P) , unde M este mulimea ce conine instruciunile Ik i pe P insui. Exemplu: void p( ) { p(); } - funcie recursiv - apel infinit

Apelul funciei p() trebuie s fie condiionat n una din variantele: if(cond) p(); while(cond) p(); do p() while(cond). Verificarea i simularea programelor recursive Se face printr-o demonstraie formal, sau testnd toate cazurile posibile. Se verific nti dac toate cazurile particulare (ce se execut cnd se ndeplinete condiia de terminare a apelului recursiv) funcioneaz corect. Se face apoi o verificare formal a funciei recursive, pentru restul cazurilor, presupunnd c toate componentele din codul funciei funcioneaz corect. Verificarea este inductiv. Acesta e un avantaj al programelor recursive, ce permite demonstrarea corectitudinii lor simplu i clar.

Sugestii metodologice UNDE ? Coninutul poate fi predat n sala de clas cu un videoproiector, sau n laboratorul de informatic . CUM ?

10

Se recomand i folosirea unor secvene din leciile de recursivitate ale bibliotecii AEL pentru o mai bun nelegere a mecanismului recursiv, alturi de clasica tabl i creta alb, precum i un flipchart pentru realizrile elevilor cu propriile exemple. Clasa poate fi organizat frontal sau pe grupe de 3-4 elevi pentru gsirea unor exemple recursive cotidiene. Ca materiale suport se pot folosi:

Fia de documentare 4.1 : Subprograme, modulul 4. O prezentare multimedia care s cuprind urmtoarele noiuni: proces recursiv, motor, condiie de oprire. Activiti interactive, de genul urmator: conversaie, studiu de caz, tehnica ciorchinele.

Ca materiale de evaluare se pot folosi: probe practice i scrise, precum i planele - proiect realizate de elevi. De exemplu

Proiect realizat de elevii clasei a X a sub conducerea doamnei profesor Adriana Chere, prof. gr. II, Liceul Teoretic "Nicolae Blcescu", Cluj- Napoca

11

Tema 2. Recursivitate i iterativitate

Fia suport 2.1 Algoritmi care implementeaz definiii recursive.

Definiie O definiie recursiv este definiia n care un obiect se definete prin el insui. Definiia conine o condiie de terminare, indicnd modul de prsire a definiiei i o parte ce precizeaz definirea recursiv propriu-zis. Ca exemple: factorialul, algoritmul lui Euclid de aflare a celui mai mare divizor comun a dou numere date naturale, irul lui Fibonacci , calculul funciei Manna-Pnueli, funcia lui Ackermann, suma cifrelor unui numr natural, etc.

Definiie Se numete recursivitate liniar recursivitatea in care nu pot aprea pe ramuri diferite ale execuiei programului mai multe apeluri recursive, adic pe un anumit nivel apare doar un singur apel recursiv.

Exemplu 1. Se dau dou numere naturale a i b. Se cere s se calculeze cel mai mare divisor comun al lor folosind algoritmul lui Euclid. Pentru rezolvare, utilizm o definiie recursiv a celui mai mare divizor comun pentru dou numere naturale a i b.

a, a = b Cmmdc(a,b)= c m m d (ac b, b) ,a > b c m m d (ac, b a) ,a < b

Aceast formul este transmis n funcia recursiv cmmdc. #include <iostream.h> int cmmdc(int a,int b){ if (a==b) return a; else if(a>b) return cmmdc(a-b,b); else return cmmdc(a,b-a); } void main(){ int a,b; 12

cout<<"Introduceti numerele: "; cin>>a>>b; cout<<"cmmdc dintre "<<a<<" i "<<b<<" este "<<cmmdc(a,b); } Exemplu 2. Fie fib: N N. S se calculeze fib(n), pentru n natural.

1, n = 0 Fib(n)= 1, n = 1 in rest fib(n 1) + fib(n 2)

#include<iostream.h> Int n ; int fib(int n) { if(n==0 || n==1) return 1; else return fib(n-1)+fib(n-2); } void main(){ cout<<n= ; cin>>n; cout<<fib(n); } Ce se ntmpl dac n este relativ mare ( n=100) ? Dar foarte mare? Exemplu 3. Calculul funciei Manna-Pnueli pentru un x intreg.:

=2 x 1, x. > 1 F(x)= F ( F ( x + 2) , x < 1 2

Transpunem formula ntr-o funcie recursiv: # include <iostream.h> Int manna(int x) { if(x>=12) return x-1; else return manna(manna(x+2)); } void main() { int x; cout<<n=; cin >>n; cout<<mana(x); } 13

Exemplu 4. Se d funcia lui Ackermann, definit mai jos. Se citesc numerele m i n naturale. S se calculeze Ack(m,n).

n + 1, m = 0 Ack(m,n)= A c k (m 1,1),n = 0 A ck (m, n 1) ),a ltfe l (m 1, A c k

Ce se ntmpl pentru valori mici ale lui m i n ? De exemplu, Ack(4,4). ncercai.. Exemplu 5. S se calculeze recursiv suma cifrelor unui numr natural. Indicatie: Se izoleaz ultima cifr, iar lui n i se atribuie ctul ntreg dintre vechea valoare i 10. Astfel gsim o relaie de recuren, necesar elaborrii variantei recursive:

0, n = 0 S(n)= n%1 0+ S (n / 1 0) ,a l t f e l
Avem programul: #include <iostream.h> int suma(long n){ if (n<10) return n; else return n%10+suma(n/10); } void main(){ int n; cout<<"n="; cin>>n; cout<<"suma cifrelor este "<<suma(n); }

Sugestii metodologice UNDE ? Coninutul poate fi predat doar n laboratorul de informatic, indicat fiecare elev s aiba locul lui la calculator. CUM ? Se recomand utilizarea calculatoarelor pentru activitile de fixare a noilor cunotine i verificarea funcionrii programelor. Se va folosi i fereastra watch de urmrire a valorii variabilelor n timpul execuiei programului. Clasa poate fi organizat frontal sau pe grupe de 3-4 elevi, avnd n vedere i elevii cu nevoi speciale, pentru care se vor alege aplicatii mai accesibile, sau din contr cu un nivel mai ridicat de dificultate.. Se vor alege ntrebri bine alese cu scopul clar de a diferenia tipurile de autoapeluri la un nivel i de a contoriza numrul de autoapelri. 14

Ca materiale suport se pot folosi i lecii din biblioteca AEL cu reprezentri grafice ale funcionrii stivei precum NetSuport School pentru prezentarea unor grafice ale profesorului, respectiv elevilor.

Urmrirea raionamentului i a implementrii este punct de plecare pentru probele de evaluare scrise sau practice.

Tema 2. Recursivitate i iterativitate

Fia suport 2.2 Tipuri de algoritmi de traversare i inversare a unei structuri

Traversarea i inversarea unei structuri inseamn efectuarea unor operaii oarecare asupra tuturor elementelor unei structuri n ordine direct, respectiv n ordine invers. Variantele recursive snt mai elegante i concise, dect alte metode. Se pot aplica structurilor de tip tablou, list, fiier i pot fi o soluie pentru diverse probleme (transformarea unui ntreg dintr-o baz n alta, etc). ntr-o form general, algoritmii se pot scrie: funcie traversare(tip_element element) { dac( element <> ultimul_din_structura) atunci traversare(element_urmator) prelucrare(element); } funcie inversare (tip_element element) { daca( element <> ultimul_din_structura) atunci traversare(element_urmator); prelucrare(element) }

Apelul iniial al procedurii se face cu primul element al structurii. De observat importana ca parametrul formal al celor dou funcii s fie de tip valoare, pentru a nu fi alterat de apelul recursiv.

15

Exemplu 1: Se citesc i se afiseaz elementele ntregi ale unui vector. Cele dou funcii recursive, pentru citire i afiare pot ncepe cu ultimul element din vector i se termin cu primul. #include <iostream.h> int n,a[100]; void citeste(int i) {if (i!=n-1) citeste(i+1); cout<<i<< ; cin>>a[i];} void scrie(int i) {if (i!=n-1) scrie(i+1); cout<<a[i]<< ;} void main() {cout<<n=; cin>>n; citeste(n-1); scrie(n-1);} Exemplul 2. S se verifice dac exist ntr-un vector cu n elemente ntregi, cel puin un element cu valoarea intreag x. Fie vectorul a=(a1,a2,...,an). Funcia iterativ gasit(x,i) este definit astfel.

, a c ax ( a 1a, 2 ,..., an) tr u e d gasit(x,i)= f a ls ,ed a c ax ( a 1a, 2 ,..., an)

Se obsrev c funcia gasit are valoarea true fie dac elementul curent are valoarea x, fie dac cel puin unul din elementele anterior testate are valoarea x. Funcia recursiv poate fi definit n dou moduri: Varianta 1- se evalueaz funcia gasit(x,n-1): #include <iostream.h> int a[100]; int gasit(int x, int i) {if(i = = 0) return x = = a[0]; else return ((x = = a[i]) || gasit(x,i-1));} void main() {int x,i,n; cout<<n= ; cin>>x; cout<<x= ; cin>>x; for(i=0;i<n;i++) {cout<<a[<<i<<]=; cin>>a[i];} if(gasit(x,n-1)) cout<<s-a gasit elementul<<x; else cout<<nu s-a gasit elementul<<x;} 16

Varianta 2- se evalueaz funcia gasit(x,0): #include <iostream.h> int a[100]; int gasit(int x, int i) {if(i = = n-1) return x = = a[n-1]; else return ((x = = a[i]) || gasit(x,i+1));} void main() {int x,i,n; cout<<n= ; cin>>x; cout<<x= ; cin>>x; for(i=0;i<n;i++) {cout<<a[<<i<<]=; cin>>a[i];} if(gasit(x,0)) cout<<s-a gasit elementul<<x; else cout<<nu s-a gasit elementul<<x;} Varianta 3 pentru a se opri autoapelul dac deja s-a gsit un element cu valoarea x , vom proceda astfel. #include <iostream.h> int a[100]; int gasit(int x, int i) {if(i > n) return 0]; else return (x = = a[i]) return 1 ; else return gasit(x,i+1);} void main() {int x,i,n; cout<<n= ; cin>>x; cout<<x= ; cin>>x; for(i=0;i<n;i++) {cout<<a[<<i<<]=; cin>>a[i];} if(gasit(x,0)) cout<<s-a gasit elementul<<x; else cout<<nu s-a gasit elementul<<x;} Exemplul 3. S se verifice dac exist , ntr-un vector cu elemente intregi , cel puin un element pozitiv. Avem i aici trei variante ca i n exemplul 2, alegem spre prezentare varianta cea mai eficient. #include <iostream.h> 17

int a[100],n; int pozitiv(int i) {if(i<=n) return 0; else if (a[i]>0) return 1; else return pozitiv(i+1);} void main() {int i; count<<n= ; cin>>n; for(i=0;i<n;i++) {cout<<a[<<i<<]=; cin>>a[i];} if(pozitiv(0)) cout<<s-a gasit cel putin un element pozitiv; else cout<<nu s-a gasit nici un element pozitiv;} Exemplul 4. Se d un tablou bidimensional cu n linii i m coloane numere ntregi i se cere suma elementelor pare din matrice. #include <iostream.h> int suma(int i, int j, int m, int a[][20]) {if (i = = 0 && j = = 0) if (a[0][0]%2==0) return a[0][0]; else return 0; else if (a[i][j]%2==0) if (j==0) return a[i][j]+suma(i-1,m-1,m,a); else return a[i][j]+suma(i,j-1,m,a); else if(j==0) return suma(i-1,m-1,m,a); else return suma(i,j-1,m,a);} void citeste (int a[][20], int &n, int &m) {int i,j; cout<<n=; cin>>n; cout<<m=; cin>>m for(i=0;i<n;i++) for(j=0;j<m;j++) {cout<<a(<<i+1<<,<<j+1<<)= ; cin>>a[i][j];}} void main() {int n,m,a[20][20]; citeste(a,n,m); cout<<suma este<<suma(n-1,m-1,m,a)<<endl;}

Sugestii metodologice 18

UNDE ? Coninutul poate fi predat n sala de clas, dar se recomand laboratorul de informatic. CUM ? Se recomand utilizarea calculatoarelor pentru activitile de fixare a noilor cunotine i verificarea funcionrii programelor. Se va folosi i fereastra watch de urmrire a valorii variabilelor n timpul execuiei programului. Clasa poate fi organizat frontal sau pe grupe de 3-4 elevi, avnd n vedere i elevii cu nevoi speciale, pentru care se vor alege aplicatii mai accesibile, sau din contr cu un nivel mai ridicat de dificultate.. Se vor alege ntrebri bine alese cu scopul clar de a diferenia tipurile de autoapeluri la un nivel i de a contoriza numrul de autoapelri. Realizai o relaie bun cu elevii, mai ales cu cei care necesit nevoi speciale. Stabilii de comun acord o strategie pentru ca elevul s poat face fa situaiei respective . Ca materiale suport se pot folosi i lecii din biblioteca AEL cu reprezentri grafice ale funcionrii stivei precum i NetSuport School pentru prezentarea unor grafice ale profesorului, respectiv elevilor.

Urmrirea raionamentului i a implementrii este punct de plecare pentru probele de evaluare scrise sau practice. .

19

Tema 2. Recursivitate i iterativitate

Fia suport 2.3 Tipuri de algoritmi de divizare.

Definiie Tehnica divizarii ("divide and conquer" sau divide et impera), este fundamental n elaborarea algoritmilor i const n descompunerea unei probleme complexe n mai multe subprobleme a cror rezolvare e mai simpl i din soluiile crora se poate determina soluia problemei iniiale (exemple: gsirea minimului i maximului valorilor elementelor unui tablou, cutarea binar, sortare Quicksort, turnurile din Hanoi). Un algoritm de divizare general s-ar putea scrie: void rezolv(problema x){ if (x se imparte in subprobleme){ imparim pe x in pri x1,...,xk rezolv(x1); rezolv(xk); } else }

Exemplul 1. Se citete un vector cu n componente numere naturale. S se tipreasc valoarea maxim din vector. Problema se rezolv eficient cu metodele cunoscute , dar poate fi folosit ca un exemplu i pentru tehnica recursiv. 20

Se procedeaz astfel: dac(i==j) maxim va fi v[i]; altfel se mparte vectorul in doi vectori , primul cu componente de la i la (i+j)/2 ; al doilea cu componente de la (i+j)/2+1 pna la j; se rezolv subproblemele, iar soluia va fi dat de maximul dintre cele dou subprobleme.

#include <iostream.h> int v[10],n; int max(int i, int j) { int a, b; if (i==j) return v[i]; else { a=max(i,(i+j)/2); b=max((i+j)/2+1,j); if(a>b)return a; else return b;}} void main() {cout<<n=; cin>>n; for(int i=1;i<=n;i++) {cout<<v[<<i<<]=; cin>>v[i];} cout<<max=<<max(1,n); } Exemplul 2. Cutarea binar. Se citete un vector cu n componente numere ntregi ,unde numerele se presupun ordonate cresctor i o valoare intreag nr. S se decid dac nr se gsete sau nu printre numerele citite, iar in caz afirmativ s se tipreasc indicele componentei care conine acea valoare.

Indicaie: Problema este de a decide dac valoarea cutat se gsete printre numerele de indice cuprins ntre i i j (iniial i=1 , j=n). Procedm astfel: dac nr coincide cu valoarea de indice (i+j)/2 ( mijloc ) se tiprete indicele i se revine din apel; contrar, dac i<j (nu s-a cutat peste tot) problema se descompune astfel: Dac numrul este mai mic dect valoarea testat (din mijloc), inseamn c avem anse s-l gsim ntre componentele cu indicele cuprins ntre i i (i+j)/2-1, caz in care reapelam funcia cu aceti parametri. Dac numrul este mai mare dect valoarea testat (din mijloc), inseamn c avem anse s-l gsim ntre componentele cu indicele cuprins ntre (i+j)/2+1 i j, caz n care reapelm funcia cu aceti parametri. Problema nu se descompune in alte subprobleme ci se reduce la o subproblem. #include <iostream.h> int v[100],n,nr; 21

void caut(int i,int j) {if (nr==v[(i+j)/2] cout<<gasit<< <<indice <<(i+j)/2; else if(i<j) if (nr<v[(i+j)/2]) caut (I,(i+j)/2-1); else caut ((i+j)/2+1,j); }} void main() {cout<<n=; cin>>n; for(int i=1;i<=n;i++) {cout<<v[<<i<<]; cin>>v[i];} cout<<nr=; cin>>nr; caut(1,n);} Sugestii metodologice UNDE ? Coninutul poate fi predat n sala de clas, dar se recomand laboratorul de informatic. CUM ? Se recomand utilizarea calculatoarelor pentru activitile de fixare a noilor cunotine i verificarea funcionrii programelor. Se va folosi i fereastra watch de urmrire a valorii variabilelor n timpul execuiei programului. Clasa poate fi organizat frontal sau pe grupe de 3-4 elevi, avnd n vedere i elevii cu nevoi speciale, pentru care se vor alege aplicatii mai accesibile, sau din contr cu un nivel mai ridicat de dificultate.. Pentru antrenarea elevilor cu nevoi speciale: Folosii laudele ct de mult putei n ceea ce privete activitatea elevilor , atitudinea lor i modul n care i-au mbuntit comportamentul ;gndii-v la anumite modaliti de rsplat care i-ar putea motiva pe elevi . Analizai curriculumul, modul n care acesta este predat i dac elevii l consider interesant sau motivant. Folosii o varietate de activiti, inclusiv pentru cele care implic utilizarea calculatorului. Deseori elevii se implic atunci cnd lucreaz cu programe intractive i le face plcere cnd nva ceva nou.. Distribuii elevii n grupuri cu ali elevi care i vor motiva i sprijini. Ca materiale suport se pot folosi lecii din biblioteca AEL cu reprezentri grafice ale funcionrii stivei, precum i NetSuport School pentru prezentarea unor grafice ale profesorului, respectiv elevilor.

Urmrirea raionamentului i a implementrii este punct de plecare pentru probele de evaluare scrise sau practice. 22

Tema 2. Recursivitate i iterativitate

Fia suport 2.4 Tipuri de algoritmi recursivi cu revenire

Definiie Algoritmii cu revenire (algoritmi de tip backtracking) se aplic problemelor n care soluia se poate reprezenta sub forma unui vector x=(x1,x2,...xn) cu S=S1 x S2 x...x Sn, unde mulimile Si sunt finite, S numindu-se spatiul soluiilor posibile. n particular, Si sunt identice avind acelai numr M de elemente. Pentru fiecare problem concret sunt date anumite relaii ntre componentele vectorului x, numite condiii interne. Determinarea tuturor soluiilor rezultat se poate face genernd toate soluiile posibile i verificnd apoi dac satisfac condiiile interne. Dar timpul de calcul ar fi foarte mare (daca mulimile Si ar avea numai cite 2 elemente, timpul ar fi proporional cu 2n). Metoda backtracking urmrete evitarea generrii tuturor soluiilor posible. Elementele vectorului x primesc valori pe rnd, lui xi i se atribuie valori, doar dac x 1,x2,...,xi-1 au primit deja valori, valorile atribuite trebuind s verifice condiiile de continuitate referitoare la x1,x2,...,xi. Doar apoi se trece la calculul lui xi+1. n cazul nendeplinirii condiiilor de continuitate, se alege urmtoarea valoare posibil pentru x i. Dac Si a fost epuizat, se micoreaz i, ncercnd o alt alegere pentru xi-1. Pe acest metod se bazeaz rezolvarea unor probleme clasice ca: permutri de n, "opt regine", partiii, a "relaiilor stabile", colorarea unei hrti, tierea unui fir de lungime l n pri de lungimi date, etc. Metoda backtracking poate fi implementat att iterativ ct i recursiv. . Se consider rutina general recursiv back cu un parametru p, care reprezint nivelul stivei. Contorul i al ciclului for ia pe rnd toate valorile posibile fiecrui nivel. Se obine soluie cnd stiva este complet. void back(int p) 23

{int i; for(i=1;i<=n;i++) {st[p]=i; if valid(p) if(p==n) tipar (p) else back(p+1); } } Exemplul 1. S se calculeze recursiv permutri de n, n natural citit de la tastatur. #include <iostream.h> #include <math.h> int t[20],n; void tipar() {for(int i=1;i<=n;i++) cout<<t[i]; cout<<endl;} void perm(int k) {int I,j,corect; if (k==n+1)tipar(); else {for(i=t[k]+1;i<=n;i++) { t[k]=i; corect=1; for(j=1;j<=k-1;j++) if(t[j]==t[k] ) corect=0; if (corect)perm(k+1);}} t[k]=0;} void main() {cout<<n=; cin>>n; perm(1);} Exemplul 2. Se dau n dame pe o tabl de ah de dimensiune n*n. S se afieze toate soluiile posibile de aranjare a celor n dame pe tabl astfel inct s nu se atace. Indicaie Metoda de rezolvare seaman cu rezolvarea permutrilor doar c n condiia de validare se adaug condiia ca damele s nu se atace. Se poate folosi urmatoarea procedur back: void dame(int k) {int I,j,corect; if (k==n+1)tipar(); else {for(i=t[k]+1;i<=n;i++) { t[k]=i; corect=1; 24

for(j=1;j<=k-1;j++) if(t[j]==t[k] || abs(t[k]-t[j])==(k-j)) corect=0; if (corect)dame(k+1);}} t[k]=0;} Exemplul 3. Generarea partiiilor unui numr natural . Se citete n natural , s se tipreasc toate modurile de descompunere a lui ca sum de n numere naturale. #include <iostream.h> #include <math.h> int s[20],n; void tipar(int k) {for(int i=1;i<=k;i++) cout<<s[i]; cout<<endl;} void part(int k, int v) {int i; s[k]=v; tipar(k); for(i=1;i<=s[k]-1;i++) {s[k]=s[k]-i; part(k+1,i); s[k]=s[k]+i;}} void main() {cout<<n=; cin>>n; part(1,n);}

Sugestii metodologice UNDE ? Coninutul poate fi predat n sala de clasa, dar se recomand laboratorul de informatic. CUM ? Se recomand utilizarea calculatoarelor pentru activitile de fixare a noilor cunotine i verificarea funcionrii programelor. Se va folosi i fereastra watch de urmrire a valorii variabilelor n timpul execuiei programului. Clasa poate fi organizat frontal sau pe grupe de 3-4 elevi, avnd n vedere i elevii cu nevoi speciale, pentru care se vor alege aplicatii mai accesibile, sau din contr cu un nivel mai ridicat de dificultate.. Se vor alege ntrebri bine alese cu scopul clar de a diferenia tipurile de autoapeluri la un nivel i de a contoriza numrul de autoapelri. Se va urmri evidenierea greelilor tipice n elaborarea algoritmilor. Ca materiale suport se pot folosi i lecii din biblioteca AEL cu reprezentri grafice ale funcionrii stivei precum NetSuport School pentru prezentarea unor grafice ale profesorului, respectiv elevilor. 25

Urmrirea raionamentului i a implementrii este punct de plecare pentru probele de evaluare scrise sau practice.

Tema 2. Recursivitate i iterativitate

Fia suport 2.5 Algoritmi recursivi i iterativi

Axiom S-a demonstrat matematic c orice algoritm recursiv poate fi scris i iterativ, i reciproc.

Folosind fia suport 2.1 se vor rescrie algoritmii recursivi prezentai acolo, n mod iterativ. Exemplu 1. Se dau dou numere naturale a i b.Se cere s se calculeze cel mai mare divizor comun al lor folosind algoritmul lui Euclid. Pentru rezolvare, utilizm o definiie recursiv a celui mai mare divizor comun pentru dou numere naturale a i b.

a, a = b Cmmdc(a,b)= c m m d (ac b, b) ,a > b c m m d (ac, b a) ,a < b

#include <iostream.h> void main() {cout<<a=; cin>>a; cout<<b=; 26

cin>>b; while(a!=b) if(a>b) a=a-b; else b=b-a; cout<<cmmdc=<<a;} Exemplu 2. Fie fib: N N. S se calculeze fib(n), pentru n natural.

1, n = 0 Fib(n)= 1, n = 1 in rest fib(n 1) + fib(n 2)

#include <iostream.h> void main() {int n,f0=1,f1=1,f2; cout<<n=; cin>>n; if(!n) cout<<f0; else if (n==1) cout<<f1; else {for (int i=2;i<=n;i++)26 {f2=f0+f1; f0=f1; f1=f2;} cout<<f2;} Exemplu 3. Calculul funciei Manna-Pnueli pentru un x intreg.:

=2 x 1, x. > 1 F(x)= F ( F ( x + 2) , x < 1 2

#include <iostream.h> int st[100],n,k; main() {cout<<n=; cin>>n; k=1; st[1]=n; while (k>0) if(st[k]<12) {k++; 27

st[k]=st[k-1]+2;} else {k--; if(k>0)st[k]=st[k+1]-1;} cout<<n=[1]-1;} Exemplu 4. Se d funcia lui Ackermann, definit mai jos. Se citesc numerele m i n naturale. S se calculeze Ack(m,n).

n + 1, m = 0 Ack(m,n)= A c k (m 1,1),n = 0 A ck (m, n 1) ),a ltfe l (m 1, A c k

#include <iostream.h> int st[10000][2]; void main() {int m,n,k; cout<<m=; cin>>m; cout<<n=; cin>>n; k=1; st[k][0]=m; st[k][1]=n; while(k>0) if(st[k][0] && st[k][1]) { k++; st[k][0]=st[k-a][0]; st[k][1]=st[k-1][1]-1; }else if(!st[k][1]) { st[k][0]= st[k][0]-1; st[k][1]=1;} else k--; if(k>0) { st[k][0]= st[k][0]-1; st[k][1]= st[k+1][1]+1;}} cout<<ac(<<,<<n<<)=<<st[1][1]+1;} Exemplu 5. S se calculeze recursiv suma cifrelor unui numr natural. #include <iostream.h> void main() {int n,s=0; cout<<n=; cin>>n; while(n) {s+=n%10; n/=10;} cout<<s=<<s;}

Sugestii metodologice 28

UNDE ? Coninutul poate fi predat n sala de clasa, dar se recomand laboratorul de informatic. CUM ? Se recomand utilizarea calculatoarelor pentru activitile de fixare a noilor cunotine i verificarea funcionrii programelor. Se va folosi i fereastra watch de urmrire a valorii variabilelor n timpul execuiei programului. Clasa poate fi organizat frontal sau pe grupe de 3-4 elevi, avnd n vedere i elevii cu nevoi speciale, pentru care se vor alege aplicatii mai accesibile, sau din contr cu un nivel mai ridicat de dificultate.. Se vor alege ntrebri bine alese cu scopul clar de a diferenia tipurile de autoapeluri la un nivel i de a contoriza numrul de autoapelri. Se va urmri:

testarea i analizarea comportamentului programelor pentru diferite date de intrare; ncurajarea discuiilor purtate ntre elevi, exprimarea i ascultarea prerilor fiecruia.

Ca materiale suport se pot folosi i lecii din biblioteca AEL cu reprezentri grafice ale funcionrii stivei precum NetSuport School pentru prezentarea unor grafice ale profesorului, respectiv elevilor.

Urmrirea raionamentului i a implementrii este punct de plecare pentru probele de evaluare scrise sau practice.

Tema 3. Avantajele i dezavantajele utilizrii recursivitii

Fia suport 3.1 Eliminarea recursivitii

Definiie Orice program recursiv poate fi transformat n unul iterativ, s-a demonstrat matematic acest lucru. Algoritmul iterativ poate deveni ns, mai complicat i mai greu de neles. De multe ori, soluia unei probleme poate fi elaborat mult mai uor, mai clar i mai simplu de verificat, printr-un algoritm recursiv. Pentru implementare, poate fi necesar transformarea algoritmului recursiv n unul nerecursiv, n situaiile: soluia problemei trebuie scris ntr-un limbaj nerecursiv; un caz particular sunt compilatoarele ce "traduc" un program recursiv dintr-un limbaj de nivel inalt n cod main (nerecursiv) varianta recursiv ar duce la o vitez de execuie i spaiu de memorie prea mari, transformarea n una nerecursiv, eliminnd dezavantajele. Se va prezenta una din metodele de eliminare a recursivitii ce folosete o structur de date de tip stiv. n scrierea unei variante nerecursive, trebuie parcuri toi paii implicai n varianta recursiv, prin tehnici nerecursive. Recursivitatea implic folosirea cel puin a unei stive. La fiecare apel recursiv sunt depuse in stiv date, care sunt extrase la revenirea din acel apel. E simplu 29

dac datele pentru un apel se organizeaz ntr-o structur, un apel nsemnnd introducerea in stiv a unei structuri, revenirea, extragerea structurii. Exemplu 1 S comparm n continuare soluia recursiv i cea iterativ pentru o problem celebr: Cte perechi de iepuri se pot obine n n luni dintr-o singur pereche tiind c: - la momentul iniial, iepurii din prima pereche sunt nou-nscui; - fiecare nou pereche de iepuri devine fertil dup o lun; - fiecare pereche produce o pereche de descendeni n fiecare lun; - nici un iepure nu moare. Numrul perechilor de iepuri din fiecare lun este descris de irul: Luna Nr. perechi 0 1 1 1 2 2 3 3 4 5 5 8 6 1 3 7 2 1 8 3 4 .

Notm cu U(n) numrul perechilor din luna n. Atunci avem: U(n) = 1, 1, U(n-1)+U(n-2), n=0 n=1 n>=2

Acest ir este chiar irul lui Fibonacci. Algoritmul recursiv decurge astfel: pentru calculul lui fib(n) sunt calculai fib(n-1) i fib(n2), ai cror parametri sunt depui pe stiv. De exemplu, pentru a calcula fib(10) se calculeaz fib(9) i fib(8); fib(9) ca sum de fib(8) i fib(7), dup care se calculeaz fib(8) nc o dat. S ne imaginm, pentru fib(800), de cte ori se calculeaz fib(3) ! Deoarece metoda implic determinarea, cu salvrile pe stiv aferente, a acelorai valori n mod repetat, este de preferat, evident, varianta iterativ, mult mai natural n aceast situaie.

Din aplicaile prezentate in fiele 2.1 i 2.5 se observ diferenele dintre cele dou metode de rezolvare astfel: Avantajul recursivitii const n faptul c soluile recursive sunt mult mai clare , mai scurte i mai uor de urmrit, deci mult mai elegante. Ele sunt mult mai avantajoase dect cele iterative dac: Soluiile problemei sunt definite recursiv; Cerinele problemei sunt formulate recursiv. n unele cazuri este foarte greu de definit o soluie iterativ , cum este cazul algoritmilor n care o funcie recursiv apeleaz o alt funcie recursiv care depinde de prima funcie (recursivitate indirect) i atunci n mod obligatoriu este preferabil algoritmul recursiv. Exemplu 2 Se consider irurile definite recurent astel: A0=a; b0=b; a,b>0: a + bn 1 a n = n 1 , bn = a n 1bn 1 2 30

S se scrie un program care s citeasc a,b i n i s se calculeze an i bn. #include <iostream.h> #include <math.h> double a,b; int n; double bn(int n); double an(int n) {if (!n)return a; else return (an(n-1)+bn(n-1))/2;} double bn(int n) {if (!n) return b; else return sqrt(an(n-1)*bn(n-1)); } void main() {cout<<a=; cin>>a; cout<<b=; cin>>b; cout<<n; cin>>n; cout<<an(n)<< <<bn(n);} Totui , fiecare apel al unui suprogram recursiv inseamn nc o zon de memorie rezervat pentru execuia subprogramului ( variabilele locale i instruciunile). Pentru o adncime mare a recursivitii, algoritmii recursivi nu mai sunt eficieni deoarece timpul de execuie crete din cauza timpilor necesari pentru mecanismul de apel i pentru administrarea stivei de sistem. Apare posibilitatea unei erori datorit depirii memoriei alocate de compilator pentru stiv. Vezi funcia Ackermann pentru valori mici i funcia Fibonacci pentru valori ale lui n foarte mari.

Este indicat s se argumenteze bine care metod este aleas pentru rezolvarea unei probleme.

Sugestii metodologice UNDE ? Locul de desfurare a instruirii se recomand a fi un laborator de informatic n care pentru optimizarea demersului didactic - este necesar s existe o dotare minimal care presupune un numr de calculatoare egal cu numrul elevilor din clas, conectate n reea i cu acces la toate serviciile INTERNET. Configuraia calculatoarelor trebuie s permit rularea aplicaiilor prin care vor fi formate competenele specifice. CUM ? Se recomand utilizarea calculatoarelor pentru activitile de fixare a noilor cunotine i verificarea funcionrii programelor. Se va folosi i fereastra watch de urmrire a valorii variabilelor n timpul execuiei programului. 31

n strategia didactic propunem folosirea metodelor active de nvare, cum sunt: explicaia n etapa de comunicare; nvarea prin descoperire dirijat, inductiv, experimental; conversaia de consolidare n etapa de fixare a cunotintelor, problematizarea.

discuii despre activiti cotidiene i modelarea acestora sub forma unei secvene bine definite de pai; citirea atent a enunului unei probleme; combinarea unor prelucrri elementare pentru obinerea anumitor prelucrri complexe n funcie de scopul propus; explicarea conceptelor referitoare la subprograme recursive; descompunerea rezolvrii unei probleme n subprobleme; identificarea unor situaii n care alegerea unui algoritm prezint avantaje n raport cu altul; exersarea crerii i aplicrii programelor pentru rezolvarea unor probleme ntlnite de elevi n studiul altor discipline colare;

Clasa poate fi organizat frontal sau pe grupe de 3-4 elevi, avnd n vedere i elevii cu nevoi speciale, pentru care se vor alege aplicatii mai accesibile, sau din contr cu un nivel mai ridicat de dificultate.. Ca materiale suport se pot folosi i lecii din biblioteca AEL cu reprezentri grafice ale funcionrii stivei precum NetSuport School pentru prezentarea unor grafice ale profesorului, respectiv elevilor.

Urmrirea raionamentului i a implementrii este punct de plecare pentru probele de evaluare scrise sau practice.

32

Tema 4. Tehnica de programare Divide et Impera

Fia suport 4.1 Descriere general
Divide et impera este o tehnic special prin care se pot rezolva anumite probleme. Expresia provine din latin unde exista i este celebr: Divide et impera . n romn este mai cunoscut ca: dezbin i stpnete. Expresia este atribuit lui Filip al II-lea, rege al Macedoniei (382-336 .C.), descriind politica sa mpotriva oraelor-state greceti. Divide et Impera, ca tehnic de programare, se bazeaz pe un principiu asemnator celui din viaa politic i social, scopul fiind ns total diferit.

Tehnica Divide et Impera const n dou etape: Divide. Problema dat este mprit n dou sau mai multe subprobleme de acelai tip, dar de dimensiuni mai mici. Subproblemele se rezolv direct, dac dimensiunea lor permite aceasta (cazuri elementare), sau, fiind de acelai tip, se rezolv n mod recursiv, prin acelai procedeu. Impera. Se combin soluiile subproblemelor pentru a obine soluia problemei iniiale. 33

Restricii Metoda Divide Et Impera se poate aplica n rezolvarea unei probleme care ndeplinete urmtoarele condiii : - se poate descompune n ( dou sau mai multe) suprobleme ; - aceste subprobleme sunt independente una fa de alta (o subproblem nu se rezolv pe baza alteia i nu se folosete de rezultatele celeilalte); - aceste subprobleme sunt similare cu problema iniial; - la rndul lor subproblemele se pot descompune (dac este necesar) n alte subprobleme mai simple; - aceste subprobleme simple se pot soluiona imediat prin algoritmul simplificat. Evident nu toate problemele pot fi rezolvate prin utilizarea acestei tehnici. Fr team de a grei, putem afirma c numrul lor este relativ mic, tocmai datorit restriciilor de mai sus.

Pentru a intui funcionarea algoritmului lum ca exemplu un turneu de tenis. Participanii sunt mprii n dou grupe- se organizeaz turneul n cadrul fiecrei grupe, iar finala se va disputa ntre cei doi ctigtori ai turneului pe grupe. Ctigtorul finalei este ctigtorul ntregului turneu. Organizarea turneului pe grupe se face dup acelai procedeu: se mpart concurenii din cadrul grupei pe semigrupe, se organizeaz turneul pe semigrupe, iar ctigtorul grupei se decide ntr-un meci de semifinal ntre cei doi ctigtori din cele dou semigrupe .a.m.d. mprirea se repet pn cnd avem doar doi juctori, care joac un meci direct. Schema general Metoda Divide Et Impera admite o implementare recursiv, deorece subproblemele sunt similare problemei iniiale, dar de dimensiuni mai mici . Principiul fundamental al recursivitii este autoapelarea unui subprogram cnd acesta este activ; ceea ce se intampl la un nivel, se intampl la orice nivel, avnd grij s asigurm condiia de terminare a apelurilor repetate. Asemntor se intmpl i n cazul metodei Divite Et Impera ; la un anumit nivel sunt doua posibiliti: s-a ajuns la o (sub)problem simpl ce admite o rezolvare imediat, caz n care se rezolv (sub)problema i se revine din apel (la subproblema anterioar, de dimensiuni mai mari); s-a ajuns la o (sub)problem care nu admite o rezolvare imediat, caz n care o descompunem in dou sau mai multe subprobleme i pentru fiecare din ele se continu apelurile recursive (ale procedurii sau funciei). n etapa final a metodei Divide Et Impera se produce combinarea subproblemelor (rezolvate deja) prin secvenele de revenire din apelurile recursive. Etapele metodei Divide Et Impera- prezentate anterior, se pot reprezenta prin urmtorul subprogram general recursiv exprimat n limbaj natural: Subprogram DIVIMP (X); Dac PROBLEMA X este simpl Atunci se rezolv i se obine soluia SOL 34

Altfel pentru i=1,k execut DIVIMP(X) i se obine SOL1; Sf _dac Se combina soluiile SOL 1,... ,SOL K i se obine SOL; Sf _subprogram; Deci, subprogramul DIVIMP se apeleaz pentru problema iniial X; aceasta admite descompunerea n K subprobleme simple; pentru acestea se reapeleaz recursiv subprogramul; n final se combin soluiile acestor K subprobleme. Identificarea dimensiunii subproblemelor n general un subprogram Divide Et Impera se aplic unui tablou (vector) V = <v1,...,vn> (V[1..n], n=dim[V]), asupra cruia vrem sa aplicm o operaie oarecare (sortare, determinarea valorii maxime, determinarea cmmdc, etc). Identificarea modalitii de mprire n subprobleme n acest caz se execut mprirea n dou subprobleme de dimensiuni aproximativ egale i anume [n/2] . mprirea n subprobleme are loc pn cnd dimensiunea acestora devine suficient de mic pentru a fi rezolvate n mod direct (cazul de baz). Rezolvarea subproblemelor Se rezolv subproblema direct. Combinarea soluiilor Dup rezolvarea celor dou subprobleme se execut faza de combinare a rezultatelor n vederea rezolvrii ntregii probleme. Se face prin interclasarea soluiilor. Subprogramul divide Subprogram DivImp(V,p,q) Daca q-p <= 1 atunci Rezolva(V,p,q) altfel m=(p+q) div 2 DivImp(V,p,m) DivImp(V,m+1,q) Combina(V,p,m,q) Sf_Daca Sf_subprogram. Apelul subprogramului Iniial p=1, q=n, rezult DivImp(V,1,n).

Sugestii metodologice UNDE ? Coninutul poate fi predat n sala de clas sau n laboratorul de informatic. CUM ? Se recomand utilizarea unui videoproiector pentru o mai buna vizualizare i implicit nelegere a noilor cunotine.. 35

Clasa poate fi organizat frontal, avnd n vedere i elevii cu nevoi speciale, pentru care se vor alege exemple ct mai accesibile, sau din contr cu un nivel mai ridicat de dificultate. Se vor alege ntrebri bine fixate cu scopul clar de a identifica modul de mprire n subprobleme i de a identifica modaliti de combinare a rezultatelor subproblemelor. Ca materiale suport se va folosi i fia suport 2.4 de la tema 2.

Urmrirea raionamentului i a implementrii este punct de plecare pentru probele de evaluare scrise sau practice. Se vor alege i probleme de verificare a gestionrii stivei pentru acest tip de problem.

Tema 5. Tehnica de programare Backtracking

Fia suport 5.1 Descrierea tehnicii

Aceast tehnic se folosete n rezolvarea problemelor care ndeplinesc simultan urmtoarele condiii: - soluia lor poate fi pus sub forma unui vector S= x1 x2 , xn cu x1 A1, x2 A2 Xn A n ; - mulimile A1, A2 , ., An sunt mulimi finite, iar elementele lor se consider c se afl ntr-o relaie de ordine bine stabilit; - nu se dispune de o alt metod de rezolvare, mai rapid - x1 x2 , xn pot fi la rndul lor vectori; - A1, A2 , An pot coincide. Tehnica Backtracking are la baz un principiu extrem de simplu: - se construiete soluia pas cu pas: x1, x2 ,xn - dac se constat c, pentru o valoare aleas, nu avem cum s ajungem la soluie, se renun la acea valoare i se reia cutarea din punctul n care am rmas. 36

Concret: - se alege primul element x, ce aparine lui A; - presupunnd generate elementele x1,x2 ,xk , aparinnd mulimilor A1, A2 ,Ak se alege (dac exist) xk+1 , primul element disponibil din mulimea Ak+1 , apar dou posibiliti : 1) Nu s-a gsit un astfel de element, caz n care caz n care se reia cutarea considernd generate elementele x1,x2 ,xk-1 , iar aceasta se reia de la urmtorul element al mulimii Ak rmas netestat; 2) A fost gsit, caz n care se testeaz dac acesta ndeplinete anumite condiii de continuare aprnd astfel dou posibiliti: - ndeplinete, caz n care se testeaz dac s-a ajuns la soluie i apar din nou dou posibiliti: - s-a ajuns la soluie, se tiprete soluia i se reia algoritmul considernd generate elementele x1,x2 ,xk , (se caut n continuare, un alt element al mulimii Ak , rmas netestat); - nu s-a ajuns la soluie, caz n care se reia algoritmul considernd generate elementele x1,x2 ,xk , i se caut un prim element xk+1 din Ak+1. - nu le ndeplinete, caz n care se reia algoritmul considernd generate elementele x1,x2 ,xk , iar elementul xk+1 se caut ntre elementele mulimii Ak+1, rmase netestate. Algoritmii se termin atunci cnd nu exist nici un element x1 din A1 netestat. Observaie: tehnica Backtracking are ca rezultat obinerea tuturor soluiilor problemei. n cazul n care se cere o singur soluie se poate fora oprirea, atunci cnd aceasta a fost gsit. Am artat c orice soluie se genereaz sub form de vector. Vom considera c generarea soluiilor se face intr-o stiv. Astfel, x1 din A1, se va gsi pe primul nivel al stivei, x2 din A2 se va gsi pe al doilea nivel ... al stivei,... xk din Ak se va gsi pe nivelul k al stivei. n acest fel, stiva (notat ST) va arta astfel:

xk

x2 x

ST

1 Nivelul k+1 al stivei trebuie iniializat (pentru a alege, n ordine, elementele mulimii k+1 ). Iniializarea trebuie fcut cu o valoare aflat (n relaia de ordine considerat, pentru mulimea Ak+1 ) naintea tuturor valorilor posibile din mulime. De exemplu, pentru generarea permutrilor mulimii {1,2.....n}, orice nivel al stivei va lua valori de la 1 la n. Iniializarea unui nivel (oarecare) se face cu valoarea 0. Funcia de iniializare o vom numi Init(). Gsirea urmtorului element al mulimii Ak (element care a fost netestat) se face cu ajutorul funciei Am_Suceeesor(). AS este o variabil boolean. n situaia n care am

37

gsit elementul, acesta este pus n stiv i AS ia valoarea TRUE, contrar (nu a rmas un element netestat) AS ia valoarea FALSE.. Odat ales un element, trebuie vzut dac acesta ndeplinete condiiile de continuare (altfel spus, dac elementul este valid). Acest test se face cu ajutorul funciei E_Valid(). Testul dac s-a ajuns sau nu la soluia final se face cu ajutorul funciei Solutie() iar o soluie se tiprete cu ajutorul funciei Tipar(). Prezentm n continuare rutina Back(): void back () { int AS; k=1; Init(); while (k>0) { do {} while ((AS=Am_Suceeesor()) && !E_Valid()); if (AS) if (Solutie()) Tipar(); else {k++; Init();} else k--; } } Observaie: Problemele rezolvate prin aceast metod necesit un timp ndelungat. Din acest motiv, este bine s utilizm metoda numai atunci cnd nu avem la dispoziie un alt algoritm mai eficient. Cu toate c exist probleme pentru care nu se pot elabora ali algoritmi mai eficieni, tehnica backtracking trebuie aplicat numai n ultim instan. Exemplu: Fiind dat o tabl de ah, de dimensiune n, xn, se cer toate soluiile de aranjare a n dame, astfel nct s nu se afle dou dame pe aceeai linie, coloan sau diagonal (dame s nu se atace reciproc).

Presupunnd c dispunem de o tabl de dimensiune 4x4, o soluie ar fi urmtoarea: D D D D Observm c o dam trebuie s fie plasat singur pe linie. Plasm prima dam pe linia 1, coloana 1. D

A doua dam nu poate fi aezat dect n coloana 3. D D 38

Observm c a treia dam nu poate fi plasat n linia 3. ncercm atunci plasarea celei de-a doua dame n coloana 4. D D

A treia dam nu poate fi plasat dect n coloana 2. D D D

n aceast situaie dama a patra nu mai poate fi aezat. ncercnd s avansm cu dama a treia, observm c nu este posibil s o plasm nici n coloana 3, nici n coloana 4, deci o vom scoate de pe tabl. Dama a doua nu mai poate avansa, deci i ea este scoas de pe tabl. Avansm cu prima dam n coloana 2. D

A doua dam nu poate fi aezat dect n coloana 4. D D

Dama a treia se aeaz n prima coloan. D D D Acum este posibil s plasm a patra dam n coloana 3 si astfel am obinut o soluie a problemei. D D D D 39

Algoritmul continu n acest mod pn cnd trebuie scoas de pe tabl prima dam. Pentru reprezentarea unei soluii putem folosi un vector cu n componente (avnd n vedere c pe fiecare linie se gsete o singur dam). Exemplu pentru soluia gsit avem vectorul ST ce poate fi asimilat unei stive. Dou dame se gsesc pe aceeai diagonal dac i numai dac este ndeplinit condiia: |st(i)-st(j)|=|i-j| ( diferena, n modul, ntre linii si coloane este aceeai).

3 ST(4) 1 ST(3) n general ST(i)=k semnific faptul c pe linia i dama ocup poziia k. 4 ST(2) 2
ST(1)

Astfel n tabla 4 x4 avem situaia: st(1)= 1 i = 1 D st(3)= 3 j = 3 D |st(1) - st(3)| = |1 3| = 2 D |i j| = |1 3| = 2 D sau situaia D D D D ntruct dou dame nu se pot gsi n aceeai coloan, rezult c o soluie este sub form de permutare. O prim idee ne conduce la generarea tuturor permutrilor i la extragerea soluiilor pentru problema ca dou dame s nu fie plasate n aceeai diagonal. A proceda astfel, nseamn c lucrm conform strategiei backtracking. Aceasta presupune c imediat ce am gsit dou dame care se atac, s relum cutarea. lat algoritmul, conform strategiei generate de backtracking: - n prima poziie a stivei se ncarc valoarea 1, cu semnificaia c n linia unu se aeaz prima dam n coloan. - Linia 2 se ncearc aezarea damei n coloana 1, acest lucru nefiind posibil ntruct avem doua dame pe aceeai coloan. - n linia 2 se ncearc aezarea damei n coloana 2 , ns acest lucru nu este posibil, pentru c damele se gsesc pe aceiai diagonal (|st(1)-st(2)|=|1-2|); - Aezarea damei 2 n coloana 3 este posibil. - Nu se poate plasa dama 3 n coloana 1, ntruct n liniile 1-3 damele ocupa acelai coloan. - i aceast ncercare eueaz ntruct damele de pe 2 i 3 sunt pe aceeai diagonal. - Damele de pe 2-3 se gsesc pe aceeai coloan. - Damele de pe 2-3 se gsesc pe aceeai diagonal. - Am cobort n stiv mutnd dama de pe linia 2 i coloana 3 n coloana 4. Algoritmul se ncheie atunci cnd stiva este vid. 40 st(1) = 3 i = 1 st(3) = 1 j = 3 |st(i) - st(j)| = |3 1| = 2 |i j| = |1 3| = 2

#include<iostream.h> #include<math.h> int st[100],n,k; void init() { st[k]=0;} int Am_Succesor() { if (st[k]<n) { st[k]++; return 1; } else return 0; } int E_Valid() {for (int i=1;i<k;i++) if(st[k]==st[i] || abs(st[k]-st[i])==abs(k-1) ) return 0; return 1; } int Solutie () {return k==n;} void Tipar () {for(int i=1;i<=n<i++) cout<<st[i]; cout<<endl; } void back() {int AS;k=1; Init(); While(k>0) { do{}while((AS=Am_Succesor()) && !E_Valid()); if(AS) if (Solutie())Tipar(); else{k++;Init();} else k--; } } main() { cout<<"n=";cin>>n; back(); }

Sugestii metodologice UNDE ? 41

Locul de desfurare a instruirii se recomand a fi un laborator de informatic n care pentru optimizarea demersului didactic - este necesar s existe o dotare minimal care presupune un numr de calculatoare egal cu numrul elevilor din clas, conectate n reea i cu acces la toate serviciile INTERNET. Configuraia calculatoarelor trebuie s permit rularea aplicaiilor prin care vor fi formate competenele specifice. CUM ? Se recomand utilizarea calculatoarelor pentru activitile de fixare a noilor cunotine i verificarea funcionrii programelor. Se va folosi i fereastra watch de urmrire a valorii variabilelor n timpul execuiei programului. n strategia didactic propunem folosirea metodelor active de nvare, cum sunt: explicaia n etapa de comunicare; nvarea prin descoperire dirijat, inductiv, experimental; conversaia de consolidare n etapa de fixare a cunotintelor, problematizarea.

discuii despre activiti cotidiene i modelarea acestora sub forma unei secvene bine definite de pai; citirea atent a enunului unei probleme; combinarea unor prelucrri elementare pentru obinerea anumitor prelucrri complexe n funcie de scopul propus; explicarea conceptelor referitoare la subprograme recursive; descompunerea rezolvrii unei probleme n subprobleme; identificarea unor situaii n care alegerea unui algoritm prezint avantaje n raport cu altul; exersarea crerii i aplicrii programelor pentru rezolvarea unor probleme ntlnite de elevi n studiul altor discipline colare;

Clasa poate fi organizat frontal sau pe grupe de 3-4 elevi, avnd n vedere i elevii cu nevoi speciale, pentru care se vor alege aplicatii mai accesibile, sau din contr cu un nivel mai ridicat de dificultate.. Ca materiale suport se pot folosi i lecii din biblioteca AEL cu reprezentri grafice ale funcionrii stivei precum NetSuport School pentru prezentarea unor grafice ale profesorului, respectiv elevilor.

Urmrirea raionamentului i a implementrii este punct de plecare pentru probele de evaluare scrise sau practice.

42

Tema 5. Tehnica de programareBacktracking

Fia suport 5.2 Backtracking recursiv
n fia suport 5.1 am prezentat tehnica Backtracking clasic, nerecursiv, iar n fia suport 5.2 prezentm varianta recursiv a acestei tehnici. n acest caz soluiile finale st[i] sunt generate n cadrul funciei back_recursiv(int k), unde k reprezint nivelul pn la care s-a ajuns pe stiv. Adic la fiecare execuie din lanul de auto-apeluri, funcia back_recursiv trateaz nivelul k al stivei. Algoritmul recursiv de backtracking este prezentat mai jos n limbajul pseudocod. back_recursiv( int k) pentru contor de la <v1> la <vn> execut nceput st[k]contor 43

dac valid(k) atunci dac<soluia este final> atunci apel tipar altfel auto-apel back_recursiv(k+1) sfrit ntrun ciclu, prin variabila contor vor trece pe rnd toate valorile din intervalul <v1> la <vn> care ar putea fi ncercate pe nivelul k al stivei. La fiecare pas al ciclului, pentru fiecare dintre valorile variabilei contor: .Se memoreaz pe nivelul k valoarea contor prin st[k]contor. Se obine astfel soluia parial(st[1],st[2],,st[k]), Se verific dac aceast soluie este valid prin funcia valid(k). Dac da atunci se verific dac soluia este final : - Dac este soluie final atunci se apeleaz funcia tipar; - n caz contrar, avem o soluie valid dar care nu este i final.Vom . urca la nivelul urmtor n stiv prin apelul back_recursiv(k+1). Algoritmul se reia de la capt, dar cu k+1 n loc de k.

Exemplu 1. Problema damelor de ah. Se cere gsirea tuturor soluiilor de aezare pe tabla de ah de n linii i n coloane a n dame, astfel nct ele s nu se atace. Se consider c ele se atac dac sunt pe aceeai linie, coloan sau diagonal. ntruct pe o linie se gsete o singur dam, soluia se prezint sub form de vector x =(x1, x2, ... ,xn), unde xi reprezint coloana pe care se afl dama n linia i. Condiiile de continuare sunt: a) dou dame nu se pot afla pe aceeai coloan, adic: X[ i ] < > X[ j] pentru i < > j ; b) dou dame nu se pot afla pe aceeai diagonal, adic: k - i < > X[ k ] X[ i ] pentru i = 1, 2, ... k - 1. Varianta recursiv este urmtoarea: #include <stdio.h> #include <conio.h> #include <iostream.h: > #define nmax 10 int n; /*dimensiunea (ordinul) tablei de ah */ int nr_solutie; int x[nmax]; int valid(int k) { /*testeaz condiiile de continuare */ int p; for(p=1;p<=k-1;p++) if((x[k]==x[p]) | (abs(k-p) == abs(x[k]-x[p]))) return 0; return 1; } void back_recursiv(int k) { int i,j,p; for(j=1;j<=n;j++) 44

{ x[k]=j; if(valid(k)==1) if(k<n) back_recursiv(k+1); else { /*tiprirea soluiei */ nr_solutie++; cout<<"\nSOLUTIA nr. " <<nr_solutie); for(i=1;i<=n;i++) { for(p=1;p<=n;p++) if(x[i]==p) cout<<"1"; else cout<<0<<endl; }; getch(); } } } void main(void) { cout<<"\nOrdinul tablei de sah n="; cin>>n; nr_solutie=0; back_recursiv(1); cout<<"\nSFARSIT\n"; } Se observ c tiprirea unei soluii se face chiar n interiorul funciei recursive. Apelul funciei back_recursiv se face n funcia principal main() prin apelul back_recursiv(1). Exemplu 2. Problema permutrilor Se citete un numr natural n. S se genereze toate permutrile mulimii {1,2,,n}. Generarea permutrilor se va face innd cont c orice permutare va fii alctuit din elemente distincte ale mulimii A={1,2,..,n}. #include<conio.h> #include<iostream.h> int st[21],n; void init() {int i; cout<<"n="; cin>>n; for(i=1;i<=n;i++) st[i]=0; } void tipar(int k) { int i; for (i=1;i<=k;i++) cout<<st[i]; cout<<endl; } 45

int valid(int k) { int i,ok; ok=1; for(i=1;i<k;i++) if (st[i]==st[k]) ok=0; return ok; } void back(int k) { int i; for(i=1;i<=n;i++) { st[k]=i; if (valid(k)) if(k==n) tipar(k); else back(k+1); } } main() { init(); back(1); getch(); } Exemplul 3: Generarea aranjamentelor: Se citesc n i p. S se genereze toate aranjamentele de n luate cte p #include<conio.h> #include<iostream.h> int st[21],n,p void init() {int i; cout<<"n="; cin>>n; cout<<"p="; cin>>p; for(i=1;i<=n;i++) st[i]=0; } void tipar(int k) { int i; for (i=1;i<=k;i++) cout<<st[i]; cout<<endl; } int valid(int k) { int i,ok; ok=1; for(i=1;i<k;i++) if (st[i]==st[k]) ok=0; return ok; } void back(int k) { int i; for(i=1;i<=n;i++) 46

{ st[k]=i; if (valid(k)) if(k==p) tipar(k); else back(k+1); } } main() { init(); back(1); getch(); }

Sugestii metodologice UNDE ? Coninutul poate fi predat n sala de clasa, dar se recomand laboratorul de informatic. CUM ? Se recomand utilizarea calculatoarelor pentru activitile de fixare a noilor cunotine i verificarea funcionrii programelor. Se va folosi i fereastra watch de urmrire a valorii variabilelor n timpul execuiei programului. Clasa poate fi organizat frontal sau pe grupe de 3-4 elevi, avnd n vedere i elevii cu nevoi speciale, pentru care se vor alege aplicaii mai accesibile, sau din contr cu un nivel mai ridicat de dificultate.. Se vor alege ntrebri bine alese cu scopul backtracking clasic de cel recursiv. Se va urmri:

clar de a diferenia mecanismul de

testarea i analizarea comportamentului programelor pentru diferite date de intrare; ncurajarea discuiilor purtate ntre elevi, exprimarea i ascultarea prerilor fiecruia. se vor ncuraja elevii s identifice tipul de problem prezentat. se vor ncuraja elevii s creeze ei nii probleme pe tipurile date.

Ca materiale suport se pot folosi i lecii din biblioteca AEL cu reprezentri grafice ale funcionrii stivei la aplicaiile de backtracking recursiv,precum NetSuport School pentru prezentarea unor programe ale profesorului, respectiv elevilor.

Urmrirea raionamentului i a implementrii este punct de plecare pentru probele de evaluare scrise sau practice, precum i testarea programelor pentru valori diferite ale datelor de intrare.

47

48

Tema 6. Tehnica de programare Greedy

Fia suport 6.1 Descrierea tehnicii
Dei este practic imposibil s fie dat forma general, a unei probleme rezolvabile cu tehnica Greedy, ncercm totui. Restricii S considerm o mulime A cu n elemente. Se cere o submulime a sa cu m<=n elemente (n cazul m=n este important ordinea alegerii elementelor), astfel nct s fie ndeplinite anumite condiii (acestea difer de la o problem la alta).

Exemplu: se consider o mulime de n numere reale. Se cere o submulime a sa, astfel nct suma elementelor sale s fie maxim. Pentru rezolvare, se va alege un prim element al mulimii de numere reale. Dac este posibil, acesta va fi adugat soluiei, iniial vide. Posibilitatea ca acesta s fie adugat este dat de semnul numrului (acesta trebuie s fie mai mare ca 0). Se alege un al doilea numr, cu care se procedeaz n mod asemntor. ................................................................................................................ Algoritmul se ncheie cnd au fost alese i eventual adugate toate elementele mulimii. Schema general Greedy Pentru a rezolva o problem cu Greedy, soluia se construiete, dup regula: Pentru fiecare element care urmeaz s fie adugat soluiei finale, se efectueaz o alegere a sa din elementele mulimii A (dup un mecanism specific fiecrei probleme n parte), iar dac este posibil, acesta este adugat. Algoritmul se termin fie cnd a fost gsit soluia cerut, fie cnd s-a constatat inexistena acesteia. Intuitiv, alegem un element, al doilea,...pn cnd obinem ce dorim sau pn cnd au fost testate toate elementele mulimii. De aici provine i numele metodei greedy (lacom).

Greedy pare att de simpl nct, la nceput, ne mir faptul c a fost evideniat ca tehnic. La o analiz atent, vom observa c lucrurile nu stau chiar aa. Exemplul prezentat este didactic (l rezolvm i fr s tim c exist aceast tehnic), el nu are alt rol dect de a evidenia caracteristicile tehnicii.

Definiie Tehnica Greedy poate fi privit ca o particularizare a tehnicii Backtracking, n care se renun la mecanismul de ntoarcere. S analizm, n paralel, cele dou tehnici, pentru a putea stabili asemnrile i diferenele existente ntre ele: 49

 ambele tehnici ofer soluii sub form de vector; tehnica Backtracking poate oferi toate soluiile problemei, n timp ce tehnica Greedy ofer o singur soluie; tehnica Greedy nu dispune de mecanismul ntoarcerii, specific tehnicii backtracking. Aceasta este diferena esenial dintre cele dou tehnici, diferen care are consecine uriae n ce privete aplicabilitatea lor Consecina 1. Este necesar ca cel care elaboreaz un algoritm Greedy s tie faptul c, procednd n modul ales de el, ajunge la rezultatul dorit. Pentru fiecare problem n parte, dupa ce se indentific un algoritm, este obligatoriu s se demonstreze c acesta conduce la soluia optim. Demonstraia faptului c se ajunge la soluia optim este specific fiecrei probleme n parte. Consecina 2. Tehnica Greedy conduce la timp de calcul polinomial. Motivul care conduce la acest timp de calcul, ine de mecanismul tehnicii.S presupunem c mulimea din care se face alegerea are n elemente i c soluia are tot n elemente (caz maxim). Se fac n alegeri, la fiecare alegere se fac n teste, rezult un algoritm cu timp O(n2). Selectarea elementelor ce formeaz soluia De multe ori, este necesar ca elementele mulimii A s fie sortate, pentru ca apoi s alegem din acestea, iar sortarea necesit un timp minim O(nxlog2n). ns sortarea se efectueaz la nceput. Prin urmare, acest timp se adun, deci nu influeneaz rezultatul. O ntrebare fireasc: fiind dat o problem, exist ntotdeauna un algoritm de tip greedy care gsete soluia optim?Evident, nu. Exist probleme pentru care nu se cunosc astfel de algoritmi.Mai mult, pentru cele mai multe probleme, nu se cunosc algoritmi Greedy. Generarea i afiarea soluiei. Deoarece soluia problemelor ce se rezolv cu acest tehnic este sub form de vector, acesta se completeaz pas cu pas i apoi se afieaz. Avantajul tehnicii Avantajul timpului polinomial, conduce la necesitatea utilizrii tehnicii Greedy. Din alt punct de vedere, nu tuturor problemelor li se pot aplica algoritmi de acest tip. Ce este de fcut? Pentru problemele pentru care nu se cunosc algoritmi care necesit timp polinomial, se caut soluii, chiar dac nu optime, dar apropiate de acestea, dar care au fost obinute n timp util. Multe din aceste soluii sunt obinute cu Greedy. Astfel de algoritmi se numesc algoritmi euristici. Probleme pentru care Greedy obine soluia optim Exemplul 1. Problema spectacolelor 50

ntr-o sal, ntr-o zi, trebuie planificate n spectacole. Pentru fiecare spectacol se cunoate intervalul n care se desfoar:[st, sf]. Se cere s se planifice un numr maxim de spectacole astfel nct s nu se suprapun. Rezolvare Fie o planificare optim a spectacolelor (un numr maxim k de spectacole i1,i2,...ik, unde i1,i2,...ik {1,2,..n} i spectacolul ij are lor naintea spectacolului ij+1).O astfel de planificare ndeplinete condiia: spectacolul ij+1 ncepe dup terminarea spectacolului ij. O consecin imediat a condiiei de mai sus este: spectacolul ij ia sfrit naintea terminrii spectacolului ij+1 (consecina nu implic un efort de gndire deosebit). Vom construi o soluie dup urmtorul algoritm: 1) sortm spectacolele dup ora terminrii lor; 2) primul spectacol programat este cel care se termin cel mai devreme; 3) alegem primul spectacol dintre cele care urmeaz n ir ultimului spectacol programat care ndeplinete condiia c ncepe dup ce s-a terminat ultimul spectacol programat; 4) dac tentativa de mai sus a euat(nu am gsit un astfel de spectacol) algoritmul se termin, altfel se programeaz spectacolul gsit i algoritmul se reia de la pasul 3. Algoritmul de mai sus conduce la soluia optim(numr maxim de spectacole programate). Acest program se ncadreaz n tehnica Greedy pentru c: la un pas de a alege un spectacol (cu ora de terminare mai mare dect ora de terminare a ultimului spectacol programat iar dac este posibil (dac are ora de nceput dup ora de sfrit a ultimului spectacol programat) este adugat soluiei.Odat adugat (programat) un spectacol, acesta rmne n cadrul soluiei. #include<iostream.h> int s[2][10],o[10],n,I,h1,m1,h2,m2,ora; void sortare() { int gata,m,i; do { gata=1; for(i=1;i<=n-1;i++) if (s[1][o[i]]>s[i][o[i+1]) { m=o[i] ; o[i]=o[i+1]; o[i+1]=m; gata=0; } while (!gata); } main() {cout<<n=;cin>>n; for(i=1;i<=n;i++) {o[i]=I; cout<<ora de inceput pentru spectacol <<i<< (hh mm)=; cin>>h1>>m1; s[0][i]=h1*60+m1; cout<<ora de sfarsit pentru specatcol <<i<< (hh mm)=; cin>>h2>>m2; 51

s[1][i]=h2*60+m2; } sortare(); cout<<ordinea spectacolelor este<<endl<<o[i]<<endl; ora=s[1][o[1]]; For(i=2;i<=n;i++) { if (s[0][o[i]]>=ora) {cout<<o[i]<<endl; ora=s[i] [o[i]];} } } Exemplul 2. Problema rucsacului O persoan are un rucsac cu care poate transporta o greutate maxim G. Persoana are la dispoziie n obiecte si cunoate pentru fiecare obiect greutatea si 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 sa fie maxim. O precizare n plus transform aceast problem n alte dou probleme distincte. Aceast precizare se refer la faptul c obiectele pot fi sau nu tiate pentru transportul la destinaie. In prima situaie, problema poart numele de problema continu a rucsacului, iar n a doua avem problema discreta a rucsacului. Aceste dou probleme se rezolv diferit Varianta continu a problemei rucsacului este rezolvat mai jos, iar cea discret se rezolv cu ajutorul programrii dinamice. Problema continu a rucsacului, n care persoana are posibilitatea s taie obiectele. n acest fel, se poate obine o ncrcare mai eficient a rucsacului. Algoritmul este urmtorul: se calculeaz, pentru fiecare obiect n parte, eficiena de transport rezultat prin mprirea ctigului la greutate (de fapt, acesta reprezint ctigul obinut prin transportul unitii de greutate); obiectele se sorteaz n ordine descresctoare a eficienei de transport si se preiau n calcul n aceast ordine; ctigul iniial va fi 0, iar greutatea rmas de ncrcat va fi greutatea rucsacului; att timp ct nu a fost completat greutatea maxim a rucsacului si nu au fost luate in considerare toate obiectele, se procedeaz astfel: dintre obiectele nencrcate se selecteaz acela cu cea mai ridicat eficien de transport i avem dou posibiliti: acesta ncape n totalitate n rucsac, deci se scade din greutatea rmas de ncrcat greutatea obiectului, la ctig se cumuleaz ctigul datorat transportului acestui obiect; se tiprete 1, n sensul c ntregul obiect a fost ncrcat; obiectul nu ncape n totalitate n rucsac, caz n care se calculeaz ce parte din el poate fi transportat, se cumuleaz ctigul obinut cu transportul acestei pri din obiect, se tiprete procentul care s-a ncrcat din obiect, iar greutatea rmas de ncrcat devine 0.

Vom considera un exemplu numeric. Greutatea care poate fi transportat cu ajutorul rucsacului aste 3 Avem la dispoziie 3 obiecte. Greutatea i ctigul pentru fiecare obiect sunt prezentate mai jos: 52

Eficiena de transport este 1 pentru primul obiect, 4 pentru al doilea si 2 pentru al treilea. n concluzie, obiectul 2 se ncarc n ntregime n rucsac, obinnd un ctig de 4 i rmne o capacitate de transport de dou uniti de greutate. Se ncarc 2/3 din obiectul 3 (care este al doilea n ordinea eficienei de transport) pentru care se obine ctigul 4. Ctigul obinut n total este 8. Se remarca strategia GREEDY prin alegerea obiectului care va fi transportat, alegere asupra creia nu se revine. #include<iostream.h> double c[9],g[9],ef[9],gv,man,castig; int n,i,man1,inv,ordine[9]; main() {cout<<greutatea ; cin>>gv; cout<<numar obiecte ; cin>>n; for(i=1;i<=n;i++) {cout<<c[<<i<<]=; cin>>c[i]; cout<<g[<<i<<]=; cin>>g[i]; ordine[i]=I; ef[i]=c[i]/g[i]; } do { inv=0; for(i=1;i<=n-1;i++) if(ef[i]<ef[i+1]) {man=ef[i]; ef[i]=ef[i+1]; ef[i+1]=man; man=c[i]; c[i]=c[i+1]; c[i+1]=man; man=g[i]; g[i]=g[i+1]; g[i+1]=man; inv=1; man1=ordine[i]; ordine[i]=ordine[i+1]; ordine[i+1]=man1;} }while (inv); i=1; while (gv>0 && i<=n) { if (gv>g[i]) {cout<< obiectul <<ordine[i]<< <<i<<endl; gv-=gv[i]; castig=castig+c[i]; } else {cout<<obiectul <<ordine[i]<< <<gv/g[i]<<endl; castig=castig+c[i]*gv/g[i]; gv=0; } i++; } cout<<castig total <<castig; 53

Sugestii metodologice UNDE ? Coninutul poate fi predat n sala de clasa cu ajutorul unui videoproiector, dar se recomand laboratorul de informatic. CUM ? Se recomand utilizarea calculatoarelor pentru buna deprindere a noilor cunotine i verificarea funcionrii programelor. Se va folosi i fereastra watch de urmrire a valorii variabilelor n timpul execuiei programului. Clasa poate fi organizat frontal sau pe grupe de 3-4 elevi, avnd n vedere i elevii cu nevoi speciale, pentru care se vor alege aplicaii mai accesibile, sau din contr cu un nivel mai ridicat de dificultate.. Se vor alege ntrebri bine alese cu scopul clar de a diferenia mecanismul de urcare i coborre n stiv cu toate elementele mulimii de succesori.. Se va urmri:

testarea i analizarea comportamentului programelor pentru diferite date de intrare; ncurajarea discuiilor purtate ntre elevi, exprimarea i ascultarea prerilor fiecruia. nsuirea restriciilor pentru tehnica Greedy. ntocmirea de proiecte pe echipe de 4+6 elevi.

Este recomandabil ca organizarea demersului didactic corespunztor unitii de nvare s in cont de parcurgerea a trei secvene, ce pot fi descrise sintetic prin: familiarizare; structurare; aplicare. Ca materiale suport se pot folosi i lecii din biblioteca AEL sau a tablelor inteligente, daca exist n dotare.Se va folosi NetSuport School pentru prezentarea unor programe ale profesorului, respectiv elevilor.

Urmrirea raionamentului i a implementrii este punct de plecare pentru probele de evaluare scrise sau practice, precum i testarea programelor pentru valori diferite ale datelor de intrare. Se va urm[ri ca probele de evaluare s aib i funcia de dezvoltare a capacitilor elevului.

54

IV. Fia rezumat

Numele elevului: _________________________ Numele profesorului: _________________________
Competene care trebuie dobndite Activiti efectuate i comentarii Data activitatii Evaluare Satisfctor

Bine

Refacere

Comp 1 (Aici se trece numele competentei)

Activitate 1

Activitate2

Comentarii

Prioriti de dezvoltare

Competene care urmeaz s fie dobndite (pentru fia urmtoare)

Resurse necesare

55

Competene care trebuie dobndite Aceast fi de nregistrare este fcut pentru a evalua, n mod separat, evoluia legat de diferite competene. Acest lucru nseamn specificarea competenelor tehnice generale i competenelor pentru abiliti cheie, care trebuie dezvoltate i evaluate. Profesorul poate utiliza fiele de lucru prezentate n auxiliar i/sau poate elabora alte lucrri n conformitate cu criteriile de performan ale competenei vizate i de specializarea clasei. Activiti efectuate i comentarii Aici ar trebui s se poat nregistra tipurile de activiti efectuate de elev, materialele utilizate i orice alte comentarii suplimentare care ar putea fi relevante pentru planificare sau feed-back. Prioriti pentru dezvoltare Partea inferioar a fiei este conceput pentru a meniona activitile pe care elevul trebuie s le efectueze n perioada urmtoare ca parte a viitoarelor module. Aceste informaii ar trebui s permit profesorilor implicai s pregteasc elevul pentru ceea ce va urma. Competenele care urmeaz s fie dobndite n aceast csu, profesorii trebuie s nscrie competenele care urmeaz a fi dobndite. Acest lucru poate implica continuarea lucrului pentru aceleai competene sau identificarea altora care trebuie avute in vedere. Resurse necesare Aici se pot nscrie orice fel de resurse speciale solicitate:manuale tehnice, reete, seturi de instruciuni i orice fel de fie de lucru care ar putea reprezenta o surs de informare suplimentar pentru un elev care nu a dobndit competenele cerute.

Not: acest format de fi este un instrument detaliat de nregistrare a progresului elevilor. Pentru fiecare elev se pot realiza mai multe astfel de fie pe durata derulrii modulului, aceasta permind evaluarea precis a evoluiei elevului, n acelai timp furniznd informaii relevante pentru analiz.

56

V. Bibliografie
1. Sorin, Tudor (1998). Tehnici de programare,Bucuresti:Editura PegasuS. 2. Mateescu, Daniel George. Moraru, Florin Pavel(2006). Informatica pentru liceu si bacalaureat Materia de clasa a XI-a, Sibiu: Editura Donaris. 3. Cerchez, Emanuela. Serban, Marinel.(2005) Programarea in limbajul C/C++ volumul 2, Bucuresti:Editura Polirom. 4. Milosescu, Mariana.(2005) Informatica clasa a X-a, Bucuresti: Editura Diactica si Pedagogica. 5. Sorin, Tudor. (2008) Informatica clasa a IX si X a , Bucuresti: L&S Info-Mat. 6. ***. La http://www.timsoft.ro/aux/module/modul11.html 02.05.2009 7. ***. La http://labs.cs.utt.ro/labs/sdaa/html/sda/l1.html 04.05.2009 8. *** La http://ro.wikipedia.org/wiki/Divide_et_impera 12.05.2009 9. *** La www.educativ.ro 12.05.2009 10. *** La http://www.scribd.com/doc/8066145/Metoda-Backtracking 13.05.2009 11. *** La www.didactic.ro/files/12/metoda_greedy.doc 13.05.2009 12. *** La http://www.advancedelearning.ro/materiale/cataloage/ro/cat_inf_ro.pdf 13.05.2009 13.*** La http://portal2.ise.ro la 14.05.2009

57