Algopedia - User contributions [en]

Clasa a 7-a Lecția 5: Precalculare

2025-06-11T13:43:18Z

Mihai:

== Înregistrare video lecție ==

{{#ev:youtube|https://youtu.be/n_LKos0gG0Q|||||start=6180&end=10200&loop=1}}

== Despre precalculare ==

Precalcularea este un termen general pentru folosirea unor structuri auxiliare de date, uneori fără o legătură directă cu problema de rezolvat, care ne ajută în rezolvarea problemei.

Aceste structuri de date sunt calculate la început, înainte de calculul propriu zis, ceea ce duce la denumire: precalculare.

De obicei precalcularea reduce complexitatea anumitor pași din algoritm, prețul ei fiind un calcul mic la început, astfel încât, per total, algoritmul va fi mai rapid.

În engleză acest subiect este numit precomputation. Wikipedia oferă exemple de algoritmi complecși de precalculare. Noi vom discuta în continuare despre algoritmi de precalculare de bază, ce apar uzual în programare și la concursuri.

=== Santinela în căutarea liniară ===

Precum știm, codul clasic de căutare a elementului e în vectorul <source lang="C" enclose="none">v[]</source> de <source lang="C" enclose="none">n</source> elemente este:

<syntaxhighlight lang="C" line>
i = 0;
while ( i < n && v[i] != e )
i++;
if ( i < n ) // ... testul daca am gasit elementul
</syntaxhighlight>

Am discutat cum putem elimina unul din testele din <source lang="C" enclose="none">while</source> folosind o santinelă. Vom așeza e pe prima poziție în afara vectorului. Astfel, ne asigurăm că vom găsi elementul în vector. Putem, deci, să nu mai testăm condiția <source lang="C" enclose="none">i</source>. Noul cod va fi:

<syntaxhighlight lang="C" line>
v[n] = e;
i = 0;
while ( v[i] != e )
i++;
if ( i < n ) // ... testul daca am gasit elementul
</syntaxhighlight>

Așezarea santinelei în vector poate fi un exemplu foarte simplu de precalculare. Ea va folosi un element al vectorului, ce va trebui dimensionat cu unu în plus.

* Avantaje: cod mai rapid și mai scurt.
* Schimbă complexitatea algoritmului: nu.
* Timp precalculare: ''O(1)''.
* Memorie extra folosită: ''O(1)'' (un element în plus).

=== Bordarea ===

Bordarea, tehnica prin care ''înconjurăm'' matricea cu elemente distincte, ar putea fi și ea considerată o precalculare. În loc de o santinelă avem acum multiple santinele. Codul de testare al depășirii matricei se simplifică și devine mai eficient.

* Avantaje: cod mai rapid și mai scurt.
* Schimbă complexitatea algoritmului: nu.
* Memorie extra folosită: ''O(n)'' ('''n''' este dimensiunea matricei).

=== Precalculare de tip caracter ===

Dacă avem nevoie să aflăm dacă un caracter dat este cifră, testul clasic este:

<syntaxhighlight lang="C" line>
if ( ch >= '0' && ch <= '9' )
// ...
</syntaxhighlight>

Putem elimina un test dacă precalculăm un vector de stegulețe, pentru toate caracterele, care să aibă 1 pe pozițiile caracterelor cifre și 0 în rest. Astfel:

<syntaxhighlight lang="C" line>
char ecifra[128];

// precalculare: initializare ecifra[]
for ( ch = '0'; ch <= '9'; ch++ )
ecifra[ch] = 1;

// test cifra
if ( ecifra[ch] )
// ...
</syntaxhighlight>

Vom calcula la început câte o valoare per cifră. Apoi, în algoritm vom scuti unul din teste.

Din fericire nu trebuie să facem explicit acest lucru. Biblioteca ne oferă funcția:

<syntaxhighlight lang="C" line>
int isdigit( int ch )
</syntaxhighlight>

Aceasta face exact ce ne dorim.

Există și alte funcții, cum ar fi <source lang="C" enclose="none">isalpha()</source> (testare literă) și <source lang="C" enclose="none">isalnum()</source> (testare cifra sau litera).

* Avantaje: cod mai rapid și mai scurt.
* Schimbă complexitatea algoritmului: nu.
* Timp precalculare: ''O(Σ)'' (unde '''Σ''' este numărul de caractere).
* Memorie extra folosită: ''O(Σ)'' (unde '''Σ''' este numărul de caractere).

=== Prelucrare valori cifre în baze de numerație ===

Să luăm ca exemplu problema [https://www.nerdarena.ro/problema/criptic criptic]. La intrare se aflau numere în baza 62, ce trebuiau citite ca întregi în memorie. Pentru aceasta trebuia să calculăm valoarea unei cifre. Codul simplu și direct va fi:

<syntaxhighlight lang="C" line>
char ch;
// ...
ch = fgetc( fin );
if ( ch >= '0' && ch <= '9' )
v = ch - '0';
else if ( ch >= 'a' && ch <= 'z' )
v = ch - 'a' + 10;
else
v = ch - 'A' + 36;
</syntaxhighlight>

El va face 2 sau 4 teste de inegalitate. Pentru a nu avea nici un test putem precalcula într-un vector valorile cifrelor în baza 62:

<syntaxhighlight lang="C" line>
int val[128];
// ...
for ( ch = '0'; ch <= '9'; ch++ ) // valorile cifrelor
val[ch] = ch - '0';
for ( ch = 'a'; ch <= 'z'; ch++ )
val[ch] = ch - 'a' + 10;
for ( ch = 'A'; ch <= 'Z'; ch++ )
val[ch] = ch - 'A' + 36;
</syntaxhighlight>

Apoi, la folosire:

<syntaxhighlight lang="C" line>
char ch;
// ...
ch = fgetc( fin );
v = val[ch];
</syntaxhighlight>

* Avantaje: cod mai rapid și mai scurt.
* Schimbă complexitatea algoritmului: nu.
* Timp precalculare: ''O(Σ)'' (unde '''Σ''' este numărul de caractere).
* Memorie extra folosită: ''O(Σ)'' (unde '''Σ''' este numărul de caractere).

=== Ciurul lui Eratostene ===

V-aţi gândit vreodată că ciurul lui Eratostene este de fapt o precalculare a unui vector de frecvenţă <source lang="C" enclose="none">ciur[]</source>, care, pentru fiecare număr <source lang="C" enclose="none">p</source>, calculează <source lang="C" enclose="none">ciur[p]</source> care ne spune dacă <source lang="C" enclose="none">p</source> este prim?

Cum am calcula primalitatea tuturor numerelor până la <source lang="C" enclose="none">n</source> în absența ciurului? Am verifica de primalitate fiecare din numere, în ''O(p)''. Complexitatea algoritmului ar fi: <math>\sqrt{1} + \sqrt{2} + \sqrt{3} + ... + \sqrt{n}</math>.

Această sumă este ''<math>O(n \sqrt{n})</math>'' (demonstrația depășește nivelul cercului nostru). În realitate lucrurile stau puțin mai bine, în sensul că nu vom ajunge cu divizorii până la ''<math>\sqrt{k}</math>'' decât pentru <source lang="C" enclose="none">k</source> prim. O estimare a numerelor prime până la <source lang="C" enclose="none">n</source> este <math>\frac{n}{log{n}}</math>.

De aceea, o estimare ajustată a complexității ar fi ''<math>O(\frac{n\sqrt{n}}{log{n}})</math>''.

Am putea face și o altă optimizare: să împărțim <source lang="C" enclose="none">k</source> doar la numerele prime de până la el. Aceasta mai reduce complexitatea într-un mod ce ar complica și mai mult formula.

Să nu uităm un lucru important: '''factorizarea folosește împărțiri'''. Ceea ce, pentru numerele cu care lucrăm noi, introduce o constantă multiplicativă foarte mare, circa 15 până la 30, comparabilă cu optimizări de tipul ''O(log n)''.

Prin comparație, ciurul lui Eratostene general are complexitatea ''O(n log n)'' și nu folosește împărțiri, iar pentru cazul testului de primalitate el poate fi adus la ''O(n log log n)''.

Să ne reamintim unele din aplicațiile ciurului lui Eratostene:

* Numărul de divizori primi (unici sau neunici) ai tuturor numerelor până la <source lang="C" enclose="none">n</source>
* Suma divizorilor primi (unici sau neunici) ai tuturor numerelor până la <source lang="C" enclose="none">n</source>
* Numărul de divizori ai tuturor numerelor până la <source lang="C" enclose="none">n</source>
* Suma divizorilor tuturor numerelor până la <source lang="C" enclose="none">n</source>
* Descompunerea în factori primi a tuturor numerelor până la <source lang="C" enclose="none">n</source>
* Numărul de numere prime cu fiecare din numerele până la <source lang="C" enclose="none">n</source>

'''Concluzii:'''

* Avantaje: cod mai rapid și mai scurt.
* Schimbă complexitatea algoritmului: da.
* Timp precalculare: ''O(n log n)'' sau ''O( n log log n)''.
* Memorie extra folosită: ''O(n)''.

=== Suma între i și j ===

În multe probleme apare următoarea subproblemă: dat un vector <source lang="C" enclose="none">v[]</source> de <source lang="C" enclose="none">n</source> elemente întregi, să se răspundă la multe întrebări de forma '''care este suma elementelor vectorului între poziţiile <source lang="C" enclose="none">i</source> şi <source lang="C" enclose="none">j</source>?'''.

În acest caz vom precalcula o structură de date auxiliară, şi anume un vector <source lang="C" enclose="none">s[]</source>, astfel încât <source lang="C" enclose="none">s[i]</source> este suma elementelor de la 0 până la <source lang="C" enclose="none">i</source> (inclusiv). El se mai numeşte şi vectorul sumei prefixelor lui <source lang="C" enclose="none">v[]</source>. Construcția acestui vector se poate face liniar deoarece avem relaţia <source lang="C" enclose="none">s[i] = s[i-1] + v[i]</source>.

Odată calculat acest vector putem răspunde în timp constant la întrebări. Suma elementelor între <source lang="C" enclose="none">i</source> şi <source lang="C" enclose="none">j</source> este <source lang="C" enclose="none">s[j] - s[i-1]</source>.

Complexitatea algoritmului forță brută de calcul al unei sume ar fi ''O(n)'', pe medie. Precalcularea o reduce la ''O(1)''.

* Avantaje: cod mai rapid și mai scurt.
* Schimbă complexitatea algoritmului: da.
* Timp precalculare: ''O(n)''.
* Memorie extra folosită: ''O(n)''.

Sumele parțiale pot fi folosite și pentru a răspunde rapid la alt tip de întrebări: ''dat S, care este cea mai mare poziție i în vector cu proprietatea că suma elementelor de la 0 la i este mai mică sau egală cu S?''

Sumele parțiale într-un vector cu elemente naturale au proprietatea că sunt crescătoare. De aceea putem căuta suma S binar în vectorul de sume parțiale. Răspunsul la întrebare ar fi ''O(n)'' prin forță brută. Folosind sume parțiale putem răspunde în ''O(log n)''.

=== Suma între (l1, c1) şi (l2, c2) ===

Este problema anterioară extinsă la matrice: avem o matrice de numere întregi şi întrebări de forma: '''care este suma elementelor matricei în dreptunghiul care are drept colţuri opuse (l1, c1) şi (l2, c2)?'''.

În mod similar vom precalcula o matrice auxiliară cu suma elementelor matricei originale între ''(0, 0)'' şi ''(i, j)''. Ea poate fi calculată în timp constant per element, astfel:

[[Image:matrice-numar-1-v2.gif|frame|none|Calcul matrice sume parțiale în dreptunghiuri care pornesc în origine]]

: <source lang="C" enclose="none">s[l][c] = s[l][c-1] + s[l-1][c] - s[l-1][c-1] + m[l][c]</source>

* <source lang="C" enclose="none">s</source> este matricea pe care o precalculăm;
* <source lang="C" enclose="none">m</source> este matricea cu valorile inițiale.

Odată calculată matricea s[][] putem răspunde în timp constant la întrebări. Suma elementelor între (l1, c1) şi (l2, c2) este:

[[Image:matrice-numar-1-dreptunghi-v2.gif|frame|none|Calcul suma numerelor în orice dreptunghi]]

: <source lang="C" enclose="none">S = s[l2][c2] - s[l2][c1-1] - s[l1-1][c2] + s[l1-1][c1-1]</source>

* <source lang="C" enclose="none">S</source> este suma căutată;
* <source lang="C" enclose="none">s</source> este matricea pe care o precalculăm.

Complexitatea algoritmului forță brută de calcul al unei sume ar fi ''O(n2)'', pe medie. Precalcularea o reduce la ''O(1)''.

* Avantaje: cod mai rapid și mai scurt.
* Schimbă complexitatea algoritmului: da.
* Timp precalculare: ''O(n2)''.
* Memorie extra folosită: ''O(n2)''.

=== Numărul de biţi 1 într-un întreg ===

Cum putem calcula numărul de cifre 1 din reprezentarea în baza 2 a unui număr?

* Direct: ''shift and mask''. Complexitate ''O(nr. biţi)''
* Folosind expresia <source lang="C" enclose="none">x & (x - 1)</source>. Complexitate ''O(nr. biţi)''
* Cu precalculare: ţinem un vector în care elementul <source lang="C" enclose="none">v[x]</source> este numărul de biţi 1 din reprezentarea în baza 2 a lui <source lang="C" enclose="none">x</source>.

Concluzii precalculare număr de biți 1:

* Avantaje: cod mai rapid.
* Schimbă complexitatea algoritmului: da.
* Timp precalculare: ''O(xMax log xMax)''.
* Memorie extra folosită: ''O(2nr. biți)'', sau ''O(xMax)''. Poate fi prohibitiv dacă '''xMax''' este mare.

Întrebări:

* Se poate mai bine decât ''O(nr. biţi)'' '''fără memorie suplimentară''' (adică ''O(1)'' memorie suplimentară)?
* Putem adapta metoda precalculării și la numere '''xMax''' mari, gen numere întregi pe <source lang="C" enclose="none">int</source>?

=== Vector de diferențe (difference array) ===

''Mai poartă denumirea și de sume de intervale sau șmenul lui Mars''

Se dă un vector cu <source lang="C" enclose="none">n</source> elemente, iniţial zero. O operaţiune pe acest vector constă în incrementarea fiecărui element între indicii <source lang="C" enclose="none">i</source> şi <source lang="C" enclose="none">j</source>. Se dau <source lang="C" enclose="none">m</source> operaţiuni de executat. Să se afişeze valorile finale ale vectorului.

Soluţia forţă brută implică execuţia celor <source lang="C" enclose="none">m</source> operaţiuni. O operaţiune constă în incrementarea a maxim n elemente din vector, deci avem <source lang="C" enclose="none">n x m</source> operaţii, plus afişarea elementelor finale. Complexitatea totală este ''O(mn)''.

'''Exemplu'''

În următorul exemplu avem un vector inițial zero și se cere să executăm două operațiuni: operațiunea a va incrementa elementele de la pozițiile 2 la 13 și operațiunea b care va incrementa elementele de la pozițiile 6 la 9.

[[File:mars-1D-brut.gif|frame|none|Operațiuni aplicate cu metoda forță brută]]

'''Îmbunătățire'''

Se poate mai bine? Putem optimiza timpul unei operaţiuni. Ideea este următoarea: în loc să incrementăm pe rând elementele vectorului, am putea să le grupăm. Pentru aceasta vom întârzia incrementarea, marcând doar locurile unde trebuie să adunăm.

Cu alte cuvinte: am putea considera intervalele ca pe nişte paranteze aşezate pe o dreaptă. O paranteză deschisă înseamnă că de acum înainte trebuie să adunăm 1 la toate elementele care urmează. O paranteză închisă înseamnă că ne putem opri din adunat 1. Să presupunem că nu avem capete de interval suprapuse. Atunci am putea memora parantezele într-un vector separat. Vom memora 1 pentru o paranteză deschisă, -1 pentru o paranteză închisă şi 0 în caz că nu avem nici un capăt de interval în acel element.

'''Ipoteză:''' vectorul <source lang="C" enclose="none">s[]</source> de sume parţiale ale acestui vector constituie chiar rezolvarea problemei.

Avem, deci: <source lang="C" enclose="none">s[i] = v[0] + v[1] + ... + v[i]</source>

Înseamnă că <source lang="C" enclose="none">v[k]</source> se va aduna la toate sumele <source lang="C" enclose="none">s[k], s[k+1], ..., s[n]</source>. Ceea ce înseamnă că dacă pe poziția <source lang="C" enclose="none">k</source> în vectorul <source lang="C" enclose="none">v[]</source> avem valoarea unu, acea valoare se va propaga în toate elementele lui <source lang="C" enclose="none">s[]</source> începând cu poziția <source lang="C" enclose="none">k</source>.

Dorim să aplicăm un interval [2, 13], deci vom plasa 1 pe poziția 2. El se va propaga până la finalul vectorului <source lang="C" enclose="none">s[]</source>. Dar noi vrem ca începând cu poziția 14 acel 1 să nu se mai propage. Deoarece nu putem acest lucru, vom face altceva: vom plasa valoarea -1 pe poziția 14. Ea se va propaga, și ea, până la final de vector <source lang="C" enclose="none">s[]</source>, adunându-se la fiecare element o singură dată. Ea va anula propagarea elementului 1 plasat la poziția 2.

Similar, dacă dorim să aplicăm intervalul [6, 9] vom plasa 1 pe poziția 6 în <source lang="C" enclose="none">v[]</source> și -1 pe poziția 10.

După ce am plasat toate intervalele, vom calcula în <source lang="C" enclose="none">s[]</source> sumele parțiale ale lui <source lang="C" enclose="none">v[]</source>. Vectorul <source lang="C" enclose="none">s[]</source> este răspunsul, valorile finale cerute.

În fapt, nu avem nevoie de doi vectori. Putem suprascrie vectorul <source lang="C" enclose="none">v[]</source>, deoarece nu mai avem nevoie de elementele marker.

[[File:mars-1D-optim.gif|frame|none|Operațiuni aplicate prin precalculare]]

'''Funcţionează acest algoritm dacă avem capete de interval suprapuse?''' Da, cu condiţia ca elementul în care se suprapun capete să fie suma acelor capete, adică o sumă de 1 şi -1. Aceasta înseamnă că atunci când generăm vectorul de paranteze nu vom scrie <source lang="C" enclose="none">s[i] = 1</source> ci <source lang="C" enclose="none">s[i]++</source> (la fel şi pentru -1, vom decrementa).

'''Generalizare 1:''' putem generaliza această metodă pentru problema în care intervalele nu adună 1, ci orice număr, constant pe parcursul intervalului. Cum generalizăm? O paranteză deschisă nu va aduna 1, ci constanta respectivă.

'''Generalizare 2:''' dar dacă vectorul iniţial are valori diferite de zero? În acest caz vom calcula un vector separat, iniţializat cu zero, pe care facem calculul sumelor parţiale. Acest vector ne va spune cu cât s-a mărit fiecare element zero. În final vom aduna acest vector de sume parţiale la vectorul iniţial.

Acest exemplu de precalculare, este cunoscut printre unii din voi drept ''șmenul lui Mars'', denumire care îmi displace deoarece sugerează că informatica este o colecție de șmenuri.

'''Când nu funcţionează această soluţie?'''

Atunci când coordonatele intervalelor sunt prea mari pentru ca vectorul de sume parţiale să încapă în memorie.

Să presupunem că ni se cere numărul maxim din vectorul de sume parţiale. În acest caz există o soluţie alternativă, mai generală (în sensul în care rezolvă o clasă mai mare de probleme cu intervale), care nu folosește precalculare: putem memora capetele de intervale, pe care apoi le ordonăm crescător, ţinând minte de ce tip sunt, închis sau deschis.

Apoi le parcurgem în ordine, calculînd sumele parţiale fără să le stocăm. Suma parţială maximă este răspunsul cerut.

Desigur că atunci când vectorul încape în memorie, e mai uşoară precalcularea.

* Avantaje: cod mai rapid.
* Schimbă complexitatea algoritmului: da.
* Timp precalculare: ''O(k) - k'' numărul de intervale.
* Memorie extra folosită: ''O(MAXCOORD)''. Poate fi prohibitiv dacă '''MAXCOORD''' este mare.

=== Matrice de differențe (difference arrays 2D) ===

''Mai poartă denumirea de sume de dreptunghiuri''

Acest tip de precalculare se poate extinde în două dimensiuni, pe matrice: se dau <source lang="C" enclose="none">m</source> dreptunghiuri care adună 1 la toate elementele respective dintr-o matrice. De data aceasta vom folosi o matrice de sume parțiale, ce necesită ''O(n2)'' memorie.

Nu voi detalia algoritmul, iată partea de plasare a unui dreptunghi ''(l1, c1)'' -> ''(l2, c2)''. Desenul arată punctele unde se adună/scade 1:

[[File:mars-2D-optim.gif|frame|none|Operațiuni aplicate prin precalculare]]

Această metodă nu se justifică decât în măsura în care este facil de programat, deoarece avem o soluție de aceeași complexitate care folosește varianta 1D, pe vector, folosind doar ''O(n)'' memorie, ca la problema [https://www.nerdarena.ro/problema/flori1 flori1].

== Exemple de probleme cu precalculare ==

* [https://www.nerdarena.ro/problema/paisprezece Paisprezece]: necesită un vector ce păstrează numere prime, ciurul lui Eratostene.
* [https://www.nerdarena.ro/problema/intervale Intervale]: ciurului lui Eratostene, sume parţiale.
* [https://www.nerdarena.ro/problema/reginald Reginald], o optimizare a problemei anterioare.
* [https://www.nerdarena.ro/problema/puncte1 Puncte1]: o rezolvare posibilă folosește precalcularea sumelor parţiale ale unei matrice
* [https://www.nerdarena.ro/problema/extraterestri Extraterestri] precalculare vector sume prefixe parțiale (a.k.a. șmenul lui Mars)
* [https://www.nerdarena.ro/problema/extraterestri1 Extraterestri1] Mars + normalizare coordonate
* [https://www.nerdarena.ro/problema/flori Flori] Precalculare matrice sume prefixe parţiale (a.k.a. şmenul lui Mars 2D)
* [https://www.nerdarena.ro/problema/flori1 Flori1] exemplu de problemă nerezolvabilă cu precalculare 2D din lipsă de memorie

== Concluzii ==

* Precalcularea foloseşte atunci când avem de răspuns la mai multe întrebări costisitoare. Aceste întrebări pot fi explicite, cerute de enunţ, sau implicite, decurgând din metoda de rezolvare.
* Precalcularea poate folosi şi atunci când numărul de întrebări este mult mai mare decât numărul de răspunsuri posibile, caz în care putem precalcula toate răspunsurile într-un tabel înainte de a răspunde la întrebări. Această precalculare seamănă cu memoizarea. Diferența constă în faptul că precalcularea este executată explicit înainte de calcul, pe când memoizarea ține minte valori calculate în timpul calculului.
* Precalcularea foloseşte o structură de date adiţională şi memorie suplimentară. Uneori putem economisi memorie folosindu-ne chiar de structura de date iniţială.

== Tema 5 ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/intervale Intervale] dată pregătire OJI 2013 clasa a 9-a la Vianu
* [https://www.nerdarena.ro/problema/patrate1 Patrate1] dată la cercul de informatică Vianu 2013 clasa a 6-a rezolvată în cel mult ''O(n3)''!
* [https://www.nerdarena.ro/problema/extraterestri Extraterestri] dată la OJI 2012 clasa a 8-a

== Tema opțională ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/reginald Reginald] dată la pregătire olimpiadă 2013 clasele 7/8/9/10 la Vianu
* [https://www.nerdarena.ro/problema/flori1 Flori1] dată la pregătire baraj gimnaziu 2013 la Vianu

Opțional, gândiți-vă la următoarele întrebări - calcul număr biți 1 în reprezentarea binară a unui întreg:

* Se poate mai bine decât ''O(nr. biţi)'' fără memorie suplimentară (adică ''O(1)'' memorie suplimentară)?
* Putem adapta metoda precalculării și la numere '''xMax''' mari, gen numere întregi pe <source lang="C" enclose="none">int</source>?

[http://solpedia.francu.com/wiki/index.php/Clasa_a_7-a_Lec%C8%9Bia_5:_Precalculare Accesează rezolvarea temei 5]

Clasa a 7-a Lecția 4: Liste (2)

2025-06-11T13:39:56Z

Mihai:

== Înregistrare video curs ==

{{#ev:youtube|https://youtu.be/WvM90m3wRPo|||||start=4835&end=8880&loop=1}}

== Operații cu liste ==

Să vedem câteva exemple de manipulare a listelor. În toate aceste exemple vom considera liste de întregi reprezentate astfel:

<syntaxhighlight lang="C" line>
int key[MAXL]; // valori intregi memorate de lista
int next[MAXL]; // următorul element in lista
</syntaxhighlight>

Lista este definită de prima sa celulă:
<syntaxhighlight lang="C" line>
int l;
</syntaxhighlight>

===Lungimea unei liste===

Să se calculeze lungimea unei liste.

<syntaxhighlight lang="C" line>
// returneaza numarul de elemente al unei liste
int listLen( int l ) {
int len = 0; // initial lungimea este zero

while ( l != NIL ) { // l pointeaza la o celula?
len++; // numaram acea celula
l = next[l]; // si avansam la urmatoarea celula
}

return len; // returnam numarul de celule numarate
}
</syntaxhighlight>

===Căutare liniară element in listă===

Să se caute indicele (pointerul) primei celule ce conține un element.

<syntaxhighlight lang="C" line>
// returneaza indicele celulei care contine elementul e
// sau NIL daca el nu exista
int listFind( int e, int l ) {
while ( l != NIL && key[l] != e ) // avem o celula in l si nu contine e?
l = next[l]; // avansam la urmatoarea celula

return l; // l va fi fie celula elementului gasit, fie NIL cind negasit
}
</syntaxhighlight>

===Răsturnare listă===

Să se răstoarne o listă. La final lista inițială va fi distrusă. Lista cea nouă va conține exact celulele listei originale, dar cu elementele în ordine inversă.

<syntaxhighlight lang="C" line>
// rastoarna lista primita si returneaza lista rasturnata
// distruge lista initiala
int listReverse( int l ) {
int cell, // pointer la o celula
r = NIL; // lista noua, cea rasturnata

while ( l != NIL ) {
cell = l; // memoram celula curenta, capul listei l
l = next[l]; // avansam in lista l
next[cell] = r; // adaugam celula curenta in capul listei r
r = cell; // cell devine lista r
}

return r;
}
</syntaxhighlight>

===Eliminare duplicate în listă sortată crescător===

Dată o listă ale cărei elemente sunt ordonate crescător, să se transforme în listă mulțime prin eliminarea duplicatelor.

<syntaxhighlight lang="C" line>
// transforma o lista ordonata crescator intr-o lista multime
// prin eliminarea duplicatelor
// nu schimba elementul initial al listei
void listSet( int l ) {
if ( l != NIL ) {
while ( next[l] != NIL )
if ( key[next[l]] == key[l] ) // elementul urm este egal cu cel curent?
next[l] = next[next[l]]; // daca da, elimina elementul urmator
else
l = next[l]; // altfel avanseaza la elementul urmator
}
}
</syntaxhighlight>

===Exemplu de folosire a funcțiilor de mai sus===

Iată un program care folosește funcțiile de mai sus:

<syntaxhighlight lang="C" line>
// Exemple de implementare diverse operatii elementare pe liste
#include <stdio.h>

#define NIL -1
#define MAXL 1000

int key[MAXL]; // valori intregi memorate de lista
int next[MAXL]; // următorul element in lista

// returneaza numarul de elemente al unei liste
int listLen( int l ) {
int len = 0; // initial lungimea este zero

while ( l != NIL ) { // l pointeaza la o celula?
len++; // numaram acea celula
l = next[l]; // si avansam la urmatoarea celula
}

return len; // returnam numarul de celule numarate
}

// returneaza indicele celulei care contine elementul e
// sau NIL daca el nu exista
int listFind( int e, int l ) {
while ( l != NIL && key[l] != e ) // avem o celula in l si nu contine e?
l = next[l]; // avansam la urmatoarea celula

return l; // l va fi fie celula elementului gasit, fie NIL cind negasit
}

// rastoarna lista primita si returneaza lista rasturnata
// distruge lista initiala
int listReverse( int l ) {
int cell, // pointer la o celula
r = NIL; // lista noua, cea rasturnata

while ( l != NIL ) {
cell = l; // memoram celula curenta, capul listei l
l = next[l]; // avansam in lista l
next[cell] = r; // adaugam celula curenta in capul listei r
r = cell; // cell devine lista r
}

return r;
}

// transforma o lista ordonata crescator intr-o lista multime
// prin eliminarea duplicatelor
// nu schimba elementul initial al listei
void listSet( int l ) {
if ( l != NIL ) {
while ( next[l] != NIL )
if ( key[next[l]] == key[l] ) // elementul urm este egal cu cel curent?
next[l] = next[next[l]]; // daca da, elimina elementul urmator
else
l = next[l]; // altfel avanseaza la elementul urmator
}
}

// tipareste elementele unei liste cu un spatiu intre ele
void listPrint( int l, FILE *f ) {
while ( l != NIL ) {
fprintf( f, "%d ", key[l] );
l = next[l];
}
}

int main() {
FILE *fin, *fout;
int n, i, e1, e2, l, r;

fin = fopen( "lista.in", "r" );
fscanf( fin, "%d%d%d", &n, &e1, &e2 );
if ( n == 0 )
l = NIL;
else {
l = 0;
for ( i = 0; i < n; i++ ) {
fscanf( fin, "%d", &key[i] );
next[i] = i + 1;
}
next[n - 1] = NIL;
}
fclose( fin );

fout = fopen( "lista.out", "w" );
fprintf( fout, "lista citita: [" );
listPrint( l, fout );
fprintf( fout, "]\n" );

fprintf( fout, "lungime: %d\n", listLen( l ) );

fprintf( fout, "celula cu cheie %d are indice %d\n", e1, listFind( e1, l ) );
fprintf( fout, "celula cu cheie %d are indice %d\n", e2, listFind( e2, l ) );

r = listReverse( l );

fprintf( fout, "lista inversata: [" );
listPrint( r, fout );
fprintf( fout, "]\n" );

listSet( r );

fprintf( fout, "lista multime: [" );
listPrint( r, fout );
fprintf( fout, "]\n" );

fprintf( fout, "lungime: %d\n", listLen( r ) );
fclose( fout );

return 0;
}
</syntaxhighlight>

Programul de mai sus a fost executat pe următorul fișier de intrare, lista.in:

<syntaxhighlight lang="C" line>
10 6 1
9 9 7 7 6 5 5 4 3 3 2
</syntaxhighlight>

== Exemple de probleme rezolvate cu liste ==

===Problema Onigim===

Problema [https://www.nerdarena.ro/problema/onigim Onigim] a fost dată la ONI 2013 clasa a 5a. Ea admite o rezolvare foarte scurtă cu liste, desigur peste nivelul clasei a 5a.

Observăm că:

* Toți elevii care au același număr de elevi ''sub ei'' vor avea același punctaj.
* Elevii pot fi, deci, împărțiți în grupuri de elevi cu același punctaj.
* Numărul de grupuri de elevi este exact numărul de punctaje distincte.
* Deoarece punctajele distincte se dau în ordine crescătoare, un algoritm banal ar fi să parcurgem grupurile de elevi în ordinea crescătoare a numărului de elevi ''sub'' acel grup.
* Toți elevii dintr-un grup primesc nota punctajului curent, apoi avansăm la următorul grup.

Cum implementăm acest algoritm destul de ușor? Trebuie să memorăm cumva aceste grupuri. Astfel, un grup este format din ID-uri, iar toate ID-urile au ceva în comun, care este unic: numărul de elevi ''sub'' acele ID-uri.

Astfel ne vine ideea să folosim liste: ce-ar fi ca pentru fiecare număr posibil de elevi ''sub'' să menținem câte o listă de ID-uri? Dacă pentru un număr de elevi ''sub'' nu există ID-uri lista va fi vidă.

Iată gruparea de ID-uri de elevi pe liste, conform exemplului din problemă:

{|
| valign="top"|
<pre>6 4
100 150 175 200
4 2 0 0 3 4</pre>
|-
| valign="top"|[[File:lista-onigim.gif|frame|none|Exemplul din problema onigim - concept structură de date]]
|}

'''Explicații''': avem patru punctaje distincte obținute, 100 150 175 și 200. Avem șase elevi numerotați de la 1 la 6. În desen observăm că avem o listă de doi copii care au zero copii ''sub'' ei, anume cei cu ID-urile 4 și 3. De aceea ei sunt ''agățați'' la lista zero. Avem alți doi copii care au patru copii ''sub'' ei, cu ID-urile 1 și 6. Ei sunt ''agățați'' la lista patru. Și tot așa, mai avem câte un singur copil în grupurile 2 și 3.

'''Cum rezolvăm problema''' pe baza acestei structuri? Printr-o parcurgere a listelor în ordine, de sus în jos și de la stînga la dreapta. Toate ID-urile din prima listă, 3 și 4, vor primi primul punctaj, adică 100. Toate ID-urile din a doua listă, adică 2, vor primi următorul punctaj, adică 150. Și așa mai departe. Printr-o singură parcurgere putem rezolva toate cele trei puncte ale problemei. Succes! :-)

'''De remarcat''': o implementare îngrijită a acestui algoritm va avea circa 50 de linii, iar ca linii de program efectiv probabil 40.

===Problema Macheta===

Problema [https://www.nerdarena.ro/problema/macheta Macheta] a fost dată la ONI 2011 clasa a 8-a. Ea admite o rezolvare foarte scurtă cu liste, care nu apare printre rezolvările oficiale.

Observăm că:

* O clădire ''C'' este vizibilă dacă există o coordonată ''x'' pe care se află numai clădiri mai mici, în fața clădirii ''C''.
* Putem, astfel, verifica vizibilitatea unei clădiri verificând vizibilitatea fiecărei coordonate ''x'' acoperite de ea.

Deja avem un algoritm rezonabil: pentru fiecare clădire ''C'', parcurgem fiecare coordonată ''x'' a ei, iar pentru fiecare coordonată verificăm toate clădirile ''B'' dacă:

* ''B'' este în fața lui ''C'' (''y'' mai mic)
* ''B'' acoperă coordonata ''x''
* ''B'' are înălțime mai mare ca ''C''

Ce complexitate are acest algoritm?

Pentru fiecare clădire vom parcurge fiecare coordonată a ei, apoi fiecare altă clădire. Rezultă o complexitate ''O(N2 Lx)''. După înlocuiri rezultă circa 10 milioane de operații, pare că algoritmul acesta banal s-ar încadra în timp.

Dar să mergem mai departe cu observațiile:

* Deoarece vom verifica doar clădirile din fața lui ''C'', ne interesează doar clădirile cu ''y'' mai mic.
* Pare a fi util să parcurgem clădirile în ordinea crescătoare a lui ''y''.
* Pentru fiecare coordonată ''x'' a clădirii ''C'' curente ne interesează maximul de înălțime de pînă acum, la acea coordonată.
* Astfel, putem memora un vector de înălțimi maxime, care pentru fiecare coordonată ''x'' memorează cea mai înaltă clădire vizibilă la coordonata ''x'', pînă la acest moment.

Cum implementăm acest algoritm?

Cumva trebuie să parcurgem clădirile în ordinea crescătoare a lui ''y''. Soluțiile oficiale sar imediat la sortare. Dar să nu ne grăbim! Sortarea este lentă, ar fi bine să o evităm dacă putem.

Și desigur că putem: ce-ar fi să păstram pentru fiecare coordonată ''y'' o listă de clădiri ce încep la acea coordonată? Apoi parcurgem clădirile în ordinea lui ''y''.

Iată gruparea de clădiri pe liste, conform exemplului din problemă:

{|
| valign="top"|[[File:macheta.jpg|frame|none|Exemplul din problema macheta - desen]]
| valign="top"|[[File:lista-macheta.gif|frame|none|Exemplul din problema macheta - concept structură de date]]
|}

'''Explicații''': avem o clădire care începe la ''y''=1 - clădirea 3. Avem o clădire care începe la ''y''=2 - clădirea 2. Avem două clădiri care încep la ''y''=3 - 4 și 5. Și o clădire care începe la ''y''=6 - clădirea 1.

'''Cum rezolvăm problema''' pe baza acestei structuri? Printr-o parcurgere a listelor în ordine, de sus în jos și de la stânga la dreapta. Pentru fiecare clădire ''C'' parcurgem coordonatele ei ''x'', verificând vectorul de înălțimi <<source lang="C" enclose="none">h[x]</source>. Dacă măcar una din înălțimi este mai mică, clădirea este vizibilă. Atenție, înălțimile trebuie actualizate dacă înălțimea lui ''C'' este mai mare decît cea a lui <code>h[x]</code>.

'''De remarcat''': o implementare îngrijită a acestui algoritm va avea circa 50 de linii, iar ca linii de program efectiv probabil 40.

Ce complexitate are acest algoritm?

Construcția listelor este ''O(N)'', numărul de clădiri. Parcurgerea listelor este ''O(N + Ly)''. Pentru fiecare clădire vom prelucra în timp constant fiecare coordonată ''x'' a sa. Rezultă complexitatea finală ''O(N Lx + Ly)''. După înlocuiri rezultă circa 100 000 de operații. Memoria va fi ''O(Lx)'', adică neglijabilă.

Din nou, o problemă intenționată spre a fi grea devine simplă prin folosirea listelor.

== Tema 4 ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]), folosind liste!

* [https://www.nerdarena.ro/problema/onigim Onigim], dată la ONI 2013 clasa a 5-a;
* [https://www.nerdarena.ro/problema/macheta Macheta], dată la ONI 2011 clasa a 8-a;
* [https://www.nerdarena.ro/problema/criptic Criptic].

==Tema opțională==

'''Detecție listă cu buclă'''

Să se determine dacă o listă se întoarce la ea însăși (unul din elemente pointează la o celulă din-naintea lui). Nu aveți voie să vă legați de valorile memorate, ele pot fi duplicat. Vă puteți folosi strict de legăturile listei, vectorul <source lang="C" enclose="none">next[]</source>.

Vă rămâne ca temă de gândire:

* Ușor: ''O(n2)'' - unde <source lang="C" enclose="none">n</source> este numărul de elemente al listei
* Greu: ''O(n)''

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_4:_Liste_(2) Accesează rezolvarea temei 4]

Clasa a 7-a Lecția 4: Liste (2)

2025-06-11T13:39:42Z

Mihai: /* Înregistrare video curs */

Clasa a 7-a Lecția 4: Liste (2)

2025-06-11T13:38:37Z

Mihai: /* Înregistrare video curs */

== Înregistrare video curs ==

{{#ev:youtube|https://youtu.be/WvM90m3wRPo|||||start=4835&loop=1}}

== Operații cu liste ==

Să vedem câteva exemple de manipulare a listelor. În toate aceste exemple vom considera liste de întregi reprezentate astfel:

<syntaxhighlight lang="C" line>
int key[MAXL]; // valori intregi memorate de lista
int next[MAXL]; // următorul element in lista
</syntaxhighlight>

Lista este definită de prima sa celulă:
<syntaxhighlight lang="C" line>
int l;
</syntaxhighlight>

===Lungimea unei liste===

Să se calculeze lungimea unei liste.

<syntaxhighlight lang="C" line>
// returneaza numarul de elemente al unei liste
int listLen( int l ) {
int len = 0; // initial lungimea este zero

while ( l != NIL ) { // l pointeaza la o celula?
len++; // numaram acea celula
l = next[l]; // si avansam la urmatoarea celula
}

return len; // returnam numarul de celule numarate
}
</syntaxhighlight>

===Căutare liniară element in listă===

Să se caute indicele (pointerul) primei celule ce conține un element.

<syntaxhighlight lang="C" line>
// returneaza indicele celulei care contine elementul e
// sau NIL daca el nu exista
int listFind( int e, int l ) {
while ( l != NIL && key[l] != e ) // avem o celula in l si nu contine e?
l = next[l]; // avansam la urmatoarea celula

return l; // l va fi fie celula elementului gasit, fie NIL cind negasit
}
</syntaxhighlight>

===Răsturnare listă===

Să se răstoarne o listă. La final lista inițială va fi distrusă. Lista cea nouă va conține exact celulele listei originale, dar cu elementele în ordine inversă.

<syntaxhighlight lang="C" line>
// rastoarna lista primita si returneaza lista rasturnata
// distruge lista initiala
int listReverse( int l ) {
int cell, // pointer la o celula
r = NIL; // lista noua, cea rasturnata

while ( l != NIL ) {
cell = l; // memoram celula curenta, capul listei l
l = next[l]; // avansam in lista l
next[cell] = r; // adaugam celula curenta in capul listei r
r = cell; // cell devine lista r
}

return r;
}
</syntaxhighlight>

===Eliminare duplicate în listă sortată crescător===

Dată o listă ale cărei elemente sunt ordonate crescător, să se transforme în listă mulțime prin eliminarea duplicatelor.

<syntaxhighlight lang="C" line>
// transforma o lista ordonata crescator intr-o lista multime
// prin eliminarea duplicatelor
// nu schimba elementul initial al listei
void listSet( int l ) {
if ( l != NIL ) {
while ( next[l] != NIL )
if ( key[next[l]] == key[l] ) // elementul urm este egal cu cel curent?
next[l] = next[next[l]]; // daca da, elimina elementul urmator
else
l = next[l]; // altfel avanseaza la elementul urmator
}
}
</syntaxhighlight>

===Exemplu de folosire a funcțiilor de mai sus===

Iată un program care folosește funcțiile de mai sus:

<syntaxhighlight lang="C" line>
// Exemple de implementare diverse operatii elementare pe liste
#include <stdio.h>

#define NIL -1
#define MAXL 1000

int key[MAXL]; // valori intregi memorate de lista
int next[MAXL]; // următorul element in lista

// returneaza numarul de elemente al unei liste
int listLen( int l ) {
int len = 0; // initial lungimea este zero

while ( l != NIL ) { // l pointeaza la o celula?
len++; // numaram acea celula
l = next[l]; // si avansam la urmatoarea celula
}

return len; // returnam numarul de celule numarate
}

// returneaza indicele celulei care contine elementul e
// sau NIL daca el nu exista
int listFind( int e, int l ) {
while ( l != NIL && key[l] != e ) // avem o celula in l si nu contine e?
l = next[l]; // avansam la urmatoarea celula

return l; // l va fi fie celula elementului gasit, fie NIL cind negasit
}

// rastoarna lista primita si returneaza lista rasturnata
// distruge lista initiala
int listReverse( int l ) {
int cell, // pointer la o celula
r = NIL; // lista noua, cea rasturnata

while ( l != NIL ) {
cell = l; // memoram celula curenta, capul listei l
l = next[l]; // avansam in lista l
next[cell] = r; // adaugam celula curenta in capul listei r
r = cell; // cell devine lista r
}

return r;
}

// transforma o lista ordonata crescator intr-o lista multime
// prin eliminarea duplicatelor
// nu schimba elementul initial al listei
void listSet( int l ) {
if ( l != NIL ) {
while ( next[l] != NIL )
if ( key[next[l]] == key[l] ) // elementul urm este egal cu cel curent?
next[l] = next[next[l]]; // daca da, elimina elementul urmator
else
l = next[l]; // altfel avanseaza la elementul urmator
}
}

// tipareste elementele unei liste cu un spatiu intre ele
void listPrint( int l, FILE *f ) {
while ( l != NIL ) {
fprintf( f, "%d ", key[l] );
l = next[l];
}
}

int main() {
FILE *fin, *fout;
int n, i, e1, e2, l, r;

fin = fopen( "lista.in", "r" );
fscanf( fin, "%d%d%d", &n, &e1, &e2 );
if ( n == 0 )
l = NIL;
else {
l = 0;
for ( i = 0; i < n; i++ ) {
fscanf( fin, "%d", &key[i] );
next[i] = i + 1;
}
next[n - 1] = NIL;
}
fclose( fin );

fout = fopen( "lista.out", "w" );
fprintf( fout, "lista citita: [" );
listPrint( l, fout );
fprintf( fout, "]\n" );

fprintf( fout, "lungime: %d\n", listLen( l ) );

fprintf( fout, "celula cu cheie %d are indice %d\n", e1, listFind( e1, l ) );
fprintf( fout, "celula cu cheie %d are indice %d\n", e2, listFind( e2, l ) );

r = listReverse( l );

fprintf( fout, "lista inversata: [" );
listPrint( r, fout );
fprintf( fout, "]\n" );

listSet( r );

fprintf( fout, "lista multime: [" );
listPrint( r, fout );
fprintf( fout, "]\n" );

fprintf( fout, "lungime: %d\n", listLen( r ) );
fclose( fout );

return 0;
}
</syntaxhighlight>

Programul de mai sus a fost executat pe următorul fișier de intrare, lista.in:

<syntaxhighlight lang="C" line>
10 6 1
9 9 7 7 6 5 5 4 3 3 2
</syntaxhighlight>

== Exemple de probleme rezolvate cu liste ==

===Problema Onigim===

Problema [https://www.nerdarena.ro/problema/onigim Onigim] a fost dată la ONI 2013 clasa a 5a. Ea admite o rezolvare foarte scurtă cu liste, desigur peste nivelul clasei a 5a.

Observăm că:

* Toți elevii care au același număr de elevi ''sub ei'' vor avea același punctaj.
* Elevii pot fi, deci, împărțiți în grupuri de elevi cu același punctaj.
* Numărul de grupuri de elevi este exact numărul de punctaje distincte.
* Deoarece punctajele distincte se dau în ordine crescătoare, un algoritm banal ar fi să parcurgem grupurile de elevi în ordinea crescătoare a numărului de elevi ''sub'' acel grup.
* Toți elevii dintr-un grup primesc nota punctajului curent, apoi avansăm la următorul grup.

Cum implementăm acest algoritm destul de ușor? Trebuie să memorăm cumva aceste grupuri. Astfel, un grup este format din ID-uri, iar toate ID-urile au ceva în comun, care este unic: numărul de elevi ''sub'' acele ID-uri.

Astfel ne vine ideea să folosim liste: ce-ar fi ca pentru fiecare număr posibil de elevi ''sub'' să menținem câte o listă de ID-uri? Dacă pentru un număr de elevi ''sub'' nu există ID-uri lista va fi vidă.

Iată gruparea de ID-uri de elevi pe liste, conform exemplului din problemă:

{|
| valign="top"|
<pre>6 4
100 150 175 200
4 2 0 0 3 4</pre>
|-
| valign="top"|[[File:lista-onigim.gif|frame|none|Exemplul din problema onigim - concept structură de date]]
|}

'''Explicații''': avem patru punctaje distincte obținute, 100 150 175 și 200. Avem șase elevi numerotați de la 1 la 6. În desen observăm că avem o listă de doi copii care au zero copii ''sub'' ei, anume cei cu ID-urile 4 și 3. De aceea ei sunt ''agățați'' la lista zero. Avem alți doi copii care au patru copii ''sub'' ei, cu ID-urile 1 și 6. Ei sunt ''agățați'' la lista patru. Și tot așa, mai avem câte un singur copil în grupurile 2 și 3.

'''Cum rezolvăm problema''' pe baza acestei structuri? Printr-o parcurgere a listelor în ordine, de sus în jos și de la stînga la dreapta. Toate ID-urile din prima listă, 3 și 4, vor primi primul punctaj, adică 100. Toate ID-urile din a doua listă, adică 2, vor primi următorul punctaj, adică 150. Și așa mai departe. Printr-o singură parcurgere putem rezolva toate cele trei puncte ale problemei. Succes! :-)

'''De remarcat''': o implementare îngrijită a acestui algoritm va avea circa 50 de linii, iar ca linii de program efectiv probabil 40.

===Problema Macheta===

Problema [https://www.nerdarena.ro/problema/macheta Macheta] a fost dată la ONI 2011 clasa a 8-a. Ea admite o rezolvare foarte scurtă cu liste, care nu apare printre rezolvările oficiale.

Observăm că:

* O clădire ''C'' este vizibilă dacă există o coordonată ''x'' pe care se află numai clădiri mai mici, în fața clădirii ''C''.
* Putem, astfel, verifica vizibilitatea unei clădiri verificând vizibilitatea fiecărei coordonate ''x'' acoperite de ea.

Deja avem un algoritm rezonabil: pentru fiecare clădire ''C'', parcurgem fiecare coordonată ''x'' a ei, iar pentru fiecare coordonată verificăm toate clădirile ''B'' dacă:

* ''B'' este în fața lui ''C'' (''y'' mai mic)
* ''B'' acoperă coordonata ''x''
* ''B'' are înălțime mai mare ca ''C''

Ce complexitate are acest algoritm?

Pentru fiecare clădire vom parcurge fiecare coordonată a ei, apoi fiecare altă clădire. Rezultă o complexitate ''O(N2 Lx)''. După înlocuiri rezultă circa 10 milioane de operații, pare că algoritmul acesta banal s-ar încadra în timp.

Dar să mergem mai departe cu observațiile:

* Deoarece vom verifica doar clădirile din fața lui ''C'', ne interesează doar clădirile cu ''y'' mai mic.
* Pare a fi util să parcurgem clădirile în ordinea crescătoare a lui ''y''.
* Pentru fiecare coordonată ''x'' a clădirii ''C'' curente ne interesează maximul de înălțime de pînă acum, la acea coordonată.
* Astfel, putem memora un vector de înălțimi maxime, care pentru fiecare coordonată ''x'' memorează cea mai înaltă clădire vizibilă la coordonata ''x'', pînă la acest moment.

Cum implementăm acest algoritm?

Cumva trebuie să parcurgem clădirile în ordinea crescătoare a lui ''y''. Soluțiile oficiale sar imediat la sortare. Dar să nu ne grăbim! Sortarea este lentă, ar fi bine să o evităm dacă putem.

Și desigur că putem: ce-ar fi să păstram pentru fiecare coordonată ''y'' o listă de clădiri ce încep la acea coordonată? Apoi parcurgem clădirile în ordinea lui ''y''.

Iată gruparea de clădiri pe liste, conform exemplului din problemă:

{|
| valign="top"|[[File:macheta.jpg|frame|none|Exemplul din problema macheta - desen]]
| valign="top"|[[File:lista-macheta.gif|frame|none|Exemplul din problema macheta - concept structură de date]]
|}

'''Explicații''': avem o clădire care începe la ''y''=1 - clădirea 3. Avem o clădire care începe la ''y''=2 - clădirea 2. Avem două clădiri care încep la ''y''=3 - 4 și 5. Și o clădire care începe la ''y''=6 - clădirea 1.

'''Cum rezolvăm problema''' pe baza acestei structuri? Printr-o parcurgere a listelor în ordine, de sus în jos și de la stânga la dreapta. Pentru fiecare clădire ''C'' parcurgem coordonatele ei ''x'', verificând vectorul de înălțimi <<source lang="C" enclose="none">h[x]</source>. Dacă măcar una din înălțimi este mai mică, clădirea este vizibilă. Atenție, înălțimile trebuie actualizate dacă înălțimea lui ''C'' este mai mare decît cea a lui <code>h[x]</code>.

'''De remarcat''': o implementare îngrijită a acestui algoritm va avea circa 50 de linii, iar ca linii de program efectiv probabil 40.

Ce complexitate are acest algoritm?

Construcția listelor este ''O(N)'', numărul de clădiri. Parcurgerea listelor este ''O(N + Ly)''. Pentru fiecare clădire vom prelucra în timp constant fiecare coordonată ''x'' a sa. Rezultă complexitatea finală ''O(N Lx + Ly)''. După înlocuiri rezultă circa 100 000 de operații. Memoria va fi ''O(Lx)'', adică neglijabilă.

Din nou, o problemă intenționată spre a fi grea devine simplă prin folosirea listelor.

== Tema 4 ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]), folosind liste!

* [https://www.nerdarena.ro/problema/onigim Onigim], dată la ONI 2013 clasa a 5-a;
* [https://www.nerdarena.ro/problema/macheta Macheta], dată la ONI 2011 clasa a 8-a;
* [https://www.nerdarena.ro/problema/criptic Criptic].

==Tema opțională==

'''Detecție listă cu buclă'''

Să se determine dacă o listă se întoarce la ea însăși (unul din elemente pointează la o celulă din-naintea lui). Nu aveți voie să vă legați de valorile memorate, ele pot fi duplicat. Vă puteți folosi strict de legăturile listei, vectorul <source lang="C" enclose="none">next[]</source>.

Vă rămâne ca temă de gândire:

* Ușor: ''O(n2)'' - unde <source lang="C" enclose="none">n</source> este numărul de elemente al listei
* Greu: ''O(n)''

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_4:_Liste_(2) Accesează rezolvarea temei 4]

Clasa a 7-a Lecția 3: Liste (1)

2025-06-11T11:07:18Z

Mihai:

== Înregistrare video lecție ==

{{#ev:youtube|https://youtu.be/yMeFuBS5ovA|||||start=5795&end=12840&loop=1}}

==Conceptului de liste==

===Definiție===

În informatică '''o listă înlănțuită este o structură de date care constă dintr-un grup de noduri care împreună reprezintă o secvență'''. În forma ei cea mai simplă, fiecare nod este format din date și o referință (înlănțuire) către nodul următor în secvență. Lista înlănțuită permite inserarea și ștergerea eficientă a elementelor de pe orice poziție în secvență.

[[Image:lista-exemplu.gif|frame|none|Exemplu de listă înlănțuită]]

După cum puteți să vedeți, există o diferență mare între vectori și liste. Vectorii au poziții consecutive în care stocăm date pe când listele au referințe pentru a putea determina ordinea. Referințele pot avea oricare valori, neavând obligația să fie într-o ordine anume.

Pentru a înțelege mai bine diferența dintre liste și vectori, urmăriți clipul de mai jos:

<youtube height="720" width="1280">https://www.youtube.com/watch?v=b5QR4AmrspU</youtube>

===Implementare===

O implementare posibilă este folosind doi vectori: un vector <source lang="C" enclose="none">v[]</source> care memorează elementele listei (numere întregi de exemplu) și un vector <source lang="C" enclose="none">next[]</source>, care memorează indicele următorului element din listă.

Perechea <source lang="C" enclose="none">(v[i], next[i])</source> conține o celulă sau un nod al listei. Această celulă este memorată la poziția i, dar ea '''nu este celula numărul i'''! Ordinea în care memorăm celulele listei în vector nu are nici o relevanță. Importantă este înlănțuirea acestor celule, dată de vectorul <source lang="C" enclose="none">next[]</source>.

Ultima celulă a listei nu va avea un element următor. Avem nevoie de o valoare specială, terminator de listă pe care să o memorăm în vectorul <source lang="C" enclose="none">next[]</source> pentru ultima celulă. Aici se practică două variante:

# Valoarea 0. În acest caz în care nu vom putea folosi celula 0 din perechea de vectori. Vom vedea că nu e chiar o risipă, deoarece de multe ori vom folosi o santinelă pe poziția zero.

# Valoarea -1. În acest caz putem folosi toate celulele din perechea de vectori.

===Operații cu liste===

====Crearea unei liste cu elemente citite la intrare====

Vom folosi valoarea -1 ca terminator de listă:
<syntaxhighlight lang="c" line>
#define NIL -1

fscanf( fin, "%d", &n );
for ( i = 0; i < n; i++ ) {
fscanf( fin, "%d", &v[i] );
next[i] = i + 1;
}
next[n - 1] = NIL; // ultimul element din listă
</syntaxhighlight>

Observăm că fiecare element se leagă de cel de după el, mai puțin ultimul.

Ce complexitate are citirea unei liste?

Desigur ''O(n)'', ca și citirea unui vector.

====Afișarea unei liste====

<syntaxhighlight lang="c" line>
i = 0;
while ( i != NIL ) { // avem o celulă din listă, nu terminatorul
fprintf( fout, "%d ", v[i] ); // afișăm elementul listei
i = next[i]; // trecem la următorul element din listă
}
fprintf( fout, "\n" );
</syntaxhighlight>

Ce complexitate are scrierea unei liste?

Desigur ''O(n)'', ca și scrierea unui vector.

====Inserare element în listă după celula i====

Să presupunem că la poziția <source lang="C" enclose="none">i</source> avem celula cu elementul 45, ca mai jos. Dorim să inserăm o celulă cu elementul 12, aflată la poziția pos imediat după celula <source lang="C" enclose="none">i</source>. Iată cum vom proceda:

{|
| valign="top"|[[File:lista-inserare-desen.gif|frame|none|Inserare element - concept]]
| valign="top"|[[File:lista-inserare-implementare.gif|frame|none|Inserare element - implementare]]
|}

<syntaxhighlight lang="c" line>
// pos conține poziția nodului de inserat
next[pos] = next[i];
next[i] = pos;
</syntaxhighlight>

Ce complexitate are inserarea?

Desigur, ''O(1)''. Comparați cu un vector, unde inserarea este ''O(n)''.

====Ștergere din listă a celulei aflate după celula i====

Să presupunem că la poziția <source lang="C" enclose="none">i</source> avem celula cu elementul 45, ca mai jos. Dorim să eliminăm celula care apare în listă după celula <source lang="C" enclose="none">i</source>, cea cu elementul 10, aflat la poziția <source lang="C" enclose="none">j</source>. Iată cum vom proceda:

{|
| valign="top"|[[Image:lista-stergere-desen.gif|frame|none|Ștergere element - concept]]
| valign="top"|[[Image:lista-stergere-implementare.gif|frame|none|Ștergere element - implementare]]
|}

<syntaxhighlight lang="c" line>
next[i] = next[next[i]];
</syntaxhighlight>

Ce complexitate are inserarea?

Desigur, ''O(1)''. Comparați cu un vector, unde ștergerea este ''O(n)''.

====Valoarea elementului numărul k în listă====

Pentru a afla valoarea celui de-al <source lang="C" enclose="none">k</source>-lea element în listă va trebui să parcurgem primele <source lang="C" enclose="none">k</source> elemente, de la începutul listei. Să presupunem că prima celulă din listă este <source lang="C" enclose="none">i</source>. Atunci codul va fi:

<syntaxhighlight lang="c" line>
for ( j = 1; j < k; j++ ) // vom avansa de k-1 ori
i = next[i]; // avansam la urmatoarea celula din lista
printf( "Elementul numarul %d in lista este %d\n", k, v[i] )
</syntaxhighlight>

Ce complexitate are aflarea elementului <source lang="C" enclose="none">k</source>?

Ea este ''O(k)''. Comparați cu un vector, unde este ''O(1)''.

== Exemple de probleme rezolvate cu liste ==

===Aplicație 1: v-ați ascunselea===

'''n''' copii numerotați de la 1 la '''n''' și așezați în cerc numără la v-ați ascunselea, din '''k''' în '''k''', începând cu copilul 1. Date '''n''' și '''k''' să se afișeze ordinea în care ies copiii din cerc.

O rezolvare simplă este să memorăm numerele de la 1 la <source lang="C" enclose="none">n</source> într-un vector și apoi să avansăm <source lang="C" enclose="none">k</source> elemente și să afișăm elementul curent, iar apoi să îl setăm pe zero. Reluăm căutarea de <source lang="C" enclose="none">n</source> ori, ignorând elementele zero:

<syntaxhighlight lang="c" line>
#include <stdio.h>

int v[100];

int main() {
int n, k, i, j, pos;

scanf( "%d%d", &n, &k );
for ( i = 0; i < n; i++ )
v[i] = i + 1;
pos = n - 1;
for ( i = 0; i < n; i++ ) {
// avanseaza k elemente nenule
for ( j = 0; j < k; j++ ) {
pos = (pos + 1) % n;
while ( v[pos] == 0 )
pos = (pos + 1) % n;
}
printf( "%d ", v[pos] );
v[pos] = 0;
}
printf( "\n" );

return 0;
}</syntaxhighlight>

Ce complexitate are acest algoritm?

Dacă mai avem <source lang="C" enclose="none">i</source> copii în cerc îi vom număra de <source lang="C" enclose="none">k/i</source> ori. Restul elementelor fiind zero, vom face <source lang="C" enclose="none">k/i</source> parcurgeri ale întregului vector, deci <source lang="C" enclose="none">n·k/i</source> operații. Rezultă numărul de operații total:

: Număr operații = n*n/n + n*n/(n-1) + n*n/(n-2) + ... + n*n/2 + n*n/1.

Dăm factor comun n2:

: Număr operații = n2(1/n + 1/(n-1) + 1/(n-2) + ... + 1/2 + 1/1).

Suma dintre paranteze va fi studiată în clasa a zecea. Ea este aproximativ <source lang="C" enclose="none">log n</source>. Rezultă complexitatea soluției: ''O(n·k·log n)''.

Observăm o anume risipă în această soluție: deși avem poate doar doi copii în listă, noi vom număra până la <source lang="C" enclose="none">k</source>. Putem optimiza algoritmul numărând până la <source lang="C" enclose="none">k % i</source>, unde <source lang="C" enclose="none">i</source> este numărul de copii rămași în cerc.

Iată o soluție care folosește această idee:

<syntaxhighlight lang="c" line>
#include <stdio.h>

int v[100];

int main() {
int n, k, i, j, pos, a;

scanf( "%d%d", &n, &k );
for ( i = 0; i < n; i++ )
v[i] = i + 1;
pos = n - 1;
for ( i = n; i > 0; i-- ) { // numarul de copii scade de la n la 0
// numarul de copii ramasi in cerc este i
// avansam k % i deoarece nu are rost sa numaram dincolo de numarul
// de copii din cerc
a = k % i == 0 ? i : k % i; // trebuie sa avansam macar un copil
for ( j = 0; j < a; j++ ) {
pos = (pos + 1) % n; // avansam indicele - numaram copilul
while ( v[pos] == 0 ) // gasim urmatorul copil
pos = (pos + 1) % n;
}
printf( "%d ", v[pos] );
v[pos] = 0;
}
printf( "\n" );

return 0;
}</syntaxhighlight>

Ce complexitate are această soluție?

La fiecare pas vom trece maxim o dată prin toți copiii rămași în cerc. Vom parcurge, deci, cel mult o dată întregul vector de <source lang="C" enclose="none">n</source> elemente pentru fiecare copil care iese. Complexitatea va fi ''O(n2)''.

O soluție alternativă este una în care la fiecare pas eliminăm copilul din cerc ștergând valoarea sa din vector, prin deplasarea elementelor vectorului. Iată acea soluție:

<syntaxhighlight lang="c" line>
#include <stdio.h>

int v[100];

int main() {
int n, k, i, j, pos;

scanf( "%d%d", &n, &k );
for ( i = 0; i < n; i++ )
v[i] = i + 1;
pos = 0;
for ( i = n; i > 0; i-- ) { // numarul de copii scade de la n la 0
pos = (pos + k - 1) % i; // sarim peste k-1 copii in vector de marime i
printf( "%d ", v[pos] ); // afisam copilul
for ( j = pos + 1; j < i; j++ ) // eliminam copilul din vector
v[j - 1] = v[j];
}
printf( "\n" );

return 0;
}</syntaxhighlight>

Ce complexitate are această soluție?

De data aceasta avansul la următorul copil este ''O(1)''. Dar eliminarea elementului din vector este ''O(i)'' pe cazul cel mai rău, când mai avem <source lang="C" enclose="none">i</source> copii în cerc. Drept care vom avea:

: Număr operații = n + (n-1) + (n-2) + ... + 2 + 1

Aceasta fiind suma lui Gauss, rezultă o complexitate ''O(n2</sup)'', identică cu cea anterioară. Ea ne duce însă către o soluție mai bună. Care este pasul scump în această soluție? Eliminarea elementului din vector! Precum am văzut, eliminarea este rapidă într-o listă. Drept care hai să încercăm o soluție cu liste.

Vom așeza numerele de la 1 la n într-o listă. Restul algoritmului este identic cu cel anterior

<syntaxhighlight lang="c" line>
#include <stdio.h>

int v[100], next[100];

int main() {
int n, k, i, j, pos;

scanf( "%d%d", &n, &k );
// initializam lista
for ( i = 0; i < n; i++ ) {
v[i] = i + 1;
next[i] = (i + 1) % n;
}

pos = n - 1; // pos e pozitia copilului din-nainte de copilul de eliminat
for ( i = 0; i < n; i++ ) {
// avanseaza k - 1 elemente deoarece eliminarea conteaza ca un element
for ( j = 1; j < k; j++ )
pos = next[pos];
printf( "%d ", v[next[pos]] );
next[pos] = next[next[pos]];
}
printf( "\n" );

return 0;
}
</syntaxhighlight>

Remarcăm folosirea unei liste circulare. Ea nu are un prim sau un ultim element ci doar un element de pornire. Ea corespunde realității - copiii sunt așezați în cerc. Acum putem elimina copii numărați în mod eficient, dar parcurgerea elementelor nu mai este ''O(1)'' ci ''O(k)''. Per total complexitatea se reduce la ''O(n∙k)''. Pentru k mult mai mic decât <source lang="C" enclose="none">n</source> această soluție va fi mai bună decât cele anterioare.

===Aplicație 2: bile1===

Problema [https://www.nerdarena.ro/problema/bile1 Bile1] a fost dată la ONI 2012 clasa a 7-a. Problema poate fi rezolvată folosind o matrice caracteristică a obstacolelor. Dar dacă memoria permisă ar fi fost mai mică nu o puteam rezolva în acest fel.

Rezolvarea cu liste necesită doar ''O(m+n+p)'' memorie.

Vom memora atâtea liste câte coloane avem. Fiecare listă va stoca numerele de coloane la care avem obstacole în acea listă. Liniile ce nu au obstacole vor fi reprezentate ca liste vide.

Iată conceptul structurii de date pe care o vom folosi:

{|
| valign="top"|[[File:bile1.jpg|frame|none|Exemplul din problema bile1]]
| valign="top"|[[File:lista-bile1.gif|frame|none|Exemplul din desenul problemei - concept structură de date]]
|}

Pentru implementare vom folosi ca structuri de date:

* un vector <source lang="C" enclose="none">b[n]</source> care memorează linia cu bile,n fiind numărul de coloane;
* un vector <source lang="C" enclose="none">liste[m]</source> care pentru fiecare linie pointează la o listă de coloane pe care se află obstacole, <source lang="C" enclose="none">m</source> fiind numărul de linii;
* doi vectori <source lang="C" enclose="none">col[p]</source> și <source lang="C" enclose="none">next[p]</source> care memorează coloanele obstacolelor și următorul obstacol pe linie, <source lang="C" enclose="none">p</source> fiind numărul de obstacole.

Algoritmul folosit este următorul:

<syntaxhighlight lang="c" line>
1. Citește m, n și p, setează i la zero
2. Citește fiecare obstacol (l, c) si:
2.1 col[i] = c
2.2 adaugă coloana c la lista de pe linia l, liste[l]:
2.2.1 next[i] = liste[l]
2.2.2 liste[l] = i
2.3 i = i + 1
3. Citește vectorul de bile
4. Pentru fiecare linie l de la 1 la m
4.1 parcurge lista de coloane liste[l] si pentru fiecare obstacol col[i] din listă:
4.1.1 actualizează vectorul de bile la indicele coloanei, col[i]
</syntaxhighlight>

Cum se compară cu algoritmul inițial care folosește o matrice caracteristică?

{| class="wikitable"
!Structură de date
!Complexitate timp
!Complexitate memorie
!Explicații
|-
| Matrice de frecvență a obstacolelor
| <math>O(m\times n + p)</math>
| <math>O(m\times n)</math>
| Parcurgerea matricei de frecvență este <math>O(m\times n)</math>, iar prelucrarea obstacolelor este <math>O(p)</math>
|-
| Vector de liste de coloane ale obstacolelor
| <math>O(m + n + p)</math>
| <math>O(m + n + p)</math>
| Vom parcurge strict obstacolele, de unde rezultă complexitatea <math>O(p)</math>. Parcurgem și numerele inițiale, pentru citire, deci <math>O(n)</math>. Parcurgem și toate liniile matricei, pentru a verifica dacă avem o listă cu obstacole, deci <math>O(m)</math>.
|}

Observăm că atât timpul cât și memoria se îmbunătățesc substanțial. Problema fiind dată la clasa a șaptea într-o vreme când listele nu apăreau la această clasă este puțin probabil că aceasta a fost soluția dorită.

Cu toate acestea este un caz de studiu interesant unde o structură simplă de date, pe care olimpici și profesori o ignoră adesea în rezolvarea problemelor de olimpiadă, poate duce la un algoritm simplu și foarte eficient.

Despre ce structură este vorba? Despre un vector de liste. Rețineți: această structură poate rezolva multe probleme date la concursuri.

===Aplicație 3: zigzag===

Problema [https://www.nerdarena.ro/problema/zigzag Zigzag] dată la ONI 2012 clasa a 7-a cere de la concurenți o soluție matematică, ce presupune calculul coordonatelor literelor unui șir într-o matrice de dimensiuni cunoscute. Problema are, însă, o rezolvare foarte ușoară cu un vector de liste, o rezolvare ce nu presupune matematică și nici creativitate, ci doar o implementare îngrijită.

Ca și la bile1, vom ține minte pentru fiecare linie a matricei de codificare câte o listă cu coloanele unde apar litere. Vom genera aceste liste parcurgând în matrice pozițiile <source lang="C" enclose="none">(l, c)</source> unde s-ar afla textul (înainte de a citi acel text!) și adăugând coloana <source lang="C" enclose="none">c</source> la lista liniei <source lang="C" enclose="none">l</source>. Apoi vom parcurge aceste liste, în ordine, și vom atașa fiecărei celule, pe lângă coloană, o literă din text. De fapt vom vedea că nici nu avem nevoie să stocăm coloanele, ci doar literele. În final vom parcurge celulele în ordinea alocării lor, deoarece ea este chiar ordinea textului decodificat.

Iată conceptul structurii de date pe care o vom folosi:

{|
| valign="top"|[[File:zigzag.jpg|frame|none|Exemplul din problema zigzag]]
| valign="top"|[[File:lista-zigzag.gif|frame|none|Exemplul din desenul problemei - concept structură de date]]
|}

O diferență față de bile1 este că va trebui să ținem nu numai vectorul cu începutul listelor, ci și un vector cu ultimul element din listă pentru a putea face adăugarea la coadă foarte rapid. O alternativă ar fi să parcurgem pozițiile in ordine inversă (pare mai complicat, însă). Să denumim vectorii <source lang="C" enclose="none">prim[]</source> și <source lang="C" enclose="none">ultim[]</source>.

Iată algoritmul de generare a listelor:

<syntaxhighlight lang="C" line>
// pregatim listele cu pozitiile in matricea cheie
// cheie este cheia, iar n este numărul de caractere al mesajului,
// c aloca celulele listei si este si coloana in acelasi timp
l = 0;
pas = 1; // initial linia creste din unu in unu
// nu putem avea celule pe indexul 0 deoarece cu zero codificam finalul
// de lista, deci codificam coloanele incepind cu 1, no biggie
for ( c = 1; c <= n; c++ ) {
// pentru fiecare coloana a matricei calculam
// linia corespunzatoare literei (este una singura!)
// liniile vor fi de la zero, nici un motiv sa le numerotam de la 1
// avem perechea (l, c): aseaza c in lista l
next[c] = 0; // nu urmeaza nimeni după mine, sint ultima celula
if ( prim[l] == 0 ) // lista este vida
prim[l] = ultim[l] = c;
else // avem un ultim element
ultim[l] = next[ultim[l]] = c;// atasam celula la coada ultimului element

// avanseaza linia
l = l + pas;
if ( l < 0 || l >= cheie ) { // daca am depasit marginea inversam pasul
pas = -pas;
l = l + pas + pas; // adunam de doua ori pasul pentru a ne intoarce
}
}
</syntaxhighlight>

Ce complexitate are această soluție?

Este, sper, destul de clar că atât timpul cât și memoria vor fi liniare în numărul de caractere de la intrare. Din nou, folosirea unui vector de liste rezultă într-un algoritm simplu și eficient.

Vă rămâne ca temă să continuați această implementare. Mai aveți de parcurs listele in ordinea naturală și atașat literele din text, iar la final să parcurgeți celulele în ordinea alocării lor (cu indicele c) și să afișați caracterele lor.

== Tema 3 ==

Să se rezolve următoarele probleme (program C în CodeBlocks, trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/bile1 bile1] dată la ONI 2012 clasa a 7a rezolvată cu vector de liste de obstacole.
* [https://www.nerdarena.ro/problema/zigzag zigzag] dată la ONI 2012 clasa a 7a rezolvată cu vectori de liste. Chiar dacă există și alte rezolvări, scopul este să exersați listele, nu să luați 100p la problemă!
* [https://www.nerdarena.ro/problema/lacoada la coadă] ca aplicație la liste

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_3:_Liste_(1) Accesează rezolvarea temei 3]

Clasa a 7-a Lecția 2: Problema selecției și stive

2025-06-11T11:06:17Z

Mihai:

== Înregistrare video lecție ==

{{#ev:youtube|https://youtu.be/gy3zK4E8SSo|||||start=7400&end=9880&loop=1}}

== Problema selecției ==

'''Problema'''

Dat un șir de <source lang="C" enclose="none">n</source> numere și o poziție <source lang="C" enclose="none">k</source> în acel șir să se spună ce element s-ar afla pe acea poziție dacă șirul ar fi sortat.

'''Exemplu'''

Fie șirul <source lang="C" enclose="none">3 9 23 13 18 8 3 10 2 10 15 21</source> și poziția <source lang="C" enclose="none">k = 6</source>.

Dacă am ordona șirul am obține 2 3 3 8 9 10 10 13 15 18 21 23. Pe poziția 6 se află elementul 10, care este și răspunsul dorit.

===Soluție forță brută===

O soluție ce vine ușor în minte este să sortăm vectorul și apoi să afișăm elementul de la poziția <source lang="C" enclose="none">k</source>. Nu este eficientă, complexitatea ei va fi ''O(n2)'' cu sortare prin selecție, sau ''O(n log n)'' cu sortări mai rapide.

===Soluția folosind algoritmul Quick select===

Aplicăm un pas de pivotare în mod repetat. Algoritmul este prezentat aici: [https://en.wikipedia.org/wiki/Quickselect quickselect].

Ideea pivotării este următoarea: alegem un așa numit pivot. El este un element oarecare din vector. Putem să alegem elementul aflat la jumatea vectorului, <source lang="C" enclose="none">v[n/2]</source>. Sau putem să îl alegem la întâmplare, folosind o funcție ce generează numere aleatoare, cum ar fi funcția <source lang="C" enclose="none">rand()</source> în C (parte din biblioteca <source lang="C" enclose="none">stdlib.h</source>).

Fie <source lang="C" enclose="none">p</source> indicele pivotului și <source lang="C" enclose="none">val = v[p]</source> valoarea acelui pivot. Ne propunem să separăm vectorul în două: prima parte va conține elemente mai mici sau egale cu pivotul <source lang="C" enclose="none">val</source>. A doua parte va conține elemente mai mari sau egale cu pivotul <source lang="C" enclose="none">val</source>.

Odată efecutată pivotarea vom ști în care din cele două părți se va afla elementul pe poziția <source lang="C" enclose="none">k</source> în vectorul sortat. Putem, deci, selecta acea parte, continuând algoritmul doar pentru acel subvector.

Există mai mulți algoritmi de pivotare, toți liniari. Vă rămâne ca temă să implementați unul din ei. În linkul de pe [https://en.wikipedia.org/wiki/Quickselect Wikipedia] de mai sus găsiți algoritmul propus de Lomuto, care nu este cel mai eficient. Ca bonus, v-aș recomanda să implementați [https://en.wikipedia.org/wiki/Quicksort#Hoare_partition_scheme algoritmul original al lui Tony Hoare].

Atenție! El nu este structurat! Va trebui să îl modificați! Sau, voi aprecia și mai mult dacă găsiți propria voastră implementare :-) .

'''Ce complexitate are acest algoritm?'''

Vom aplica în mod repetat pivotarea, ce are complexitate ''O(n)''. Pe medie vom păstra, la fiecare pas, jumătate din vector. Complexitatea va fi, deci, ''O(n + n/2 + n/4 + ... + 1)''. Observăm că suma nu va depăși niciodată ''2n'' (deși se va apropia de acea valoare). Complexitatea este, deci ''O(n)''.

Atenție! Aceasta este o complexitate medie! Pe cazul cel mai rău putem să selectăm mereu o parte a vectorului care are cu un element mai puțin ca vectorul curent, ceea ce duce la o complexitate de ''O(n2)'' pe cazul cel mai rău.

Aplicăm repetat pivotarea quickselect. Calcul aproximativ al complexității pe cazul mediu: este ''O(n)'', în loc de ''O(n log n)'' dacă am fi sortat.

Pentru cei curioși, există o îmbunătățire a algoritmului quick select ce îi schimbă complexitatea la ''O(n)'' chiar și pe cazul cel mai rău, dar ea depășește nivelul cursului nostru. Puteți citi mai multe despre medianul medianelor aici: [https://en.wikipedia.org/wiki/Median_of_medians https://en.wikipedia.org/wiki/Median_of_medians] .

== Stive ==

'''Ce este un tip de date abstract?'''

Un tip de date abstract este un model matematic, ce privește tipul de date din punctul de vedere al utilizatorului. Astfel, el definește operații asupra datelor și comportamentul acestor operații, dar nu specifică o implementare.

Tipurile de date abstracte separă funcționalitatea de implementare. Acest lucru este util pentru analiza complexității algoritmilor. Este de menționat faptul că unele TDA au multiple implementări, cu avantaje și dezavantaje, precum vom vedea în lecțiile următoare.

'''Ce este o stivă?'''

Stiva (în engleză ''stack'') este un concept simplu, pe care l-am mai folosit în trecut, fără a sublinia faptul că folosim o stivă.

O stivă este o ''grămadă'' de obiecte ordonate după ordinea LIFO: last in, first out. Aceasta înseamnă că putem adăuga obiecte în stivă, iar atunci când le vom scoate, le vom scoate în ordine inversă față de cum le-am adăugat. Vom vedea în lecțiile următoare că, prin contrast, coada scoate obiectele în aceeași ordine în care au fost adăugate.

Stiva este un tip de date abstract în care definim operațiile:

* <source lang="C" enclose="none">push(value)</source> - inserează o valoare dată la sfârșitul listei;
* <source lang="C" enclose="none">top</source> - returnează valoarea de la sfârșitul listei;
* <source lang="C" enclose="none">pop</source> - șterge valoarea de la sfârșitul listei;
* <source lang="C" enclose="none">empty</source> - returnează 1 dacă stiva este goală (poate fi implementată și în cadrul operației top).

Pentru aceste operații există restricția menționată, anume că valorile trebuie returnate cu regula '''LIFO''' (Last In, First Out).

Pentru a înțelege mai bine ce este o stivă, urmăriți clipul de mai jos:

<youtube height="720" width="1280">https://www.youtube.com/watch?v=I37kGX-nZEI</youtube>

===Implementare: stivă de întregi pozitivi sau zero===

În practică stiva se implementează aproape întotdeauna ca un vector căruia i se adaugă la coadă elemente:

<syntaxhighlight lang="c" line>
#define MAXN 1000

int stack[MAXN]; // stocarea valorilor propriu-zise
int stack_pointer = 0; // indice la prima valoare nefolosita in vector (totuna cu numărul de elemente din stiva)

// adauga valoarea 'val' la stiva, daca aceasta nu este plina
// returneaza 1 in caz de succes, 0 in caz de stiva plina
int push( int val ) {
if ( stack_pointer >= MAXN ) // stiva este plina?
return 0; // returnam eroare

stack[stack_pointer++] = val; // adaugam valoarea in stiva
return 1; // returnam succes
}

// returnează valoarea aflată în virful stivei, dacă ea exista
// in caz contrar returneaza -1
int top() {
return stack_pointer > 0 ? stack[stack_pointer - 1] : -1;
}

// elimina ultimul element din stiva daca se poate
// returneaza 1 daca operatia a reusit, 0 in caz de eroare
int pop() {
if ( stack_pointer == 0 ) // testam cazul de eroare
return 0;

stack_pointer--; // daca avem elemente pe stiva, il eliminam pe ultimul
return 1;
}

// returneaza 1 daca stiva este goala, 0 in caz contrar
int empty() {
return stack_pointer > 0;
}
</syntaxhighlight>

'''Observații:'''

* În această implementare, cele patru operații au complexitate ''O(1)''.
* Remarcați o folosire corectă a funcțiilor: ele implementează operațiuni ce au sens separat, de sine stătător.
* Remarcați denumirile funcțiilor: ele sugerează operațiunea implementată.
* Am folosit instrucțiunea return în mijlocul funcției. Aceasta este o excepție de la regulă. Pe caz general, atunci când la intrarea într-o funcție avem de tratat cazuri particulare de ieșire imediată din funcție, putem folosi instrucțiunea return. Codul devine astfel mai clar, iar restul corpului funcției nu se deplasează spre dreapta prin indentare.

===Sfaturi în utilizarea stivelor pentru rezolvarea problemelor===

* Pentru problemele noastre, stiva se va implementa cu ajutorul unui vector;
* Operațiile <source lang="C" enclose="none">top</source>, <source lang="C" enclose="none">empty</source> și <source lang="C" enclose="none">pop</source> presupun verificarea și manipularea numărului de elemente din vector. În exemplul de implementare numărul de elemente este denumit <source lang="C" enclose="none">stack_pointer</source>. Dar dacă vectorul vostru denumește numărul de elemente <source lang="C" enclose="none">n</source>, atunci veți opera cu <source lang="C" enclose="none">n</source>;
* Nu este neapărată nevoie să scrieți funcții ca cele de mai sus pentru a lucra cu stive. Exemplul de mai sus își dorește să explice noțiunea de tip de date abstract care definește acele operații, iar implementarea arată cum s-ar implementa ele. Deci, ne interesează modul de funcționare al stivei, dar implementarea o putem face cum simțim că se potrivește mai bine problemei.

== Tema 2 ==

Să se rezolve următoarele probleme (program C în CodeBlocks, trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/selectie Selecție]
* [https://www.nerdarena.ro/problema/betisoare Bețișoare], dată la ONI 2014 clasa a 6a
* [https://www.nerdarena.ro/problema/zuma Zuma], dată la.campion 2011
* [https://www.nerdarena.ro/problema/swap Swap], dată la ONI 2013 baraj gimnaziu.

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_2:_Problema_selec%C8%9Biei_%C8%99i_stive Accesează rezolvarea temei 2]

Clasa a 7-a Lecția 3: Liste (1)

2025-06-11T11:05:01Z

Mihai: /* Înregistrare video lecție */

== Înregistrare video lecție ==

{{#ev:youtube|https://youtu.be/yMeFuBS5ovA|||||start=5760&end=12840&loop=1}}

==Conceptului de liste==

===Definiție===

În informatică '''o listă înlănțuită este o structură de date care constă dintr-un grup de noduri care împreună reprezintă o secvență'''. În forma ei cea mai simplă, fiecare nod este format din date și o referință (înlănțuire) către nodul următor în secvență. Lista înlănțuită permite inserarea și ștergerea eficientă a elementelor de pe orice poziție în secvență.

[[Image:lista-exemplu.gif|frame|none|Exemplu de listă înlănțuită]]

După cum puteți să vedeți, există o diferență mare între vectori și liste. Vectorii au poziții consecutive în care stocăm date pe când listele au referințe pentru a putea determina ordinea. Referințele pot avea oricare valori, neavând obligația să fie într-o ordine anume.

Pentru a înțelege mai bine diferența dintre liste și vectori, urmăriți clipul de mai jos:

<youtube height="720" width="1280">https://www.youtube.com/watch?v=b5QR4AmrspU</youtube>

===Implementare===

O implementare posibilă este folosind doi vectori: un vector <source lang="C" enclose="none">v[]</source> care memorează elementele listei (numere întregi de exemplu) și un vector <source lang="C" enclose="none">next[]</source>, care memorează indicele următorului element din listă.

Perechea <source lang="C" enclose="none">(v[i], next[i])</source> conține o celulă sau un nod al listei. Această celulă este memorată la poziția i, dar ea '''nu este celula numărul i'''! Ordinea în care memorăm celulele listei în vector nu are nici o relevanță. Importantă este înlănțuirea acestor celule, dată de vectorul <source lang="C" enclose="none">next[]</source>.

Ultima celulă a listei nu va avea un element următor. Avem nevoie de o valoare specială, terminator de listă pe care să o memorăm în vectorul <source lang="C" enclose="none">next[]</source> pentru ultima celulă. Aici se practică două variante:

# Valoarea 0. În acest caz în care nu vom putea folosi celula 0 din perechea de vectori. Vom vedea că nu e chiar o risipă, deoarece de multe ori vom folosi o santinelă pe poziția zero.

# Valoarea -1. În acest caz putem folosi toate celulele din perechea de vectori.

===Operații cu liste===

====Crearea unei liste cu elemente citite la intrare====

Vom folosi valoarea -1 ca terminator de listă:
<syntaxhighlight lang="c" line>
#define NIL -1

fscanf( fin, "%d", &n );
for ( i = 0; i < n; i++ ) {
fscanf( fin, "%d", &v[i] );
next[i] = i + 1;
}
next[n - 1] = NIL; // ultimul element din listă
</syntaxhighlight>

Observăm că fiecare element se leagă de cel de după el, mai puțin ultimul.

Ce complexitate are citirea unei liste?

Desigur ''O(n)'', ca și citirea unui vector.

====Afișarea unei liste====

<syntaxhighlight lang="c" line>
i = 0;
while ( i != NIL ) { // avem o celulă din listă, nu terminatorul
fprintf( fout, "%d ", v[i] ); // afișăm elementul listei
i = next[i]; // trecem la următorul element din listă
}
fprintf( fout, "\n" );
</syntaxhighlight>

Ce complexitate are scrierea unei liste?

Desigur ''O(n)'', ca și scrierea unui vector.

====Inserare element în listă după celula i====

Să presupunem că la poziția <source lang="C" enclose="none">i</source> avem celula cu elementul 45, ca mai jos. Dorim să inserăm o celulă cu elementul 12, aflată la poziția pos imediat după celula <source lang="C" enclose="none">i</source>. Iată cum vom proceda:

{|
| valign="top"|[[File:lista-inserare-desen.gif|frame|none|Inserare element - concept]]
| valign="top"|[[File:lista-inserare-implementare.gif|frame|none|Inserare element - implementare]]
|}

<syntaxhighlight lang="c" line>
// pos conține poziția nodului de inserat
next[pos] = next[i];
next[i] = pos;
</syntaxhighlight>

Ce complexitate are inserarea?

Desigur, ''O(1)''. Comparați cu un vector, unde inserarea este ''O(n)''.

====Ștergere din listă a celulei aflate după celula i====

Să presupunem că la poziția <source lang="C" enclose="none">i</source> avem celula cu elementul 45, ca mai jos. Dorim să eliminăm celula care apare în listă după celula <source lang="C" enclose="none">i</source>, cea cu elementul 10, aflat la poziția <source lang="C" enclose="none">j</source>. Iată cum vom proceda:

{|
| valign="top"|[[Image:lista-stergere-desen.gif|frame|none|Ștergere element - concept]]
| valign="top"|[[Image:lista-stergere-implementare.gif|frame|none|Ștergere element - implementare]]
|}

<syntaxhighlight lang="c" line>
next[i] = next[next[i]];
</syntaxhighlight>

Ce complexitate are inserarea?

Desigur, ''O(1)''. Comparați cu un vector, unde ștergerea este ''O(n)''.

====Valoarea elementului numărul k în listă====

Pentru a afla valoarea celui de-al <source lang="C" enclose="none">k</source>-lea element în listă va trebui să parcurgem primele <source lang="C" enclose="none">k</source> elemente, de la începutul listei. Să presupunem că prima celulă din listă este <source lang="C" enclose="none">i</source>. Atunci codul va fi:

<syntaxhighlight lang="c" line>
for ( j = 1; j < k; j++ ) // vom avansa de k-1 ori
i = next[i]; // avansam la urmatoarea celula din lista
printf( "Elementul numarul %d in lista este %d\n", k, v[i] )
</syntaxhighlight>

Ce complexitate are aflarea elementului <source lang="C" enclose="none">k</source>?

Ea este ''O(k)''. Comparați cu un vector, unde este ''O(1)''.

== Exemple de probleme rezolvate cu liste ==

===Aplicație 1: v-ați ascunselea===

'''n''' copii numerotați de la 1 la '''n''' și așezați în cerc numără la v-ați ascunselea, din '''k''' în '''k''', începând cu copilul 1. Date '''n''' și '''k''' să se afișeze ordinea în care ies copiii din cerc.

O rezolvare simplă este să memorăm numerele de la 1 la <source lang="C" enclose="none">n</source> într-un vector și apoi să avansăm <source lang="C" enclose="none">k</source> elemente și să afișăm elementul curent, iar apoi să îl setăm pe zero. Reluăm căutarea de <source lang="C" enclose="none">n</source> ori, ignorând elementele zero:

<syntaxhighlight lang="c" line>
#include <stdio.h>

int v[100];

int main() {
int n, k, i, j, pos;

scanf( "%d%d", &n, &k );
for ( i = 0; i < n; i++ )
v[i] = i + 1;
pos = n - 1;
for ( i = 0; i < n; i++ ) {
// avanseaza k elemente nenule
for ( j = 0; j < k; j++ ) {
pos = (pos + 1) % n;
while ( v[pos] == 0 )
pos = (pos + 1) % n;
}
printf( "%d ", v[pos] );
v[pos] = 0;
}
printf( "\n" );

return 0;
}</syntaxhighlight>

Ce complexitate are acest algoritm?

Dacă mai avem <source lang="C" enclose="none">i</source> copii în cerc îi vom număra de <source lang="C" enclose="none">k/i</source> ori. Restul elementelor fiind zero, vom face <source lang="C" enclose="none">k/i</source> parcurgeri ale întregului vector, deci <source lang="C" enclose="none">n·k/i</source> operații. Rezultă numărul de operații total:

: Număr operații = n*n/n + n*n/(n-1) + n*n/(n-2) + ... + n*n/2 + n*n/1.

Dăm factor comun n2:

: Număr operații = n2(1/n + 1/(n-1) + 1/(n-2) + ... + 1/2 + 1/1).

Suma dintre paranteze va fi studiată în clasa a zecea. Ea este aproximativ <source lang="C" enclose="none">log n</source>. Rezultă complexitatea soluției: ''O(n·k·log n)''.

Observăm o anume risipă în această soluție: deși avem poate doar doi copii în listă, noi vom număra până la <source lang="C" enclose="none">k</source>. Putem optimiza algoritmul numărând până la <source lang="C" enclose="none">k % i</source>, unde <source lang="C" enclose="none">i</source> este numărul de copii rămași în cerc.

Iată o soluție care folosește această idee:

<syntaxhighlight lang="c" line>
#include <stdio.h>

int v[100];

int main() {
int n, k, i, j, pos, a;

scanf( "%d%d", &n, &k );
for ( i = 0; i < n; i++ )
v[i] = i + 1;
pos = n - 1;
for ( i = n; i > 0; i-- ) { // numarul de copii scade de la n la 0
// numarul de copii ramasi in cerc este i
// avansam k % i deoarece nu are rost sa numaram dincolo de numarul
// de copii din cerc
a = k % i == 0 ? i : k % i; // trebuie sa avansam macar un copil
for ( j = 0; j < a; j++ ) {
pos = (pos + 1) % n; // avansam indicele - numaram copilul
while ( v[pos] == 0 ) // gasim urmatorul copil
pos = (pos + 1) % n;
}
printf( "%d ", v[pos] );
v[pos] = 0;
}
printf( "\n" );

return 0;
}</syntaxhighlight>

Ce complexitate are această soluție?

La fiecare pas vom trece maxim o dată prin toți copiii rămași în cerc. Vom parcurge, deci, cel mult o dată întregul vector de <source lang="C" enclose="none">n</source> elemente pentru fiecare copil care iese. Complexitatea va fi ''O(n2)''.

O soluție alternativă este una în care la fiecare pas eliminăm copilul din cerc ștergând valoarea sa din vector, prin deplasarea elementelor vectorului. Iată acea soluție:

<syntaxhighlight lang="c" line>
#include <stdio.h>

int v[100];

int main() {
int n, k, i, j, pos;

scanf( "%d%d", &n, &k );
for ( i = 0; i < n; i++ )
v[i] = i + 1;
pos = 0;
for ( i = n; i > 0; i-- ) { // numarul de copii scade de la n la 0
pos = (pos + k - 1) % i; // sarim peste k-1 copii in vector de marime i
printf( "%d ", v[pos] ); // afisam copilul
for ( j = pos + 1; j < i; j++ ) // eliminam copilul din vector
v[j - 1] = v[j];
}
printf( "\n" );

return 0;
}</syntaxhighlight>

Ce complexitate are această soluție?

De data aceasta avansul la următorul copil este ''O(1)''. Dar eliminarea elementului din vector este ''O(i)'' pe cazul cel mai rău, când mai avem <source lang="C" enclose="none">i</source> copii în cerc. Drept care vom avea:

: Număr operații = n + (n-1) + (n-2) + ... + 2 + 1

Aceasta fiind suma lui Gauss, rezultă o complexitate ''O(n2</sup)'', identică cu cea anterioară. Ea ne duce însă către o soluție mai bună. Care este pasul scump în această soluție? Eliminarea elementului din vector! Precum am văzut, eliminarea este rapidă într-o listă. Drept care hai să încercăm o soluție cu liste.

Vom așeza numerele de la 1 la n într-o listă. Restul algoritmului este identic cu cel anterior

<syntaxhighlight lang="c" line>
#include <stdio.h>

int v[100], next[100];

int main() {
int n, k, i, j, pos;

scanf( "%d%d", &n, &k );
// initializam lista
for ( i = 0; i < n; i++ ) {
v[i] = i + 1;
next[i] = (i + 1) % n;
}

pos = n - 1; // pos e pozitia copilului din-nainte de copilul de eliminat
for ( i = 0; i < n; i++ ) {
// avanseaza k - 1 elemente deoarece eliminarea conteaza ca un element
for ( j = 1; j < k; j++ )
pos = next[pos];
printf( "%d ", v[next[pos]] );
next[pos] = next[next[pos]];
}
printf( "\n" );

return 0;
}
</syntaxhighlight>

Remarcăm folosirea unei liste circulare. Ea nu are un prim sau un ultim element ci doar un element de pornire. Ea corespunde realității - copiii sunt așezați în cerc. Acum putem elimina copii numărați în mod eficient, dar parcurgerea elementelor nu mai este ''O(1)'' ci ''O(k)''. Per total complexitatea se reduce la ''O(n∙k)''. Pentru k mult mai mic decât <source lang="C" enclose="none">n</source> această soluție va fi mai bună decât cele anterioare.

===Aplicație 2: bile1===

Problema [https://www.nerdarena.ro/problema/bile1 Bile1] a fost dată la ONI 2012 clasa a 7-a. Problema poate fi rezolvată folosind o matrice caracteristică a obstacolelor. Dar dacă memoria permisă ar fi fost mai mică nu o puteam rezolva în acest fel.

Rezolvarea cu liste necesită doar ''O(m+n+p)'' memorie.

Vom memora atâtea liste câte coloane avem. Fiecare listă va stoca numerele de coloane la care avem obstacole în acea listă. Liniile ce nu au obstacole vor fi reprezentate ca liste vide.

Iată conceptul structurii de date pe care o vom folosi:

{|
| valign="top"|[[File:bile1.jpg|frame|none|Exemplul din problema bile1]]
| valign="top"|[[File:lista-bile1.gif|frame|none|Exemplul din desenul problemei - concept structură de date]]
|}

Pentru implementare vom folosi ca structuri de date:

* un vector <source lang="C" enclose="none">b[n]</source> care memorează linia cu bile,n fiind numărul de coloane;
* un vector <source lang="C" enclose="none">liste[m]</source> care pentru fiecare linie pointează la o listă de coloane pe care se află obstacole, <source lang="C" enclose="none">m</source> fiind numărul de linii;
* doi vectori <source lang="C" enclose="none">col[p]</source> și <source lang="C" enclose="none">next[p]</source> care memorează coloanele obstacolelor și următorul obstacol pe linie, <source lang="C" enclose="none">p</source> fiind numărul de obstacole.

Algoritmul folosit este următorul:

<syntaxhighlight lang="c" line>
1. Citește m, n și p, setează i la zero
2. Citește fiecare obstacol (l, c) si:
2.1 col[i] = c
2.2 adaugă coloana c la lista de pe linia l, liste[l]:
2.2.1 next[i] = liste[l]
2.2.2 liste[l] = i
2.3 i = i + 1
3. Citește vectorul de bile
4. Pentru fiecare linie l de la 1 la m
4.1 parcurge lista de coloane liste[l] si pentru fiecare obstacol col[i] din listă:
4.1.1 actualizează vectorul de bile la indicele coloanei, col[i]
</syntaxhighlight>

Cum se compară cu algoritmul inițial care folosește o matrice caracteristică?

{| class="wikitable"
!Structură de date
!Complexitate timp
!Complexitate memorie
!Explicații
|-
| Matrice de frecvență a obstacolelor
| <math>O(m\times n + p)</math>
| <math>O(m\times n)</math>
| Parcurgerea matricei de frecvență este <math>O(m\times n)</math>, iar prelucrarea obstacolelor este <math>O(p)</math>
|-
| Vector de liste de coloane ale obstacolelor
| <math>O(m + n + p)</math>
| <math>O(m + n + p)</math>
| Vom parcurge strict obstacolele, de unde rezultă complexitatea <math>O(p)</math>. Parcurgem și numerele inițiale, pentru citire, deci <math>O(n)</math>. Parcurgem și toate liniile matricei, pentru a verifica dacă avem o listă cu obstacole, deci <math>O(m)</math>.
|}

Observăm că atât timpul cât și memoria se îmbunătățesc substanțial. Problema fiind dată la clasa a șaptea într-o vreme când listele nu apăreau la această clasă este puțin probabil că aceasta a fost soluția dorită.

Cu toate acestea este un caz de studiu interesant unde o structură simplă de date, pe care olimpici și profesori o ignoră adesea în rezolvarea problemelor de olimpiadă, poate duce la un algoritm simplu și foarte eficient.

Despre ce structură este vorba? Despre un vector de liste. Rețineți: această structură poate rezolva multe probleme date la concursuri.

===Aplicație 3: zigzag===

Problema [https://www.nerdarena.ro/problema/zigzag Zigzag] dată la ONI 2012 clasa a 7-a cere de la concurenți o soluție matematică, ce presupune calculul coordonatelor literelor unui șir într-o matrice de dimensiuni cunoscute. Problema are, însă, o rezolvare foarte ușoară cu un vector de liste, o rezolvare ce nu presupune matematică și nici creativitate, ci doar o implementare îngrijită.

Ca și la bile1, vom ține minte pentru fiecare linie a matricei de codificare câte o listă cu coloanele unde apar litere. Vom genera aceste liste parcurgând în matrice pozițiile <source lang="C" enclose="none">(l, c)</source> unde s-ar afla textul (înainte de a citi acel text!) și adăugând coloana <source lang="C" enclose="none">c</source> la lista liniei <source lang="C" enclose="none">l</source>. Apoi vom parcurge aceste liste, în ordine, și vom atașa fiecărei celule, pe lângă coloană, o literă din text. De fapt vom vedea că nici nu avem nevoie să stocăm coloanele, ci doar literele. În final vom parcurge celulele în ordinea alocării lor, deoarece ea este chiar ordinea textului decodificat.

Iată conceptul structurii de date pe care o vom folosi:

{|
| valign="top"|[[File:zigzag.jpg|frame|none|Exemplul din problema zigzag]]
| valign="top"|[[File:lista-zigzag.gif|frame|none|Exemplul din desenul problemei - concept structură de date]]
|}

O diferență față de bile1 este că va trebui să ținem nu numai vectorul cu începutul listelor, ci și un vector cu ultimul element din listă pentru a putea face adăugarea la coadă foarte rapid. O alternativă ar fi să parcurgem pozițiile in ordine inversă (pare mai complicat, însă). Să denumim vectorii <source lang="C" enclose="none">prim[]</source> și <source lang="C" enclose="none">ultim[]</source>.

Iată algoritmul de generare a listelor:

<syntaxhighlight lang="C" line>
// pregatim listele cu pozitiile in matricea cheie
// cheie este cheia, iar n este numărul de caractere al mesajului,
// c aloca celulele listei si este si coloana in acelasi timp
l = 0;
pas = 1; // initial linia creste din unu in unu
// nu putem avea celule pe indexul 0 deoarece cu zero codificam finalul
// de lista, deci codificam coloanele incepind cu 1, no biggie
for ( c = 1; c <= n; c++ ) {
// pentru fiecare coloana a matricei calculam
// linia corespunzatoare literei (este una singura!)
// liniile vor fi de la zero, nici un motiv sa le numerotam de la 1
// avem perechea (l, c): aseaza c in lista l
next[c] = 0; // nu urmeaza nimeni după mine, sint ultima celula
if ( prim[l] == 0 ) // lista este vida
prim[l] = ultim[l] = c;
else // avem un ultim element
ultim[l] = next[ultim[l]] = c;// atasam celula la coada ultimului element

// avanseaza linia
l = l + pas;
if ( l < 0 || l >= cheie ) { // daca am depasit marginea inversam pasul
pas = -pas;
l = l + pas + pas; // adunam de doua ori pasul pentru a ne intoarce
}
}
</syntaxhighlight>

Ce complexitate are această soluție?

Este, sper, destul de clar că atât timpul cât și memoria vor fi liniare în numărul de caractere de la intrare. Din nou, folosirea unui vector de liste rezultă într-un algoritm simplu și eficient.

Vă rămâne ca temă să continuați această implementare. Mai aveți de parcurs listele in ordinea naturală și atașat literele din text, iar la final să parcurgeți celulele în ordinea alocării lor (cu indicele c) și să afișați caracterele lor.

== Tema 3 ==

Să se rezolve următoarele probleme (program C în CodeBlocks, trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/bile1 bile1] dată la ONI 2012 clasa a 7a rezolvată cu vector de liste de obstacole.
* [https://www.nerdarena.ro/problema/zigzag zigzag] dată la ONI 2012 clasa a 7a rezolvată cu vectori de liste. Chiar dacă există și alte rezolvări, scopul este să exersați listele, nu să luați 100p la problemă!
* [https://www.nerdarena.ro/problema/lacoada la coadă] ca aplicație la liste

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_3:_Liste_(1) Accesează rezolvarea temei 3]

Clasa a 7-a Lecția 2: Problema selecției și stive

2025-06-11T10:59:50Z

Mihai: /* Înregistrare video lecție */

== Înregistrare video lecție ==

{{#ev:youtube|https://youtu.be/gy3zK4E8SSo|||||start=7203&end=9880&loop=1}}

== Problema selecției ==

'''Problema'''

Dat un șir de <source lang="C" enclose="none">n</source> numere și o poziție <source lang="C" enclose="none">k</source> în acel șir să se spună ce element s-ar afla pe acea poziție dacă șirul ar fi sortat.

'''Exemplu'''

Fie șirul <source lang="C" enclose="none">3 9 23 13 18 8 3 10 2 10 15 21</source> și poziția <source lang="C" enclose="none">k = 6</source>.

Dacă am ordona șirul am obține 2 3 3 8 9 10 10 13 15 18 21 23. Pe poziția 6 se află elementul 10, care este și răspunsul dorit.

===Soluție forță brută===

O soluție ce vine ușor în minte este să sortăm vectorul și apoi să afișăm elementul de la poziția <source lang="C" enclose="none">k</source>. Nu este eficientă, complexitatea ei va fi ''O(n2)'' cu sortare prin selecție, sau ''O(n log n)'' cu sortări mai rapide.

===Soluția folosind algoritmul Quick select===

Aplicăm un pas de pivotare în mod repetat. Algoritmul este prezentat aici: [https://en.wikipedia.org/wiki/Quickselect quickselect].

Ideea pivotării este următoarea: alegem un așa numit pivot. El este un element oarecare din vector. Putem să alegem elementul aflat la jumatea vectorului, <source lang="C" enclose="none">v[n/2]</source>. Sau putem să îl alegem la întâmplare, folosind o funcție ce generează numere aleatoare, cum ar fi funcția <source lang="C" enclose="none">rand()</source> în C (parte din biblioteca <source lang="C" enclose="none">stdlib.h</source>).

Fie <source lang="C" enclose="none">p</source> indicele pivotului și <source lang="C" enclose="none">val = v[p]</source> valoarea acelui pivot. Ne propunem să separăm vectorul în două: prima parte va conține elemente mai mici sau egale cu pivotul <source lang="C" enclose="none">val</source>. A doua parte va conține elemente mai mari sau egale cu pivotul <source lang="C" enclose="none">val</source>.

Odată efecutată pivotarea vom ști în care din cele două părți se va afla elementul pe poziția <source lang="C" enclose="none">k</source> în vectorul sortat. Putem, deci, selecta acea parte, continuând algoritmul doar pentru acel subvector.

Există mai mulți algoritmi de pivotare, toți liniari. Vă rămâne ca temă să implementați unul din ei. În linkul de pe [https://en.wikipedia.org/wiki/Quickselect Wikipedia] de mai sus găsiți algoritmul propus de Lomuto, care nu este cel mai eficient. Ca bonus, v-aș recomanda să implementați [https://en.wikipedia.org/wiki/Quicksort#Hoare_partition_scheme algoritmul original al lui Tony Hoare].

Atenție! El nu este structurat! Va trebui să îl modificați! Sau, voi aprecia și mai mult dacă găsiți propria voastră implementare :-) .

'''Ce complexitate are acest algoritm?'''

Vom aplica în mod repetat pivotarea, ce are complexitate ''O(n)''. Pe medie vom păstra, la fiecare pas, jumătate din vector. Complexitatea va fi, deci, ''O(n + n/2 + n/4 + ... + 1)''. Observăm că suma nu va depăși niciodată ''2n'' (deși se va apropia de acea valoare). Complexitatea este, deci ''O(n)''.

Atenție! Aceasta este o complexitate medie! Pe cazul cel mai rău putem să selectăm mereu o parte a vectorului care are cu un element mai puțin ca vectorul curent, ceea ce duce la o complexitate de ''O(n2)'' pe cazul cel mai rău.

Aplicăm repetat pivotarea quickselect. Calcul aproximativ al complexității pe cazul mediu: este ''O(n)'', în loc de ''O(n log n)'' dacă am fi sortat.

Pentru cei curioși, există o îmbunătățire a algoritmului quick select ce îi schimbă complexitatea la ''O(n)'' chiar și pe cazul cel mai rău, dar ea depășește nivelul cursului nostru. Puteți citi mai multe despre medianul medianelor aici: [https://en.wikipedia.org/wiki/Median_of_medians https://en.wikipedia.org/wiki/Median_of_medians] .

== Stive ==

'''Ce este un tip de date abstract?'''

Un tip de date abstract este un model matematic, ce privește tipul de date din punctul de vedere al utilizatorului. Astfel, el definește operații asupra datelor și comportamentul acestor operații, dar nu specifică o implementare.

Tipurile de date abstracte separă funcționalitatea de implementare. Acest lucru este util pentru analiza complexității algoritmilor. Este de menționat faptul că unele TDA au multiple implementări, cu avantaje și dezavantaje, precum vom vedea în lecțiile următoare.

'''Ce este o stivă?'''

Stiva (în engleză ''stack'') este un concept simplu, pe care l-am mai folosit în trecut, fără a sublinia faptul că folosim o stivă.

O stivă este o ''grămadă'' de obiecte ordonate după ordinea LIFO: last in, first out. Aceasta înseamnă că putem adăuga obiecte în stivă, iar atunci când le vom scoate, le vom scoate în ordine inversă față de cum le-am adăugat. Vom vedea în lecțiile următoare că, prin contrast, coada scoate obiectele în aceeași ordine în care au fost adăugate.

Stiva este un tip de date abstract în care definim operațiile:

* <source lang="C" enclose="none">push(value)</source> - inserează o valoare dată la sfârșitul listei;
* <source lang="C" enclose="none">top</source> - returnează valoarea de la sfârșitul listei;
* <source lang="C" enclose="none">pop</source> - șterge valoarea de la sfârșitul listei;
* <source lang="C" enclose="none">empty</source> - returnează 1 dacă stiva este goală (poate fi implementată și în cadrul operației top).

Pentru aceste operații există restricția menționată, anume că valorile trebuie returnate cu regula '''LIFO''' (Last In, First Out).

Pentru a înțelege mai bine ce este o stivă, urmăriți clipul de mai jos:

<youtube height="720" width="1280">https://www.youtube.com/watch?v=I37kGX-nZEI</youtube>

===Implementare: stivă de întregi pozitivi sau zero===

În practică stiva se implementează aproape întotdeauna ca un vector căruia i se adaugă la coadă elemente:

<syntaxhighlight lang="c" line>
#define MAXN 1000

int stack[MAXN]; // stocarea valorilor propriu-zise
int stack_pointer = 0; // indice la prima valoare nefolosita in vector (totuna cu numărul de elemente din stiva)

// adauga valoarea 'val' la stiva, daca aceasta nu este plina
// returneaza 1 in caz de succes, 0 in caz de stiva plina
int push( int val ) {
if ( stack_pointer >= MAXN ) // stiva este plina?
return 0; // returnam eroare

stack[stack_pointer++] = val; // adaugam valoarea in stiva
return 1; // returnam succes
}

// returnează valoarea aflată în virful stivei, dacă ea exista
// in caz contrar returneaza -1
int top() {
return stack_pointer > 0 ? stack[stack_pointer - 1] : -1;
}

// elimina ultimul element din stiva daca se poate
// returneaza 1 daca operatia a reusit, 0 in caz de eroare
int pop() {
if ( stack_pointer == 0 ) // testam cazul de eroare
return 0;

stack_pointer--; // daca avem elemente pe stiva, il eliminam pe ultimul
return 1;
}

// returneaza 1 daca stiva este goala, 0 in caz contrar
int empty() {
return stack_pointer > 0;
}
</syntaxhighlight>

'''Observații:'''

* În această implementare, cele patru operații au complexitate ''O(1)''.
* Remarcați o folosire corectă a funcțiilor: ele implementează operațiuni ce au sens separat, de sine stătător.
* Remarcați denumirile funcțiilor: ele sugerează operațiunea implementată.
* Am folosit instrucțiunea return în mijlocul funcției. Aceasta este o excepție de la regulă. Pe caz general, atunci când la intrarea într-o funcție avem de tratat cazuri particulare de ieșire imediată din funcție, putem folosi instrucțiunea return. Codul devine astfel mai clar, iar restul corpului funcției nu se deplasează spre dreapta prin indentare.

===Sfaturi în utilizarea stivelor pentru rezolvarea problemelor===

* Pentru problemele noastre, stiva se va implementa cu ajutorul unui vector;
* Operațiile <source lang="C" enclose="none">top</source>, <source lang="C" enclose="none">empty</source> și <source lang="C" enclose="none">pop</source> presupun verificarea și manipularea numărului de elemente din vector. În exemplul de implementare numărul de elemente este denumit <source lang="C" enclose="none">stack_pointer</source>. Dar dacă vectorul vostru denumește numărul de elemente <source lang="C" enclose="none">n</source>, atunci veți opera cu <source lang="C" enclose="none">n</source>;
* Nu este neapărată nevoie să scrieți funcții ca cele de mai sus pentru a lucra cu stive. Exemplul de mai sus își dorește să explice noțiunea de tip de date abstract care definește acele operații, iar implementarea arată cum s-ar implementa ele. Deci, ne interesează modul de funcționare al stivei, dar implementarea o putem face cum simțim că se potrivește mai bine problemei.

== Tema 2 ==

Să se rezolve următoarele probleme (program C în CodeBlocks, trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/selectie Selecție]
* [https://www.nerdarena.ro/problema/betisoare Bețișoare], dată la ONI 2014 clasa a 6a
* [https://www.nerdarena.ro/problema/zuma Zuma], dată la.campion 2011
* [https://www.nerdarena.ro/problema/swap Swap], dată la ONI 2013 baraj gimnaziu.

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_2:_Problema_selec%C8%9Biei_%C8%99i_stive Accesează rezolvarea temei 2]

Clasa a 7-a Lecția 1: Reguli de programare în limbajul C și complexități algoritmice

2025-06-11T10:54:36Z

Mihai: /* Înregistrare video lecție */

== Înregistrare video lecție ==

{{#ev:youtube|https://youtu.be/YJYXh3XEPUE|||||start=4920&end=10770&loop=1}}

== Reguli de programare în limbajul C ==

* Variabilele simple '''nu''' se inițializează la declarare. Ele se inițializează cât mai aproape de secțiunea de program care le folosește. Cu alte cuvinte orice variabilă se inițializează cât mai jos posibil. De ce? Pentru citibilitatea codului. Imaginați-vă că la linia 300 vedem o instrucțiune <source lang="C" enclose="none">a = a + y;</source>. Ne punem întrebarea cu ce valoare a fost inițializată <tt>a</tt>. Imaginați-vă că trebuie să mergem câteva pagini în sus pentru a constata că variabila a fost inițializată la declarare <source lang="C" enclose="none">int a = 1</source>;
* Vectorii încep de la 0, nu de la 1. Este o regulă importantă, nu o preferință personală. Avantaje: când folosim modulo, vectori caracteristici, etc.
* Vectorii au dimensiunile specificate de cerință. Ei nu se declară <source lang="C" enclose="none">int v[10010]</source>. Aceasta se cheamă ''programare aproximativă'' și nu este o practică acceptată la nivel de înalt. Dacă la matematică vi s-ar cere să rezolvați ecuația ''2 '''·''' x = 5'' și ați răspunde că ''x'' este un număr între doi și trei nu cred că ați putea fi considerați cei mai mari matematicieni ai țării. Programarea aproximativă reprezintă lenea minții. ''Să punem câteva elemente în plus, în caz că depășesc vectorul''. Cine depășește vectorul? Zâna memoriei? Nu, voi. Soluția corectă este să vă corectați gândirea și să vă ascuțiți mintea pentru ca algoritmul vostru să '''nu''' depășească vectorul. Altfel veți rămâne incapabili de a scrie programe în lumea reală unde aproximarea nu e acceptabilă.
* Reguli de indentare, exemple:
** Indentarea se face la două sau la patru spații. Două sunt suficiente pentru citibilitate. Atenție: setați code::blocks să nu folosească caractere TAB.
** Acolada deschisă se pune pe același rând cu instrucțiunea precedentă.
** Acolada închisă se pune pe rândul următor aliniată sub instrucțiunea de care aparține.
** Dacă după <source lang="C" enclose="none">else</source> urmează un <source lang="C" enclose="none">if</source> atunci instrucțiunea <source lang="C" enclose="none">if</source> se pune imediat după <source lang="C" enclose="none">else</source> pe aceeași linie, iar corpul de instrucțiuni aparținând lui <source lang="C" enclose="none">else</source> se indentează cu două spații, nu cu patru. Astfel, în cazul unor instrucțiuni de genul <source lang="C" enclose="none">if ... else if ... else if ...</source> se evită migrarea codului către dreapta prin indentări inutile.
* Fără <source lang="C" enclose="none">break / continue / return / goto</source> în interiorul buclelor. Ele distrug programarea structurată și, implicit, zeci de ani de experiență a omenirii.
* Folosim <source lang="C" enclose="none">for</source> pentru bucle cu număr cunoscut de pași, <source lang="C" enclose="none">while</source> în celelalte cazuri. Aceasta este o regulă de programare ordonată, care face codul mai citibil.
* Nu avem voie să modificăm variabila de buclă <source lang="C" enclose="none">for</source> și nici limita ei de final. Dacă este un ciclu cu număr cunoscut de pași nu avem de ce să modificăm aceste variabile.
* Când eliminăm un element din vector micșorăm numărul lui de elemente cu 1 (<source lang="C" enclose="none">n--</source>). În felul acesta <tt>n</tt> continuă să arate numărul de elemente din vector.
* Nu aveți voie să aveți warnings, vă pot fi fatale: declarați <source lang="C" enclose="none">int main()</source> și folosiți <source lang="C" enclose="none">return 0</source> la final. Eliminați orice alte warnings deoarece majoritatea sunt o problemă reală. Unele concursuri compilează sursa cu opriri la warnings (adică tratează warning-urile ca erori). Unele warnings se referă la variabile neinițializate sau la număr diferit de "%d" versus variabile citite, în <source lang="C" enclose="none">fscanf</source>, deci sunt importante. Este '''obligatoriu''' să setați Code::Blocks să vă afișeze toate warnings. Pentru aceasta, după crearea proiectului, navigați în meniul ''Project'', submeniul ''Options''. În acea fereastră setați opțiunile ''-Wall'' și ''-O2''.
* Comentați codul când e ceva complicat, de exemplu o formulă. Scrieți ideea algoritmului, dacă nu e ceva trivial. Nu trebuie să umpleți de comentarii, dar minimal. Mă ajutați mult în corectarea temei.
* Denumiți variabilele mai clar. Nu lungi, dar să aibă semnificație: <tt>prod</tt>, <tt>sum</tt>, <tt>nrcf</tt>, etc.
* Nu abuzați stegulețele. Exemplu unde nu sunt necesare break sau stegulețe: căutarea unui element <tt>e</tt> în vectorul <tt>v</tt>:
<syntaxhighlight lang="C" line>
i = 0
while ( (i < n) && (v[i] != e) )
i++;
</syntaxhighlight>
* Folosiți corect fișiere, le deschideți cu <source lang="C" enclose="none">fopen</source>, iar la final obligatoriu le închideți cu <source lang="C" enclose="none">fclose</source>. În nici un caz nu folosiți <source lang="C" enclose="none">freopen</source>.
* Folosiți doar funcțiile de intrare/ieșire C, <source lang="C" enclose="none">fscanf / fprintf / fgetc / fputc / fgets</source>. Aveți aici un sumar al acestor funcții: [[instrucțiuni de intrare/ieșire în limbajul C]]
* Nu folosiți funcții gen <source lang="C" enclose="none">sort</source> și <source lang="C" enclose="none">qsort</source>. Aveți nevoie de dispensă specială ☺

=== Declararea vectorilor cu inițializare ===

Precum știm, un vector poate primi valori la declarare. De exemplu:

<syntaxhighlight lang="C" line>
int dl[4] = { 0, -1, 0, 1 };
int dc[4] = { 1, 0, -1, 0 };
</syntaxhighlight>

=== Tabel de descriptori citire/scriere ===
Dimensiunile diverselor tipuri: în C '''char''' are 1 octet, '''short''' are 2 octeți, '''int''' are 4 octeți, '''long long''' are 8 octeți.

Să recapitulăm care sunt descriptorii de citire/scriere folosiți de <tt>scanf()</tt> și <tt>printf()</tt> pentru fiecare din tipurile învățate:

{| class="wikitable"
!Tip variabilă
!Bytes
!Valori limită
!Format folosit (litere)
|-
| <tt>char</tt>
| 1
| style="text-align:right;" | <tt>-128</tt> ... <tt>127</tt>
| <tt>'''%d'''</tt> dacă vrem să afișăm numărul întreg <tt>'''%c'''</tt> dacă vrem să afișăm caracterul
|-
| <tt>unsigned char</tt>
| 1
| style="text-align:right;" | <tt>0</tt> ... <tt>255</tt>
| <tt>'''%u'''</tt> dacă vrem să afișăm numărul întreg <tt>'''%c'''</tt> dacă vrem să afișăm caracterul
|-
| <tt>short</tt>
| 2
| style="text-align:right;" | <tt>-32768</tt> ... <tt>32767</tt>
| <tt>'''%hd'''</tt>
|-
| <tt>unsigned short</tt>
| 2
| style="text-align:right;" | <tt>0</tt> ... <tt>65535</tt>
| <tt>'''%hu'''</tt>
|-
| <tt>int</tt>
| 4
| style="text-align:right;" | <tt>-2147483648</tt> ... <tt>2147483647</tt> aproximativ '''două miliarde''' (2 cu nouă zerouri)
| <tt>'''%d'''</tt>
|-
| <tt>unsigned int</tt>
| 4
| style="text-align:right;" | <tt>0</tt> ... <tt>4294967295</tt> aproximativ '''patru miliarde''' (4 cu nouă zerouri)
| <tt>'''%u'''</tt>
|-
| <tt>long long</tt>
| 8
| style="text-align:right;" | <tt>-9223372036854775808</tt> ... <tt>9223372036854775807</tt> aproximativ '''9·1018''' (9 cu 18 zerouri)
| <tt>'''%lld'''</tt> în GNU/Linux și varena.ro <tt>'''%I64d'''</tt> în Windows
|-
| <tt>unsigned long long</tt>
| 8
| style="text-align:right;" | <tt>0</tt> ... <tt>18446744073709551615</tt> aproximativ '''18·1018''' (18 cu 18 zerouri)
| <tt>'''%llu'''</tt> în GNU/Linux și varena.ro <tt>'''%I64u'''</tt> în Windows
|-
| <tt>double</tt>
| 8
| style="text-align:right;" | valorile minime și maxime nu au aceeași relevanță, dar erorile de reprezentare cresc cu mărimea numărului
| <tt>'''%lf'''</tt>
|}

== Complexități algoritmice ==

{| class="wikitable"
!Algoritm
!Complexitate timp
!Complexitate memorie
! Explicații
|-
| Descompunerea lui <source lang="C" enclose="none">n</source> în factori primi
| <math>O(\sqrt{n})</math>
| <math>O(1)</math>
| Putem testa divizorii până la <math>O(\sqrt{n})</math>. Dacă la final n este diferit de 1, el este un factor prim al lui n la puterea 1.
|-
| Ridicare la putere ab
| <math>O(\log{b})</math>
| <math>O(1)</math>
| Vezi exponențiere logaritmică
|-
| Calcul număr de zile între două date calendaristice corecte z1.l1.a1 și z2.l2.a2
| <math>O(1)</math>
| <math>O(1)</math>
| Partea importantă este calculul numărului de ani bisecți între a1 și a2 în ''O(1)''. Ea se reduce la problema calculului numărului de numere divizibile cu ''k'' între ''a'' și ''b''.
|-
| Determinare dacă o secvență de <source lang="C" enclose="none">n</source> numere de la intrare este bitonă (sau munte)
| <math>O(n)</math>
| <math>O(1)</math>
| Pe măsură ce citim numerele decidem proprietatea cerută, nu este nevoie să le memorăm.
|-
| Determinare corectitudine șir de <source lang="C" enclose="none">n</source> paranteze închise și deschise
| <math>O(n)</math>
| <math>O(1)</math>
| Folosim un contor de paranteze deschise și încă neînchise. Nu avem nevoie să memorăm parantezele.
|-
| Determinare corectitudine șir de <source lang="C" enclose="none">n</source> paranteze rotunde, drepte și acolade
| <math>O(n)</math>
| <math>O(n)</math>
| Similar anterior, dar menținem o stivă de paranteze deschise și încă neînchise, de aceea memoria este liniară.
|-
| Determinare corectitudine șir de <source lang="C" enclose="none">n</source> paranteze de <source lang="C" enclose="none">k</source> tipuri
| <math>O(n)</math>
| <math>O(n)</math>
| Similar anterior, trebuie să avem grijă ca atunci când la intrare avem o paranteză închisă să testăm dacă pe stivă se află paranteza deschisă corectă în timp constant. Folosim un vector care pentru fiecare tip de paranteză închisă memorează codul parantezei deschise corespunzătoare.
|-
| Inserare element în vector de <source lang="C" enclose="none">n</source> elemente
| <math>O(n)</math>
| <math>O(n)</math>
| Elementele de după poziția de inserție trebuie deplasate către dreapta.
|-
| Ștergere element din vector de <source lang="C" enclose="none">n</source> elemente
| <math>O(n)</math>
| <math>O(n)</math>
| Elementele de după poziția de ștergere trebuie deplasate către stânga.
|-
| Interclasare a doi vectori ordonați de <source lang="C" enclose="none">n1</source>, respectiv <source lang="C" enclose="none">n2</source> elemente
| <math>O(n1 + n2)</math>
| <math>O(n1 + n2)</math>
|
|-
| Sortare prin selecție a <source lang="C" enclose="none">n</source> numere - select sort
| <math>O(n^2)</math>
| <math>O(n)</math>
|
|-
| Sortare prin numărare (cu vectori de frecvență) a <source lang="C" enclose="none">n</source> numere - counting sort
| <math>O(n + X_{max})</math>
| <math>O(X_{max})</math>
| <math>X_{max}</math> este valoarea maximă dintre numerele de la intrare. Va trebui să parcurgem vectorul de frecvență. La memorie se adaugă ''n'' dacă dorim să creăm un vector cu elementele sortate.
|-
| Elementul majoritar într-un vector de <source lang="C" enclose="none">n</source> elemente
| <math>O(n)</math>
| <math>O(n)</math>
| Algoritmul face două parcurgeri ale elementelor, deci trebuie să le memorăm.
|-
| Calculul tuturor numerelor prime de la 1 la <source lang="C" enclose="none">n</source> folosind ciurul lui Eratostene
| <math>O(n \log \log{n})</math>
| <math>O(n)</math>
|
|-
| Descompunerea în factori primi a tuturor numerelor de la 2 la <source lang="C" enclose="none">n</source>
| <math>O(n \log{n})</math>
| <math>O(n)</math>
| Vom calcula un ciur special în care pentru fiecare poziție ''i'' calculăm cel mai mare divizor prim al lui ''i''. Pentru a obține descompunerea în factori primi a lui ''i'' vom afla divizorii în ordine descrescătoare, împărțind repetat pe ''i'' la ciur[i].
|-
| Căutare binară în vector ordonat de <source lang="C" enclose="none">n</source> elemente
| <math>O(\log{n})</math>
| <math>O(n)</math>
|
|-
| Calculul multiplicității numărului <source lang="C" enclose="none">a</source> în <source lang="C" enclose="none">n!</source>
| <math>O(\sqrt{a} + \log{a} \log{n})</math>
| <math>O(1)</math>
| Termenul <math>O(\sqrt{a})</math> provine din descompunerea în factori primi a lui ''a''. Apoi, pentru fiecare divizor prim al lui ''a'' (<math>O(\log{a})</math>) vom calcula de câte ori se împarte ''n'' la acel divizor (<math>O(\log{n})</math>).
|}

== Funcții în limbajul C ==
Funcțiile permit programelor complicate să fie parcelate în blocuri mici, fiecare din ele fiind mai ușor de scris, citit și modificat (întreținut). Am întâlnit deja funcția <source lang="C" enclose="none">main()</source> și am folosit funcții de intrare ieșire precum <source lang="C" enclose="none">fscanf()</source> și <source lang="C" enclose="none">fprintf()</source>, precum și funcții matematice din bibliotecile standard precum <source lang="C" enclose="none">sqrt()</source> sau <source lang="C" enclose="none">abs()</source>. Vom vedea în continuare cum putem să scriem propriile noastre funcții.

=== De ce funcții ===
* Pentru a nu repeta cod.
* Pentru organizare, citibilitate, ușurinta înțelegerii codului și întreținerea codului.
* Recursivitate.

=== Sintaxa: cum scriem o funcție ===
==== Sintaxa (simplificare) ====
<tt>
tip-returnat nume-funcție( tip-1 param-1, tip-2 param-2, ..., tip-n param-n ) {
... declarații variabile ...
 
... cod funcție ...
 
return valoare-return; // dacă tipul returnat nu este 'void'
}
</tt>

==== Exemplu ====
<syntaxhighlight lang="C" line>
// functie ce returneaza valoarea minima dintre două numere
int min(int a, int b) {
int rezultat; // declaratie de variabila locala

if (a < b)
rezultat = a;
else
rezultat = b;

return rezultat;
}</syntaxhighlight>

==== Apelul ====
O funcție este apelată astfel:

==== Apelul funcțiilor ====
Pentru a apela (sau chema) o funcție vom scrie numele funcției urmat, între paranteze, de parametrii ceruți. Ei pot fi expresii, nu doar variabile. Expresiile se vor apela, iar rezultatele lor vor fi depuse, la intrarea în funcție, în variabilele parametru corespunzătoare, conform ordinii din listă. Dacă funcția returnează o valoare ea poate fi folosită sau stocată într-o variabilă:

<tt>
rez = nume-functie( valoare-1, valoare-2, ..., valoare-n );
</tt>

Iată un exemplu de folosire a funcției <source lang="C" enclose="none">min()</source>:

<syntaxhighlight lang="C" line>
#include <stdio.h>

// functie ce returnează valoarea minima dintre două numere
int min(int a, int b) {
int rezultat; // declaratie de variabila locala

if (a < b)
rezultat = a;
else
rezultat = b;

return rezultat;

int main () {
int x, y, rez;

x = 200;
y = 100;
rez = min( x, y ); // chemam functia pentru a obtine valoarea minima

printf( "Valoarea minima este: %d\n", rez );

return 0;
}</syntaxhighlight>

=== Parametri și valoare returnată ===
Precum am văzut, o funcție primește o listă de parametri și returnează o valoare. Funcția poate să nu returneze nici o valoare, caz în care tipul returnat va fi declarat ca <source lang="C" enclose="none">void</source>, sau "vid" în limba engleză.

'''Atenție''': transmisia parametrilor în funcție se face '''prin copiere'''! Aceasta înseamnă că la apelul funcției valorile din apel vor fi atribuite parametrilor ce sunt variabile nou create ce primesc acele valori.

'''Exemplul 1''': ce afișează următorul program:

<syntaxhighlight lang="C" line>
void inc( int a ) {
a++;
}

int main() {
int x;

x = 0;
inc( x );
printf( "%d\n", x );

return 0;
}</syntaxhighlight>

Parametrul <source lang="C" enclose="none">a</source> este o variabilă nou creată la intrarea în funcție în care se copiază valoarea variabilei <source lang="C" enclose="none">x</source>. Funcția modifică (incrementează) valoarea lui <source lang="C" enclose="none">a</source>, dar aceasta nu influențează valoarea lui <source lang="C" enclose="none">x</source>, ele fiind variabile diferite. De aceea programul va afișa <tt>0</tt>.

'''Exemplul 2''': ce afișează următorul program:

<syntaxhighlight lang="C" line>
void inc( int a[10] ) {
a[0]++;
}

int main() {
int v[10];

v[0] = 17;
inc( v );
printf( "%d\n", v[0] );

return 0;
}</syntaxhighlight>

Surpriză, programul va afișa 18! Elementul zero al vectorului a fost modificat. Și atunci cum rămâne cu transmisia prin copiere? Răspunsul este greu de dat fără cunoștințe despre pointeri. Vectorii sunt ei înșiși adrese de variabile întregi. Parametrul vector se transmite prin copiere, însă ceea ce se copiază este adresa unde se află șirul de întregi ai vectorilor. De aceea modificarea unui vector într-o funcție are ca efect modificarea vectorului.

Pentru moment este îndeajuns să țineți minte că variabilele simple se transmit prin copiere, iar vectorii (matricele, etc) se transmit ca atare, fără a fi copiați.

=== Cum transmitem corect vectorii unei funcții ===
Un vector este un ''tip de date abstract'' care constă dintr-o pereche ('''n''', '''v'''). '''n''' este lungimea vectorului (numărul de elememente), iar '''v''' este vectorul propriu zis. Ele nu se pot separa. De aceea vom transmite funcției atât vectorul cât și lungimea sa.

==== Exemplu: suma elementelor unui vector ====
<syntaxhighlight lang="C" line>
#include <stdio.h>

int sumaVect( int n, int v[] ) {
int i, s;

s = 0;
for ( i = 0; i < n; i++ )
s += v[i];

return s;
}

int main() {
int x;
int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

x = sumaVect( 10, a );
printf( "Suma este %d\n", x );

return 0;
}</syntaxhighlight>

=== Modificarea numărului de elemente al vectorului într-o funcție ===
Ce se întâmplă dacă funcția modifică numărul de elemente al vectorului, de exemplu inserează un element în vector? Ar trebui să modificăm numărul de elemente, ceea ce nu putem face în funcție, din cauza transmiterii prin copiere a parametrilor. O soluție poate fi ca funcția să returneze noul număr de elemente al vectorului.

==== Exemplu: ștergerea unei valori din vector ====
<syntaxhighlight lang="C" line>
#include <stdio.h>

// sterge valoarea e din v[] de pe toate pozitiile unde apare
int stergVect( int n, int v[], int e ) {
int i, j;

j = 0;
for ( i = 0; i < n; i++ )
if ( v[i] != e ) {
v[j] = v[i];
j++;
}

return j;
}

int main() {
int n, i;
int a[10] = { 1, 2, 3, 4, 2, 3, 2, 8, 9, 2 };

n = 10;
n = stergVect( n, a, 2 );
printf( "Vectorul are acum %d elemente:", n );
for ( i = 0; i < n; i++ )
printf( " %d", a[i] );
printf( "\n" );

return 0;
}</syntaxhighlight>

Programul va afișa:

<pre>Vectorul are acum 6 elemente: 1 3 4 3 8 9</pre>

Pentru matrice cărora funcția le modifică dimensiunile vom vedea mai jos cum putem proceda.

=== Exemple ===
Scrieți funcții care să rezolve:

==== Inversare vector ====
<syntaxhighlight lang="C" line>
#include <stdio.h>

// inverseaza (rastoarna) elementele unui vector
void invVect( int n, int v[] ) {
int i, j, aux;

i = 0;
j = n - 1;
while ( i < j ) {
aux = v[i];
v[i] = v[j];
v[j] = aux;
i++;
j--;
}
}

int main() {
int n, i;
int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

n = 10;
invVect( n, a );
printf( "Vectorul inversat este:" );
for ( i = 0; i < n; i++ )
printf( " %d", a[i] );
printf( "\n" );

return 0;
}</syntaxhighlight>

==== Inserare element în vector la o poziție dată ====
<syntaxhighlight lang="C" line>
#include <stdio.h>

// insereaza un element e in vectorul v de n elemente la pozitia poz
// daca poz este mai mare strict decit n nu face nimic
int insVect( int e, int n, int v[], int poz ) {
int i;

if ( poz <= n ) { // putem insera?
for ( i = n; i > poz; i-- )
v[i] = v[i - 1];
v[poz] = e;
n++;
}

return n;
}

int main() {
int n, e, i;
int a[20] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

n = 10;
e = 15;
n = insVect( e, n, a, 5 ); // insereaza 15 pe pozitia 5
printf( "Vectorul cu %d inserat pe pozitia 5 este:", e );
for ( i = 0; i < n; i++ )
printf( " %d", a[i] );
printf( "\n" );

return 0;
}</syntaxhighlight>

==== Citire întreg fără semn din fișier folosind doar fgetc() ====
<syntaxhighlight lang="C" line>
#include <stdio.h>
#include <ctype.h> // pentru isdigit()

FILE *fin;

// Citeste un intreg de la intrare
int getInt() {
int ch, n;

n = 0;
while ( !isdigit( ch = fgetc( fin ) ) ); // ignora non-cifre
do n = n * 10 + ch - '0';
while ( isdigit( ch = fgetc( fin ) ) );

return n;
}

// Citim un vector din fisierul 'fin' si il afisam
int main() {
int n, i;
int v[20];

fin = fopen( "exemplu.in", "r" );
n = getInt();
for ( i = 0; i < n; i++ )
v[i] = getInt();
fclose( fin );

printf( "Vectorul citit este:" );
for ( i = 0; i < n; i++ )
printf( " %d", v[i] );
printf( "\n" );

return 0;
}</syntaxhighlight>

Observați că am declarat variabila fișier în afara lui <source lang="C" enclose="none">main()</source> pentru a putea fi vizibilă în funcție. Vom vorbi despre aceasta mai jos.

=== Reguli de vizibilitate ale variabilelor în funcții ===
În C avem două tipuri de variabile: locale și globale.

* Variabilele locale se declară în interiorul unei funcții (sau în interiorul lui <source lang="C" enclose="none">main()</source>) și sunt vizibile (apelabile, folosibile) doar în acea funcție. Se cheamă că variabilele aparțin acelei funcții.
* Variabilele globale se declara în afara oricărei funcții și sunt vizibile din toate funcțiile, inclusiv <source lang="C" enclose="none">main()</source>. Precum știm deja ele sunt și inițializate automat cu zero.

Ce se întâmplă dacă denumim o variabilă locală cu același nume ca una globală? Cea locală are prioritate.

==== Exemplu ====
Ce afișează următorul program?

<syntaxhighlight lang="C" line>
#include <stdio.h>

int a = 100; // declarare variabila globala

void afiseaza() {
printf( "a global este %d\n", a );
}

int main () {
int a; // declarare variabila locala cu acelasi nume

a = 30; // atribuire variabila locala

afiseaza();

printf( "a local este %d\n", a );

return 0;
}</syntaxhighlight>

Programul va afișa:

<pre>a global este 100
a local este 30</pre>

=== Modificarea parametrilor cu efect la ieșirea din funcție ===
Ce facem dacă totuși ne dorim să modificăm o variabilă transmisă ca parametru? În acest caz vom apela funcția cu adresa de memorie (zisă și ''pointer'') a variabilei. Vom folosi doi operatori noi:
* <tt>&</tt> se aplică unei variabile și extrage adresa de memorie a variabilei
* <tt>*</tt> se aplică unei adrese de memorie și extrage conținutul variabilei de la acea adresă

Ar fi bine să evitați, deocamdată, deoarece mai întâi trebuie să învățați noțiunea de ''pointeri'', care nu face scopul acestei lecții.

==== Exemplu: functia swap ====
<syntaxhighlight lang="C" line>
#include <stdio.h>

void swap( int *pa, int *pb ) {
int aux;

aux = *pa;
*pa = *pb;
*pb = aux;
}

int main() {
int a, b;

a = 100;
b = 200;
swap( &a, &b );
printf( "a=%d b=%d\n", a, b );

return 0;
}</syntaxhighlight>

* Declarații de variabile și vizibilitatea acestora. Așezarea lor pe stivă.
* Conversia de tip când chemăm funcția cu alte tipuri decât cele declarate.

=== Funcțiile și programarea structurată ===
Instrucțiunea <tt>return</tt> este echivalentul unui salt la finalul funcției. Programare evident nestructurată. De aceea, deși limbajul C ne permite, nu o vom folosi '''decât la finalul funcției''', ca ultima instrucțiune. C este un limbaj vechi. Limbaje gen Pascal au rezolvat problema nestructurării eliminând instrucțiunea <tt>return</tt>.

=== Când scriem funcții? ===
Bun, am învățat funcții. Dar cum iau decizia să scriu o funcție sau nu?
* Atunci când nu putem evita repetiția de cod prin alte mijloace (factorizare, bucle, etc)
* Atunci când programul devine prea lung pentru a fi citit ușor, de obicei undeva la 80-100 de linii. Ca regulă generală o funcție ar fi bine să aibă până în 100 de linii, dar desigur regula nu este bătută în cuie.
* Atunci când simțim că o bucată semnificativă de cod are o coeziune, reprezintă un tot unitar, o putem transforma în funcție.
* Atunci când scriem o bucată de cod care execută un calcul general, gen sortare, sau citirea unui întreg, atunci o putem scrie ca funcție pentru a o refolosi în viitor. Vom vedea că aceasta este baza de pornire a bibliotecilor de funcții.
* Nu este bine să "rupem" artificial programul de dragul funcțiilor. Dacă tot programul ar avea 40 de linii, introducerea unor funcții i-ar scădea lizibilitatea.
* Pe cazul general, la olimpiade și pentru programele mici care rezolvă probleme de concurs încercați să evitați funcțiile inutile, doar de dragul artei. Când tot programul, scris elegant, ar avea 80 de linii este destul de greu să justifici introducerea unor funcții.

=== Cum denumim funcțiile? ===
O funcție trebuie denumită cât mai sugestiv. Funcții denumite <source lang="C" enclose="none">citire()</source> sau <source lang="C" enclose="none">solve()</source> cu am văzut la colegii voștri mai mari fac codul mai necitibil decât dacă ele nu existau. Ele sunt echivalentul variabilelor denumite <source lang="C" enclose="none">contor</source> sau <source lang="C" enclose="none">stegulet</source>. Așa cum stegulețul ar fi bine să se numească <source lang="C" enclose="none">terminat</source> sau <source lang="C" enclose="none">fara_zero</source>, la fel și funcțiile trebuie denumite sugestiv. Pentru cele două funcții de mai sus nume bune ar fi <source lang="C" enclose="none">citesteVectorInaltimi()</source> sau <source lang="C" enclose="none">calculSumePartiale()</source>. Observați că primul cuvânt din denumirea unei funcții începe cu literă mică, celelalte cu literă mare. Aceasta este o convenție de codare. Pentru variabile formate din mai multe cuvinte vom folosi numai litere mici, unind cuvintele cu underscore (sau underline, caracterul '_').

=== Considerente de viteză ===
Atunci când funcția poate fi chemată de un număr mare de ori calculatorul pierde un timp semnificativ în apelul de funcție. Un exemplu tipic ar fi când funcția este chemată într-o buclă care se execută de un milion de ori. Ce putem face?
* Evitați astfel de funcții, dacă nu dăunează eleganței și citibilității programului: introduceți codul funcției în loc de apel.
* Dacă totuși trebuie să folosiți o funcție aveți opțiunea să o declarați <tt>inline</tt>. Aceasta înseamnă că compilatorul nu va genera cod care să cheme funcția ci va înlocui apelul cu chiar corpul funcției, peste tot unde apare el. Este ca și cum funcția nu ar exista, păstrând însă citibilitatea programului (nu și scurtimea executabilului generat, din păcate).

== Tema 1 ==
Să se rezolve următoarele probleme (program C în CodeBlocks, trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/rapper Rapper]

* [https://www.nerdarena.ro/problema/snake Snake]

''Atenție!'' Implementările trebuie să conțină funcțiile menționate la prezentarea soluțiilor problemelor, mai sus. Mai exact:

* La problema [https://www.nerdarena.ro/problema/rapper Rapper], veți scrie și utiliza următoarele funcții (folosind doar <source lang="C" enclose="none">fgetc()</source> pentru citirea caracterelor):

<syntaxhighlight lang="C" line>
#define LINLEN 100

char linie[LINLEN + 1]; // unu in plus pentru terminatorul de linie '\0'

// citeste o linie si calculeaza numarul de nume si pozitia ultimului spatiu
void citesteLinie( FILE *fin, int *pnnume, int *psp ) {
// ... corpul functiei
}

// calculeaza nota prezenta in linia curenta
// nota este un numar intre 0 si 1000, pentru a nu avea un numar cu zecimale
// i este pozitia ultimului spatiu din linie
int calcNota( int i ) {
int nota = 0;

// ... corpul functiei

return nota;
}

// exemplu de utilizare
int main() {
FILE *fin, *fout;
int i, nnume, sp;

fin = fopen( "rapper.in", "r" );
// ...
citesteLinie( fin, &nnume, &sp ); // citeste prima linie
while ( nnume > 0 ) { // linia are macar un spatiu - nu este ultima
nlin++; // numaram inca o linie
// ...
citesteLinie( fin, &nnume, &sp ); // citeste urmatoarea linie
}
fclose( fin );
// ...
return 0;
}
</syntaxhighlight>

* La problema [https://www.nerdarena.ro/problema/snake snake], veți scrie și utiliza următoarele funcții:

<syntaxhighlight lang="C" line>
#define MAXN 1000
#define ZID -1
#define MAR -2

int dlin[4] = { 0, 1, 0, -1 };
int dcol[4] = { 1, 0, -1, 0 };

int tabla[MAXN][MAXN];

// citeste perechi de coordonate la intrare si le marcheaza in matrice cu mark
void citestePozitii( FILE *fin, int mark ) {
// corpul functiei
}

// date:
// n - dimensiunea tablei
// (l c) - pozitia curenta
// *dir - directia curenta
//
// calculeaza (*lurm *curm) pozitia urmatoare si *dir pozitia urmatoare
inline static void genUrm( int n, int l, int c,
int *dir, int *lurm, int *curm ) {
// ... corpul functiei
}

// exemplu de utilizare
int main() {
FILE *fin, *fout;
int nivel, n, m, dir, lcap, ccap, lurm, curm, valcoada, aux;

fin = fopen( "snake.in", "r" );
fscanf( fin, "%d%d%d", &nivel, &n, &m );
citestePozitii( fin, ZID ); // citeste zidurile
citestePozitii( fin, MAR ); // citeste merele
fclose( fin );

lcap = ccap = dir = 0;
// ... alte initializari
genUrm( n, lcap, ccap, &dir, &lurm, &curm ); // urmatoarea pozitie
while ( m > 0 && <conditie non-intersectie> ) {
// ... bucla simulare, mutare sarpe, etc
genUrm( n, lcap, ccap, &dir, &lurm, &curm ); // urmatoarea pozitie
}
// ...
return 0;
}
</syntaxhighlight>

[http://solpedia.francu.com/wiki/index.php/Clasa_a_7-a_Lec%C8%9Bia_1:_Reguli_de_programare_%C3%AEn_limbajul_C_%C8%99i_complexit%C4%83%C8%9Bi_algoritmice Accesează rezolvarea temei 1]

Clasa a 7-a Lecția 27: Algoritmul Union-Find

2025-06-10T15:30:02Z

Mihai:

== Înregistrare video lecție ==

{{#ev:youtube|https://youtu.be/QCaiWycJljs|||||start=8250&end=8320&loop=1}}

== Problema Disjoint ==

Se dau <tt>N</tt> mulţimi de numere, iniţial fiecare mulţime <tt>i</tt> conţinând un singur element, mai exact elementul i. Asupra acestor mulţimi se pot face 2 tipuri de operaţii, astfel:

* operaţia de tipul 1: se dau două numere naturale <tt>x</tt> si <tt>y</tt>, între 1 şi <tt>N</tt>. Se cere să se reunească mulţimile în care se află elementul <tt>x</tt>, respectiv elementul <tt>y</tt> (se garantează că <tt>x</tt> si <tt>y</tt> nu se vor afla în aceeaşi mulţime).
* operaţia de tipul 2: se dau două numere naturale <tt>x</tt> si <tt>y</tt>, între 1 şi <tt>N</tt>. Se cere să se afişeze DA dacă cele 2 elemente se află în aceeaşi mulţime, respectiv NU în caz contrar.

=== Date de intrare ===

Pe prima linie a fişierului de intrare <tt>disjoint.in</tt> se vor afla 2 numere, <tt>N</tt> şi <tt>M</tt>, reprezentând numărul de mulţimi, respectiv numărul de operaţii efectuate. Pe următoarele <tt>M</tt> linii se vor afla câte 3 numere, cod, <tt>x</tt> si <tt>y</tt>, cod reprezentând tipul operaţiei, iar <tt>x</tt> si <tt>y</tt> având semnificaţia din enunţ.

=== Date de ieşire ===

În fişierul de ieşire disjoint.out se vor afişa mai multe linii, fiecare linie conţinând DA sau NU, reprezentând răspunsul la interogarea corespunzătoare din fişierul de intrare.

=== Restricţii ===

* 1 ≤ N ≤ 100 000
* 1 ≤ M ≤ 100 000

=== Exemplu ===

{| class="wikitable"
!<tt>disjoint.in</tt>
!<tt>disjoint.out</tt>
|- style="vertical-align:top;"
|
<tt>4 6 
1 1 2 
1 3 4 
2 1 3 
2 1 2 
1 1 3 
2 1 4</tt>
|
<tt>NU 
DA 
DA</tt>
|}

== Algoritmul union-find ==

Problema [https://www.nerdarena.ro/problema/disjoint Disjoint] şi rezolvarea ei, este o unealtă foarte utilă din trusa de scule a algoritmistului. Să definim problema:

Dată o mulţime <tt>A</tt> de valori de la 0 la <tt>N-1</tt> definim submulţimi disjuncte pe această mulţime, astfel încât aceste submulţimi să acopere mulţimea originală <tt>A</tt>. Apoi începem să reunim unele dintre aceste mulţimi. Reuniunea se face menţionând două elemente ale submulţimilor ce se doresc reunite (dacă elementele se găsesc deja în aceeaşi submulţime nu vom face nimic). După ce efectuăm aceste operaţii de reuniune dorim să răspundem la întrebarea ''ce submulţimi avem?''.

Cu alte cuvinte, cunoscând N şi ştiind că iniţial fiecare număr face parte din propria submulţime şi apoi dându-se mai multe perechi de numere <tt>(ai, aj)</tt> cu semnificaţia ''mulţimea din care face parte ai se reuneşte cu mulţimea din care face parte aj'' trebuie ca în final să spunem ce submulţimi există.

Pentru a implementa algoritmul vom avea nevoie de două operaţii:

* reuneşte două mulţimi (''union'')
* găseşte mulţimea unui element (''find'')

De aici şi denumirea problemei ''union-find''. În română se regăseşte sub numele de colecţie de mulţimi disjuncte, dar se folosesc și denumirile ''DSU (disjoint set union)'' sau ''union-find''.

=== Soluție forță brută ===

O soluție posibilă ar fi ca pentru fiecare număr <tt>i</tt> să memorăm mulțimea din care face el parte. Astfel, <source lang="C" enclose="none">m[i]</source> va conține numărul mulțimii lui <tt>i</tt>. Dacă <tt>i</tt> și <tt>j</tt> fac parte din aceeași mulțime atunci <source lang="C" enclose="none">m[i] = m[j]</source>, în caz contrar <source lang="C" enclose="none">m[i] ≠ m[j]</source>.

Inițial fiecare număr va avea propria lui mulțime, adică <source lang="C" enclose="none">m[i] = i</source>.

==== Operația Find ====

Precum am spus, <tt>find(i)</tt> ne va da un identificator unic al mulțimii elementului <tt>i</tt>. În cazul nostru el va fi un număr între 0 și <tt>N-1</tt>. Cum o implementăm? Returnând chiar <source lang="C" enclose="none">m[i]</source>!

<syntaxhighlight lang="c" line>
int find( int i ) {
return m[i];
}
</syntaxhighlight>

Ce complexitate are această operație?

Desigur ''O(1)''.

==== Operația Union ====

Operația <tt>union(i, j)</tt> trebuie să reunească mulțimile din care fac parte elementele <tt>i</tt>, respectiv <tt>j</tt>. Cum o implementăm? Suprascriind identificatorul mulțimii lui <tt>j</tt> cu identificatorul mulțimii lui <tt>i</tt>, peste tot unde apare el.

<syntaxhighlight lang="c" line>
void union( int i, int j ) {
int k, mj = m[j];

for ( k = 0; k < N; k++ )
if ( m[k] == mj )
m[k] = m[i];
}
</syntaxhighlight>

Ce complexitate are această operație?

Desigur ''O(N)''.

''' Concluzie '''

Cu forța brută vom avea complexitățile:

* Find: ''O(1)'' timp.
* Union: ''O(N)'' timp.
* Memorie necesară: ''O(N)''.

=== Soluție alternativă ===

Să încercăm să optimizăm operația union. Actualizarea identificatorilor mulțimii durează mult. Ce putem face?

O idee ar fi ca, în loc să actualizăm toți identificatorii mulțimii lui <tt>j</tt>, să îl actualizăm doar pe al lui <tt>j</tt>. Astfel, fiecare element între 0 și <tt>N-1</tt> va ţine mine un şef al său din mulţime. Întocmai ca într-o companie, fiecare element al unei submulţimi va raporta unui şef, şefii vor raporta altor şefi şi aşa mai departe până ce se ajunge la şeful unic, conducătorul submulţimii. El nu are şef şi este considerat reprezentantul acelei submulţimi.

Cum memorăm acest lucru? Printr-un simplu vector de şefi (similar vectorului <source lang="C" enclose="none">m[]</source>) în care elementul <source lang="C" enclose="none">sef[i]</source> este numărul din mulţimea 0..N-1 care este şeful lui <tt>i</tt>. Ce punem în elementele şefi supremi, cele care nu au șefi? Pentru a le distinge de elementele subalterni fiecare şef suprem este propriul lui şef. Dacă elementul <tt>i</tt> este şef suprem atunci <source lang="C" enclose="none">sef[i] = i</source>. O alternativă la această reprezentare, dacă ''sacrificăm'' elementul 0, este să memorăm zero ca şef fictiv pentru elementele reprezentative ale mulţimilor.

Inițial fiecare element este propriul său șef. Atunci când căutăm o mulțime, căutăm de fapt șeful suprem, care este propriul său șef. Când unificăm mulțimile lui <tt>i</tt> și ale lui <tt>j</tt> vom nota că șeful mulțimii <tt>i</tt> devine șeful șefului mulțimii <tt>j</tt>.

==== Operația Find ====

Precum am spus, <tt>find(i)</tt> va returna șeful mulțimii din care face parte <tt>i</tt>. Cum îl găsim? Mergând la șeful lui <tt>i</tt>, apoi la șeful șefului lui <tt>i</tt> și tot așa până la șeful mulțimii. Iată o implementare recursivă simplă:

<syntaxhighlight lang="c" line>
int find( int i ) {
if ( sef[i] == i ) // daca am gasit seful suprem
return i; // il returnam
return find( sef[i] ); // altfel returnam seful sefului
}
</syntaxhighlight>

Ce complexitate are această operație?

Care este cazul cel mai rău? Când toate elementele se înșiră într-un lanț lung de șefi. În acest caz timpul este ''O(N)''.

==== Operația Union ====

Operația <tt>union(i, j)</tt> trebuie să reunească mulțimile din care fac parte elementele <tt>i</tt>, respectiv <tt>j</tt>. Cum o implementăm? Suprascriind identificatorul mulțimii lui <tt>j</tt> cu identificatorul mulțimii lui <tt>i</tt>, peste tot unde apare el.

<syntaxhighlight lang="c" line>
void union( int i, int j ) {
int sefi, sefj;

sefi = find( i ); // seful suprem al lui i
sefj = find( j ); // seful suprem al lui j

sef[sefj] = sefi; // seful suprem al lui sefj devine sefi
}
</syntaxhighlight>

Ce complexitate are această operație?

Ea apelează de două ori <tt>find()</tt>, iar apoi face ''O(1)'' operații.

''' Concluzie '''

Cu soluția alternativă avem complexitățile:

* Find: ''O(N)'' timp.
* Union: ''O(1)'' timp + complexitatea lui Find.
* Memorie necesară: ''O(N)''.

Nu pare că am avansat, nu? Poate că nu. Observăm, însă, că timpul total depinde de Find: dacă reușim să îmbunătățim complexitatea lui Find automat vom îmbunătăți și complexitatea lui Union.

Putem îmbunătăți timpul lui find la ''O(log N)'' cu o modificare destul de mică a structurii de date, dar nu voi prezenta acest lucru. Pentru cei curioși, putem memora cea mai lungă cale de șefi din fiecare mulțime, iar apoi vom atașa mulțimea mai mică la cea mai mare (alegând în mod potrivit dacă atașăm șeful lui <tt>i</tt> la <tt>j</tt> sau invers).

=== Soluție eficientă folosind compresia căii ===

Pentru a obţine cel mai eficient algoritm cunoscut avem nevoie de două optimizări: compresia căii și menținerea unui rang al fiecărei mulțimi. Voi prezenta aici doar una dintre ele, cea mai importantă, compresia căii. Ea face un lucru foarte simplu: schimbă puţin funcţia find ca, atunci când dorim să aflăm care este şeful nodului <tt>i</tt>, să lege toţi şefii parcurşi direct la şeful suprem. Cu alte cuvinte vom parcurge aceiaşi şefi intermediari până la şeful suprem, dar odată găsit va trebui să ne întoarcem la şefii intermediari şi să le schimbăm şeful. Aceasta duce aproximativ la o dublare a opreaţiilor efectuate de find. Dar, precum spunea astronatul Neil Armstrong, un pas mic pentru un om poate fi un pas uriaş pentru omenire. O mică modificare ce duce la dublarea timpului lui find duce la o scurtare fantastică a următoarelor operaţiuni ''find''.

[[File:path-compression-find.png|frame|none|Exemplu de ''find'' cu compresia căii]]

Această optimizare poartă denumirea de compresia căii, sau, în engleză, path compression.

==== Operația Find ====

Iată o modificare mică a funcției anterioare, care face și compresia căii:

<syntaxhighlight lang="c" line>
int find( int i ) {
if ( sef[i] == i ) // daca am gasit seful suprem
return i; // il returnam
return sef[i] = find( sef[i] ); // altfel legam i la seful suprem, pe care il si returnam
}
</syntaxhighlight>

==== Operația Union ====

Operația <tt>union(i, j)</tt> trebuie să reunească mulțimile din care fac parte elementele <tt>i</tt>, respectiv <tt>j</tt>. Cum o implementăm? Suprascriind identificatorul mulțimii lui <tt>j</tt> cu identificatorul mulțimii lui <tt>i</tt>, peste tot unde apare el.

<syntaxhighlight lang="c" line>
void union( int i, int j ) {
int sefi, sefj;

sefi = find( i ); // seful suprem al lui i
sefj = find( j ); // seful suprem al lui j

sef[sefj] = sefi; // seful suprem al lui sefj devine sefi
}
</syntaxhighlight>

Ce complexitate au aceste operații?

În această implementare, ele sunt ''O(log N)'' amortizat, per operație, cu o constantă foarte mică. Demonstrația acestui lucru depășește cadrul acestui curs.

''' Concluzie '''

Cu compresia căii avem complexitățile:

* Find: ''O(log N)'' timp.
* Union: ''O(log N)'' timp.
* Memorie necesară: ''O(N)''.

Notă: se poate mai bine. Dacă adăugăm și cealaltă optimizare menționată mai sus, rangul unei mulțimi, ajungem la o complexitate ''O(α(N))'', unde ''α(N)'' este inversul funcției lui Ackermann, o funcție rapid crescătoare. Cu această modificare timpul amortizat este, practic, constant.

=== Inversarea sensului ===

Ocazional veți întâlni problema inversă: se pornește cu o structură conexă care, treptat, este deconectată. Pe parcurs, se cer informații despre conexitate. Aceasta este o problemă de '''partiționare''', care nu admite o soluție directă la fel de simplă.

Dar, când memoria permite stocarea șirului de operații, o soluție este:

* Executăm toate operațiile de deconectare, obținând structura finală.
* Executăm în ordine inversă operațiile, care acum reconectează structura. Putem face aceste operații cu structuri de mulțimi disjuncte.
* Notăm răspunsurile la interogările de conexitate.
* Tipărim aceste răspunsuri în ordine inversă.

Exemple de astfel de probleme: [https://www.nerdarena.ro/problema/bile3 Bile3], [https://www.nerdarena.ro/problema/ruine Ruine], pe care le aveți la temă, respectiv tema opțională.

== Tema 27 ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/disjoint Disjoint]
* [https://www.nerdarena.ro/problema/channels Channels] dată la Shumen 2012 juniori
* [https://www.nerdarena.ro/problema/bile3 Bile3]

== Tema opțională ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/flota Flota]
* [https://www.nerdarena.ro/problema/ruine Ruine]

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_27:_Algoritmul_Union-Find&action=edit&redlink=1 Accesează rezolvarea temei 29]

Clasa a 7-a Lecția 27: Algoritmul Union-Find

2025-06-10T15:19:54Z

Mihai: Created page with "== Înregistrare video lecție == {{#ev:youtube|https://youtu.be/QCaiWycJljs|||||start=8250&end=8320&loop=1}} == Problema Disjoint == Se dau <tt>N</tt> mulţimi de numere, iniţial fiecare mulţime <tt>i</tt> conţinând un singur element, mai exact elementul i. Asupra acestor mulţimi se pot face 2 tipuri de operaţii, astfel: * operaţia de tipul 1: se dau două numere naturale <tt>x</tt> si <tt>y</tt>, între 1 şi <tt>N</tt>. Se cere să se reunească m..."

== Înregistrare video lecție ==

{{#ev:youtube|https://youtu.be/QCaiWycJljs|||||start=8250&end=8320&loop=1}}

== Problema Disjoint ==

Se dau <tt>N</tt> mulţimi de numere, iniţial fiecare mulţime <tt>i</tt> conţinând un singur element, mai exact elementul i. Asupra acestor mulţimi se pot face 2 tipuri de operaţii, astfel:

* operaţia de tipul 1: se dau două numere naturale <tt>x</tt> si <tt>y</tt>, între 1 şi <tt>N</tt>. Se cere să se reunească mulţimile în care se află elementul <tt>x</tt>, respectiv elementul <tt>y</tt> (se garantează că <tt>x</tt> si <tt>y</tt> nu se vor afla în aceeaşi mulţime).
* operaţia de tipul 2: se dau două numere naturale <tt>x</tt> si <tt>y</tt>, între 1 şi <tt>N</tt>. Se cere să se afişeze DA dacă cele 2 elemente se află în aceeaşi mulţime, respectiv NU în caz contrar.

=== Date de intrare ===

Pe prima linie a fişierului de intrare <tt>disjoint.in</tt> se vor afla 2 numere, <tt>N</tt> şi <tt>M</tt>, reprezentând numărul de mulţimi, respectiv numărul de operaţii efectuate. Pe următoarele <tt>M</tt> linii se vor afla câte 3 numere, cod, <tt>x</tt> si <tt>y</tt>, cod reprezentând tipul operaţiei, iar <tt>x</tt> si <tt>y</tt> având semnificaţia din enunţ.

=== Date de ieşire ===

În fişierul de ieşire disjoint.out se vor afişa mai multe linii, fiecare linie conţinând DA sau NU, reprezentând răspunsul la interogarea corespunzătoare din fişierul de intrare.

=== Restricţii ===

* 1 ≤ N ≤ 100 000
* 1 ≤ M ≤ 100 000

=== Exemplu ===

{| class="wikitable"
!<tt>disjoint.in</tt>
!<tt>disjoint.out</tt>
|- style="vertical-align:top;"
|
<tt>4 6 
1 1 2 
1 3 4 
2 1 3 
2 1 2 
1 1 3 
2 1 4</tt>
|
<tt>NU 
DA 
DA</tt>
|}

== Algoritmul union-find ==

Problema [https://www.nerdarena.ro/problema/disjoint Disjoint] şi rezolvarea ei, este o unealtă foarte utilă din trusa de scule a algoritmistului. Să definim problema:

Dată o mulţime <tt>A</tt> de valori de la 0 la <tt>N-1</tt> definim submulţimi disjuncte pe această mulţime, astfel încât aceste submulţimi să acopere mulţimea originală <tt>A</tt>. Apoi începem să reunim unele dintre aceste mulţimi. Reuniunea se face menţionând două elemente ale submulţimilor ce se doresc reunite (dacă elementele se găsesc deja în aceeaşi submulţime nu vom face nimic). După ce efectuăm aceste operaţii de reuniune dorim să răspundem la întrebarea ''ce submulţimi avem?''.

Cu alte cuvinte, cunoscând N şi ştiind că iniţial fiecare număr face parte din propria submulţime şi apoi dându-se mai multe perechi de numere <tt>(ai, aj)</tt> cu semnificaţia ''mulţimea din care face parte ai se reuneşte cu mulţimea din care face parte aj'' trebuie ca în final să spunem ce submulţimi există.

Pentru a implementa algoritmul vom avea nevoie de două operaţii:

* reuneşte două mulţimi (''union'')
* găseşte mulţimea unui element (''find'')

De aici şi denumirea problemei ''union-find''. În română se regăseşte sub numele de colecţie de mulţimi disjuncte, dar se folosesc și denumirile ''DSU (disjoint set union)'' sau ''union-find''.

=== Soluție forță brută ===

O soluție posibilă ar fi ca pentru fiecare număr i să memorăm mulțimea din care face el parte. Astfel, m[i] va conține numărul mulțimii lui i. Dacă i și j fac parate din aceeași mulțime atunci m[i] = m[j], în caz contrar m[i] ≠ m[j].

Inițial fiecare număr va avea propria lui mulțime, adică m[i] = i.

==== Operația Find ====

Precum am spus, find(i) ne va da un identificator unic al mulțimii elementului i. În cazul nostru el va fi un număr între 0 și N-1. Cum o implementăm? Returnând chiar m[i]!

int find( int i ) {
return m[i];
}

Ce complexitate are această operație?

Desigur O(1).

==== Operația Union ====

Operația union(i, j) trebuie să reunească mulțimile din care fac parte elementele i, respectiv j. Cum o implementăm? Suprascriind identificatorul mulțimii lui j cu identificatorul mulțimii lui i, peste tot unde apare el.

void union( int i, int j ) {
int k, mj = m[j];

for ( k = 0; k

Ce complexitate are această operație?

Desigur O(N).

''' Concluzie '''

Cu forța brută vom avea complexitățile:

Find: O(1) timp

Union: O(N) timp

Memorie necesară: O(N)

=== Soluție alternativă ===

Să încercăm să optimizăm operația union. Actualizarea identificatorilor mulțimii durează mult. Ce putem face?

O idee ar fi ca, în loc să actualizăm toți identificatorii mulțimii lui j, să îl actualizăm doar pe al lui j. Astfel, fiecare element între 0 și N-1 va ţine mine un şef al său din mulţime. Întocmai ca într-o companie, fiecare element al unei submulţimi va raporta unui şef, şefii vor raporta altor şefi şi aşa mai departe până ce se ajunge la şeful unic, conducătorul submulţimii. El nu are şef şi este considerat reprezentantul acelei submulţimi.

Cum memorăm acest lucru? Printr-un simplu vector de şefi (similar vectorului m[]) în care elementul sef[i] este numărul din mulţimea 0..N-1 care este şeful lui i. Ce punem în elementele şefi supremi, cele care nu au șefi? Pentru a le distinge de elementele subalterni fiecare şef suprem este propriul lui şef. Dacă elementul i este şef suprem atunci sef[i] = i. O alternativă la această reprezentare, dacă "sacrificăm" elementul 0, este să memorăm zero ca şef fictiv pentru elementele reprezentative ale mulţimilor.

Inițial fiecare element este propriul său șef. Atunci când căutăm o mulțime, căutăm de fapt șeful suprem, care este propriul său șef. Când unificăm mulțimile lui i și ale lui j vom nota că șeful mulțimii i devine șeful șefului mulțimii j.

==== Operația Find ====

Precum am spus, find(i) va returna șeful mulțimii din care face parte i. Cum îl găsim? Mergând la șeful lui i, apoi la șeful șefului lui i și tot așa până la șeful mulțimii. Iată o implementare recursivă simplă:

int find( int i ) {
if ( sef[i] == i ) // daca am gasit seful suprem
return i; // il returnam
return find( sef[i] ); // altfel returnam seful sefului
}

Ce complexitate are această operație?

Care este cazul cel mai rău? Când toate elementele se înșiră într-un lanț lung de șefi. În acest caz timpul este O(N).

==== Operația Union ====

Operația union(i, j) trebuie să reunească mulțimile din care fac parte elementele i, respectiv j. Cum o implementăm? Suprascriind identificatorul mulțimii lui j cu identificatorul mulțimii lui i, peste tot unde apare el.

void union( int i, int j ) {
int sefi, sefj;

sefi = find( i ); // seful suprem al lui i
sefj = find( j ); // seful suprem al lui j

sef[sefj] = sefi; // seful suprem al lui sefj devine sefi
}

Ce complexitate are această operație?

Ea apelează de două ori find(), iar apoi face O(1) operații.

''' Concluzie '''

Cu soluția alternativă avem complexitățile:

Find: O(N) timp

Union: O(1) timp + complexitatea lui Find

Memorie necesară: O(N)

Nu pare că am avansat, nu? Poate că nu. Observăm, însă, că timpul total depinde de Find: dacă reușim să îmbunătățim complexitatea lui Find automat vom îmbunătăți și complexitatea lui Union.

Putem îmbunătăți timpul lui find la O(log N) cu o modificare destul de mică a structurii de date, dar nu voi prezenta acest lucru. Pentru cei curioși, putem memora cea mai lungă cale de șefi din fiecare mulțime, iar apoi vom atașa mulțimea mai mică la cea mai mare (alegând în mod potrivit dacă atașăm șeful lui i la j sau invers).

=== Soluție eficientă folosind compresia căii ===

Pentru a obţine cel mai eficient algoritm cunoscut avem nevoie de două optimizări: compresia căii și menținerea unui rang al fiecărei mulțimi. Voi prezenta aici doar una dintre ele, cea mai importantă, compresia căii. Ea face un lucru foarte simplu: schimbă puţin funcţia find ca, atunci când dorim să aflăm care este şeful nodului i, să lege toţi şefii parcurşi direct la şeful suprem. Cu alte cuvinte vom parcurge aceiaşi şefi intermediari până la şeful suprem, dar odată găsit va trebui să ne întoarcem la şefii intermediari şi să le schimbăm şeful. Aceasta duce aproximativ la o dublare a opreaţiilor efectuate de find. Dar, precum spunea astronatul Neil Armstrong, un pas mic pentru un om poate fi un pas uriaş pentru omenire. O mică modificare ce duce la dublarea timpului lui find duce la o scurtare fantastică a următoarelor operaţiuni find.

Această optimizare poartă denumirea de compresia căii, sau, în engleză, path compression.

==== Operația Find ====

Iată o modificare mică a funcției anterioare, care face și compresia căii:

int find( int i ) {
if ( sef[i] == i ) // daca am gasit seful suprem
return i; // il returnam
return sef[i] = find( sef[i] ); // altfel legam i la seful suprem, pe care il si returnam
}

==== Operația Union ====

Operația union(i, j) trebuie să reunească mulțimile din care fac parte elementele i, respectiv j. Cum o implementăm? Suprascriind identificatorul mulțimii lui j cu identificatorul mulțimii lui i, peste tot unde apare el.

void union( int i, int j ) {
int sefi, sefj;

sefi = find( i ); // seful suprem al lui i
sefj = find( j ); // seful suprem al lui j

sef[sefj] = sefi; // seful suprem al lui sefj devine sefi
}

Ce complexitate au aceste operații?

În această implementare, ele sînt O(log N) amortizat, per operație, cu o constantă foarte mică. Demonstrația acestui lucru depășește cadrul acestui curs.

''' Concluzie '''

Cu compresia căii avem complexitățile:

Find: O(log N) timp

Union: O(log N) timp

Memorie necesară: O(N)

Notă: se poate mai bine. Dacă adăugăm și cealaltă optimizare menționată mai sus, rangul unei mulțimi, ajungem la o complexitate O(α(N)), unde α(N) este inversul funcției lui Ackermann, o funcție rapid crescătoare. Cu această modificare timpul amortizat este, practic, constant.

=== Inversarea sensului ===

Ocazional veți întâlni problema inversă: se pornește cu o structură conexă care, treptat, este deconectată. Pe parcurs, se cer informații despre conexitate. Aceasta este o problemă de partiționare, care nu admite o soluție directă la fel de simplă.

Dar, când memoria permite stocarea șirului de operații, o soluție este:

Executăm toate operațiile de deconectare, obținând structura finală.

Executăm în ordine inversă operațiile, care acum reconectează structura. Putem face aceste operații cu structuri de mulțimi disjuncte.

Notăm răspunsurile la interogările de conexitate.

Tipărim aceste răspunsuri în ordine inversă.

Exemple de astfel de probleme: bile3, ruine, pe care le aveți la temă, respectiv tema opțională.

== Tema 27 ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/disjoint Disjoint]
* [https://www.nerdarena.ro/problema/channels Channels] dată la Shumen 2012 juniori
* [https://www.nerdarena.ro/problema/bile3 Bile3]

== Tema opțională ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/flota Flota]
* [https://www.nerdarena.ro/problema/ruine Ruine]

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_27:_Algoritmul_Union-Find&action=edit&redlink=1 Accesează rezolvarea temei 29]

Clasa a 7-a Lecția 26: Programare dinamică (3)

2025-06-10T15:00:43Z

Mihai: /* Problema Poteci */

== Înregistrare video rezolvarea temei ==

{{#ev:youtube|https://www.youtube.com/watch?v=KdHv9T7Pp98|||||start=80&end=10280&loop=1}}

În continuare vom studia exemple de probleme de programare dinamică și probleme suprapuse date la olimpiadă.

== Problema Faleza ==

Problema [https://www.nerdarena.ro/problema/faleza Faleza] a fost dată la ONI 2017 clasa a 6-a. Ea este o problemă de un anumit gen, care se întâlnește din când în când la olimpiadă: probleme mascate, care au o soluție medie sau chiar grea, fără programare dinamică, dar care admit o soluție banală cu programare dinamică.

Atâta vreme cât programarea dinamică nu este în programa de olimpiadă de clasa a șasea, după părerea mea genul acesta de probleme nu sunt bune de concurs, deoarece încurajează dopajul, nu gândirea algoritmică și aprofundarea cunoștințelor. În cazul problemei [https://www.nerdarena.ro/problema/faleza Faleza] cine știe programare dinamică o poate termina în 15 minute. Cine nu, va trebui să găsească un algoritm care nu e deloc evident (mai ales la casa a 6-a), petrecând, probabil, peste o oră.

=== Soluția comisiei ===

''Construim două tablouri pe care le notăm A și B, cu numerele din fișier, în A cele de pe o parte a falezei și în B cele de pe cealaltă. Pentru simplificarea implementării, dacă avem poziții i în care A[i] = 1 și B[i] = 1 putem să analizăm doar ce se întâmplă între două astfel de poziții consecutive.''

''Parcurgem element cu element și păstrăm mereu ultima poziție pe care se află o dală bună pentru șirul A respectiv pentru șirul B, alegând, în funcție de acestea, modul de a completa dalele deteriorate.''

''Timpul de executare este liniar.''

După părerea mea este puțin vagă. În mod cert e nevoie de o analiză care nu pare simplă.

=== Soluție cu programare dinamică ===

Să simplificăm puțin enunțul: se cere să reparăm cât mai puține dale pentru a se putea ajunge de la un capăt la celălalt. Cu alte cuvinte se cere '''un drum care să treacă prin cât mai puține dale rupte'''. Dacă vom schimba codarea dalelor, cele rupte cu 1 și cele întregi cu 0, rezultă că trebuie să găsim un '''drum de sumă minimă'''.

O observație simplă, dar esențială, este că drumul minim nu se va întoarce de la dreapta la stânga. Într-adevăr, este clar că nu are de ce. Putem, deci, calcula drumurile de la stânga la dreapta.

Drept care o definiție evidentă a problemei de programare dinamică este:

S[l][c] = suma unui drum de sumă minimă pentru a ajunge în punctul (l, c).

Demonstrație de optimalitate a subprobemelor o las în seama voastră, fiind simplă.

Formula de recurență este iarăși simplă:

* Într-o dală de sus putem ajunge fie dinspre stânga, fie din jos în sus.
* Într-o dală de jos putem ajunge fie dinspre stânga, fie din sus în jos.

Vom lua în considerare minimul dintre cele două variante.

Formula de recurență este:

: <math>S[l][c] = \begin{cases} D[l][c], & \mbox{dacă } c = 0\\D[l][c] + min(S[l][c-1], S[1-l][c-1] + D[1-l][c]) & \mbox{în caz contrar}. \end{cases} </math>

Am considerat că <tt>D[l][c]</tt> este codificarea dalei din linia <tt>l</tt> și coloana <tt>c</tt>. Liniile și coloanele sunt numerotate de la 0.

Răspunsul cerut este minimul dintre <tt>S[0][n-1]</tt> și <tt>S[1][n-1]</tt>.

Ce complexitate are această soluție?

Timpul este evident ''O(n)''.

Memoria ar putea fi ''O(1)'' dacă dalele ar fi date pe linii, nu pe coloane. Așa cum este enunțul suntem obligați să le stocăm, ceea ce duce la memorie ''O(n)''. Putem însă refolosi matricea de dale pentru a calcula sumele minime. Drept care memoria va fi de <tt>2n</tt> întregi, adică 800KB.

''' Exemplu'''

Iată exemplul din enunț calculat conform formulei de mai sus.

Dalele originale (0 = întreagă, 1 = ruptă):

{| class="wikitable"
|1
|1
|0
|0
|0
|1
|1
|1
|-
|1
|1
|1
|1
|1
|1
|1
|0
|}

Calculul drumurilor minime pe coloane, de la stânga la dreapta:

{| class="wikitable"
|1
|2
|2
|2
|2
|3
|4
|5
|-
|1
|2
|3
|3
|3
|4
|5
|5
|}

== Problema Poteci ==

Problema [https://www.nerdarena.ro/problema/poteci Poteci] a fost dată la ONI 2011 baraj gimnaziu.

=== Soluția comisiei ===

Fiind vorba de baraj, soluția este una bazată pe programare dinamică:

* Pentru fiecare element din matrice vom calcula drumurile optime până la cele patru colțuri ale matricei.
* Parcurgem matricea și determinăm acel element pentru care suma celor patru drumuri este maximă.

Pentru primul pas vom folosi programarea dinamică, o procedură apelată de patru ori. În fapt, vom calcula drumurile optime de la fiecare colț către toate elementele matricei. De exemplu, pentru distanța de la colțul <tt>(1, 1)</tt> la elementul <tt>(i, j)</tt> vom avea formula de recurență:

: <math>D_{1,1}[l][c] = \begin{cases} 0, & \mbox{dacă } l = 0 \mbox{ sau } c = 0\\M[l][c] + \max{(D_{1,1}[l][c-1], D_{1,1}[l-1][c])} & \mbox{în caz contrar}. \end{cases}</math>

În final vom alege punctul din matrice (l, c) cu proprietatea:

: <math>MAX = \max\limits_{1 \leq l \leq L, 1 \leq c \leq C}{(D_{1,1}[l][c] + D_{1,C}[l][c] + D_{L,1}[l][c] + D_{L,C}[l][c])}</math>

Ce complexitate are această soluție?

Ea calculează patru matrice, deci atât timpul cât și memoria vor fi ''O(L·C)''. Mai exact, vom avea nevoie de patru matrice de elemente întregi de 1000 x 1000 elemente, circa 16MB, plus matricea originală de frumuseți, elemente <source lang="C" enclose="none">short int</source>, deci încă 2MB, total 18MB.

=== Soluție alternativă ===

O soluție care face mai puține calcule și folosește mai puțină memorie este următoarea.

'''Observație''': perechea optimă de poteci va fi alcătuită din două poteci optime.

Într-adevăr, dacă una din poteci nu ar fi optimă, am putea alege o potecă mai bună care ar duce la o pereche mai bună.

De aici vine și ideea soluției: să calculăm potecile optime pentru cei doi și să alegem punctul de intersecție a lor. Pentru aceasta va trebui să calculăm nu doar frumusețile potecilor, ci și potecile în sine. La final vom calcula intersecția potecilor.

Ce complexitate are această soluție? Ea este, desigur, tot ''O(L·C)'' atât ca timp cât și ca memorie. Însă vom calcula doar două matrice, deci timpul se reduce aproximativ la jumate. Iar memoria necesară este de o matrice pentru frumusețile originale (2MB) și o matrice de drumuri (1MB). Pentru a calcula intersecția putem refolosi matricea de drumuri. Necesarul de memorie este, deci, de numai 3MB, comparat cu cei 18MB ai soluției anterioare. Putem reduce și mai mult memoria dacă folosim pentru stocarea drumurilor matrice de biți, caz în care în loc de 1MB vom folosi 125KB, iar memoria totală folosită va fi 2.12MB. Iar folosind [https://en.wikipedia.org/wiki/Hirschberg%27s_algorithm algoritmul lui Hirschberg] putem elimina complet matricea de drumuri, ceea ce duce la 2MB memorie necesară.

'''Concluzii:'''

Timpul se reduce la jumate.

Memoria se reduce la o șesime

== Problema Optim ==

Problema [https://www.nerdarena.ro/problema/optim Optim] a fost dată la ONI 2012 clasa a 8-a. Ea are o rezolvare fără programare dinamică, ineficientă și nu chiar banal de implementat și o rezolvare cu programare dinamică, eficientă și relativ ușor de implementat.

=== Soluția combinatorică, fără programare dinamică ===

Soluția comisiei, cea combinatorică, se bazează pe generarea tuturor modurilor de a plasa <tt>K</tt> înmulțiri între <tt>N</tt> operații și calculul expresiilor respective, din care vom reține minimul și maximul. Implementarea este cea de combinări modificată să calculeze incremental expresiile.

Complexitatea este ''O(Comb(N, K))''. Pentru valori maxime obținem Comb(30, 10), aproximativ 10 milioane operații.

=== Soluție cu programare dinamică ===

Problema are două părți echivalente, minimul și maximul. Să ne concetrăm pe maxim, minimul rezolvându-se similar.

O definire directă a subproblemei ar putea fi:

MAX[i][j] = maximul care se poate obține cu numerele nr[0], nr[1], ..., nr[i] folosind i operații, din care j înmulțiri.

Are ea proprietatea de optimalitate?

Să vedem: dacă luăm o soluție optimă și eliminăm ultimul număr și ultima operație, ceea ce rămâne este optim?

Nu neapărat. Dacă ultima operație este o adunare, vom avea o subproblemă optimă, dar dacă este o înmulțire, nu.

Ce facem? Observăm că optimalitatea se păstrează la adunări, nu și la înmulțiri. Deci putem spune că, dacă <tt>MAX[i][j]</tt> este optim și are <tt>m</tt> înmulțiri în coadă, atunci și <tt>MAX[i-m-1][j-m]</tt> este optim, el fiind format din suma produselor anterioare, care dacă nu ar fi optimă am putea construi o sumă mai mare în <tt>MAX[i][j]</tt>.

Astfel, formula de recurență este:

: <math>MAX[i][j] = \begin{cases} nr[0]\cdot nr[1]\cdot\mbox{…}\cdot nr[i], & \mbox{dacă } i = j\\ \max\limits_{0 \leq m \leq j}{(MAX[i-m-1][j-m] + nr[i-m]\cdot nr[i-m+1]\cdot\mbox{…}\cdot nr[i])} & \mbox{în caz contrar}. \end{cases}</math>

Răspunsul la cerință va fi: <tt>MAX[N][K]</tt>.

Ce complexitate are această soluție?

Ea este ''O(N·K2)''. Înlocuind vom obține circa 2430 operații, un număr incredibil de mic. Probabil că mai mult va dura citirea celor 30 de numere.

Memoria folosită este cea a matricei de dimensiune <tt>N x K</tt>, deci ''O(N·K)'', din nou neglijabilă.

''' Exemplu '''

Iată exemplul din enunț calculat conform formulei de mai sus.

Fie numerele de la intrare:

{| class="wikitable"
! Indice !! 0 !! 1 !! 2 !! 3 !! 4 !! 5
|-
! Valoare || 2 || 0 || 3 || -1 || 7 || -4
|}

Calculul expresiilor maxime, pe linii, de la stânga la dreapta:

{| class="wikitable"
! rowspan="2" | Numere !! colspan="4" | Înmulțiri
|-
! 0 !! 1 !! 2 !! 3
|-
| 0 || 2 || || ||
|-
| 1 || 2 || 0 || ||
|-
| 2 || 5 || 3 || 0 ||
|-
| 3 || 4 || 2 || 2 || 0
|-
| 4 || 11 || 9 || 9 || 7
|-
| 5 || 7 || 5 || 33 || 86
|}

== Problema Joc6 ==

Problema [https://www.nerdarena.ro/problema/joc6 Joc6] a fost dată la ONI 2011 baraj gimnaziu. Este o problemă tipică de programare dinamică.

=== Soluția comisiei ===

''Pentru fiecare jucător se determină secvenţele de bile cu valori consecutive. Acest lucru se poate realiza prin utilizarea unui vector caracteristic.

După determinarea secvenţelor, se selectează secvenţa de sumă maximă ce poate fi obţinută prin utilizarea bilelor speciale, în funcţie de numărul de bile speciale pe care le are jucătorul curent. Se determină maximul sumelor maxime şi jucătorul care are acest maxim.''

Din păcate explicațiile sunt destul de vagi. Ce bănuiesc eu:

* Vom face o listă de secvențe, păstrând pentru fiecare secvență: (indice start, indice final, suma)
* Vom încerca să cuplăm secvențe astfel:
** Fie două secvențe consecutive dacă ele sunt despărțite de cel mult numărul de bile zero disponibile.
** Fie trei secvențe consecutive dacă avem măcar două bile zero, iar secvențele sunt despărțite de fix un zero.

Desigur vom lua maximul sumelor.

Ce complexitate are această soluție?

Pentru detecția secvențelor avem nevoie de un vector de frecvență, deci ''O(n + p)''. Pentru parcurgerea secvențelor avem nevoie de ''O(p)'' pași. Deoarece avem <tt>k</tt> jucători complexitatea totală este ''O(k·(n + p)''.

Dar memoria? Din cauza vectorului de frecvență vom avea nevoie de ''O(n + p)'' memorie.

Este o soluție rezonabilă, poate nu foarte grea, dar care necesită creativitate și gândire algoritmică.

=== Soluție cu programare dinamică ===

Această soluție este destul de evidentă. Din păcate ea nu necesită prea multă gândire, ceea ce, după părerea mea, face această problemă să nu fie așa de bună pentru concurs. Totuși, fiind vorba despre baraj gimnaziu, nu este grav.

Putem defini problema de programare dinamică astfel:

S[b][i] = suma maximă ce începe cu bila i, ce se poate obține folosind b bile zero

Unde <tt>b</tt> poate fi 0, 1, sau 2 în problema noastră, dar nimic nu ne împiedică să îl mărim.

Demonstrația proprietății de optimalitate a subproblemelor este destul de ușoară, v-o las ca temă de gândire.

Recurența este, iarăși, destul de clară:

* Dacă bila <tt>i</tt> există la intrare, atunci o adăugăm la secvența anterioară ce începe cu bila <tt>i+1</tt>.
* Dacă bila <tt>i</tt> nu există la intrare, atunci folosim o bilă zero. Vom avea deci aceeași valoare cu o secvență ce folosește mai puțin cu unu bile zero și care începe cu bila <tt>i+1</tt>.

Formula de recurență este:

: <math>S[b][i] = \begin{cases} 0, & \mbox{dacă } i > n \mbox{ sau } b < 0\\S[b-1][i+1] & \mbox{dacă bila i nu există}\\i + S[b][i+1] & \mbox{dacă bila i există} \end{cases}</math>

'''Observații:'''

Obținem un algoritm de complexitate similară ca timp și memorie.

Programul iese foarte scurt, circa 40 de linii efective, mulțumită programării dinamice.

Posibil să fie și ceva mai eficient, dar acest lucru nu contează prea mult deoarece timpul va fi dominat de citire.

'''Exemplu'''

Să presupunem că avem următoarele bile la intrare:

{| class="wikitable"
! Bile
| 2 || 0 || 6 || 4 || 0
|}

Atunci vom calcula tabelul următor:

{| class="wikitable"
! colspan="2" |
! colspan="6" | Bile
|-
!
!
! 1
! 2
! 3
! 4
! 5
! 6
|-
! rowspan="3" | Zerouri
! 0
| 0 || 2 || 0 || 4 || 0 || 6
|-
! 1
| 2 || 6 || 4 || 10 || 6 || 6
|-
! 2
| 6 || 12 || 10 || 10 || 6 || 6
|}

Maximul în acest tabel este 12, care este și răspunsul cerut.

== Problema Zmax ==

Problema [https://www.nerdarena.ro/problema/zmax Zmax] a fost dată la ONI 2013 baraj gimnaziu.

=== Soluție cu programare dinamică ===

Singura soluție de 100p a comisiei este cu programare dinamică.

Vom defini următoarele subprobleme:

S[l][c] = cea mai mare sumă de elemente contigue aflate pe linia l, care se termină la coloana c
D[l][c] = cea mai mare sumă de elemente contigue aflate pe linia l, care încep la coloana c
N7[l][c] = cea mai mare sumă de elemente aflate în matrice în formă de cifra '7' care se termină la (l, c).
Z[l][c] = cea mai mare sumă de elemente aflate în matrice în formă de 'Z' a cărei linie de sus se termină la (l, c).

* Primele două subprobleme se pot calcula folosind algoritmul clasic al lui Kadane.
* Subproblema <tt>N7</tt> se calculează pe baza subproblemelor <tt>S</tt> și <tt>N7</tt>, similar cu Kadane: putem continua 7-lea existent, sau să începem unul nou.
* Subproblema <tt>Z</tt> se calculează pe baza subproblemelor <tt>D</tt> și <tt>N7</tt>, similar cu Kadane: putem continua <tt>Z</tt>-ul existent, sau să începem unul nou.

Maximul din subproblema <tt>Z</tt> este răspunsul la cerință.

'''Alte probleme'''

Problema [https://www.nerdarena.ro/problema/flori2 Flori2] a fost dată la ONI 2010 baraj gimnaziu. Nu este o problemă foarte grea, dar are multe detalii.

Puteți găsi alte probleme căutând pe [https://www.nerdarena.ro/ NerdArena] după tagul ''programare dinamică''.

== Tema 26 ==
Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/optim Optim] dată la ONI 2012 clasa a 8-a
* [https://www.nerdarena.ro/problema/joc6 Joc6] dată la ONI 2011 baraj gimnaziu
* [https://www.nerdarena.ro/problema/faleza Faleza] dată la ONI 2017 clasa a 6-a

== Tema opțională ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/poteci Poteci] dată la ONI 2011 baraj gimnaziu
* [https://www.nerdarena.ro/problema/zmax Zmax] dată la ONI 2013 baraj gimnaziu
* [https://www.nerdarena.ro/problema/flori2 Flori2] dată la ONI 2010 baraj gimnaziu

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_26:_Programare_dinamic%C4%83_(3) Accesează rezolvarea temei 26]

Clasa a 7-a Lecția 26: Programare dinamică (3)

2025-06-10T14:21:11Z

Mihai:

== Înregistrare video rezolvarea temei ==

{{#ev:youtube|https://www.youtube.com/watch?v=KdHv9T7Pp98|||||start=80&end=10280&loop=1}}

În continuare vom studia exemple de probleme de programare dinamică și probleme suprapuse date la olimpiadă.

== Problema Faleza ==

Problema [https://www.nerdarena.ro/problema/faleza Faleza] a fost dată la ONI 2017 clasa a 6-a. Ea este o problemă de un anumit gen, care se întâlnește din când în când la olimpiadă: probleme mascate, care au o soluție medie sau chiar grea, fără programare dinamică, dar care admit o soluție banală cu programare dinamică.

Atâta vreme cât programarea dinamică nu este în programa de olimpiadă de clasa a șasea, după părerea mea genul acesta de probleme nu sunt bune de concurs, deoarece încurajează dopajul, nu gândirea algoritmică și aprofundarea cunoștințelor. În cazul problemei [https://www.nerdarena.ro/problema/faleza Faleza] cine știe programare dinamică o poate termina în 15 minute. Cine nu, va trebui să găsească un algoritm care nu e deloc evident (mai ales la casa a 6-a), petrecând, probabil, peste o oră.

=== Soluția comisiei ===

''Construim două tablouri pe care le notăm A și B, cu numerele din fișier, în A cele de pe o parte a falezei și în B cele de pe cealaltă. Pentru simplificarea implementării, dacă avem poziții i în care A[i] = 1 și B[i] = 1 putem să analizăm doar ce se întâmplă între două astfel de poziții consecutive.''

''Parcurgem element cu element și păstrăm mereu ultima poziție pe care se află o dală bună pentru șirul A respectiv pentru șirul B, alegând, în funcție de acestea, modul de a completa dalele deteriorate.''

''Timpul de executare este liniar.''

După părerea mea este puțin vagă. În mod cert e nevoie de o analiză care nu pare simplă.

=== Soluție cu programare dinamică ===

Să simplificăm puțin enunțul: se cere să reparăm cât mai puține dale pentru a se putea ajunge de la un capăt la celălalt. Cu alte cuvinte se cere '''un drum care să treacă prin cât mai puține dale rupte'''. Dacă vom schimba codarea dalelor, cele rupte cu 1 și cele întregi cu 0, rezultă că trebuie să găsim un '''drum de sumă minimă'''.

O observație simplă, dar esențială, este că drumul minim nu se va întoarce de la dreapta la stânga. Într-adevăr, este clar că nu are de ce. Putem, deci, calcula drumurile de la stânga la dreapta.

Drept care o definiție evidentă a problemei de programare dinamică este:

S[l][c] = suma unui drum de sumă minimă pentru a ajunge în punctul (l, c).

Demonstrație de optimalitate a subprobemelor o las în seama voastră, fiind simplă.

Formula de recurență este iarăși simplă:

* Într-o dală de sus putem ajunge fie dinspre stânga, fie din jos în sus.
* Într-o dală de jos putem ajunge fie dinspre stânga, fie din sus în jos.

Vom lua în considerare minimul dintre cele două variante.

Formula de recurență este:

: <math>S[l][c] = \begin{cases} D[l][c], & \mbox{dacă } c = 0\\D[l][c] + min(S[l][c-1], S[1-l][c-1] + D[1-l][c]) & \mbox{în caz contrar}. \end{cases} </math>

Am considerat că <tt>D[l][c]</tt> este codificarea dalei din linia <tt>l</tt> și coloana <tt>c</tt>. Liniile și coloanele sunt numerotate de la 0.

Răspunsul cerut este minimul dintre <tt>S[0][n-1]</tt> și <tt>S[1][n-1]</tt>.

Ce complexitate are această soluție?

Timpul este evident ''O(n)''.

Memoria ar putea fi ''O(1)'' dacă dalele ar fi date pe linii, nu pe coloane. Așa cum este enunțul suntem obligați să le stocăm, ceea ce duce la memorie ''O(n)''. Putem însă refolosi matricea de dale pentru a calcula sumele minime. Drept care memoria va fi de <tt>2n</tt> întregi, adică 800KB.

''' Exemplu'''

Iată exemplul din enunț calculat conform formulei de mai sus.

Dalele originale (0 = întreagă, 1 = ruptă):

{| class="wikitable"
|1
|1
|0
|0
|0
|1
|1
|1
|-
|1
|1
|1
|1
|1
|1
|1
|0
|}

Calculul drumurilor minime pe coloane, de la stânga la dreapta:

{| class="wikitable"
|1
|2
|2
|2
|2
|3
|4
|5
|-
|1
|2
|3
|3
|3
|4
|5
|5
|}

== Problema Poteci ==

Problema poteci a fost dată la ONI 2011 baraj gimnaziu.

=== Soluția comisiei ===

Fiind vorba de baraj, soluția este una bazată pe programare dinamică:

* Pentru fiecare element din matrice vom calcula drumurile optime până la cele patru colțuri ale matricei.
* Parcurgem matricea și determinăm acel element pentru care suma celor patru drumuri este maximă.

Pentru primul pas vom folosi programarea dinamică, o procedură apelată de patru ori. În fapt, vom calcula drumurile optime de la fiecare colț către toate elementele matricei. De exemplu, pentru distanța de la colțul <tt>(1, 1)</tt> la elementul <tt>(i, j)</tt> vom avea formula de recurență:

: <math>D_{1,1}[l][c] = \begin{cases} 0, & \mbox{dacă } l = 0 \mbox{ sau } c = 0\\M[l][c] + \max{(D_{1,1}[l][c-1], D_{1,1}[l-1][c])} & \mbox{în caz contrar}. \end{cases}</math>

În final vom alege punctul din matrice (l, c) cu proprietatea:

: <math>MAX = \max\limits_{1 \leq l \leq L, 1 \leq c \leq C}{(D_{1,1}[l][c] + D_{1,C}[l][c] + D_{L,1}[l][c] + D_{L,C}[l][c])}</math>

Ce complexitate are această soluție?

Ea calculează patru matrice, deci atât timpul cât și memoria vor fi ''O(L·C)''. Mai exact, vom avea nevoie de patru matrice de elemente întregi de 1000 x 1000 elemente, circa 16MB, plus matricea originală de frumuseți, elemente <source lang="C" enclose="none">short int</source>, deci încă 2MB, total 18MB.

=== Soluție alternativă ===

O soluție care face mai puține calcule și folosește mai puțină memorie este următoarea.

'''Observație''': perechea optimă de poteci va fi alcătuită din două poteci optime.

Într-adevăr, dacă una din poteci nu ar fi optimă, am putea alege o potecă mai bună care ar duce la o pereche mai bună.

De aici vine și ideea soluției: să calculăm potecile optime pentru cei doi și să alegem punctul de intersecție a lor. Pentru aceasta va trebui să calculăm nu doar frumusețile potecilor, ci și potecile în sine. La final vom calcula intersecția potecilor.

Ce complexitate are această soluție? Ea este, desigur, tot ''O(L·C)'' atât ca timp cât și ca memorie. Însă vom calcula doar două matrice, deci timpul se reduce aproximativ la jumate. Iar memoria necesară este de o matrice pentru frumusețile originale (2MB) și o matrice de drumuri (1MB). Pentru a calcula intersecția putem refolosi matricea de drumuri. Necesarul de memorie este, deci, de numai 3MB, comparat cu cei 18MB ai soluției anterioare. Putem reduce și mai mult memoria dacă folosim pentru stocarea drumurilor matrice de biți, caz în care în loc de 1MB vom folosi 125KB, iar memoria totală folosită va fi 2.12MB. Iar folosind [https://en.wikipedia.org/wiki/Hirschberg%27s_algorithm algoritmul lui Hirschberg] putem elimina complet matricea de drumuri, ceea ce duce la 2MB memorie necesară.

'''Concluzii:'''

Timpul se reduce la jumate.

Memoria se reduce la o șesime

== Problema Optim ==

Problema [https://www.nerdarena.ro/problema/optim Optim] a fost dată la ONI 2012 clasa a 8-a. Ea are o rezolvare fără programare dinamică, ineficientă și nu chiar banal de implementat și o rezolvare cu programare dinamică, eficientă și relativ ușor de implementat.

=== Soluția combinatorică, fără programare dinamică ===

Soluția comisiei, cea combinatorică, se bazează pe generarea tuturor modurilor de a plasa <tt>K</tt> înmulțiri între <tt>N</tt> operații și calculul expresiilor respective, din care vom reține minimul și maximul. Implementarea este cea de combinări modificată să calculeze incremental expresiile.

Complexitatea este ''O(Comb(N, K))''. Pentru valori maxime obținem Comb(30, 10), aproximativ 10 milioane operații.

=== Soluție cu programare dinamică ===

Problema are două părți echivalente, minimul și maximul. Să ne concetrăm pe maxim, minimul rezolvându-se similar.

O definire directă a subproblemei ar putea fi:

MAX[i][j] = maximul care se poate obține cu numerele nr[0], nr[1], ..., nr[i] folosind i operații, din care j înmulțiri.

Are ea proprietatea de optimalitate?

Să vedem: dacă luăm o soluție optimă și eliminăm ultimul număr și ultima operație, ceea ce rămâne este optim?

Nu neapărat. Dacă ultima operație este o adunare, vom avea o subproblemă optimă, dar dacă este o înmulțire, nu.

Ce facem? Observăm că optimalitatea se păstrează la adunări, nu și la înmulțiri. Deci putem spune că, dacă <tt>MAX[i][j]</tt> este optim și are <tt>m</tt> înmulțiri în coadă, atunci și <tt>MAX[i-m-1][j-m]</tt> este optim, el fiind format din suma produselor anterioare, care dacă nu ar fi optimă am putea construi o sumă mai mare în <tt>MAX[i][j]</tt>.

Astfel, formula de recurență este:

: <math>MAX[i][j] = \begin{cases} nr[0]\cdot nr[1]\cdot\mbox{…}\cdot nr[i], & \mbox{dacă } i = j\\ \max\limits_{0 \leq m \leq j}{(MAX[i-m-1][j-m] + nr[i-m]\cdot nr[i-m+1]\cdot\mbox{…}\cdot nr[i])} & \mbox{în caz contrar}. \end{cases}</math>

Răspunsul la cerință va fi: <tt>MAX[N][K]</tt>.

Ce complexitate are această soluție?

Ea este ''O(N·K2)''. Înlocuind vom obține circa 2430 operații, un număr incredibil de mic. Probabil că mai mult va dura citirea celor 30 de numere.

Memoria folosită este cea a matricei de dimensiune <tt>N x K</tt>, deci ''O(N·K)'', din nou neglijabilă.

''' Exemplu '''

Iată exemplul din enunț calculat conform formulei de mai sus.

Fie numerele de la intrare:

{| class="wikitable"
! Indice !! 0 !! 1 !! 2 !! 3 !! 4 !! 5
|-
! Valoare || 2 || 0 || 3 || -1 || 7 || -4
|}

Calculul expresiilor maxime, pe linii, de la stânga la dreapta:

{| class="wikitable"
! rowspan="2" | Numere !! colspan="4" | Înmulțiri
|-
! 0 !! 1 !! 2 !! 3
|-
| 0 || 2 || || ||
|-
| 1 || 2 || 0 || ||
|-
| 2 || 5 || 3 || 0 ||
|-
| 3 || 4 || 2 || 2 || 0
|-
| 4 || 11 || 9 || 9 || 7
|-
| 5 || 7 || 5 || 33 || 86
|}

== Problema Joc6 ==

Problema [https://www.nerdarena.ro/problema/joc6 Joc6] a fost dată la ONI 2011 baraj gimnaziu. Este o problemă tipică de programare dinamică.

=== Soluția comisiei ===

''Pentru fiecare jucător se determină secvenţele de bile cu valori consecutive. Acest lucru se poate realiza prin utilizarea unui vector caracteristic.

După determinarea secvenţelor, se selectează secvenţa de sumă maximă ce poate fi obţinută prin utilizarea bilelor speciale, în funcţie de numărul de bile speciale pe care le are jucătorul curent. Se determină maximul sumelor maxime şi jucătorul care are acest maxim.''

Din păcate explicațiile sunt destul de vagi. Ce bănuiesc eu:

* Vom face o listă de secvențe, păstrând pentru fiecare secvență: (indice start, indice final, suma)
* Vom încerca să cuplăm secvențe astfel:
** Fie două secvențe consecutive dacă ele sunt despărțite de cel mult numărul de bile zero disponibile.
** Fie trei secvențe consecutive dacă avem măcar două bile zero, iar secvențele sunt despărțite de fix un zero.

Desigur vom lua maximul sumelor.

Ce complexitate are această soluție?

Pentru detecția secvențelor avem nevoie de un vector de frecvență, deci ''O(n + p)''. Pentru parcurgerea secvențelor avem nevoie de ''O(p)'' pași. Deoarece avem <tt>k</tt> jucători complexitatea totală este ''O(k·(n + p)''.

Dar memoria? Din cauza vectorului de frecvență vom avea nevoie de ''O(n + p)'' memorie.

Este o soluție rezonabilă, poate nu foarte grea, dar care necesită creativitate și gândire algoritmică.

=== Soluție cu programare dinamică ===

Această soluție este destul de evidentă. Din păcate ea nu necesită prea multă gândire, ceea ce, după părerea mea, face această problemă să nu fie așa de bună pentru concurs. Totuși, fiind vorba despre baraj gimnaziu, nu este grav.

Putem defini problema de programare dinamică astfel:

S[b][i] = suma maximă ce începe cu bila i, ce se poate obține folosind b bile zero

Unde <tt>b</tt> poate fi 0, 1, sau 2 în problema noastră, dar nimic nu ne împiedică să îl mărim.

Demonstrația proprietății de optimalitate a subproblemelor este destul de ușoară, v-o las ca temă de gândire.

Recurența este, iarăși, destul de clară:

* Dacă bila <tt>i</tt> există la intrare, atunci o adăugăm la secvența anterioară ce începe cu bila <tt>i+1</tt>.
* Dacă bila <tt>i</tt> nu există la intrare, atunci folosim o bilă zero. Vom avea deci aceeași valoare cu o secvență ce folosește mai puțin cu unu bile zero și care începe cu bila <tt>i+1</tt>.

Formula de recurență este:

: <math>S[b][i] = \begin{cases} 0, & \mbox{dacă } i > n \mbox{ sau } b < 0\\S[b-1][i+1] & \mbox{dacă bila i nu există}\\i + S[b][i+1] & \mbox{dacă bila i există} \end{cases}</math>

'''Observații:'''

Obținem un algoritm de complexitate similară ca timp și memorie.

Programul iese foarte scurt, circa 40 de linii efective, mulțumită programării dinamice.

Posibil să fie și ceva mai eficient, dar acest lucru nu contează prea mult deoarece timpul va fi dominat de citire.

'''Exemplu'''

Să presupunem că avem următoarele bile la intrare:

{| class="wikitable"
! Bile
| 2 || 0 || 6 || 4 || 0
|}

Atunci vom calcula tabelul următor:

{| class="wikitable"
! colspan="2" |
! colspan="6" | Bile
|-
!
!
! 1
! 2
! 3
! 4
! 5
! 6
|-
! rowspan="3" | Zerouri
! 0
| 0 || 2 || 0 || 4 || 0 || 6
|-
! 1
| 2 || 6 || 4 || 10 || 6 || 6
|-
! 2
| 6 || 12 || 10 || 10 || 6 || 6
|}

Maximul în acest tabel este 12, care este și răspunsul cerut.

== Problema Zmax ==

Problema [https://www.nerdarena.ro/problema/zmax Zmax] a fost dată la ONI 2013 baraj gimnaziu.

=== Soluție cu programare dinamică ===

Singura soluție de 100p a comisiei este cu programare dinamică.

Vom defini următoarele subprobleme:

S[l][c] = cea mai mare sumă de elemente contigue aflate pe linia l, care se termină la coloana c
D[l][c] = cea mai mare sumă de elemente contigue aflate pe linia l, care încep la coloana c
N7[l][c] = cea mai mare sumă de elemente aflate în matrice în formă de cifra '7' care se termină la (l, c).
Z[l][c] = cea mai mare sumă de elemente aflate în matrice în formă de 'Z' a cărei linie de sus se termină la (l, c).

* Primele două subprobleme se pot calcula folosind algoritmul clasic al lui Kadane.
* Subproblema <tt>N7</tt> se calculează pe baza subproblemelor <tt>S</tt> și <tt>N7</tt>, similar cu Kadane: putem continua 7-lea existent, sau să începem unul nou.
* Subproblema <tt>Z</tt> se calculează pe baza subproblemelor <tt>D</tt> și <tt>N7</tt>, similar cu Kadane: putem continua <tt>Z</tt>-ul existent, sau să începem unul nou.

Maximul din subproblema <tt>Z</tt> este răspunsul la cerință.

'''Alte probleme'''

Problema [https://www.nerdarena.ro/problema/flori2 Flori2] a fost dată la ONI 2010 baraj gimnaziu. Nu este o problemă foarte grea, dar are multe detalii.

Puteți găsi alte probleme căutând pe [https://www.nerdarena.ro/ NerdArena] după tagul ''programare dinamică''.

== Tema 26 ==
Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/optim Optim] dată la ONI 2012 clasa a 8-a
* [https://www.nerdarena.ro/problema/joc6 Joc6] dată la ONI 2011 baraj gimnaziu
* [https://www.nerdarena.ro/problema/faleza Faleza] dată la ONI 2017 clasa a 6-a

== Tema opțională ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/poteci Poteci] dată la ONI 2011 baraj gimnaziu
* [https://www.nerdarena.ro/problema/zmax Zmax] dată la ONI 2013 baraj gimnaziu
* [https://www.nerdarena.ro/problema/flori2 Flori2] dată la ONI 2010 baraj gimnaziu

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_26:_Programare_dinamic%C4%83_(3) Accesează rezolvarea temei 26]

Clasa a 7-a Lecția 26: Programare dinamică (3)

2025-06-10T13:27:35Z

Mihai: Created page with "== Înregistrare video rezolvarea temei == {{#ev:youtube|https://www.youtube.com/watch?v=KdHv9T7Pp98|||||start=80&end=10280&loop=1}} În continuare vom studia exemple de probleme de programare dinamică și probleme suprapuse date la olimpiadă. == Problema Faleza == Problema [https://www.nerdarena.ro/problema/faleza Faleza] a fost dată la ONI 2017 clasa a 6-a. Ea este o problemă de un anumit gen, care se întâlnește din când în când la olimpiadă: probleme..."

== Înregistrare video rezolvarea temei ==

{{#ev:youtube|https://www.youtube.com/watch?v=KdHv9T7Pp98|||||start=80&end=10280&loop=1}}

În continuare vom studia exemple de probleme de programare dinamică și probleme suprapuse date la olimpiadă.

== Problema Faleza ==

Problema [https://www.nerdarena.ro/problema/faleza Faleza] a fost dată la ONI 2017 clasa a 6-a. Ea este o problemă de un anumit gen, care se întâlnește din când în când la olimpiadă: probleme mascate, care au o soluție medie sau chiar grea, fără programare dinamică, dar care admit o soluție banală cu programare dinamică.

Atâta vreme cât programarea dinamică nu este în programa de olimpiadă de clasa a șasea, după părerea mea genul acesta de probleme nu sunt bune de concurs, deoarece încurajează dopajul, nu gândirea algoritmică și aprofundarea cunoștințelor. În cazul problemei [https://www.nerdarena.ro/problema/faleza Faleza] cine știe programare dinamică o poate termina în 15 minute. Cine nu, va trebui să găsească un algoritm care nu e deloc evident (mai ales la casa a 6-a), petrecând, probabil, peste o oră.

=== Soluția comisiei ===

''Construim două tablouri pe care le notăm A și B, cu numerele din fișier, în A cele de pe o parte a falezei și în B cele de pe cealaltă. Pentru simplificarea implementării, dacă avem poziții i în care A[i] = 1 și B[i] = 1 putem să analizăm doar ce se întâmplă între două astfel de poziții consecutive.''

''Parcurgem element cu element și păstrăm mereu ultima poziție pe care se află o dală bună pentru șirul A respectiv pentru șirul B, alegând, în funcție de acestea, modul de a completa dalele deteriorate.''

''Timpul de executare este liniar.''

După părerea mea este puțin vagă. În mod cert e nevoie de o analiză care nu pare simplă.

=== Soluție cu programare dinamică ===

Să simplificăm puțin enunțul: se cere să reparăm cât mai puține dale pentru a se putea ajunge de la un capăt la celălalt. Cu alte cuvinte se cere '''un drum care să treacă prin cât mai puține dale rupte'''. Dacă vom schimba codarea dalelor, cele rupte cu 1 și cele întregi cu 0, rezultă că trebuie să găsim un '''drum de sumă minimă'''.

O observație simplă, dar esențială, este că drumul minim nu se va întoarce de la dreapta la stânga. Într-adevăr, este clar că nu are de ce. Putem, deci, calcula drumurile de la stânga la dreapta.

Drept care o definiție evidentă a problemei de programare dinamică este:

S[l][c] = suma unui drum de sumă minimă pentru a ajunge în punctul (l, c).

Demonstrație de optimalitate a subprobemelor o las în seama voastră, fiind simplă.

Formula de recurență este iarăși simplă:

* Într-o dală de sus putem ajunge fie dinspre stânga, fie din jos în sus.
* Într-o dală de jos putem ajunge fie dinspre stânga, fie din sus în jos.

Vom lua în considerare minimul dintre cele două variante.

Formula de recurență este:

: <math>S[l][c] = \begin{cases} D[l][c], & \mbox{dacă } c = 0\\D[l][c] + min(S[l][c-1], S[1-l][c-1] + D[1-l][c]) & \mbox{în caz contrar}. \end{cases} </math>

Am considerat că <tt>D[l][c]</tt> este codificarea dalei din linia <tt>l</tt> și coloana <tt>c</tt>. Liniile și coloanele sunt numerotate de la 0.

Răspunsul cerut este minimul dintre <tt>S[0][n-1]</tt> și <tt>S[1][n-1]</tt>.

Ce complexitate are această soluție?

Timpul este evident ''O(n)''.

Memoria ar putea fi ''O(1)'' dacă dalele ar fi date pe linii, nu pe coloane. Așa cum este enunțul suntem obligați să le stocăm, ceea ce duce la memorie ''O(n)''. Putem însă refolosi matricea de dale pentru a calcula sumele minime. Drept care memoria va fi de <tt>2n</tt> întregi, adică 800KB.

''' Exemplu'''

Iată exemplul din enunț calculat conform formulei de mai sus.

Dalele originale (0 = întreagă, 1 = ruptă):

{| class="wikitable"
|1
|1
|0
|0
|0
|1
|1
|1
|-
|1
|1
|1
|1
|1
|1
|1
|0
|}

Calculul drumurilor minime pe coloane, de la stânga la dreapta:

{| class="wikitable"
|1
|2
|2
|2
|2
|3
|4
|5
|-
|1
|2
|3
|3
|3
|4
|5
|5
|}

== Problema Poteci ==

Problema poteci a fost dată la ONI 2011 baraj gimnaziu.

=== Soluția comisiei ===

Fiind vorba de baraj, soluția este una bazată pe programare dinamică:

Pentru fiecare element din matrice vom calcula drumurile optime până la cele patru colțuri ale matricei.

Parcurgem matricea și determinăm acel element pentru care suma celor patru drumuri este maximă.

Pentru primul pas vom folosi programarea dinamică, o procedură apelată de patru ori. În fapt, vom calcula drumurile optime de la fiecare colț către toate elementele matricei. De exemplu, pentru distanța de la colțul (1, 1) la elementul (i, j) vom avea formula de recurență:

\(D_{1,1}[l][c] = \begin{cases} 0, & \mbox{dacă } l = 0 \mbox{ sau } c = 0\\M[l][c] + \max{(D_{1,1}[l][c-1], D_{1,1}[l-1][c])} & \mbox{în caz contrar}. \end{cases}\)

În final vom alege punctul din matrice (l, c) cu proprietatea:

\(MAX = \max\limits_{1 \leq l \leq L, 1 \leq c \leq C}{(D_{1,1}[l][c] + D_{1,C}[l][c] + D_{L,1}[l][c] + D_{L,C}[l][c])}\)

Ce complexitate are această soluție?

Ea calculează patru matrice, deci atât timpul cât și memoria vor fi O(L·C). Mai exact, vom avea nevoie de patru matrice de elemente întregi de 1000 x 1000 elemente, circa 16MB, plus matricea originală de frumuseți, elemente short int, deci încă 2MB, total 18MB.

=== Soluție alternativă ===

O soluție care face mai puține calcule și folosește mai puțină memorie este următoarea.

Observație: perechea optimă de poteci va fi alcătuită din două poteci optime.

Într-adevăr, dacă una din poteci nu ar fi optimă, am putea alege o potecă mai bună care ar duce la o pereche mai bună.

De aici vine și ideea soluției: să calculăm potecile optime pentru cei doi și să alegem punctul de intersecție a lor. Pentru aceasta va trebui să calculăm nu doar frumusețile potecilor, ci și potecile în sine. La final vom calcula intersecția potecilor.

Ce complexitate are această soluție? Ea este, desigur, tot O(L·C) atât ca timp cât și ca memorie. Însă vom calcula doar două matrice, deci timpul se reduce aproximativ la jumate. Iar memoria necesară este de o matrice pentru frumusețile originale (2MB) și o matrice de drumuri (1MB). Pentru a calcula intersecția putem refolosi matricea de drumuri. Necesarul de memorie este, deci, de numai 3MB, comparat cu cei 18MB ai soluției anterioare. Putem reduce și mai mult memoria dacă folosim pentru stocarea drumurilor matrice de biți, caz în care în loc de 1MB vom folosi 125KB, iar memoria totală folosită va fi 2.12MB. Iar folosind algoritmul lui Hirschberg putem elimina complet matricea de drumuri, ceea ce duce la 2MB memorie necesară.

'''Concluzii:'''

Timpul se reduce la jumate.

Memoria se reduce la o șesime

== Problema Optim ==

Problema optim a fost dată la ONI 2012 clasa a 8a. Ea are o rezolvare fără programare dinamică, ineficientă și nu chiar banal de implementat și o rezolvare cu programare dinamică, eficientă și relativ ușor de implementat.

=== Soluția combinatorică, fără programare dinamică ===

Soluția comisiei, cea combinatorică, se bazează pe generarea tuturor modurilor de a plasa K înmulțiri între N operații și calculul expresiilor respective, din care vom reține minimul și maximul. Implementarea este cea de combinări modificată să calculeze incremental expresiile.

Complexitatea este O(Comb(N, K)). Pentru valori maxime obținem Comb(30, 10), aproximativ 10 milioane operații.

=== Soluție cu programare dinamică ===

Problema are două părți echivalente, minimul și maximul. Să ne concetrăm pe maxim, minimul rezolvându-se similar.

O definire directă a subproblemei ar putea fi:

MAX[i][j] = maximul care se poate obține cu numerele nr[0], nr[1], ..., nr[i] folosind i operații, din care j înmulțiri.

Are ea proprietatea de optimalitate?

Să vedem: dacă luăm o soluție optimă și eliminăm ultimul număr și ultima operație, ceea ce rămâne este optim?

Nu neapărat. Dacă ultima operație este o adunare, vom avea o subproblemă optimă, dar dacă este o înmulțire, nu.

Ce facem? Observăm că optimalitatea se păstrează la adunări, nu și la înmulțiri. Deci putem spune că, dacă MAX[i][j] este optim și are m înmulțiri în coadă, atunci și MAX[i-m-1][j-m] este optim, el fiind format din suma produselor anterioare, care dacă nu ar fi optimă am putea construi o sumă mai mare în MAX[i][j].

Astfel, formula de recurență este:

\(MAX[i][j] = \begin{cases} nr[0]\cdot nr[1]\cdot\mbox{…}\cdot nr[i], & \mbox{dacă } i = j\\ \max\limits_{0 \leq m \leq j}{(MAX[i-m-1][j-m] + nr[i-m]\cdot nr[i-m+1]\cdot\mbox{…}\cdot nr[i])} & \mbox{în caz contrar}. \end{cases}\)

Răspunsul la cerință va fi: MAX[N][K].

Ce complexitate are această soluție?

Ea este O(N·K2). Înlocuind vom obține circa 2430 operații, un număr incredibil de mic. Probabil că mai mult va dura citirea celor 30 de numere.

Memoria folosită este cea a matricei de dimensiune N x K, deci O(N·K), din nou neglijabilă.

''' Exemplu '''

Iată exemplul din enunț calculat conform formulei de mai sus.

Fie numerele de la intrare:

Indice012345Valoare203-17-4

Calculul expresiilor maxime, pe linii, de la stânga la dreapta:

Înmulțiri0123N
u
m
e
r
e021202530342204119975753386

== Problema Joc6 ==

Problema joc6 a fost dată la ONI 2011 baraj gimnaziu. Este o problemă tipică de programare dinamică.

=== Soluția comisiei ===

"Pentru fiecare jucător se determină secvenţele de bile cu valori consecutive. Acest lucru se poate realiza prin utilizarea unui vector caracteristic.

După determinarea secvenţelor, se selectează secvenţa de sumă maximă ce poate fi obţinută prin utilizarea bilelor speciale, în funcţie de numărul de bile speciale pe care le are jucătorul curent. Se determină maximul sumelor maxime şi jucătorul care are acest maxim."

Din păcate explicațiile sunt destul de vagi. Ce bănuiesc eu:

Vom face o listă de secvențe, păstrând pentru fiecare secvență: (indice start, indice final, suma)

Vom încerca să cuplăm secvențe astfel:

Fie două secvențe consecutive dacă ele sunt despărțite de cel mult numărul de bile zero disponibile.

Fie trei secvențe consecutive dacă avem măcar două bile zero, iar secvențele sunt despărțite de fix un zero.

Desigur vom lua maximul sumelor.

Ce complexitate are această soluție?

Pentru detecția secvențelor avem nevoie de un vector de frecvență, deci O(n + p). Pentru parcurgerea secvențelor avem nevoie de O(p) pași. Deoarece avem k jucători complexitatea totală este O(k·(n + p).

Dar memoria? Din cauza vectorului de frecvență vom avea nevoie de O(n + p) memorie.

Este o soluție rezonabilă, poate nu foarte grea, dar care necesită creativitate și gândire algoritmică.

=== Soluție cu programare dinamică ===

Această soluție este destul de evidentă. Din păcate ea nu necesită prea multă gândire, ceea ce, după părerea mea, face această problemă să nu fie așa de bună pentru concurs. Totuși, fiind vorba despre baraj gimnaziu, nu este grav.

Putem defini problema de programare dinamică astfel:

S[b][i] = suma maximă ce începe cu bila i, ce se poate obține folosind b bile zero

Unde b poate fi 0, 1, sau 2 în problema noastră, dar nimic nu ne împiedică să îl mărim.

Demonstrația proprietății de optimalitate a subproblemelor este destul de ușoară, v-o las ca temă de gândire.

Recurența este, iarăși, destul de clară:

Dacă bila i există la intrare, atunci o adăugăm la secvența anterioară ce începe cu bila i+1.

Dacă bila i nu există la intrare, atunci folosim o bilă zero. Vom avea deci aceeași valoare cu o secvență ce folosește mai puțin cu unu bile zero și care începe cu bila i+1.

Formula de recurență este:

\(S[b][i] = \begin{cases} 0, & \mbox{dacă } i > n \mbox{ sau } b S[][] pe coloane vom avea nevoie de O(b) memorie, deoarece vom stoca doar o linie, dar O(b) este practic constant. Memorie totală necesară: O(n + b).

'''Observații:'''

Obținem un algoritm de complexitate similară ca timp și memorie.

Programul iese foarte scurt, circa 40 de linii efective, mulțumită programării dinamice.

Posibil să fie și ceva mai eficient, dar acest lucru nu contează prea mult deoarece timpul va fi dominat de citire.

'''Exemplu'''

Să presupunem că avem următoarele bile la intrare:

Bile20640

Atunci vom calcula tabelul următor:

Bile123456010101Z
e
r
o
u
r
i0020406126410662612101066

Maximul în acest tabel este 12, care este și răspunsul cerut.

== Problema Zmax ==

Problema zmax a fost dată la ONI 2013 baraj gimnaziu.

=== Soluție cu programare dinamică ===

Singura soluție de 100p a comisiei este cu programare dinamică.

Vom defini următoarele subprobleme:

S[l][c] = cea mai mare sumă de elemente contigue aflate pe linia l, care se termină la coloana c

D[l][c] = cea mai mare sumă de elemente contigue aflate pe linia l, care încep la coloana c

N7[l][c] = cea mai mare sumă de elemente aflate în matrice în formă de cifra '7' care se termină la (l, c).

Z[l][c] = cea mai mare sumă de elemente aflate în matrice în formă de 'Z' a cărei linie de sus se termină la (l, c).

Primele două subprobleme se pot calcula folosind algoritmul clasic al lui Kadane.

Subproblema N7 se calculează pe baza subproblemelor S și N7, similar cu Kadane: putem continua 7-lea existent, sau să începem unul nou.

Subproblema Z se calculează pe baza subproblemelor D și N7, similar cu Kadane: putem continua Z-ul existent, sau să începem unul nou.

Maximul din subproblema Z este răspunsul la cerință.

'''Alte probleme'''

Problema flori2 a fost dată la ONI 2010 baraj gimnaziu. Nu este o problemă foarte grea, dar are multe detalii.

Puteți găsi alte probleme căutând pe Nerdarena după tagul "programare dinamică".

== Tema 26 ==
Tema 27 presupune să se rezolve următoarele probleme (program C trimis la NerdArena):

optim

joc6

faleza

== Tema 26 opțională ==

poteci

zmax

flori2

Clasa a 7-a Lecția 25: Programare dinamică (2)

2025-06-10T12:28:02Z

Mihai:

== Înregistrare video lecție ==

{{#ev:youtube|https://youtu.be/z4433kBdq2A|||||start=5580&end=9780&loop=1}}

== Problema rucsacului ==

'''Atenție:''' veți avea la temă ca aplicație problema [https://www.nerdarena.ro/problema/rucsac1 Rucsac1].

Se dă o mulțime formată din <tt>N</tt> obiecte, fiecare având o greutate și o valoare. Într-un rucsac putem încărca o greutate maxim <tt>G</tt>. Ne dorim să încărcăm rucsacul cu obiecte astfel încât să maximizăm valoarea totală.

Problema este una foarte practică, ne dorim să optimizăm raportul valoare/greutate, încărcând obiecte cât mai valoroase, dar cât mai ușoare.

=== Exemplu ===

Să presupunem că avem următoarele obiecte:

{| class="wikitable"
! Nr. || 1 || 2 || 3 || 4 || 5 || 6
|-
! Greutate
| 3 || 3 || 1 || 1 || 2 || 1
|-
! Valoare
| 7 || 4 || 2 || 9 || 4 || 5
|}

Rucsacul are mărime 10. Care este valoarea maximă a obiectelor ce pot fi încărcate în rucsac?

Singura posibilitate este să alegem obiectele <tt>{ 1, 2, 4, 5, 6 }</tt>. Ele au greutatea totală 10 și valoarea totală 29.

=== Încercarea 1: după obiecte ===

Definirea problemei de programare dinamică nu este evidentă. Voi încerca să arăt un mod de gândire posibil, care implică mai multe posibilități pe care le vom verifica și apoi elimina, ajungând în final la o definire bună a problemei.

Să definim

V[i] = valoarea maximă ce se poate obține cu primele i greutăți, astfel încât greutatea totală să nu depășească G

Are <source lang="C" enclose="none">V[i]</source> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă, <source lang="C" enclose="none">V[i]</source>. Ea va conține unele din primele <tt>i</tt> obiecte. Ultimul obiect este obiectul <tt>k ≤ i</tt>. Atunci este <source lang="C" enclose="none">V[k]</source> optimă?

Nu neapărat! Este posibil să găsim o soluție <source lang="C" enclose="none">V[k]</source> cu valoare mai mare, dar pe care să nu o putem folosi în construcția problemei <source lang="C" enclose="none">V[i]</source> deoarece am depăși greutatea.

'''Concluzie:''' nu putem folosi programarea dinamică cu o astfel de definire a problemei.

=== Încercarea 2: după greutatea totală ===

Să facem o altă încercare. Să definim

V[g] = valoarea maximă ce se poate obține într-un rucsac de mărime g

Are <source lang="C" enclose="none">V[g]</source> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă, <source lang="C" enclose="none">V[g]</source>. Ea va conține unele obiecte, a căror sumă a greutăților nu depășește <tt>g</tt>. Fie ultimul obiect folosit obiectul <tt>k</tt> ce are greutate <tt>Gk</tt>. Este <code>V[g-Gk]</code> optimă?

Răspunsul este: nu, deoarece s-ar putea ca optimul să includă <source lang="C" enclose="none">V[g]</source> (pe care nu avem voie să o folosim de două ori).

'''Concluzie:''' nu putem folosi programarea dinamică nici cu această definire a problemei.

=== Încercarea 3: după obiecte și greutate totală ===

Să încercăm să combinăm cele două încercări de mai sus. Să definim

V[i][g] = valoarea maximă ce se poate obține cu primele i greutăți într-un rucsac de mărime g

Are <source lang="C" enclose="none">V[i][g]</source> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă <source lang="C" enclose="none">V[i][g]</source>. Fie ultimul obiect folosit obiectul <tt>k</tt> ce are greutate <tt>Gk</tt>. Este <code>V[k][g-Gk]</code> optimă? Să presupunem că nu ar fi. Atunci am putea găsi o valoare mai mare, folosind primele <tt>k</tt> obiecte ce vor încăpea în greutatea <tt>g-Gk</tt>. Putem folosi această valoare pentru a obține o valoare mai mare pentru problema originală, <source lang="C" enclose="none">V[i][g]</source>.

'''Concluzie:''' putem folosi programarea dinamică cu această definiție a problemei.

Construim formula de recurență. Pentru a calcula <source lang="C" enclose="none">V[i][g]</source> avem două variante:

* Fie nu folosim greutatea <tt>Gi</tt>, caz în care vom obține valoarea <source lang="C" enclose="none">V[i-1][g]</source> (aceeași greutate, dar folosind primele <tt>i-1</tt> obiecte).
* Fie folosim greutatea <tt>Gi</tt>, caz în care vom obține valoarea <code>V[i-1][g-Gi] + Pi</code> (greutatea este cea care rămâne în rucsac după ce folosim <tt>Gi</tt>, și apoi putem folosi primele <tt>i-1</tt> obiecte).

: <math>V[i][g] = \begin{cases} 0, & \text{dacă } i = 0 \text{ sau } g = 0 \\ max(V[i-1][g], V[i-1][g-G_{i}] + P_{i}) & \text{în caz contrar}. \end{cases}</math>

Unde <tt>(Gi, Pi)</tt> sunt greutatea, respectiv valoarea obiectului <tt>i</tt>.

Răspunsul la problemă este elementul <source lang="C" enclose="none">V[N][G]</source>.

=== Exemplu ===

Fie obiectele din exemplul de mai sus:

{| class="wikitable"
! Nr. || 1 || 2 || 3 || 4 || 5 || 6
|-
! Greutate
| 3 || 3 || 1 || 1 || 2 || 1
|-
! Valoare
| 7 || 4 || 2 || 9 || 4 || 5
|}

Vom completa, pe linii, următorul tabel:

{| class="wikitable"
! Obiect !! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9 !! 10
|-
!0
|0||0||0||0||0||0||0||0||0||0||0
|-
!1
|0||0||0||7||7||7||7||7||7||7||7
|-
!2
|0||0||0||7||7||7||11||11||11||11||11
|-
!3
|0||2||2||7||9||9||11||13||13||13||13
|-
!4
|0||9||11||11||16||18||18||20||22||22||22
|-
!5
|0||9||11||13||16||18||20||22||22||24||26
|-
!6
|0||9||14||16||18||21||23||25||27||27||29
|}

=== Analiză ===

Acest algoritm are complexitate ''O(N·G)''. Memoria folosită este ''O(G)'' dacă memorăm doar o linie din matrice. Dacă dorim să aflăm și o soluție maximală (obiectele din componența soluției), nu doar mărimea ei, vom avea nevoie de memorie ''O(N·G)'', precum vom vedea mai jos.

Există un algoritm care reduce necesarul de memorie la ''O(G)''.

=== Reconstrucția soluției ===

Dorim să aflăm nu doar valoarea maximă, ci și obiectele selectate. Cum procedăm?

Pentru a putea reconstrui soluția vom memora în fiecare căsuță, direcția din care provine ea, adică din care am calculat acel maxim. Direcția poate fi spre stânga-sus sau spre în sus. Apoi vom porni din elementul <source lang="C" enclose="none">V[N][G]</source> și vom urma aceste direcții până ce ieșim din matrice. De fiecare dată când urmăm o diagonală reținem obiectul selectat, care este chiar rândul curent. Astfel, descoperirea obiectelor se face în ordine inversă.

== Distanța edit (Levenshtein) ==

'''Atenție:''' veți avea această problemă la temă.

Se dau două șiruri de caractere, <tt>X</tt> și <tt>Y</tt>. Putem efectua trei operațiuni asupra șirului <tt>X</tt>:

* Inserare caracter la orice poziție
* Ștergere caracter la orice poziție
* Suprascriere - înlocuire a unui caracter cu un alt caracter

Care este numărul minim de operații asupra șirului <tt>X</tt> care îl transformă în șirul <tt>Y</tt>?

'''Definim [https://en.wikipedia.org/wiki/Edit_distance distanța edit] ca fiind acest număr minim de operații'''. Deoarece operațiile sunt unele frecvente într-un editor de texte, de aici vine și denumirea de distanță edit.

==== Exemplu ====

Acest exemplu este inspirat de la wikipedia.

Fie șirurile:

X: KITTEN
Y: SITTING

Numărul minim de operații pentru a transforma <tt>X</tt> în <tt>Y</tt> este 3. De exemplu:

# Înlocuim <tt>K</tt> cu <tt>S</tt>: <tt>KITTEN → SITTEN</tt>
# Înlocuim <tt>E</tt> cu <tt>I</tt>: <tt>SITTEN → SITTIN</tt>
# Adăugăm la final un <tt>G</tt>: <tt>SITTIN → SITTING</tt>

==== Soluție ====

Problema este aproape identică cu subsecvența maximală comună a două șiruri. Vom defini:

D(i, j) = numărul minim de operații ce transformă șirul X[1..i]] în șirul Y[1..j]

Nu voi face demonstrația optimalității subproblemelor, deoarece este similară cu ce de la subsecvența maximală comună a două șiruri.

Obținem relația de recurență:

: <math>\operatorname{D}_{X,Y}(i,j) = \begin{cases} \max(i,j) & \text{ dacă } \min(i,j)=0, \\ \min \begin{cases} \operatorname{D}_{X,Y}(i-1,j) + 1 \\ \operatorname{D}_{X,Y}(i,j-1) + 1 \\ \operatorname{D}_{X,Y}(i-1,j-1) + X_i \neq Y_j \end{cases} & \text{ în caz contrar.} \end{cases} </math>

Distanța edit între cele două șiruri este <tt>D(m, n)</tt>.

==== Analiză ====

Acest algoritm are complexitate ''O(m·n)'', unde <tt>m</tt> și <tt>n</tt> sunt lungimile șirurilor. Memoria folosită este ''O(min(m, n))'' dacă memorăm doar o linie din matrice. Dacă dorim să aflăm și operațiile efectuate, nu doar numărul lor, vom avea nevoie de memorie ''O(m·n)'', precum vom vedea mai jos.

Există un algoritm care reduce necesarul de memorie la ''O(min(m, n))'' chiar și cu reconstrucția soluției.

==== Reconstrucția soluției ====

Dorim să aflăm nu doar distanța dintre cele două șiruri, ci și o secvență de operații. Cum procedăm? În mod similar cu subsecvența maximală comună.

Pentru a putea reconstrui soluția vom memora în fiecare căsuță din matrice direcția din care provine ea, adică din care am calculat acel maxim. Direcția poate fi spre stânga, spre sus, sau în diagonală stânga-sus. Apoi vom porni din elementul <source lang="C" enclose="none">v[]</source>D[m][n]</source> și vom urma aceste direcții până ce ieșim din matrice. Astfel:

* Direcția spre stânga înseamnă o inserare de caracter.
* Direcție spre sus înseamnă o ștergere de caracter.
* Direcția diagonală înseamnă:
** O suprascriere dacă caracterele respective sunt diferite.
** Nimic (nici o operație) dacă caracterele sunt egale.

=== Înmulțirea optimală a unui șir de matrice ===

Se dă un produs matricial de <tt>N</tt> matrice. Înmulțirea matricelor este asociativă, deci nu contează în ce ordine efectuăm înmulțirile. Dar numărul de operații elementare va diferi în funcție de ordine. Să se găsească o ordine de înmulțire care minimizează numărul de înmulțiri elementare.

Vom discuta pe scurt această problemă, deoarece matematica necesară depășește nivelul clasei a șaptea.

Cei interesați pot rezolva problema: [http://nerdarena.ro/problema/pdm Pdm] ca aplicație.

== Numărare optime prin programarea dinamică ==

Câte soluții distincte posibile admite o problemă de programare dinamică?

Orice problemă de programare dinamică admite un optim. Soluția optimă nu este, de obicei, unică. Putem, deci, pune întrebarea:

* Care este numărul de soluții optime ale unei probleme de programare dinamică?

Răspunsul se poate da foarte ușor, folosind același tabel cu care calculăm subproblemele. Vom memora, pe lângă valoarea maximă (sau minimă) și numărul de moduri în care se poate ajunge la ea.

=== Exemplu: subsecvența crescătoare de lungime maximă ===

Să luăm exemplul de data trecută:

0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15

Avem formula de recurență:

L[i] = max(L[j]+1), j > i și V[j] ≥ V[i]

Vom calcula și <source lang="C" enclose="none">MAX[i]</source> ca fiind suma tuturor <source lang="C" enclose="none">MAX[j]</source> pentru acei indecși <tt>j</tt> unde relația de maxim este satisfăcută.

Exemplu:

{| class="wikitable"
! V
| 0 || 8 || 4 || 12 || 2 || 10 || 6 || 14 || 1 || 9 || 5 || 13 || 3 || 11 || 7 || 15
|-
! L
| 6 || 4 || 5 || 3 || 5 || 3 || 4 || 2 || 4 || 3 || 3 || 2 || 3 || 2 || 2 || 1
|-
! MAX
| 4 || 7 || 2 || 2 || 2 || 3 || 2 || 1 || 7 || 2 || 3 || 1 || 2 || 1 || 1 || 1
|}

Avem, deci, patru secvențe crescătoare de lungime maximală, anume 6. Toate încep cu elementul 0. Două dintre ele continuă cu elementul 4, celelalte două cu elementul 2.

'''Explicație:''' elementul curent se poate atașa oricărei secvențe maximale anterior găsite. Dacă o secvență anterioară avea <tt>k</tt> posibilități de formare, atunci și noile secvențe formate vor fi tot în număr de <tt>k</tt>. Dacă avem mai multe posibilități de secvențe anterioare, toate vor contribui în egală măsură. De aceea le însumăm.

=== Discuție: problema rucsacului ===

Discuție despre cum calculăm numărul de soluții posibile în cazul problemei rucsacului: pe baza relației de recurență calculăm numărul de soluții. El se poate ''transfera'' de la elementul generator. Sau, în caz că ambele moduri de generare duc la același profit vom însuma numărul de soluții.

== Probleme suprapuse (numărare soluții neoptimale) ==

Există unele probleme care nu cer să se determine un optim, ci să se numere soluții. Ele nu se rezolvă prin programare dinamică, deoarece nu se cere optimul. Ele sunt adesea confundate cu probleme de programare dinamică.

În realitate ele sunt probleme de numărare, folosind structura de probleme suprapuse.

Să luăm câteva exemple.

=== Rucsac ===

'''Atenție:''' veți avea această problemă la temă.

Problema [https://www.nerdarena.ro/problema/rucsac Rucsac] cere să se calculeze câte subsecvențe distincte (necontigue) au suma egală cu un număr dat.

Problema este echivalentă cu cea a rucsacului: numerele de la intrare reprezintă atât greutatea cât și valoarea obiectelor. Însă trebuie să selectăm obiecte astfel încât suma greutăților să fie exact <tt>K</tt>, numărul dat.

==== Exemplu ====

Fie numerele: <tt>8 3 6 5 2</tt> și numărul dat <tt>K = 11</tt>.

Vom avea trei subsecvențe distincte a căror sumă este 11:

8 3
3 6 2
6 5

==== Soluție ====

'''Observație importantă:''' Nu putem folosi definiția anterioară a problemei, deoarece ea admite soluții care nu ''umplu'' exact rucsacul. Aceste soluții nu sunt admisibile.

Vom defini problema ușor diferit:

V[i][g] = valoarea maximă ce se poate obține cu primele i greutăți într-un rucsac de mărime g complet umplut. Valoarea va fi zero dacă nu putem umple greutatea g.

În cazul nostru, deoarece valoarea este egală cu greutatea acea valoare va fi chiar greutatea <tt>g</tt>. Problema se transformă în există un mod de a forma o greutate <tt>g</tt> cu primele <tt>i</tt> obiecte? Răspunsul este unu dacă este afirmativ, sau zero dacă nu se poate forma o greutate. Matricea va fi o matrice de zero și unu.

Formula de recurență se modifică și ea, puțin:

: <math>V[i][g] = \begin{cases} 0, & \mbox{dacă } i = 0 \text{ și } g > 0 \\ 1, & \text{dacă } g = 0 \\ or(V[i-1][g], V[i-1][g-G_{i}]) & \text{în caz contrar}. \end{cases} </math>

unde <tt>or(x, y)</tt> este 1 dacă măcar unul dintre <tt>x</tt>, <tt>y</tt> este 1, sau zero în caz contrar.

Pe ultima linie a matricei <tt>V</tt> vom avea 1 pentru greutățile ce se pot obține.

Acum: cum modificăm soluția să calculeze nu doar dacă o greutate se poate obține, ci în câte moduri distincte?

Vom calcula:

NSOL[i][g] = numărul de moduri în care putem forma greutatea g folosind primele i numere. Acest număr va fi zero dacă greutatea nu se poate obține.

Formula de recurență este aproape identică cu cea anterioară.

: <math>NSOL[i][g] = \begin{cases} 0, & \text{dacă } i = 0 \mbox{ și } g > 0 \\ 1, & \text{dacă } g = 0 \\ NSOL[i-1][g] + NSOL[i-1][g-G_{i}] & \text{în caz contrar}. \end{cases}</math>

Numărul de moduri în care putem alege numere de sumă <tt>K</tt> este <source lang="C" enclose="none">NSOL[N][K]</source>, elementul din colțul din dreapta-jos al matricei <source lang="C" enclose="none">NSOL</source>.

==== Exemplu ====

Pentru exemplul anterior, avem numerele: <tt>8 3 6 5 2</tt> și numărul dat K = 11.

Vom calcula tabelul:

{| class="wikitable"
! !!0!!1!!2!!3!!4!!5!!6!!7!!8!!9!!10!!11
|-
!0
|1||0||0||0||0||0||0||0||0||0||0||0
|-
!1
|1||0||0||0||0||0||0||0||1||0||0||0
|-
!2
|1||0||0||1||0||0||0||0||1||0||0||1
|-
!3
|1||0||0||1||0||0||1||0||1||1||0||1
|-
!4
|1||0||0||1||0||1||1||0||2||1||0||2
|-
!5
|1||0||1||1||0||2||1||1||3||1||2||3
|}

Avem, deci, trei moduri de a obține suma 11.

==== Analiză ====

Algoritmul are aceeași complexitate în timp și memorie ca și problema originală, anume ''O(N·K)'' timp și ''O(K)'' memorie, dacă memorăm doar o linie a matricei.

=== Cifreco ===

'''Atenție:''' veți avea această problemă la temă.

Problema [https://www.nerdarena.ro/problema/cifreco Cifreco] a fost dată la ONI 2012 baraj gimnaziu. Deși se poate rezolva cu alte metode, ea are o rezolvare foarte eficientă și simplu de implementat folosind numărarea prin probleme suprapuse.

Problema cere ca, dîndu-se două numere <tt>x</tt> și <tt>y</tt>, să se găsească câte numere există între aceste valori cu proprietățile:

* Au <tt>N</tt> cifre, tot atâtea cifre câte au și numerele <tt>x</tt> și <tt>y</tt>.
* Suma cifrelor lor este <tt>N+8</tt> (la fel ca și <tt>x</tt> și <tt>y</tt>).

==== Soluție ====

Să ne propunem mai întâi să rezolvăm o problemă mai simplă: câte numere de <tt>N</tt> cifre au suma cifrelor <tt>N+8</tt>? Cu alte cuvinte nu vom ține cont de valorile <tt>x</tt> și <tt>y</tt>.

Descompunerea în subprobleme suprapuse nu este foarte evidentă. Vom introduce o dimensiune auxiliară: vom varia suma cifrelor. Astfel, definim:

NSOL[N][S] = numărul de numere de N cifre a căror sumă este S.

Ce formulă de recurență avem?

Cum se poate forma un număr de <tt>N</tt> cifre? Punând pe prima poziție toate cifrele permise și apoi formând un număr cu <tt>N-1</tt> cifre. Vom avea, deci:

NSOL[N][S] = NSOL[N-1][S-1] + NSOL[N-1][S-2] + ... + NSOL[N-1][N-1]

Astfel:

* Primul termen este numărul de numere care încep cu 1
* Al doilea termen este numărul de numere care încep cu 2
*...
* Ultimul termen este numărul de numere care încep cu <tt>S - N + 1</tt>, aceasta fiind cea mai mare cifră pentru care cifrele rămase mai pot forma suma <tt>N-1</tt>.

Am putea să pornim la implementare. Însă mai putem face o optimizare. Să observăm că, conform definiției:

NSOL[N][S-1] = NSOL[N-1][S-2] + ... + NSOL[N-1][N-1]

De aici rezultă o formulă mai simplă de calcul pentru <source lang="C" enclose="none">NSOL[N][S]</source>:

NSOL[N][S] = NSOL[N-1][S-1] + NSOL[N][S-1]

Vom completa acest tabel pentru valori maxime. Astfel vom putea răspunde în ''O(1)'' la întrebări de forma:

* Câte numere de <tt>N</tt> cifre au suma <tt>S</tt>?

Acum revenim la problema noastră. Trebuie să calculăm câte numere de <tt>N</tt> cifre au suma <tt>N+8</tt> între '''x și y'''. Cum o rezolvăm?

Ne propunem să calculăm câte numere sunt mai mici sau egale cu <tt>k</tt>. Fie, de exemplu, <tt>k = 623</tt>. Vom proceda astfel:

* Vom calcula câte numere încep cu 1 și au suma cifrelor 11. Ele sunt toate mai mici strict ca 623. Vom folosi <source lang="C" enclose="none">NSOL[2][10]</source>.
* Vom calcula câte numere încep cu 2 și au suma cifrelor 11. Vom folosi <source lang="C" enclose="none">NSOL[2][9]</source>.
* ...
* Vom calcula câte numere încep cu 5 și au suma cifrelor 11. Vom folosi <source lang="C" enclose="none">NSOL[2][6]</source>.

În acest moment ne-au rămas doar numere care încep cu 6. Câte vor fi ele? Atâtea câte numere există mai mici ca 23, a căror sumă a cifrelor să fie 5. Reluăm, deci, problema de mai sus cu alți parametri, continuând să adunăm.

Putem acum calcula:

NN(k) = numărul de numere mai mici sau egale cu un număr k.

Pentru a răspunde la problemă vom calcula:

NN(x, y) = NN(y) - NN(x) + 1

Ce complexitate are această soluție?

Calculul tabelului este ''O(N·Σ)'' - un număr foarte mic, circa 162. Mărimea tabelului va fi aceeași.

Calculul răspunsului necesită o plimbare prin cifre, efectuată pentru fiecare cifră a numărului <tt>x</tt> sau <tt>y</tt>. Este, deci ''O(suma cifrelor) = O(N) - un număr și mai mic'', circa 54.

Aveți această problemă la temă.

'''Atenție!''' Calculul numărului de numere mai mici sau egale cu <tt>k</tt> se poate face mai ușor pornind de la cea mai din dreapta cifră, în loc de cea mai din stânga. Ideea este aceeași, doar ordinea de calcul se inversează.

=== Șir2 ===

Problema [https://www.nerdarena.ro/problema/sir2 Șir2] este o problemă tipică de numărare folosind probleme suprapuse. Ne vom ocupa doar de al doilea subpunct care cere să se calculeze în câte feluri se poate scrie un număr <tt>N</tt> ca sumă de <tt>M</tt> numere nenule. Ordinea termenilor contează.

Vom avea o recurență similară cu cea de la [https://www.nerdarena.ro/problema/cifreco Cifreco]:

NSOL[M][S] = numărul de secvențe de numere nenule de lungime M a căror sumă este S.

Recurența nu este foarte grea. Similar cu [https://www.nerdarena.ro/problema/cifreco Cifreco] avem:

NSOL[M][S] = NSOL[M-1][S-1] + NSOL[M-1][S-2] + ... + NSOL[M-1][M-1]

Astfel:

* Primul termen este numărul de secvențe care încep cu 1.
* Al doilea termen este numărul de secvențe care încep cu 2.
* ...
* Ultimul termen este numărul de secvențe care încep cu <tt>S-M+1</tt>, aceasta fiind cel mai mare număr pentru care cifrele rămase mai pot forma suma <tt>M</tt>.

La fel ca la [https://www.nerdarena.ro/problema/cifreco Cifreco], putem reduce această recurență la una mai simplă:

NSOL[M][S] = NSOL[M-1][S-1] + NSOL[M][S-1]

Soluția problemei va fi elementul <source lang="C" enclose="none">NSOL[M][N]</source>.

Observații:

* Aveți grijă la calcule, ele trebuie făcute modulo 104729.
* Din toate elementele unei sume putem scădea 1. Obținem un șir de elemente naturale, posibil nule, a căror sumă echivalentă trebuie micșorată cu <tt>M</tt>.
* Astfel, problema se simplifică dacă:
** Considerați că numerele pot fi nule.
** Reduceți suma cerută, <tt>N</tt>, înlocuind-o cu <tt>N-M</tt>.
** Numărul de posibilități rămâne același, dar tabelul se simplifică.

Ce complexitate are acest algoritm?

El este ''O(M·(N-M))'' ca timp și memorie.

== Tema 25 ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/rucsac1 Rucsac1] ca aplicație la problema rucsacului.
* [https://www.nerdarena.ro/problema/siruri2 Șiruri2] ca aplicație la distanța edit.
* [https://www.nerdarena.ro/problema/rucsac Rucsac] ca aplicație de numărare cu probleme suprapuse.
* [https://www.nerdarena.ro/problema/cifreco Cifreco] dată la ONI 2012 baraj gimnaziu, ca aplicație de numărare cu probleme suprapuse.

== Tema opțională ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/pdm Pdm] ca aplicație la înmulțirea optimală de matrice
* [https://www.nerdarena.ro/problema/cutii Cutii] problemă simpatică

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_25:_Programare_dinamic%C4%83_(2) Accesează rezolvarea temei 25]

Clasa a 7-a Lecția 25: Programare dinamică (2)

2025-06-10T11:51:41Z

Mihai:

== Înregistrare video lecție ==

{{#ev:youtube|https://youtu.be/z4433kBdq2A|||||start=5580&end=9780&loop=1}}

== Problema rucsacului ==

'''Atenție:''' veți avea la temă ca aplicație problema [https://www.nerdarena.ro/problema/rucsac1 Rucsac1].

Se dă o mulțime formată din <tt>N</tt> obiecte, fiecare având o greutate și o valoare. Într-un rucsac putem încărca o greutate maxim <tt>G</tt>. Ne dorim să încărcăm rucsacul cu obiecte astfel încât să maximizăm valoarea totală.

Problema este una foarte practică, ne dorim să optimizăm raportul valoare/greutate, încărcând obiecte cât mai valoroase, dar cât mai ușoare.

=== Exemplu ===

Să presupunem că avem următoarele obiecte:

{| class="wikitable"
! Nr. || 1 || 2 || 3 || 4 || 5 || 6
|-
! Greutate
| 3 || 3 || 1 || 1 || 2 || 1
|-
! Valoare
| 7 || 4 || 2 || 9 || 4 || 5
|}

Rucsacul are mărime 10. Care este valoarea maximă a obiectelor ce pot fi încărcate în rucsac?

Singura posibilitate este să alegem obiectele <tt>{ 1, 2, 4, 5, 6 }</tt>. Ele au greutatea totală 10 și valoarea totală 29.

=== Încercarea 1: după obiecte ===

Definirea problemei de programare dinamică nu este evidentă. Voi încerca să arăt un mod de gândire posibil, care implică mai multe posibilități pe care le vom verifica și apoi elimina, ajungând în final la o definire bună a problemei.

Să definim

V[i] = valoarea maximă ce se poate obține cu primele i greutăți, astfel încât greutatea totală să nu depășească G

Are <source lang="C" enclose="none">V[i]</source> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă, <source lang="C" enclose="none">V[i]</source>. Ea va conține unele din primele <tt>i</tt> obiecte. Ultimul obiect este obiectul <tt>k ≤ i</tt>. Atunci este <source lang="C" enclose="none">V[k]</source> optimă?

Nu neapărat! Este posibil să găsim o soluție <source lang="C" enclose="none">V[k]</source> cu valoare mai mare, dar pe care să nu o putem folosi în construcția problemei <source lang="C" enclose="none">V[i]</source> deoarece am depăși greutatea.

'''Concluzie:''' nu putem folosi programarea dinamică cu o astfel de definire a problemei.

=== Încercarea 2: după greutatea totală ===

Să facem o altă încercare. Să definim

V[g] = valoarea maximă ce se poate obține într-un rucsac de mărime g

Are <source lang="C" enclose="none">V[g]</source> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă, <source lang="C" enclose="none">V[g]</source>. Ea va conține unele obiecte, a căror sumă a greutăților nu depășește <tt>g</tt>. Fie ultimul obiect folosit obiectul <tt>k</tt> ce are greutate <tt>Gk</tt>. Este <code>V[g-Gk]</code> optimă?

Răspunsul este: nu, deoarece s-ar putea ca optimul să includă <source lang="C" enclose="none">V[g]</source> (pe care nu avem voie să o folosim de două ori).

'''Concluzie:''' nu putem folosi programarea dinamică nici cu această definire a problemei.

=== Încercarea 3: după obiecte și greutate totală ===

Să încercăm să combinăm cele două încercări de mai sus. Să definim

V[i][g] = valoarea maximă ce se poate obține cu primele i greutăți într-un rucsac de mărime g

Are <source lang="C" enclose="none">V[i][g]</source> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă <source lang="C" enclose="none">V[i][g]</source>. Fie ultimul obiect folosit obiectul <tt>k</tt> ce are greutate <tt>Gk</tt>. Este <code>V[k][g-Gk]</code> optimă? Să presupunem că nu ar fi. Atunci am putea găsi o valoare mai mare, folosind primele <tt>k</tt> obiecte ce vor încăpea în greutatea <tt>g-Gk</tt>. Putem folosi această valoare pentru a obține o valoare mai mare pentru problema originală, <source lang="C" enclose="none">V[i][g]</source>.

'''Concluzie:''' putem folosi programarea dinamică cu această definiție a problemei.

Construim formula de recurență. Pentru a calcula <source lang="C" enclose="none">V[i][g]</source> avem două variante:

* Fie nu folosim greutatea <tt>Gi</tt>, caz în care vom obține valoarea <source lang="C" enclose="none">V[i-1][g]</source> (aceeași greutate, dar folosind primele <tt>i-1</tt> obiecte).
* Fie folosim greutatea <tt>Gi</tt>, caz în care vom obține valoarea <code>V[i-1][g-Gi] + Pi</code> (greutatea este cea care rămâne în rucsac după ce folosim <tt>Gi</tt>, și apoi putem folosi primele <tt>i-1</tt> obiecte).

: <math>V[i][g] = \begin{cases} 0, & \text{dacă } i = 0 \text{ sau } g = 0 \\ max(V[i-1][g], V[i-1][g-G_{i}] + P_{i}) & \text{în caz contrar}. \end{cases}</math>

Unde <tt>(Gi, Pi)</tt> sunt greutatea, respectiv valoarea obiectului <tt>i</tt>.

Răspunsul la problemă este elementul <source lang="C" enclose="none">V[N][G]</source>.

==== Exemplu ====

Fie obiectele din exemplul de mai sus:

{| class="wikitable"
! Nr. || 1 || 2 || 3 || 4 || 5 || 6
|-
! Greutate
| 3 || 3 || 1 || 1 || 2 || 1
|-
! Valoare
| 7 || 4 || 2 || 9 || 4 || 5
|}

Vom completa, pe linii, următorul tabel:

{| class="wikitable"
! Obiect !! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9 !! 10
|-
!0
|0||0||0||0||0||0||0||0||0||0||0
|-
!1
|0||0||0||7||7||7||7||7||7||7||7
|-
!2
|0||0||0||7||7||7||11||11||11||11||11
|-
!3
|0||2||2||7||9||9||11||13||13||13||13
|-
!4
|0||9||11||11||16||18||18||20||22||22||22
|-
!5
|0||9||11||13||16||18||20||22||22||24||26
|-
!6
|0||9||14||16||18||21||23||25||27||27||29
|}

==== Analiză ====

Acest algoritm are complexitate ''O(N·G)''. Memoria folosită este ''O(G)'' dacă memorăm doar o linie din matrice. Dacă dorim să aflăm și o soluție maximală (obiectele din componența soluției), nu doar mărimea ei, vom avea nevoie de memorie ''O(N·G)'', precum vom vedea mai jos.

Există un algoritm care reduce necesarul de memorie la ''O(G)''.

==== Reconstrucția soluției ====

Dorim să aflăm nu doar valoarea maximă, ci și obiectele selectate. Cum procedăm?

Pentru a putea reconstrui soluția vom memora în fiecare căsuță, direcția din care provine ea, adică din care am calculat acel maxim. Direcția poate fi spre stânga-sus sau spre în sus. Apoi vom porni din elementul <source lang="C" enclose="none">V[N][G]</source> și vom urma aceste direcții până ce ieșim din matrice. De fiecare dată când urmăm o diagonală reținem obiectul selectat, care este chiar rândul curent. Astfel, descoperirea obiectelor se face în ordine inversă.

=== Distanța edit (Levenshtein) ===

'''Atenție:''' veți avea această problemă la temă.

Se dau două șiruri de caractere, <tt>X</tt> și <tt>Y</tt>. Putem efectua trei operațiuni asupra șirului <tt>X</tt>:

* Inserare caracter la orice poziție
* Ștergere caracter la orice poziție
* Suprascriere - înlocuire a unui caracter cu un alt caracter

Care este numărul minim de operații asupra șirului <tt>X</tt> care îl transformă în șirul <tt>Y</tt>?

'''Definim [https://en.wikipedia.org/wiki/Edit_distance distanța edit] ca fiind acest număr minim de operații'''. Deoarece operațiile sunt unele frecvente într-un editor de texte, de aici vine și denumirea de distanță edit.

==== Exemplu ====

Acest exemplu este inspirat de la wikipedia.

Fie șirurile:

X: KITTEN
Y: SITTING

Numărul minim de operații pentru a transforma <tt>X</tt> în <tt>Y</tt> este 3. De exemplu:

# Înlocuim <tt>K</tt> cu <tt>S</tt>: <tt>KITTEN → SITTEN</tt>
# Înlocuim <tt>E</tt> cu <tt>I</tt>: <tt>SITTEN → SITTIN</tt>
# Adăugăm la final un <tt>G</tt>: <tt>SITTIN → SITTING</tt>

==== Soluție ====

Problema este aproape identică cu subsecvența maximală comună a două șiruri. Vom defini:

D(i, j) = numărul minim de operații ce transformă șirul X[1..i]] în șirul Y[1..j]

Nu voi face demonstrația optimalității subproblemelor, deoarece este similară cu ce de la subsecvența maximală comună a două șiruri.

Obținem relația de recurență:

: <math>\operatorname{D}_{X,Y}(i,j) = \begin{cases} \max(i,j) & \text{ dacă } \min(i,j)=0, \\ \min \begin{cases} \operatorname{D}_{X,Y}(i-1,j) + 1 \\ \operatorname{D}_{X,Y}(i,j-1) + 1 \\ \operatorname{D}_{X,Y}(i-1,j-1) + X_i \neq Y_j \end{cases} & \text{ în caz contrar.} \end{cases} </math>

Distanța edit între cele două șiruri este <tt>D(m, n)</tt>.

==== Analiză ====

Acest algoritm are complexitate ''O(m·n)'', unde <tt>m</tt> și <tt>n</tt> sunt lungimile șirurilor. Memoria folosită este ''O(min(m, n))'' dacă memorăm doar o linie din matrice. Dacă dorim să aflăm și operațiile efectuate, nu doar numărul lor, vom avea nevoie de memorie ''O(m·n)'', precum vom vedea mai jos.

Există un algoritm care reduce necesarul de memorie la ''O(min(m, n))'' chiar și cu reconstrucția soluției.

==== Reconstrucția soluției ====

Dorim să aflăm nu doar distanța dintre cele două șiruri, ci și o secvență de operații. Cum procedăm? În mod similar cu subsecvența maximală comună.

Pentru a putea reconstrui soluția vom memora în fiecare căsuță din matrice direcția din care provine ea, adică din care am calculat acel maxim. Direcția poate fi spre stânga, spre sus, sau în diagonală stânga-sus. Apoi vom porni din elementul <source lang="C" enclose="none">v[]</source>D[m][n]</source> și vom urma aceste direcții până ce ieșim din matrice. Astfel:

* Direcția spre stânga înseamnă o inserare de caracter.
* Direcție spre sus înseamnă o ștergere de caracter.
* Direcția diagonală înseamnă:
** O suprascriere dacă caracterele respective sunt diferite.
** Nimic (nici o operație) dacă caracterele sunt egale.

=== Înmulțirea optimală a unui șir de matrice ===

Se dă un produs matricial de <tt>N</tt> matrice. Înmulțirea matricelor este asociativă, deci nu contează în ce ordine efectuăm înmulțirile. Dar numărul de operații elementare va diferi în funcție de ordine. Să se găsească o ordine de înmulțire care minimizează numărul de înmulțiri elementare.

Vom discuta pe scurt această problemă, deoarece matematica necesară depășește nivelul clasei a șaptea.

Cei interesați pot rezolva problema: [http://nerdarena.ro/problema/pdm Pdm] ca aplicație.

== Numărare optime prin programarea dinamică ==

Câte soluții distincte posibile admite o problemă de programare dinamică?

Orice problemă de programare dinamică admite un optim. Soluția optimă nu este, de obicei, unică. Putem, deci, pune întrebarea:

* Care este numărul de soluții optime ale unei probleme de programare dinamică?

Răspunsul se poate da foarte ușor, folosind același tabel cu care calculăm subproblemele. Vom memora, pe lângă valoarea maximă (sau minimă) și numărul de moduri în care se poate ajunge la ea.

=== Exemplu: subsecvența crescătoare de lungime maximă ===

Să luăm exemplul de data trecută:

0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15

Avem formula de recurență:

L[i] = max(L[j]+1), j > i și V[j] ≥ V[i]

Vom calcula și <source lang="C" enclose="none">MAX[i]</source> ca fiind suma tuturor <source lang="C" enclose="none">MAX[j]</source> pentru acei indecși <tt>j</tt> unde relația de maxim este satisfăcută.

Exemplu:

{| class="wikitable"
! V
| 0 || 8 || 4 || 12 || 2 || 10 || 6 || 14 || 1 || 9 || 5 || 13 || 3 || 11 || 7 || 15
|-
! L
| 6 || 4 || 5 || 3 || 5 || 3 || 4 || 2 || 4 || 3 || 3 || 2 || 3 || 2 || 2 || 1
|-
! MAX
| 4 || 7 || 2 || 2 || 2 || 3 || 2 || 1 || 7 || 2 || 3 || 1 || 2 || 1 || 1 || 1
|}

Avem, deci, patru secvențe crescătoare de lungime maximală, anume 6. Toate încep cu elementul 0. Două dintre ele continuă cu elementul 4, celelalte două cu elementul 2.

'''Explicație:''' elementul curent se poate atașa oricărei secvențe maximale anterior găsite. Dacă o secvență anterioară avea <tt>k</tt> posibilități de formare, atunci și noile secvențe formate vor fi tot în număr de <tt>k</tt>. Dacă avem mai multe posibilități de secvențe anterioare, toate vor contribui în egală măsură. De aceea le însumăm.

=== Discuție: problema rucsacului ===

Discuție despre cum calculăm numărul de soluții posibile în cazul problemei rucsacului: pe baza relației de recurență calculăm numărul de soluții. El se poate ''transfera'' de la elementul generator. Sau, în caz că ambele moduri de generare duc la același profit vom însuma numărul de soluții.

== Probleme suprapuse (numărare soluții neoptimale) ==

Există unele probleme care nu cer să se determine un optim, ci să se numere soluții. Ele nu se rezolvă prin programare dinamică, deoarece nu se cere optimul. Ele sunt adesea confundate cu probleme de programare dinamică.

În realitate ele sunt probleme de numărare, folosind structura de probleme suprapuse.

Să luăm câteva exemple.

=== Rucsac ===

'''Atenție:''' veți avea această problemă la temă.

Problema [https://www.nerdarena.ro/problema/rucsac Rucsac] cere să se calculeze câte subsecvențe distincte (necontigue) au suma egală cu un număr dat.

Problema este echivalentă cu cea a rucsacului: numerele de la intrare reprezintă atât greutatea cât și valoarea obiectelor. Însă trebuie să selectăm obiecte astfel încât suma greutăților să fie exact <tt>K</tt>, numărul dat.

==== Exemplu ====

Fie numerele: <tt>8 3 6 5 2</tt> și numărul dat <tt>K = 11</tt>.

Vom avea trei subsecvențe distincte a căror sumă este 11:

8 3
3 6 2
6 5

==== Soluție ====

'''Observație importantă:''' Nu putem folosi definiția anterioară a problemei, deoarece ea admite soluții care nu ''umplu'' exact rucsacul. Aceste soluții nu sunt admisibile.

Vom defini problema ușor diferit:

V[i][g] = valoarea maximă ce se poate obține cu primele i greutăți într-un rucsac de mărime g complet umplut. Valoarea va fi zero dacă nu putem umple greutatea g.

În cazul nostru, deoarece valoarea este egală cu greutatea acea valoare va fi chiar greutatea <tt>g</tt>. Problema se transformă în există un mod de a forma o greutate <tt>g</tt> cu primele <tt>i</tt> obiecte? Răspunsul este unu dacă este afirmativ, sau zero dacă nu se poate forma o greutate. Matricea va fi o matrice de zero și unu.

Formula de recurență se modifică și ea, puțin:

: <math>V[i][g] = \begin{cases} 0, & \mbox{dacă } i = 0 \text{ și } g > 0 \\ 1, & \text{dacă } g = 0 \\ or(V[i-1][g], V[i-1][g-G_{i}]) & \text{în caz contrar}. \end{cases} </math>

unde <tt>or(x, y)</tt> este 1 dacă măcar unul dintre <tt>x</tt>, <tt>y</tt> este 1, sau zero în caz contrar.

Pe ultima linie a matricei <tt>V</tt> vom avea 1 pentru greutățile ce se pot obține.

Acum: cum modificăm soluția să calculeze nu doar dacă o greutate se poate obține, ci în câte moduri distincte?

Vom calcula:

NSOL[i][g] = numărul de moduri în care putem forma greutatea g folosind primele i numere. Acest număr va fi zero dacă greutatea nu se poate obține.

Formula de recurență este aproape identică cu cea anterioară.

: <math>NSOL[i][g] = \begin{cases} 0, & \text{dacă } i = 0 \mbox{ și } g > 0 \\ 1, & \text{dacă } g = 0 \\ NSOL[i-1][g] + NSOL[i-1][g-G_{i}] & \text{în caz contrar}. \end{cases}</math>

Numărul de moduri în care putem alege numere de sumă <tt>K</tt> este <source lang="C" enclose="none">NSOL[N][K]</source>, elementul din colțul din dreapta-jos al matricei <source lang="C" enclose="none">NSOL</source>.

==== Exemplu ====

Pentru exemplul anterior, avem numerele: <tt>8 3 6 5 2</tt> și numărul dat K = 11.

Vom calcula tabelul:

{| class="wikitable"
! !!0!!1!!2!!3!!4!!5!!6!!7!!8!!9!!10!!11
|-
!0
|1||0||0||0||0||0||0||0||0||0||0||0
|-
!1
|1||0||0||0||0||0||0||0||1||0||0||0
|-
!2
|1||0||0||1||0||0||0||0||1||0||0||1
|-
!3
|1||0||0||1||0||0||1||0||1||1||0||1
|-
!4
|1||0||0||1||0||1||1||0||2||1||0||2
|-
!5
|1||0||1||1||0||2||1||1||3||1||2||3
|}

Avem, deci, trei moduri de a obține suma 11.

==== Analiză ====

Algoritmul are aceeași complexitate în timp și memorie ca și problema originală, anume ''O(N·K)'' timp și ''O(K)'' memorie, dacă memorăm doar o linie a matricei.

=== Cifreco ===

'''Atenție:''' veți avea această problemă la temă.

Problema [https://www.nerdarena.ro/problema/cifreco Cifreco] a fost dată la ONI 2012 baraj gimnaziu. Deși se poate rezolva cu alte metode, ea are o rezolvare foarte eficientă și simplu de implementat folosind numărarea prin probleme suprapuse.

Problema cere ca, dîndu-se două numere <tt>x</tt> și <tt>y</tt>, să se găsească câte numere există între aceste valori cu proprietățile:

* Au <tt>N</tt> cifre, tot atâtea cifre câte au și numerele <tt>x</tt> și <tt>y</tt>.
* Suma cifrelor lor este <tt>N+8</tt> (la fel ca și <tt>x</tt> și <tt>y</tt>).

==== Soluție ====

Să ne propunem mai întâi să rezolvăm o problemă mai simplă: câte numere de <tt>N</tt> cifre au suma cifrelor <tt>N+8</tt>? Cu alte cuvinte nu vom ține cont de valorile <tt>x</tt> și <tt>y</tt>.

Descompunerea în subprobleme suprapuse nu este foarte evidentă. Vom introduce o dimensiune auxiliară: vom varia suma cifrelor. Astfel, definim:

NSOL[N][S] = numărul de numere de N cifre a căror sumă este S.

Ce formulă de recurență avem?

Cum se poate forma un număr de <tt>N</tt> cifre? Punând pe prima poziție toate cifrele permise și apoi formând un număr cu <tt>N-1</tt> cifre. Vom avea, deci:

NSOL[N][S] = NSOL[N-1][S-1] + NSOL[N-1][S-2] + ... + NSOL[N-1][N-1]

Astfel:

* Primul termen este numărul de numere care încep cu 1
* Al doilea termen este numărul de numere care încep cu 2
*...
* Ultimul termen este numărul de numere care încep cu <tt>S - N + 1</tt>, aceasta fiind cea mai mare cifră pentru care cifrele rămase mai pot forma suma <tt>N-1</tt>.

Am putea să pornim la implementare. Însă mai putem face o optimizare. Să observăm că, conform definiției:

NSOL[N][S-1] = NSOL[N-1][S-2] + ... + NSOL[N-1][N-1]

De aici rezultă o formulă mai simplă de calcul pentru <source lang="C" enclose="none">NSOL[N][S]</source>:

NSOL[N][S] = NSOL[N-1][S-1] + NSOL[N][S-1]

Vom completa acest tabel pentru valori maxime. Astfel vom putea răspunde în ''O(1)'' la întrebări de forma:

* Câte numere de N cifre au suma S?

Acum revenim la problema noastră. Trebuie să calculăm câte numere de <tt>N</tt> cifre au suma <tt>N+8</tt> între '''x și y'''. Cum o rezolvăm?

Ne propunem să calculăm câte numere sunt mai mici sau egale cu <tt>k</tt>. Fie, de exemplu, <tt>k = 623</tt>. Vom proceda astfel:

* Vom calcula câte numere încep cu 1 și au suma cifrelor 11. Ele sunt toate mai mici strict ca 623. Vom folosi <source lang="C" enclose="none">NSOL[2][10]</source>.
* Vom calcula câte numere încep cu 2 și au suma cifrelor 11. Vom folosi <source lang="C" enclose="none">NSOL[2][9]</source>.
* ...
* Vom calcula câte numere încep cu 5 și au suma cifrelor 11. Vom folosi <source lang="C" enclose="none">NSOL[2][6]</source>.

În acest moment ne-au rămas doar numere care încep cu 6. Câte vor fi ele? Atâtea câte numere există mai mici ca 23, a căror sumă a cifrelor să fie 5. Reluăm, deci, problema de mai sus cu alți parametri, continuând să adunăm.

Putem acum calcula:

NN(k) = numărul de numere mai mici sau egale cu un număr k.

Pentru a răspunde la problemă vom calcula:

NN(x, y) = NN(y) - NN(x) + 1

Ce complexitate are această soluție?

Calculul tabelului este ''O(N·Σ)'' - un număr foarte mic, circa 162. Mărimea tabelului va fi aceeași.

Calculul răspunsului necesită o plimbare prin cifre, efectuată pentru fiecare cifră a numărului x sau y. Este, deci ''O(suma cifrelor) = O(N) - un număr și mai mic'', circa 54.

Aveți această problemă la temă.

'''Atenție!''' Calculul numărului de numere mai mici sau egale cu k se poate face mai ușor pornind de la cea mai din dreapta cifră, în loc de cea mai din stânga. Ideea este aceeași, doar ordinea de calcul se inversează.

=== Șir2 ===

Problema șir2 este o problemă tipică de numărare folosind probleme suprapuse. Ne vom ocupa doar de al doilea subpunct care cere să se calculeze în câte feluri se poate scrie un număr N ca sumă de M numere nenule. Ordinea termenilor contează.

Vom avea o recurență similară cu cea de la cifreco:

NSOL[M][S] = numărul de secvențe de numere nenule de lungime M a căror sumă este S.

Recurența nu este foarte grea. Similar cu cifreco avem:

NSOL[M][S] = NSOL[M-1][S-1] + NSOL[M-1][S-2] + ... + NSOL[M-1][M-1]

Astfel:

Primul termen este numărul de secvențe care încep cu 1.

Al doilea termen este numărul de secvențe care încep cu 2.

...

Ultimul termen este numărul de secvențe care încep cu S-M+1, aceasta fiind cel mai mare număr pentru care cifrele rămase mai pot forma suma M.

La fel ca la cifreco, putem reduce această recurență la una mai simplă:

NSOL[M][S] = NSOL[M-1][S-1] + NSOL[M][S-1]

Soluția problemei va fi elementul NSOL[M][N].

Observații:

Aveți grijă la calcule, ele trebuie făcute modulo 104729.

Din toate elementele unei sume putem scădea 1. Obținem un șir de elemente naturale, posibil nule, a căror sumă echivalentă trebuie micșorată cu M.

Astfel, problema se simplifică dacă:

Considerați că numerele pot fi nule

Reduceți suma cerută, N, înlocuind-o cu N-M.

Numărul de posibilități rămâne același, dar tabelul se simplifică.

Ce complexitate are acest algoritm?

El este O(M·(N-M)) ca timp și memorie.

== Tema 26 - cercul de informatică pentru performanță clasa a șaptea ==
Tema 26 presupune să se rezolve următoarele probleme (program C trimis la NerdArena):

rucsac1 ca aplicație la problema rucsacului.

șiruri2 ca aplicație la distanța edit.

rucsac ca aplicație de numărare cu probleme suprapuse

cifreco dată la ONI 2012 baraj gimnaziu, ca aplicație de numărare cu probleme suprapuse

Tema opțională

Tema 26 opțională presupune să rezolvați următoarele probleme (program C trimis la NerdArena):

pdm ca aplicație la înmulțirea optimală de matrice

cutii problemă simpatică

Clasa a 7-a Lecția 25: Programare dinamică (2)

2025-06-10T11:38:02Z

Mihai:

== Înregistrare video lecție ==

{{#ev:youtube|https://youtu.be/z4433kBdq2A|||||start=5580&end=9780&loop=1}}

== Problema rucsacului ==

'''Atenție:''' veți avea la temă ca aplicație problema [https://www.nerdarena.ro/problema/rucsac1 Rucsac1].

Se dă o mulțime formată din <tt>N</tt> obiecte, fiecare având o greutate și o valoare. Într-un rucsac putem încărca o greutate maxim <tt>G</tt>. Ne dorim să încărcăm rucsacul cu obiecte astfel încât să maximizăm valoarea totală.

Problema este una foarte practică, ne dorim să optimizăm raportul valoare/greutate, încărcând obiecte cât mai valoroase, dar cât mai ușoare.

=== Exemplu ===

Să presupunem că avem următoarele obiecte:

{| class="wikitable"
! Nr. || 1 || 2 || 3 || 4 || 5 || 6
|-
! Greutate
| 3 || 3 || 1 || 1 || 2 || 1
|-
! Valoare
| 7 || 4 || 2 || 9 || 4 || 5
|}

Rucsacul are mărime 10. Care este valoarea maximă a obiectelor ce pot fi încărcate în rucsac?

Singura posibilitate este să alegem obiectele <tt>{ 1, 2, 4, 5, 6 }</tt>. Ele au greutatea totală 10 și valoarea totală 29.

=== Încercarea 1: după obiecte ===

Definirea problemei de programare dinamică nu este evidentă. Voi încerca să arăt un mod de gândire posibil, care implică mai multe posibilități pe care le vom verifica și apoi elimina, ajungând în final la o definire bună a problemei.

Să definim

V[i] = valoarea maximă ce se poate obține cu primele i greutăți, astfel încât greutatea totală să nu depășească G

Are <source lang="C" enclose="none">V[i]</source> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă, <source lang="C" enclose="none">V[i]</source>. Ea va conține unele din primele <tt>i</tt> obiecte. Ultimul obiect este obiectul <tt>k ≤ i</tt>. Atunci este <source lang="C" enclose="none">V[k]</source> optimă?

Nu neapărat! Este posibil să găsim o soluție <source lang="C" enclose="none">V[k]</source> cu valoare mai mare, dar pe care să nu o putem folosi în construcția problemei <source lang="C" enclose="none">V[i]</source> deoarece am depăși greutatea.

'''Concluzie:''' nu putem folosi programarea dinamică cu o astfel de definire a problemei.

=== Încercarea 2: după greutatea totală ===

Să facem o altă încercare. Să definim

V[g] = valoarea maximă ce se poate obține într-un rucsac de mărime g

Are <source lang="C" enclose="none">V[g]</source> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă, <source lang="C" enclose="none">V[g]</source>. Ea va conține unele obiecte, a căror sumă a greutăților nu depășește <tt>g</tt>. Fie ultimul obiect folosit obiectul <tt>k</tt> ce are greutate <tt>Gk</tt>. Este <code>V[g-Gk]</code> optimă?

Răspunsul este: nu, deoarece s-ar putea ca optimul să includă <source lang="C" enclose="none">V[g]</source> (pe care nu avem voie să o folosim de două ori).

'''Concluzie:''' nu putem folosi programarea dinamică nici cu această definire a problemei.

=== Încercarea 3: după obiecte și greutate totală ===

Să încercăm să combinăm cele două încercări de mai sus. Să definim

V[i][g] = valoarea maximă ce se poate obține cu primele i greutăți într-un rucsac de mărime g

Are <source lang="C" enclose="none">V[i][g]</source> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă <source lang="C" enclose="none">V[i][g]</source>. Fie ultimul obiect folosit obiectul <tt>k</tt> ce are greutate <tt>Gk</tt>. Este <code>V[k][g-Gk]</code> optimă? Să presupunem că nu ar fi. Atunci am putea găsi o valoare mai mare, folosind primele <tt>k</tt> obiecte ce vor încăpea în greutatea <tt>g-Gk</tt>. Putem folosi această valoare pentru a obține o valoare mai mare pentru problema originală, <source lang="C" enclose="none">V[i][g]</source>.

'''Concluzie:''' putem folosi programarea dinamică cu această definiție a problemei.

Construim formula de recurență. Pentru a calcula <source lang="C" enclose="none">V[i][g]</source> avem două variante:

* Fie nu folosim greutatea <tt>Gi</tt>, caz în care vom obține valoarea <source lang="C" enclose="none">V[i-1][g]</source> (aceeași greutate, dar folosind primele <tt>i-1</tt> obiecte).
* Fie folosim greutatea <tt>Gi</tt>, caz în care vom obține valoarea <code>V[i-1][g-Gi] + Pi</code> (greutatea este cea care rămâne în rucsac după ce folosim <tt>Gi</tt>, și apoi putem folosi primele <tt>i-1</tt> obiecte).

: <math>V[i][g] = \begin{cases} 0, & \text{dacă } i = 0 \text{ sau } g = 0 \\ max(V[i-1][g], V[i-1][g-G_{i}] + P_{i}) & \text{în caz contrar}. \end{cases}</math>

Unde <tt>(Gi, Pi)</tt> sunt greutatea, respectiv valoarea obiectului <tt>i</tt>.

Răspunsul la problemă este elementul <source lang="C" enclose="none">V[N][G]</source>.

==== Exemplu ====

Fie obiectele din exemplul de mai sus:

{| class="wikitable"
! Nr. || 1 || 2 || 3 || 4 || 5 || 6
|-
! Greutate
| 3 || 3 || 1 || 1 || 2 || 1
|-
! Valoare
| 7 || 4 || 2 || 9 || 4 || 5
|}

Vom completa, pe linii, următorul tabel:

{| class="wikitable"
! Obiect !! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9 !! 10
|-
!0
|0||0||0||0||0||0||0||0||0||0||0
|-
!1
|0||0||0||7||7||7||7||7||7||7||7
|-
!2
|0||0||0||7||7||7||11||11||11||11||11
|-
!3
|0||2||2||7||9||9||11||13||13||13||13
|-
!4
|0||9||11||11||16||18||18||20||22||22||22
|-
!5
|0||9||11||13||16||18||20||22||22||24||26
|-
!6
|0||9||14||16||18||21||23||25||27||27||29
|}

==== Analiză ====

Acest algoritm are complexitate ''O(N·G)''. Memoria folosită este ''O(G)'' dacă memorăm doar o linie din matrice. Dacă dorim să aflăm și o soluție maximală (obiectele din componența soluției), nu doar mărimea ei, vom avea nevoie de memorie ''O(N·G)'', precum vom vedea mai jos.

Există un algoritm care reduce necesarul de memorie la ''O(G)''.

==== Reconstrucția soluției ====

Dorim să aflăm nu doar valoarea maximă, ci și obiectele selectate. Cum procedăm?

Pentru a putea reconstrui soluția vom memora în fiecare căsuță, direcția din care provine ea, adică din care am calculat acel maxim. Direcția poate fi spre stânga-sus sau spre în sus. Apoi vom porni din elementul <source lang="C" enclose="none">V[N][G]</source> și vom urma aceste direcții până ce ieșim din matrice. De fiecare dată când urmăm o diagonală reținem obiectul selectat, care este chiar rândul curent. Astfel, descoperirea obiectelor se face în ordine inversă.

=== Distanța edit (Levenshtein) ===

'''Atenție:''' veți avea această problemă la temă.

Se dau două șiruri de caractere, <tt>X</tt> și <tt>Y</tt>. Putem efectua trei operațiuni asupra șirului <tt>X</tt>:

* Inserare caracter la orice poziție
* Ștergere caracter la orice poziție
* Suprascriere - înlocuire a unui caracter cu un alt caracter

Care este numărul minim de operații asupra șirului <tt>X</tt> care îl transformă în șirul <tt>Y</tt>?

'''Definim [https://en.wikipedia.org/wiki/Edit_distance distanța edit] ca fiind acest număr minim de operații'''. Deoarece operațiile sunt unele frecvente într-un editor de texte, de aici vine și denumirea de distanță edit.

==== Exemplu ====

Acest exemplu este inspirat de la wikipedia.

Fie șirurile:

X: KITTEN
Y: SITTING

Numărul minim de operații pentru a transforma <tt>X</tt> în <tt>Y</tt> este 3. De exemplu:

# Înlocuim K cu S: KITTEN → SITTEN
# Înlocuim E cu I: SITTEN → SITTIN
# Adăugăm la final un G: SITTIN → SITTING

==== Soluție ====

Problema este aproape identică cu subsecvența maximală comună a două șiruri. Vom defini:

D(i, j) = numărul minim de operații ce transformă șirul X[1..i]] în șirul Y[1..j]

Nu voi face demonstrația optimalității subproblemelor, deoarece este similară cu ce de la subsecvența maximală comună a două șiruri.

Obținem relația de recurență:

: <math>\operatorname{D}_{X,Y}(i,j) = \begin{cases} \max(i,j) & \text{ dacă } \min(i,j)=0, \\ \min \begin{cases} \operatorname{D}_{X,Y}(i-1,j) + 1 \\ \operatorname{D}_{X,Y}(i,j-1) + 1 \\ \operatorname{D}_{X,Y}(i-1,j-1) + X_i \neq Y_j \end{cases} & \text{ în caz contrar.} \end{cases} </math>

Distanța edit între cele două șiruri este <tt>D(m, n)</tt>.

==== Analiză ====

Acest algoritm are complexitate ''O(m·n)'', unde <tt>m</tt> și <tt>n</tt> sunt lungimile șirurilor. Memoria folosită este ''O(min(m, n))'' dacă memorăm doar o linie din matrice. Dacă dorim să aflăm și operațiile efectuate, nu doar numărul lor, vom avea nevoie de memorie ''O(m·n)'', precum vom vedea mai jos.

Există un algoritm care reduce necesarul de memorie la ''O(min(m, n))'' chiar și cu reconstrucția soluției.

==== Reconstrucția soluției ====

Dorim să aflăm nu doar distanța dintre cele două șiruri, ci și o secvență de operații. Cum procedăm? În mod similar cu subsecvența maximală comună.

Pentru a putea reconstrui soluția vom memora în fiecare căsuță din matrice direcția din care provine ea, adică din care am calculat acel maxim. Direcția poate fi spre stânga, spre sus, sau în diagonală stânga-sus. Apoi vom porni din elementul <source lang="C" enclose="none">v[]</source>D[m][n]</source> și vom urma aceste direcții până ce ieșim din matrice. Astfel:

* Direcția spre stânga înseamnă o inserare de caracter.
* Direcție spre sus înseamnă o ștergere de caracter.
* Direcția diagonală înseamnă:
** O suprascriere dacă caracterele respective sunt diferite.
** Nimic (nici o operație) dacă caracterele sunt egale.

==== Înmulțirea optimală a unui șir de matrice ====

Se dă un produs matricial de <tt>N</tt> matrice. Înmulțirea matricelor este asociativă, deci nu contează în ce ordine efectuăm înmulțirile. Dar numărul de operații elementare va diferi în funcție de ordine. Să se găsească o ordine de înmulțire care minimizează numărul de înmulțiri elementare.

Vom discuta pe scurt această problemă, deoarece matematica necesară depășește nivelul clasei a șaptea.

Cei interesați pot rezolva problema: [http://nerdarena.ro/problema/pdm Pdm] ca aplicație.

== Numărare optime prin programarea dinamică ==

Câte soluții distincte posibile admite o problemă de programare dinamică?

Orice problemă de programare dinamică admite un optim. Soluția optimă nu este, de obicei, unică. Putem, deci, pune întrebarea:

Care este numărul de soluții optime ale unei probleme de programare dinamică?

Răspunsul se poate da foarte ușor, folosind același tabel cu care calculăm subproblemele. Vom memora, pe lîngă valoarea maximă (sau minimă) și numărul de moduri în care se poate ajunge la ea.

Exemplu: subsecvența crescătoare de lungime maximă

Să luăm exemplul de data trecută: 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15

Avem formula de recurență: L[i] = max(L[j]+1), j > i și V[j] ≥ V[i]

Vom calcula și MAX[i] ca fiind suma tuturor MAX[j] pentru acei indecși j unde relația de maxim este satisfăcută.

Exemplu:

V0841221061419513311715L6453534243323221MAX4722232172312111

Avem, deci, patru secvențe crescătoare de lungime maximală, anume 6. Toate încep cu elementul 0. Două dintre ele continuă cu elementul 4, celelalte două cu elementul 2.

Explicație: elementul curent se poate atașa oricărei secvențe maximale anterior găsite. Dacă o secvență anterioară avea k posibilități de formare, atunci și noile secvențe formate vor fi tot în număr de k. Dacă avem mai multe posibilități de secvențe anterioare, toate vor contribui în egală măsură. De aceea le însumăm.

Discuție: problema rucsacului

Discuție despre cum calculăm numărul de soluții posibile în cazul problemei rucsacului: pe baza relației de recurență calculăm numărul de soluții. El se poate "transfera" de la elementul generator. Sau, în caz că ambele moduri de generare duc la același profit vom însuma numărul de soluții.

== Probleme suprapuse (numărare soluții neoptimale) ==
Există unele probleme care nu cer să se determine un optim, ci să se numere soluții. Ele nu se rezolvă prin programare dinamică, deoarece nu se cere optimul. Ele sunt adesea confundate cu probleme de programare dinamică.

În realitate ele sunt probleme de numărare, folosind structura de probleme suprapuse.

Să luăm câteva exemple.

Rucsac

Atenție: veți avea această problemă la temă.

Problema rucsac cere să se calculeze câte subsecvențe distincte (necontigue) au suma egală cu un număr dat.

Problema este echivalentă cu cea a rucsacului: numerele de la intrare reprezintă atât greutatea cât și valoarea obiectelor. Însă trebuie să selectăm obiecte astfel încât suma greutăților să fie exact K, numărul dat.

Exemplu

Fie numerele: 8 3 6 5 2 și numărul dat K = 11.

Vom avea trei subsecvențe distincte a căror sumă este 11:

8 3
3 6 2
6 5

Soluție

Observație importantă:

Nu putem folosi definiția anterioară a problemei, deoarece ea admite soluții care nu "umplu" exact rucsacul. Aceste soluții nu sunt admisibile.

Vom defini problema ușor diferit:

V[i][g] = valoarea maximă ce se poate obține cu primele i greutăți într-un rucsac de mărime g complet umplut. Valoarea va fi zero dacă nu putem umple greutatea g.

În cazul nostru, deoarece valoarea este egală cu greutatea acea valoare va fi chiar greutatea g. Problema se transformă în există un mod de a forma o greutate g cu primele i obiecte? Răspunsul este unu dacă este afirmativ, sau zero dacă nu se poate forma o greutate. Matricea va fi o matrice de zero și unu.

Formula de recurență se modifică și ea, puțin:

\( V[i][g] = \begin{cases} 0, & \mbox{dacă } i = 0 \text{ și } g > 0 \\ 1, & \text{dacă } g = 0 \\ or(V[i-1][g], V[i-1][g-G_{i}]) & \text{în caz contrar}. \end{cases} \)

unde or(x, y) este 1 dacă măcar unul dintre x, y este 1, sau zero în caz contrar.

Pe ultima linie a matricei V vom avea 1 pentru greutățile ce se pot obține.

Acum: cum modificăm soluția să calculeze nu doar dacă o greutate se poate obține, ci în câte moduri distincte?

Vom calcula:

NSOL[i][g] = numărul de moduri în care putem forma greutatea g folosind primele i numere. Acest număr va fi zero dacă greutatea nu se poate obține.

Formula de recurență este aproape identică cu cea anterioară.

\( NSOL[i][g] = \begin{cases} 0, & \text{dacă } i = 0 \mbox{ și } g > 0 \\ 1, & \text{dacă } g = 0 \\ NSOL[i-1][g] + NSOL[i-1][g-G_{i}] & \text{în caz contrar}. \end{cases} \)

Numărul de moduri în care putem alege numere de sumă K este NSOL[N][K], elementul din colțul din dreapta-jos al matricei NSOL.

Exemplu

Pentru exemplul anterior, avem numerele: 8 3 6 5 2

și numărul dat K = 11.

Vom calcula tabelul:

01234567891011010000000000011000000010002100100001001310010010110141001011021025101102113123

Avem, deci, trei moduri de a obține suma 11.

Analiză

Algoritmul are aceeași complexitate în timp și memorie ca și problema originală, anume O(N·K) timp și O(K) memorie, dacă memorăm doar o linie a matricei.

Cifreco

Atenție: veți avea această problemă la temă.

Problema cifreco a fost dată la ONI 2012 baraj gimnaziu. Deși se poate rezolva cu alte metode, ea are o rezolvare foarte eficientă și simplu de implementat folosind numărarea prin probleme suprapuse.

Problema cere ca, dîndu-se două numere x și y, să se găsească cîte numere există între aceste valori cu proprietățile:

Au N cifre, tot atîtea cifre cîte au și numerele x și y.

Suma cifrelor lor este N+8 (la fel ca și x și y).

Soluție

Să ne propunem mai întîi să rezolvăm o problemă mai simplă: cîte numere de N cifre au suma cifrelor N+8? Cu alte cuvinte nu vom ține cont de valorile x și y.

Descompunerea în subprobleme suprapuse nu este foarte evidentă. Vom introduce o dimensiune auxiliară: vom varia suma cifrelor. Astfel, definim:

NSOL[N][S] = numărul de numere de N cifre a căror sumă este S.

Ce formulă de recurență avem?

Cum se poate forma un număr de N cifre? Punînd pe prima poziție toate cifrele permise și apoi formând un număr cu N-1 cifre. Vom avea, deci:

NSOL[N][S] = NSOL[N-1][S-1] + NSOL[N-1][S-2] + ... + NSOL[N-1][N-1]

Astfel:

Primul termen este numărul de numere care încep cu 1

Al doilea termen este numărul de numere care încep cu 2

...

Ultimul termen este numărul de numere care încep cu S - N + 1, aceasta fiind cea mai mare cifră pentru care cifrele rămase mai pot forma suma N-1.

Am putea să pornim la implementare. Însă mai putem face o optimizare. Să observăm că, conform definiției:

NSOL[N][S-1] = NSOL[N-1][S-2] + ... + NSOL[N-1][N-1]

De aici rezultă o formulă mai simplă de calcul pentru NSOL[N][S]:

NSOL[N][S] = NSOL[N-1][S-1] + NSOL[N][S-1]

Vom completa acest tabel pentru valori maxime. Astfel vom putea răspunde în O(1) la întrebări de forma:

Câte numere de N cifre au suma S?

Acum revenim la problema noastră. Trebuie să calculăm câte numere de N cifre au suma N+8 între x și y. Cum o rezolvăm?

Ne propunem să calculăm câte numere sunt mai mici sau egale cu k. Fie, de exemplu, k = 623. Vom proceda astfel:

Vom calcula câte numere încep cu 1 și au suma cifrelor 11. Ele sunt toate mai mici strict ca 623. Vom folosi NSOL[2][10].

Vom calcula câte numere încep cu 2 și au suma cifrelor 11. Vom folosi NSOL[2][9].

...

Vom calcula câte numere încep cu 5 și au suma cifrelor 11. Vom folosi NSOL[2][6].

În acest moment ne-au rămas doar numere care încep cu 6. Câte vor fi ele? Atâtea câte numere există mai mici ca 23, a căror sumă a cifrelor să fie 5. Reluăm, deci, problema de mai sus cu alți parametri, continuând să adunăm.

Putem acum calcula:

NN(k) = numărul de numere mai mici sau egale cu un număr k.

Pentru a răspunde la problemă vom calcula:

NN(x, y) = NN(y) - NN(x) + 1

Ce complexitate are această soluție?

Calculul tabelului este O(N·Σ) - un număr foarte mic, circa 162. Mărimea tabelului va fi aceeași.

Calculul răspunsului necesită o plimbare prin cifre, efectuată pentru fiecare cifră a numărului x sau y. Este, deci O(suma cifrelor) = O(N) - un număr și mai mic, circa 54.

Aveți această problemă la temă.

Atenție! Calculul numărului de numere mai mici sau egale cu k se poate face mai ușor pornind de la cea mai din dreapta cifră, în loc de cea mai din stânga. Ideea este aceeași, doar ordinea de calcul se inversează.

Șir2

Problema șir2 este o problemă tipică de numărare folosind probleme suprapuse. Ne vom ocupa doar de al doilea subpunct care cere să se calculeze în câte feluri se poate scrie un număr N ca sumă de M numere nenule. Ordinea termenilor contează.

Vom avea o recurență similară cu cea de la cifreco:

NSOL[M][S] = numărul de secvențe de numere nenule de lungime M a căror sumă este S.

Recurența nu este foarte grea. Similar cu cifreco avem:

NSOL[M][S] = NSOL[M-1][S-1] + NSOL[M-1][S-2] + ... + NSOL[M-1][M-1]

Astfel:

Primul termen este numărul de secvențe care încep cu 1.

Al doilea termen este numărul de secvențe care încep cu 2.

...

Ultimul termen este numărul de secvențe care încep cu S-M+1, aceasta fiind cel mai mare număr pentru care cifrele rămase mai pot forma suma M.

La fel ca la cifreco, putem reduce această recurență la una mai simplă:

NSOL[M][S] = NSOL[M-1][S-1] + NSOL[M][S-1]

Soluția problemei va fi elementul NSOL[M][N].

Observații:

Aveți grijă la calcule, ele trebuie făcute modulo 104729.

Din toate elementele unei sume putem scădea 1. Obținem un șir de elemente naturale, posibil nule, a căror sumă echivalentă trebuie micșorată cu M.

Astfel, problema se simplifică dacă:

Considerați că numerele pot fi nule

Reduceți suma cerută, N, înlocuind-o cu N-M.

Numărul de posibilități rămâne același, dar tabelul se simplifică.

Ce complexitate are acest algoritm?

El este O(M·(N-M)) ca timp și memorie.

== Tema 26 - cercul de informatică pentru performanță clasa a șaptea ==
Tema 26 presupune să se rezolve următoarele probleme (program C trimis la NerdArena):

rucsac1 ca aplicație la problema rucsacului.

șiruri2 ca aplicație la distanța edit.

rucsac ca aplicație de numărare cu probleme suprapuse

cifreco dată la ONI 2012 baraj gimnaziu, ca aplicație de numărare cu probleme suprapuse

Tema opțională

Tema 26 opțională presupune să rezolvați următoarele probleme (program C trimis la NerdArena):

pdm ca aplicație la înmulțirea optimală de matrice

cutii problemă simpatică

Clasa a 7-a Lecția 25: Programare dinamică (2)

2025-06-10T11:33:56Z

Mihai:

== Înregistrare video lecție ==

{{#ev:youtube|https://youtu.be/z4433kBdq2A|||||start=5580&end=9780&loop=1}}

== Problema rucsacului ==

'''Atenție:''' veți avea la temă ca aplicație problema [https://www.nerdarena.ro/problema/rucsac1 Rucsac1].

Se dă o mulțime formată din <tt>N</tt> obiecte, fiecare având o greutate și o valoare. Într-un rucsac putem încărca o greutate maxim <tt>G</tt>. Ne dorim să încărcăm rucsacul cu obiecte astfel încât să maximizăm valoarea totală.

Problema este una foarte practică, ne dorim să optimizăm raportul valoare/greutate, încărcând obiecte cât mai valoroase, dar cât mai ușoare.

=== Exemplu ===

Să presupunem că avem următoarele obiecte:

{| class="wikitable"
! Nr. || 1 || 2 || 3 || 4 || 5 || 6
|-
! Greutate
| 3 || 3 || 1 || 1 || 2 || 1
|-
! Valoare
| 7 || 4 || 2 || 9 || 4 || 5
|}

Rucsacul are mărime 10. Care este valoarea maximă a obiectelor ce pot fi încărcate în rucsac?

Singura posibilitate este să alegem obiectele <tt>{ 1, 2, 4, 5, 6 }</tt>. Ele au greutatea totală 10 și valoarea totală 29.

=== Încercarea 1: după obiecte ===

Definirea problemei de programare dinamică nu este evidentă. Voi încerca să arăt un mod de gândire posibil, care implică mai multe posibilități pe care le vom verifica și apoi elimina, ajungând în final la o definire bună a problemei.

Să definim

V[i] = valoarea maximă ce se poate obține cu primele i greutăți, astfel încât greutatea totală să nu depășească G

Are <source lang="C" enclose="none">V[i]</source> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă, <source lang="C" enclose="none">V[i]</source>. Ea va conține unele din primele <tt>i</tt> obiecte. Ultimul obiect este obiectul <tt>k ≤ i</tt>. Atunci este <source lang="C" enclose="none">V[k]</source> optimă?

Nu neapărat! Este posibil să găsim o soluție <source lang="C" enclose="none">V[k]</source> cu valoare mai mare, dar pe care să nu o putem folosi în construcția problemei <source lang="C" enclose="none">V[i]</source> deoarece am depăși greutatea.

'''Concluzie:''' nu putem folosi programarea dinamică cu o astfel de definire a problemei.

=== Încercarea 2: după greutatea totală ===

Să facem o altă încercare. Să definim

V[g] = valoarea maximă ce se poate obține într-un rucsac de mărime g

Are <source lang="C" enclose="none">V[g]</source> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă, <source lang="C" enclose="none">V[g]</source>. Ea va conține unele obiecte, a căror sumă a greutăților nu depășește <tt>g</tt>. Fie ultimul obiect folosit obiectul <tt>k</tt> ce are greutate <tt>Gk</tt>. Este <code>V[g-Gk]</code> optimă?

Răspunsul este: nu, deoarece s-ar putea ca optimul să includă <source lang="C" enclose="none">V[g]</source> (pe care nu avem voie să o folosim de două ori).

'''Concluzie:''' nu putem folosi programarea dinamică nici cu această definire a problemei.

=== Încercarea 3: după obiecte și greutate totală ===

Să încercăm să combinăm cele două încercări de mai sus. Să definim

V[i][g] = valoarea maximă ce se poate obține cu primele i greutăți într-un rucsac de mărime g

Are <source lang="C" enclose="none">V[i][g]</source> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă <source lang="C" enclose="none">V[i][g]</source>. Fie ultimul obiect folosit obiectul <tt>k</tt> ce are greutate <tt>Gk</tt>. Este <code>V[k][g-Gk]</code> optimă? Să presupunem că nu ar fi. Atunci am putea găsi o valoare mai mare, folosind primele <tt>k</tt> obiecte ce vor încăpea în greutatea <tt>g-Gk</tt>. Putem folosi această valoare pentru a obține o valoare mai mare pentru problema originală, <source lang="C" enclose="none">V[i][g]</source>.

'''Concluzie:''' putem folosi programarea dinamică cu această definiție a problemei.

Construim formula de recurență. Pentru a calcula <source lang="C" enclose="none">V[i][g]</source> avem două variante:

* Fie nu folosim greutatea <tt>Gi</tt>, caz în care vom obține valoarea <source lang="C" enclose="none">V[i-1][g]</source> (aceeași greutate, dar folosind primele <tt>i-1</tt> obiecte).
* Fie folosim greutatea <tt>Gi</tt>, caz în care vom obține valoarea <code>V[i-1][g-Gi] + Pi</code> (greutatea este cea care rămâne în rucsac după ce folosim <tt>Gi</tt>, și apoi putem folosi primele <tt>i-1</tt> obiecte).

<math>V[i][g] = \begin{cases} 0, & \text{dacă } i = 0 \text{ sau } g = 0 \\ max(V[i-1][g], V[i-1][g-G_{i}] + P_{i}) & \text{în caz contrar}. \end{cases}</math>

Unde <tt>(Gi, Pi)</tt> sunt greutatea, respectiv valoarea obiectului <tt>i</tt>.

Răspunsul la problemă este elementul <source lang="C" enclose="none">V[N][G]</source>.

==== Exemplu ====

Fie obiectele din exemplul de mai sus:

{| class="wikitable"
! Nr. || 1 || 2 || 3 || 4 || 5 || 6
|-
! Greutate
| 3 || 3 || 1 || 1 || 2 || 1
|-
! Valoare
| 7 || 4 || 2 || 9 || 4 || 5
|}

Vom completa, pe linii, următorul tabel:

{| class="wikitable"
! Obiect !! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9 !! 10
|-
!0
|0||0||0||0||0||0||0||0||0||0||0
|-
!1
|0||0||0||7||7||7||7||7||7||7||7
|-
!2
|0||0||0||7||7||7||11||11||11||11||11
|-
!3
|0||2||2||7||9||9||11||13||13||13||13
|-
!4
|0||9||11||11||16||18||18||20||22||22||22
|-
!5
|0||9||11||13||16||18||20||22||22||24||26
|-
!6
|0||9||14||16||18||21||23||25||27||27||29
|}

==== Analiză ====

Acest algoritm are complexitate ''O(N·G)''. Memoria folosită este ''O(G)'' dacă memorăm doar o linie din matrice. Dacă dorim să aflăm și o soluție maximală (obiectele din componența soluției), nu doar mărimea ei, vom avea nevoie de memorie ''O(N·G)'', precum vom vedea mai jos.

Există un algoritm care reduce necesarul de memorie la ''O(G)''.

==== Reconstrucția soluției ====

Dorim să aflăm nu doar valoarea maximă, ci și obiectele selectate. Cum procedăm?

Pentru a putea reconstrui soluția vom memora în fiecare căsuță, direcția din care provine ea, adică din care am calculat acel maxim. Direcția poate fi spre stânga-sus sau spre în sus. Apoi vom porni din elementul <source lang="C" enclose="none">v[]</source>V[N][G]</source> și vom urma aceste direcții până ce ieșim din matrice. De fiecare dată când urmăm o diagonală reținem obiectul selectat, care este chiar rândul curent. Astfel, descoperirea obiectelor se face în ordine inversă.

=== Distanța edit (Levenshtein) ===

'''Atenție:''' veți avea această problemă la temă.

Se dau două șiruri de caractere, <tt>X</tt> și <tt>Y</tt>. Putem efectua trei operațiuni asupra șirului <tt>X</tt>:

* Inserare caracter la orice poziție
* Ștergere caracter la orice poziție
* Suprascriere - înlocuire a unui caracter cu un alt caracter

Care este numărul minim de operații asupra șirului <tt>X</tt> care îl transformă în șirul <tt>Y</tt>?

'''Definim [https://en.wikipedia.org/wiki/Edit_distance distanța edit] ca fiind acest număr minim de operații'''. Deoarece operațiile sunt unele frecvente într-un editor de texte, de aici vine și denumirea de distanță edit.

==== Exemplu ====

Acest exemplu este inspirat de la wikipedia.

Fie șirurile:

X: KITTEN
Y: SITTING

Numărul minim de operații pentru a transforma X în Y este 3. De exemplu:

# Înlocuim K cu S: KITTEN → SITTEN
# Înlocuim E cu I: SITTEN → SITTIN
# Adăugăm la final un G: SITTIN → SITTING

==== Soluție ====

Problema este aproape identică cu subsecvența maximală comună a două șiruri. Vom defini:

D(i, j) = numărul minim de operații ce transformă șirul X[1..i]] în șirul Y[1..j]

Nu voi face demonstrația optimalității subproblemelor, deoarece este similară cu ce de la subsecvența maximală comună a două șiruri.

Obținem relația de recurență:

\( \operatorname{D}_{X,Y}(i,j) = \begin{cases} \max(i,j) & \text{ dacă } \min(i,j)=0, \\ \min \begin{cases} \operatorname{D}_{X,Y}(i-1,j) + 1 \\ \operatorname{D}_{X,Y}(i,j-1) + 1 \\ \operatorname{D}_{X,Y}(i-1,j-1) + X_i \neq Y_j \end{cases} & \text{ în caz contrar.} \end{cases} \)

Distanța edit între cele două șiruri este D(m, n).

==== Analiză ====

Acest algoritm are complexitate O(m·n), unde m și n sunt lungimile șirurilor. Memoria folosită este O(min(m, n)) dacă memorăm doar o linie din matrice. Dacă dorim să aflăm și operațiile efectuate, nu doar numărul lor, vom avea nevoie de memorie O(m·n), precum vom vedea mai jos.

Există un algoritm care reduce necesarul de memorie la O(min(m, n)) chiar și cu reconstrucția soluției.

==== Reconstrucția soluției ====

Dorim să aflăm nu doar distanța dintre cele două șiruri, ci și o secvență de operații. Cum procedăm? În mod similar cu subsecvența maximală comună.

Pentru a putea reconstrui soluția vom memora în fiecare căsuță din matrice direcția din care provine ea, adică din care am calculat acel maxim. Direcția poate fi spre stânga, spre sus, sau în diagonală stânga-sus. Apoi vom porni din elementul D[m][n] și vom urma aceste direcții până ce ieșim din matrice. Astfel:

Direcția spre stânga înseamnă o inserare de caracter.

Direcție spre sus înseamnă o ștergere de caracter.

Direcția diagonală înseamnă:

O suprascriere dacă caracterele respective sunt diferite.

Nimic (nici o operație) dacă caracterele sunt egale.

==== Înmulțirea optimală a unui șir de matrice ====

Se dă un produs matricial de N matrice. Înmulțirea matricelor este asociativă, deci nu contează în ce ordine efectuăm înmulțirile. Dar numărul de operații elementare va diferi în funcție de ordine. Să se găsească o ordine de înmulțire care minimizează numărul de înmulțiri elementare.

Vom discuta pe scurt această problemă, deoarece matematica necesară depășește nivelul clasei a șaptea.

Cei interesați pot rezolva problema:

pdm ca aplicație.

== Numărare optime prin programarea dinamică ==

Câte soluții distincte posibile admite o problemă de programare dinamică?

Orice problemă de programare dinamică admite un optim. Soluția optimă nu este, de obicei, unică. Putem, deci, pune întrebarea:

Care este numărul de soluții optime ale unei probleme de programare dinamică?

Răspunsul se poate da foarte ușor, folosind același tabel cu care calculăm subproblemele. Vom memora, pe lîngă valoarea maximă (sau minimă) și numărul de moduri în care se poate ajunge la ea.

Exemplu: subsecvența crescătoare de lungime maximă

Să luăm exemplul de data trecută: 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15

Avem formula de recurență: L[i] = max(L[j]+1), j > i și V[j] ≥ V[i]

Vom calcula și MAX[i] ca fiind suma tuturor MAX[j] pentru acei indecși j unde relația de maxim este satisfăcută.

Exemplu:

V0841221061419513311715L6453534243323221MAX4722232172312111

Avem, deci, patru secvențe crescătoare de lungime maximală, anume 6. Toate încep cu elementul 0. Două dintre ele continuă cu elementul 4, celelalte două cu elementul 2.

Explicație: elementul curent se poate atașa oricărei secvențe maximale anterior găsite. Dacă o secvență anterioară avea k posibilități de formare, atunci și noile secvențe formate vor fi tot în număr de k. Dacă avem mai multe posibilități de secvențe anterioare, toate vor contribui în egală măsură. De aceea le însumăm.

Discuție: problema rucsacului

Discuție despre cum calculăm numărul de soluții posibile în cazul problemei rucsacului: pe baza relației de recurență calculăm numărul de soluții. El se poate "transfera" de la elementul generator. Sau, în caz că ambele moduri de generare duc la același profit vom însuma numărul de soluții.

== Probleme suprapuse (numărare soluții neoptimale) ==
Există unele probleme care nu cer să se determine un optim, ci să se numere soluții. Ele nu se rezolvă prin programare dinamică, deoarece nu se cere optimul. Ele sunt adesea confundate cu probleme de programare dinamică.

În realitate ele sunt probleme de numărare, folosind structura de probleme suprapuse.

Să luăm câteva exemple.

Rucsac

Atenție: veți avea această problemă la temă.

Problema rucsac cere să se calculeze câte subsecvențe distincte (necontigue) au suma egală cu un număr dat.

Problema este echivalentă cu cea a rucsacului: numerele de la intrare reprezintă atât greutatea cât și valoarea obiectelor. Însă trebuie să selectăm obiecte astfel încât suma greutăților să fie exact K, numărul dat.

Exemplu

Fie numerele: 8 3 6 5 2 și numărul dat K = 11.

Vom avea trei subsecvențe distincte a căror sumă este 11:

8 3
3 6 2
6 5

Soluție

Observație importantă:

Nu putem folosi definiția anterioară a problemei, deoarece ea admite soluții care nu "umplu" exact rucsacul. Aceste soluții nu sunt admisibile.

Vom defini problema ușor diferit:

V[i][g] = valoarea maximă ce se poate obține cu primele i greutăți într-un rucsac de mărime g complet umplut. Valoarea va fi zero dacă nu putem umple greutatea g.

În cazul nostru, deoarece valoarea este egală cu greutatea acea valoare va fi chiar greutatea g. Problema se transformă în există un mod de a forma o greutate g cu primele i obiecte? Răspunsul este unu dacă este afirmativ, sau zero dacă nu se poate forma o greutate. Matricea va fi o matrice de zero și unu.

Formula de recurență se modifică și ea, puțin:

\( V[i][g] = \begin{cases} 0, & \mbox{dacă } i = 0 \text{ și } g > 0 \\ 1, & \text{dacă } g = 0 \\ or(V[i-1][g], V[i-1][g-G_{i}]) & \text{în caz contrar}. \end{cases} \)

unde or(x, y) este 1 dacă măcar unul dintre x, y este 1, sau zero în caz contrar.

Pe ultima linie a matricei V vom avea 1 pentru greutățile ce se pot obține.

Acum: cum modificăm soluția să calculeze nu doar dacă o greutate se poate obține, ci în câte moduri distincte?

Vom calcula:

NSOL[i][g] = numărul de moduri în care putem forma greutatea g folosind primele i numere. Acest număr va fi zero dacă greutatea nu se poate obține.

Formula de recurență este aproape identică cu cea anterioară.

\( NSOL[i][g] = \begin{cases} 0, & \text{dacă } i = 0 \mbox{ și } g > 0 \\ 1, & \text{dacă } g = 0 \\ NSOL[i-1][g] + NSOL[i-1][g-G_{i}] & \text{în caz contrar}. \end{cases} \)

Numărul de moduri în care putem alege numere de sumă K este NSOL[N][K], elementul din colțul din dreapta-jos al matricei NSOL.

Exemplu

Pentru exemplul anterior, avem numerele: 8 3 6 5 2

și numărul dat K = 11.

Vom calcula tabelul:

01234567891011010000000000011000000010002100100001001310010010110141001011021025101102113123

Avem, deci, trei moduri de a obține suma 11.

Analiză

Algoritmul are aceeași complexitate în timp și memorie ca și problema originală, anume O(N·K) timp și O(K) memorie, dacă memorăm doar o linie a matricei.

Cifreco

Atenție: veți avea această problemă la temă.

Problema cifreco a fost dată la ONI 2012 baraj gimnaziu. Deși se poate rezolva cu alte metode, ea are o rezolvare foarte eficientă și simplu de implementat folosind numărarea prin probleme suprapuse.

Problema cere ca, dîndu-se două numere x și y, să se găsească cîte numere există între aceste valori cu proprietățile:

Au N cifre, tot atîtea cifre cîte au și numerele x și y.

Suma cifrelor lor este N+8 (la fel ca și x și y).

Soluție

Să ne propunem mai întîi să rezolvăm o problemă mai simplă: cîte numere de N cifre au suma cifrelor N+8? Cu alte cuvinte nu vom ține cont de valorile x și y.

Descompunerea în subprobleme suprapuse nu este foarte evidentă. Vom introduce o dimensiune auxiliară: vom varia suma cifrelor. Astfel, definim:

NSOL[N][S] = numărul de numere de N cifre a căror sumă este S.

Ce formulă de recurență avem?

Cum se poate forma un număr de N cifre? Punînd pe prima poziție toate cifrele permise și apoi formând un număr cu N-1 cifre. Vom avea, deci:

NSOL[N][S] = NSOL[N-1][S-1] + NSOL[N-1][S-2] + ... + NSOL[N-1][N-1]

Astfel:

Primul termen este numărul de numere care încep cu 1

Al doilea termen este numărul de numere care încep cu 2

...

Ultimul termen este numărul de numere care încep cu S - N + 1, aceasta fiind cea mai mare cifră pentru care cifrele rămase mai pot forma suma N-1.

Am putea să pornim la implementare. Însă mai putem face o optimizare. Să observăm că, conform definiției:

NSOL[N][S-1] = NSOL[N-1][S-2] + ... + NSOL[N-1][N-1]

De aici rezultă o formulă mai simplă de calcul pentru NSOL[N][S]:

NSOL[N][S] = NSOL[N-1][S-1] + NSOL[N][S-1]

Vom completa acest tabel pentru valori maxime. Astfel vom putea răspunde în O(1) la întrebări de forma:

Câte numere de N cifre au suma S?

Acum revenim la problema noastră. Trebuie să calculăm câte numere de N cifre au suma N+8 între x și y. Cum o rezolvăm?

Ne propunem să calculăm câte numere sunt mai mici sau egale cu k. Fie, de exemplu, k = 623. Vom proceda astfel:

Vom calcula câte numere încep cu 1 și au suma cifrelor 11. Ele sunt toate mai mici strict ca 623. Vom folosi NSOL[2][10].

Vom calcula câte numere încep cu 2 și au suma cifrelor 11. Vom folosi NSOL[2][9].

...

Vom calcula câte numere încep cu 5 și au suma cifrelor 11. Vom folosi NSOL[2][6].

În acest moment ne-au rămas doar numere care încep cu 6. Câte vor fi ele? Atâtea câte numere există mai mici ca 23, a căror sumă a cifrelor să fie 5. Reluăm, deci, problema de mai sus cu alți parametri, continuând să adunăm.

Putem acum calcula:

NN(k) = numărul de numere mai mici sau egale cu un număr k.

Pentru a răspunde la problemă vom calcula:

NN(x, y) = NN(y) - NN(x) + 1

Ce complexitate are această soluție?

Calculul tabelului este O(N·Σ) - un număr foarte mic, circa 162. Mărimea tabelului va fi aceeași.

Calculul răspunsului necesită o plimbare prin cifre, efectuată pentru fiecare cifră a numărului x sau y. Este, deci O(suma cifrelor) = O(N) - un număr și mai mic, circa 54.

Aveți această problemă la temă.

Atenție! Calculul numărului de numere mai mici sau egale cu k se poate face mai ușor pornind de la cea mai din dreapta cifră, în loc de cea mai din stânga. Ideea este aceeași, doar ordinea de calcul se inversează.

Șir2

Problema șir2 este o problemă tipică de numărare folosind probleme suprapuse. Ne vom ocupa doar de al doilea subpunct care cere să se calculeze în câte feluri se poate scrie un număr N ca sumă de M numere nenule. Ordinea termenilor contează.

Vom avea o recurență similară cu cea de la cifreco:

NSOL[M][S] = numărul de secvențe de numere nenule de lungime M a căror sumă este S.

Recurența nu este foarte grea. Similar cu cifreco avem:

NSOL[M][S] = NSOL[M-1][S-1] + NSOL[M-1][S-2] + ... + NSOL[M-1][M-1]

Astfel:

Primul termen este numărul de secvențe care încep cu 1.

Al doilea termen este numărul de secvențe care încep cu 2.

...

Ultimul termen este numărul de secvențe care încep cu S-M+1, aceasta fiind cel mai mare număr pentru care cifrele rămase mai pot forma suma M.

La fel ca la cifreco, putem reduce această recurență la una mai simplă:

NSOL[M][S] = NSOL[M-1][S-1] + NSOL[M][S-1]

Soluția problemei va fi elementul NSOL[M][N].

Observații:

Aveți grijă la calcule, ele trebuie făcute modulo 104729.

Din toate elementele unei sume putem scădea 1. Obținem un șir de elemente naturale, posibil nule, a căror sumă echivalentă trebuie micșorată cu M.

Astfel, problema se simplifică dacă:

Considerați că numerele pot fi nule

Reduceți suma cerută, N, înlocuind-o cu N-M.

Numărul de posibilități rămâne același, dar tabelul se simplifică.

Ce complexitate are acest algoritm?

El este O(M·(N-M)) ca timp și memorie.

== Tema 26 - cercul de informatică pentru performanță clasa a șaptea ==
Tema 26 presupune să se rezolve următoarele probleme (program C trimis la NerdArena):

rucsac1 ca aplicație la problema rucsacului.

șiruri2 ca aplicație la distanța edit.

rucsac ca aplicație de numărare cu probleme suprapuse

cifreco dată la ONI 2012 baraj gimnaziu, ca aplicație de numărare cu probleme suprapuse

Tema opțională

Tema 26 opțională presupune să rezolvați următoarele probleme (program C trimis la NerdArena):

pdm ca aplicație la înmulțirea optimală de matrice

cutii problemă simpatică

Clasa a 7-a Lecția 25: Programare dinamică (2)

2025-06-10T11:33:05Z

Mihai:

== Înregistrare video lecție ==

{{#ev:youtube|https://youtu.be/z4433kBdq2A|||||start=5580&end=9780&loop=1}}

== Problema rucsacului ==

'''Atenție:''' veți avea la temă ca aplicație problema [https://www.nerdarena.ro/problema/rucsac1 Rucsac1].

Se dă o mulțime formată din <tt>N</tt> obiecte, fiecare având o greutate și o valoare. Într-un rucsac putem încărca o greutate maxim <tt>G</tt>. Ne dorim să încărcăm rucsacul cu obiecte astfel încât să maximizăm valoarea totală.

Problema este una foarte practică, ne dorim să optimizăm raportul valoare/greutate, încărcând obiecte cât mai valoroase, dar cât mai ușoare.

=== Exemplu ===

Să presupunem că avem următoarele obiecte:

{| class="wikitable"
! Nr. || 1 || 2 || 3 || 4 || 5 || 6
|-
! Greutate
| 3 || 3 || 1 || 1 || 2 || 1
|-
! Valoare
| 7 || 4 || 2 || 9 || 4 || 5
|}

Rucsacul are mărime 10. Care este valoarea maximă a obiectelor ce pot fi încărcate în rucsac?

Singura posibilitate este să alegem obiectele <tt>{ 1, 2, 4, 5, 6 }</tt>. Ele au greutatea totală 10 și valoarea totală 29.

=== Încercarea 1: după obiecte ===

Definirea problemei de programare dinamică nu este evidentă. Voi încerca să arăt un mod de gândire posibil, care implică mai multe posibilități pe care le vom verifica și apoi elimina, ajungând în final la o definire bună a problemei.

Să definim

V[i] = valoarea maximă ce se poate obține cu primele i greutăți, astfel încât greutatea totală să nu depășească G

Are <source lang="C" enclose="none">V[i]</source> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă, <source lang="C" enclose="none">V[i]</source>. Ea va conține unele din primele <tt>i</tt> obiecte. Ultimul obiect este obiectul <tt>k ≤ i</tt>. Atunci este <source lang="C" enclose="none">V[k]</source> optimă?

Nu neapărat! Este posibil să găsim o soluție <source lang="C" enclose="none">V[k]</source> cu valoare mai mare, dar pe care să nu o putem folosi în construcția problemei <source lang="C" enclose="none">V[i]</source> deoarece am depăși greutatea.

'''Concluzie:''' nu putem folosi programarea dinamică cu o astfel de definire a problemei.

=== Încercarea 2: după greutatea totală ===

Să facem o altă încercare. Să definim

V[g] = valoarea maximă ce se poate obține într-un rucsac de mărime g

Are <source lang="C" enclose="none">V[g]</source> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă, <source lang="C" enclose="none">V[g]</source>. Ea va conține unele obiecte, a căror sumă a greutăților nu depășește <tt>g</tt>. Fie ultimul obiect folosit obiectul <tt>k</tt> ce are greutate <tt>Gk</tt>. Este <code>V[g-Gk]</code> optimă?

Răspunsul este: nu, deoarece s-ar putea ca optimul să includă <source lang="C" enclose="none">V[g]</source> (pe care nu avem voie să o folosim de două ori).

'''Concluzie:''' nu putem folosi programarea dinamică nici cu această definire a problemei.

=== Încercarea 3: după obiecte și greutate totală ===

Să încercăm să combinăm cele două încercări de mai sus. Să definim

V[i][g] = valoarea maximă ce se poate obține cu primele i greutăți într-un rucsac de mărime g

Are <source lang="C" enclose="none">V[i][g]</source> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă <source lang="C" enclose="none">V[i][g]</source>. Fie ultimul obiect folosit obiectul <tt>k</tt> ce are greutate <tt>Gk</tt>. Este <code>V[k][g-Gk]</code> optimă? Să presupunem că nu ar fi. Atunci am putea găsi o valoare mai mare, folosind primele <tt>k</tt> obiecte ce vor încăpea în greutatea <tt>g-Gk</tt>. Putem folosi această valoare pentru a obține o valoare mai mare pentru problema originală, <source lang="C" enclose="none">V[i][g]</tt>.

'''Concluzie:''' putem folosi programarea dinamică cu această definiție a problemei.

Construim formula de recurență. Pentru a calcula <source lang="C" enclose="none">V[i][g]</source> avem două variante:

* Fie nu folosim greutatea <tt>Gi</tt>, caz în care vom obține valoarea <source lang="C" enclose="none">V[i-1][g]</source> (aceeași greutate, dar folosind primele <tt>i-1</tt> obiecte).
* Fie folosim greutatea <tt>Gi</tt>, caz în care vom obține valoarea <source lang="C" enclose="none">V[i-1][g-Gi] + Pi</source> (greutatea este cea care rămâne în rucsac după ce folosim <tt>Gi</tt>, și apoi putem folosi primele <tt>i-1</tt> obiecte).

<math>V[i][g] = \begin{cases} 0, & \text{dacă } i = 0 \text{ sau } g = 0 \\ max(V[i-1][g], V[i-1][g-G_{i}] + P_{i}) & \text{în caz contrar}. \end{cases}</math>

Unde <tt>(Gi, Pi)</tt> sunt greutatea, respectiv valoarea obiectului <tt>i</tt>.

Răspunsul la problemă este elementul <source lang="C" enclose="none">V[N][G]</source>.

==== Exemplu ====

Fie obiectele din exemplul de mai sus:

{| class="wikitable"
! Nr. || 1 || 2 || 3 || 4 || 5 || 6
|-
! Greutate
| 3 || 3 || 1 || 1 || 2 || 1
|-
! Valoare
| 7 || 4 || 2 || 9 || 4 || 5
|}

Vom completa, pe linii, următorul tabel:

{| class="wikitable"
! Obiect !! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9 !! 10
|-
!0
|0||0||0||0||0||0||0||0||0||0||0
|-
!1
|0||0||0||7||7||7||7||7||7||7||7
|-
!2
|0||0||0||7||7||7||11||11||11||11||11
|-
!3
|0||2||2||7||9||9||11||13||13||13||13
|-
!4
|0||9||11||11||16||18||18||20||22||22||22
|-
!5
|0||9||11||13||16||18||20||22||22||24||26
|-
!6
|0||9||14||16||18||21||23||25||27||27||29
|}

==== Analiză ====

Acest algoritm are complexitate ''O(N·G)''. Memoria folosită este ''O(G)'' dacă memorăm doar o linie din matrice. Dacă dorim să aflăm și o soluție maximală (obiectele din componența soluției), nu doar mărimea ei, vom avea nevoie de memorie ''O(N·G)'', precum vom vedea mai jos.

Există un algoritm care reduce necesarul de memorie la ''O(G)''.

==== Reconstrucția soluției ====

Dorim să aflăm nu doar valoarea maximă, ci și obiectele selectate. Cum procedăm?

Pentru a putea reconstrui soluția vom memora în fiecare căsuță, direcția din care provine ea, adică din care am calculat acel maxim. Direcția poate fi spre stânga-sus sau spre în sus. Apoi vom porni din elementul <source lang="C" enclose="none">v[]</source>V[N][G]</source> și vom urma aceste direcții până ce ieșim din matrice. De fiecare dată când urmăm o diagonală reținem obiectul selectat, care este chiar rândul curent. Astfel, descoperirea obiectelor se face în ordine inversă.

=== Distanța edit (Levenshtein) ===

'''Atenție:''' veți avea această problemă la temă.

Se dau două șiruri de caractere, <tt>X</tt> și <tt>Y</tt>. Putem efectua trei operațiuni asupra șirului <tt>X</tt>:

* Inserare caracter la orice poziție
* Ștergere caracter la orice poziție
* Suprascriere - înlocuire a unui caracter cu un alt caracter

Care este numărul minim de operații asupra șirului <tt>X</tt> care îl transformă în șirul <tt>Y</tt>?

'''Definim [https://en.wikipedia.org/wiki/Edit_distance distanța edit] ca fiind acest număr minim de operații'''. Deoarece operațiile sunt unele frecvente într-un editor de texte, de aici vine și denumirea de distanță edit.

==== Exemplu ====

Acest exemplu este inspirat de la wikipedia.

Fie șirurile:

X: KITTEN
Y: SITTING

Numărul minim de operații pentru a transforma X în Y este 3. De exemplu:

# Înlocuim K cu S: KITTEN → SITTEN
# Înlocuim E cu I: SITTEN → SITTIN
# Adăugăm la final un G: SITTIN → SITTING

==== Soluție ====

Problema este aproape identică cu subsecvența maximală comună a două șiruri. Vom defini:

D(i, j) = numărul minim de operații ce transformă șirul X[1..i]] în șirul Y[1..j]

Nu voi face demonstrația optimalității subproblemelor, deoarece este similară cu ce de la subsecvența maximală comună a două șiruri.

Obținem relația de recurență:

\( \operatorname{D}_{X,Y}(i,j) = \begin{cases} \max(i,j) & \text{ dacă } \min(i,j)=0, \\ \min \begin{cases} \operatorname{D}_{X,Y}(i-1,j) + 1 \\ \operatorname{D}_{X,Y}(i,j-1) + 1 \\ \operatorname{D}_{X,Y}(i-1,j-1) + X_i \neq Y_j \end{cases} & \text{ în caz contrar.} \end{cases} \)

Distanța edit între cele două șiruri este D(m, n).

==== Analiză ====

Acest algoritm are complexitate O(m·n), unde m și n sunt lungimile șirurilor. Memoria folosită este O(min(m, n)) dacă memorăm doar o linie din matrice. Dacă dorim să aflăm și operațiile efectuate, nu doar numărul lor, vom avea nevoie de memorie O(m·n), precum vom vedea mai jos.

Există un algoritm care reduce necesarul de memorie la O(min(m, n)) chiar și cu reconstrucția soluției.

==== Reconstrucția soluției ====

Dorim să aflăm nu doar distanța dintre cele două șiruri, ci și o secvență de operații. Cum procedăm? În mod similar cu subsecvența maximală comună.

Pentru a putea reconstrui soluția vom memora în fiecare căsuță din matrice direcția din care provine ea, adică din care am calculat acel maxim. Direcția poate fi spre stânga, spre sus, sau în diagonală stânga-sus. Apoi vom porni din elementul D[m][n] și vom urma aceste direcții până ce ieșim din matrice. Astfel:

Direcția spre stânga înseamnă o inserare de caracter.

Direcție spre sus înseamnă o ștergere de caracter.

Direcția diagonală înseamnă:

O suprascriere dacă caracterele respective sunt diferite.

Nimic (nici o operație) dacă caracterele sunt egale.

==== Înmulțirea optimală a unui șir de matrice ====

Se dă un produs matricial de N matrice. Înmulțirea matricelor este asociativă, deci nu contează în ce ordine efectuăm înmulțirile. Dar numărul de operații elementare va diferi în funcție de ordine. Să se găsească o ordine de înmulțire care minimizează numărul de înmulțiri elementare.

Vom discuta pe scurt această problemă, deoarece matematica necesară depășește nivelul clasei a șaptea.

Cei interesați pot rezolva problema:

pdm ca aplicație.

== Numărare optime prin programarea dinamică ==

Câte soluții distincte posibile admite o problemă de programare dinamică?

Orice problemă de programare dinamică admite un optim. Soluția optimă nu este, de obicei, unică. Putem, deci, pune întrebarea:

Care este numărul de soluții optime ale unei probleme de programare dinamică?

Răspunsul se poate da foarte ușor, folosind același tabel cu care calculăm subproblemele. Vom memora, pe lîngă valoarea maximă (sau minimă) și numărul de moduri în care se poate ajunge la ea.

Exemplu: subsecvența crescătoare de lungime maximă

Să luăm exemplul de data trecută: 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15

Avem formula de recurență: L[i] = max(L[j]+1), j > i și V[j] ≥ V[i]

Vom calcula și MAX[i] ca fiind suma tuturor MAX[j] pentru acei indecși j unde relația de maxim este satisfăcută.

Exemplu:

V0841221061419513311715L6453534243323221MAX4722232172312111

Avem, deci, patru secvențe crescătoare de lungime maximală, anume 6. Toate încep cu elementul 0. Două dintre ele continuă cu elementul 4, celelalte două cu elementul 2.

Explicație: elementul curent se poate atașa oricărei secvențe maximale anterior găsite. Dacă o secvență anterioară avea k posibilități de formare, atunci și noile secvențe formate vor fi tot în număr de k. Dacă avem mai multe posibilități de secvențe anterioare, toate vor contribui în egală măsură. De aceea le însumăm.

Discuție: problema rucsacului

Discuție despre cum calculăm numărul de soluții posibile în cazul problemei rucsacului: pe baza relației de recurență calculăm numărul de soluții. El se poate "transfera" de la elementul generator. Sau, în caz că ambele moduri de generare duc la același profit vom însuma numărul de soluții.

== Probleme suprapuse (numărare soluții neoptimale) ==
Există unele probleme care nu cer să se determine un optim, ci să se numere soluții. Ele nu se rezolvă prin programare dinamică, deoarece nu se cere optimul. Ele sunt adesea confundate cu probleme de programare dinamică.

În realitate ele sunt probleme de numărare, folosind structura de probleme suprapuse.

Să luăm câteva exemple.

Rucsac

Atenție: veți avea această problemă la temă.

Problema rucsac cere să se calculeze câte subsecvențe distincte (necontigue) au suma egală cu un număr dat.

Problema este echivalentă cu cea a rucsacului: numerele de la intrare reprezintă atât greutatea cât și valoarea obiectelor. Însă trebuie să selectăm obiecte astfel încât suma greutăților să fie exact K, numărul dat.

Exemplu

Fie numerele: 8 3 6 5 2 și numărul dat K = 11.

Vom avea trei subsecvențe distincte a căror sumă este 11:

8 3
3 6 2
6 5

Soluție

Observație importantă:

Nu putem folosi definiția anterioară a problemei, deoarece ea admite soluții care nu "umplu" exact rucsacul. Aceste soluții nu sunt admisibile.

Vom defini problema ușor diferit:

V[i][g] = valoarea maximă ce se poate obține cu primele i greutăți într-un rucsac de mărime g complet umplut. Valoarea va fi zero dacă nu putem umple greutatea g.

În cazul nostru, deoarece valoarea este egală cu greutatea acea valoare va fi chiar greutatea g. Problema se transformă în există un mod de a forma o greutate g cu primele i obiecte? Răspunsul este unu dacă este afirmativ, sau zero dacă nu se poate forma o greutate. Matricea va fi o matrice de zero și unu.

Formula de recurență se modifică și ea, puțin:

\( V[i][g] = \begin{cases} 0, & \mbox{dacă } i = 0 \text{ și } g > 0 \\ 1, & \text{dacă } g = 0 \\ or(V[i-1][g], V[i-1][g-G_{i}]) & \text{în caz contrar}. \end{cases} \)

unde or(x, y) este 1 dacă măcar unul dintre x, y este 1, sau zero în caz contrar.

Pe ultima linie a matricei V vom avea 1 pentru greutățile ce se pot obține.

Acum: cum modificăm soluția să calculeze nu doar dacă o greutate se poate obține, ci în câte moduri distincte?

Vom calcula:

NSOL[i][g] = numărul de moduri în care putem forma greutatea g folosind primele i numere. Acest număr va fi zero dacă greutatea nu se poate obține.

Formula de recurență este aproape identică cu cea anterioară.

\( NSOL[i][g] = \begin{cases} 0, & \text{dacă } i = 0 \mbox{ și } g > 0 \\ 1, & \text{dacă } g = 0 \\ NSOL[i-1][g] + NSOL[i-1][g-G_{i}] & \text{în caz contrar}. \end{cases} \)

Numărul de moduri în care putem alege numere de sumă K este NSOL[N][K], elementul din colțul din dreapta-jos al matricei NSOL.

Exemplu

Pentru exemplul anterior, avem numerele: 8 3 6 5 2

și numărul dat K = 11.

Vom calcula tabelul:

01234567891011010000000000011000000010002100100001001310010010110141001011021025101102113123

Avem, deci, trei moduri de a obține suma 11.

Analiză

Algoritmul are aceeași complexitate în timp și memorie ca și problema originală, anume O(N·K) timp și O(K) memorie, dacă memorăm doar o linie a matricei.

Cifreco

Atenție: veți avea această problemă la temă.

Problema cifreco a fost dată la ONI 2012 baraj gimnaziu. Deși se poate rezolva cu alte metode, ea are o rezolvare foarte eficientă și simplu de implementat folosind numărarea prin probleme suprapuse.

Problema cere ca, dîndu-se două numere x și y, să se găsească cîte numere există între aceste valori cu proprietățile:

Au N cifre, tot atîtea cifre cîte au și numerele x și y.

Suma cifrelor lor este N+8 (la fel ca și x și y).

Soluție

Să ne propunem mai întîi să rezolvăm o problemă mai simplă: cîte numere de N cifre au suma cifrelor N+8? Cu alte cuvinte nu vom ține cont de valorile x și y.

Descompunerea în subprobleme suprapuse nu este foarte evidentă. Vom introduce o dimensiune auxiliară: vom varia suma cifrelor. Astfel, definim:

NSOL[N][S] = numărul de numere de N cifre a căror sumă este S.

Ce formulă de recurență avem?

Cum se poate forma un număr de N cifre? Punînd pe prima poziție toate cifrele permise și apoi formând un număr cu N-1 cifre. Vom avea, deci:

NSOL[N][S] = NSOL[N-1][S-1] + NSOL[N-1][S-2] + ... + NSOL[N-1][N-1]

Astfel:

Primul termen este numărul de numere care încep cu 1

Al doilea termen este numărul de numere care încep cu 2

...

Ultimul termen este numărul de numere care încep cu S - N + 1, aceasta fiind cea mai mare cifră pentru care cifrele rămase mai pot forma suma N-1.

Am putea să pornim la implementare. Însă mai putem face o optimizare. Să observăm că, conform definiției:

NSOL[N][S-1] = NSOL[N-1][S-2] + ... + NSOL[N-1][N-1]

De aici rezultă o formulă mai simplă de calcul pentru NSOL[N][S]:

NSOL[N][S] = NSOL[N-1][S-1] + NSOL[N][S-1]

Vom completa acest tabel pentru valori maxime. Astfel vom putea răspunde în O(1) la întrebări de forma:

Câte numere de N cifre au suma S?

Acum revenim la problema noastră. Trebuie să calculăm câte numere de N cifre au suma N+8 între x și y. Cum o rezolvăm?

Ne propunem să calculăm câte numere sunt mai mici sau egale cu k. Fie, de exemplu, k = 623. Vom proceda astfel:

Vom calcula câte numere încep cu 1 și au suma cifrelor 11. Ele sunt toate mai mici strict ca 623. Vom folosi NSOL[2][10].

Vom calcula câte numere încep cu 2 și au suma cifrelor 11. Vom folosi NSOL[2][9].

...

Vom calcula câte numere încep cu 5 și au suma cifrelor 11. Vom folosi NSOL[2][6].

În acest moment ne-au rămas doar numere care încep cu 6. Câte vor fi ele? Atâtea câte numere există mai mici ca 23, a căror sumă a cifrelor să fie 5. Reluăm, deci, problema de mai sus cu alți parametri, continuând să adunăm.

Putem acum calcula:

NN(k) = numărul de numere mai mici sau egale cu un număr k.

Pentru a răspunde la problemă vom calcula:

NN(x, y) = NN(y) - NN(x) + 1

Ce complexitate are această soluție?

Calculul tabelului este O(N·Σ) - un număr foarte mic, circa 162. Mărimea tabelului va fi aceeași.

Calculul răspunsului necesită o plimbare prin cifre, efectuată pentru fiecare cifră a numărului x sau y. Este, deci O(suma cifrelor) = O(N) - un număr și mai mic, circa 54.

Aveți această problemă la temă.

Atenție! Calculul numărului de numere mai mici sau egale cu k se poate face mai ușor pornind de la cea mai din dreapta cifră, în loc de cea mai din stânga. Ideea este aceeași, doar ordinea de calcul se inversează.

Șir2

Problema șir2 este o problemă tipică de numărare folosind probleme suprapuse. Ne vom ocupa doar de al doilea subpunct care cere să se calculeze în câte feluri se poate scrie un număr N ca sumă de M numere nenule. Ordinea termenilor contează.

Vom avea o recurență similară cu cea de la cifreco:

NSOL[M][S] = numărul de secvențe de numere nenule de lungime M a căror sumă este S.

Recurența nu este foarte grea. Similar cu cifreco avem:

NSOL[M][S] = NSOL[M-1][S-1] + NSOL[M-1][S-2] + ... + NSOL[M-1][M-1]

Astfel:

Primul termen este numărul de secvențe care încep cu 1.

Al doilea termen este numărul de secvențe care încep cu 2.

...

Ultimul termen este numărul de secvențe care încep cu S-M+1, aceasta fiind cel mai mare număr pentru care cifrele rămase mai pot forma suma M.

La fel ca la cifreco, putem reduce această recurență la una mai simplă:

NSOL[M][S] = NSOL[M-1][S-1] + NSOL[M][S-1]

Soluția problemei va fi elementul NSOL[M][N].

Observații:

Aveți grijă la calcule, ele trebuie făcute modulo 104729.

Din toate elementele unei sume putem scădea 1. Obținem un șir de elemente naturale, posibil nule, a căror sumă echivalentă trebuie micșorată cu M.

Astfel, problema se simplifică dacă:

Considerați că numerele pot fi nule

Reduceți suma cerută, N, înlocuind-o cu N-M.

Numărul de posibilități rămâne același, dar tabelul se simplifică.

Ce complexitate are acest algoritm?

El este O(M·(N-M)) ca timp și memorie.

== Tema 26 - cercul de informatică pentru performanță clasa a șaptea ==
Tema 26 presupune să se rezolve următoarele probleme (program C trimis la NerdArena):

rucsac1 ca aplicație la problema rucsacului.

șiruri2 ca aplicație la distanța edit.

rucsac ca aplicație de numărare cu probleme suprapuse

cifreco dată la ONI 2012 baraj gimnaziu, ca aplicație de numărare cu probleme suprapuse

Tema opțională

Tema 26 opțională presupune să rezolvați următoarele probleme (program C trimis la NerdArena):

pdm ca aplicație la înmulțirea optimală de matrice

cutii problemă simpatică

Clasa a 7-a Lecția 25: Programare dinamică (2)

2025-06-10T11:30:40Z

Mihai: Created page with "== Înregistrare video lecție == {{#ev:youtube|https://youtu.be/z4433kBdq2A|||||start=5580&end=9780&loop=1}} == Problema rucsacului == '''Atenție:''' veți avea la temă ca aplicație problema [https://www.nerdarena.ro/problema/rucsac1 Rucsac1]. Se dă o mulțime formată din <tt>N</tt> obiecte, fiecare având o greutate și o valoare. Într-un rucsac putem încărca o greutate maxim <tt>G</tt>. Ne dorim să încărcăm rucsacul cu obiecte astfel încât să m..."

== Înregistrare video lecție ==

{{#ev:youtube|https://youtu.be/z4433kBdq2A|||||start=5580&end=9780&loop=1}}

== Problema rucsacului ==

'''Atenție:''' veți avea la temă ca aplicație problema [https://www.nerdarena.ro/problema/rucsac1 Rucsac1].

Se dă o mulțime formată din <tt>N</tt> obiecte, fiecare având o greutate și o valoare. Într-un rucsac putem încărca o greutate maxim <tt>G</tt>. Ne dorim să încărcăm rucsacul cu obiecte astfel încât să maximizăm valoarea totală.

Problema este una foarte practică, ne dorim să optimizăm raportul valoare/greutate, încărcând obiecte cât mai valoroase, dar cât mai ușoare.

=== Exemplu ===

Să presupunem că avem următoarele obiecte:

{| class="wikitable"
! Nr. || 1 || 2 || 3 || 4 || 5 || 6
|-
! Greutate
| 3 || 3 || 1 || 1 || 2 || 1
|-
! Valoare
| 7 || 4 || 2 || 9 || 4 || 5
|}

Rucsacul are mărime 10. Care este valoarea maximă a obiectelor ce pot fi încărcate în rucsac?

Singura posibilitate este să alegem obiectele <tt>{ 1, 2, 4, 5, 6 }</tt>. Ele au greutatea totală 10 și valoarea totală 29.

=== Încercarea 1: după obiecte ===

Definirea problemei de programare dinamică nu este evidentă. Voi încerca să arăt un mod de gândire posibil, care implică mai multe posibilități pe care le vom verifica și apoi elimina, ajungând în final la o definire bună a problemei.

Să definim

V[i] = valoarea maximă ce se poate obține cu primele i greutăți, astfel încât greutatea totală să nu depășească G

Are <source lang="C" enclose="none">V[i]</source> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă, <source lang="C" enclose="none">V[i]</source>. Ea va conține unele din primele <tt>i</tt> obiecte. Ultimul obiect este obiectul <tt>k ≤ i</tt>. Atunci este <source lang="C" enclose="none">V[k]</source> optimă?

Nu neapărat! Este posibil să găsim o soluție <source lang="C" enclose="none">V[k]</source> cu valoare mai mare, dar pe care să nu o putem folosi în construcția problemei <source lang="C" enclose="none">V[i]</source> deoarece am depăși greutatea.

'''Concluzie:''' nu putem folosi programarea dinamică cu o astfel de definire a problemei.

=== Încercarea 2: după greutatea totală ===

Să facem o altă încercare. Să definim

V[g] = valoarea maximă ce se poate obține într-un rucsac de mărime g

Are <source lang="C" enclose="none">V[g]</source> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă, <source lang="C" enclose="none">V[g]</source>. Ea va conține unele obiecte, a căror sumă a greutăților nu depășește <tt>g</tt>. Fie ultimul obiect folosit obiectul <tt>k</tt> ce are greutate <tt>Gk</tt>. Este <source lang="C" enclose="none">V[g-Gk]</source> optimă?

Răspunsul este: nu, deoarece s-ar putea ca optimul să includă <source lang="C" enclose="none">V[g]</tt> (pe care nu avem voie să o folosim de două ori).

'''Concluzie:''' nu putem folosi programarea dinamică nici cu această definire a problemei.

=== Încercarea 3: după obiecte și greutate totală ===

Să încercăm să combinăm cele două încercări de mai sus. Să definim

V[i][g] = valoarea maximă ce se poate obține cu primele i greutăți într-un rucsac de mărime g

Are <source lang="C" enclose="none">V[i][g]</source> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă <source lang="C" enclose="none">V[i][g]</source>. Fie ultimul obiect folosit obiectul <tt>k</tt> ce are greutate <tt>Gk</tt>. Este <source lang="C" enclose="none">V[k][g-Gk]</tt> optimă? Să presupunem că nu ar fi. Atunci am putea găsi o valoare mai mare, folosind primele <tt>k</tt> obiecte ce vor încăpea în greutatea <tt>g-Gk</tt>. Putem folosi această valoare pentru a obține o valoare mai mare pentru problema originală, <source lang="C" enclose="none">V[i][g]</tt>.

'''Concluzie:''' putem folosi programarea dinamică cu această definiție a problemei.

Construim formula de recurență. Pentru a calcula <source lang="C" enclose="none">V[i][g]</source> avem două variante:

* Fie nu folosim greutatea <tt>Gi</tt>, caz în care vom obține valoarea <source lang="C" enclose="none">V[i-1][g]</source> (aceeași greutate, dar folosind primele <tt>i-1</tt> obiecte).
* Fie folosim greutatea <tt>Gi</tt>, caz în care vom obține valoarea <source lang="C" enclose="none">V[i-1][g-Gi] + Pi</source> (greutatea este cea care rămâne în rucsac după ce folosim <tt>Gi</tt>, și apoi putem folosi primele <tt>i-1</tt> obiecte).

<math>V[i][g] = \begin{cases} 0, & \text{dacă } i = 0 \text{ sau } g = 0 \\ max(V[i-1][g], V[i-1][g-G_{i}] + P_{i}) & \text{în caz contrar}. \end{cases}</math>

Unde <tt>(Gi, Pi)</tt> sunt greutatea, respectiv valoarea obiectului <tt>i</tt>.

Răspunsul la problemă este elementul <source lang="C" enclose="none">V[N][G]</source>.

==== Exemplu ====

Fie obiectele din exemplul de mai sus:

{| class="wikitable"
! Nr. || 1 || 2 || 3 || 4 || 5 || 6
|-
! Greutate
| 3 || 3 || 1 || 1 || 2 || 1
|-
! Valoare
| 7 || 4 || 2 || 9 || 4 || 5
|}

Vom completa, pe linii, următorul tabel:

{| class="wikitable"
! Obiect !! 0 !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9 !! 10
|-
!0
|0||0||0||0||0||0||0||0||0||0||0
|-
!1
|0||0||0||7||7||7||7||7||7||7||7
|-
!2
|0||0||0||7||7||7||11||11||11||11||11
|-
!3
|0||2||2||7||9||9||11||13||13||13||13
|-
!4
|0||9||11||11||16||18||18||20||22||22||22
|-
!5
|0||9||11||13||16||18||20||22||22||24||26
|-
!6
|0||9||14||16||18||21||23||25||27||27||29
|}

==== Analiză ====

Acest algoritm are complexitate ''O(N·G)''. Memoria folosită este ''O(G)'' dacă memorăm doar o linie din matrice. Dacă dorim să aflăm și o soluție maximală (obiectele din componența soluției), nu doar mărimea ei, vom avea nevoie de memorie ''O(N·G)'', precum vom vedea mai jos.

Există un algoritm care reduce necesarul de memorie la ''O(G)''.

==== Reconstrucția soluției ====

Dorim să aflăm nu doar valoarea maximă, ci și obiectele selectate. Cum procedăm?

Pentru a putea reconstrui soluția vom memora în fiecare căsuță, direcția din care provine ea, adică din care am calculat acel maxim. Direcția poate fi spre stânga-sus sau spre în sus. Apoi vom porni din elementul <source lang="C" enclose="none">v[]</source>V[N][G]</source> și vom urma aceste direcții până ce ieșim din matrice. De fiecare dată când urmăm o diagonală reținem obiectul selectat, care este chiar rândul curent. Astfel, descoperirea obiectelor se face în ordine inversă.

=== Distanța edit (Levenshtein) ===

'''Atenție:''' veți avea această problemă la temă.

Se dau două șiruri de caractere, <tt>X</tt> și <tt>Y</tt>. Putem efectua trei operațiuni asupra șirului <tt>X</tt>:

* Inserare caracter la orice poziție
* Ștergere caracter la orice poziție
* Suprascriere - înlocuire a unui caracter cu un alt caracter

Care este numărul minim de operații asupra șirului <tt>X</tt> care îl transformă în șirul <tt>Y</tt>?

'''Definim [https://en.wikipedia.org/wiki/Edit_distance distanța edit] ca fiind acest număr minim de operații'''. Deoarece operațiile sunt unele frecvente într-un editor de texte, de aici vine și denumirea de distanță edit.

==== Exemplu ====

Acest exemplu este inspirat de la wikipedia.

Fie șirurile:

X: KITTEN
Y: SITTING

Numărul minim de operații pentru a transforma X în Y este 3. De exemplu:

# Înlocuim K cu S: KITTEN → SITTEN
# Înlocuim E cu I: SITTEN → SITTIN
# Adăugăm la final un G: SITTIN → SITTING

==== Soluție ====

Problema este aproape identică cu subsecvența maximală comună a două șiruri. Vom defini:

D(i, j) = numărul minim de operații ce transformă șirul X[1..i]] în șirul Y[1..j]

Nu voi face demonstrația optimalității subproblemelor, deoarece este similară cu ce de la subsecvența maximală comună a două șiruri.

Obținem relația de recurență:

\( \operatorname{D}_{X,Y}(i,j) = \begin{cases} \max(i,j) & \text{ dacă } \min(i,j)=0, \\ \min \begin{cases} \operatorname{D}_{X,Y}(i-1,j) + 1 \\ \operatorname{D}_{X,Y}(i,j-1) + 1 \\ \operatorname{D}_{X,Y}(i-1,j-1) + X_i \neq Y_j \end{cases} & \text{ în caz contrar.} \end{cases} \)

Distanța edit între cele două șiruri este D(m, n).

==== Analiză ====

Acest algoritm are complexitate O(m·n), unde m și n sunt lungimile șirurilor. Memoria folosită este O(min(m, n)) dacă memorăm doar o linie din matrice. Dacă dorim să aflăm și operațiile efectuate, nu doar numărul lor, vom avea nevoie de memorie O(m·n), precum vom vedea mai jos.

Există un algoritm care reduce necesarul de memorie la O(min(m, n)) chiar și cu reconstrucția soluției.

==== Reconstrucția soluției ====

Dorim să aflăm nu doar distanța dintre cele două șiruri, ci și o secvență de operații. Cum procedăm? În mod similar cu subsecvența maximală comună.

Pentru a putea reconstrui soluția vom memora în fiecare căsuță din matrice direcția din care provine ea, adică din care am calculat acel maxim. Direcția poate fi spre stânga, spre sus, sau în diagonală stânga-sus. Apoi vom porni din elementul D[m][n] și vom urma aceste direcții până ce ieșim din matrice. Astfel:

Direcția spre stânga înseamnă o inserare de caracter.

Direcție spre sus înseamnă o ștergere de caracter.

Direcția diagonală înseamnă:

O suprascriere dacă caracterele respective sunt diferite.

Nimic (nici o operație) dacă caracterele sunt egale.

==== Înmulțirea optimală a unui șir de matrice ====

Se dă un produs matricial de N matrice. Înmulțirea matricelor este asociativă, deci nu contează în ce ordine efectuăm înmulțirile. Dar numărul de operații elementare va diferi în funcție de ordine. Să se găsească o ordine de înmulțire care minimizează numărul de înmulțiri elementare.

Vom discuta pe scurt această problemă, deoarece matematica necesară depășește nivelul clasei a șaptea.

Cei interesați pot rezolva problema:

pdm ca aplicație.

== Numărare optime prin programarea dinamică ==

Câte soluții distincte posibile admite o problemă de programare dinamică?

Orice problemă de programare dinamică admite un optim. Soluția optimă nu este, de obicei, unică. Putem, deci, pune întrebarea:

Care este numărul de soluții optime ale unei probleme de programare dinamică?

Răspunsul se poate da foarte ușor, folosind același tabel cu care calculăm subproblemele. Vom memora, pe lîngă valoarea maximă (sau minimă) și numărul de moduri în care se poate ajunge la ea.

Exemplu: subsecvența crescătoare de lungime maximă

Să luăm exemplul de data trecută: 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15

Avem formula de recurență: L[i] = max(L[j]+1), j > i și V[j] ≥ V[i]

Vom calcula și MAX[i] ca fiind suma tuturor MAX[j] pentru acei indecși j unde relația de maxim este satisfăcută.

Exemplu:

V0841221061419513311715L6453534243323221MAX4722232172312111

Avem, deci, patru secvențe crescătoare de lungime maximală, anume 6. Toate încep cu elementul 0. Două dintre ele continuă cu elementul 4, celelalte două cu elementul 2.

Explicație: elementul curent se poate atașa oricărei secvențe maximale anterior găsite. Dacă o secvență anterioară avea k posibilități de formare, atunci și noile secvențe formate vor fi tot în număr de k. Dacă avem mai multe posibilități de secvențe anterioare, toate vor contribui în egală măsură. De aceea le însumăm.

Discuție: problema rucsacului

Discuție despre cum calculăm numărul de soluții posibile în cazul problemei rucsacului: pe baza relației de recurență calculăm numărul de soluții. El se poate "transfera" de la elementul generator. Sau, în caz că ambele moduri de generare duc la același profit vom însuma numărul de soluții.

== Probleme suprapuse (numărare soluții neoptimale) ==
Există unele probleme care nu cer să se determine un optim, ci să se numere soluții. Ele nu se rezolvă prin programare dinamică, deoarece nu se cere optimul. Ele sunt adesea confundate cu probleme de programare dinamică.

În realitate ele sunt probleme de numărare, folosind structura de probleme suprapuse.

Să luăm câteva exemple.

Rucsac

Atenție: veți avea această problemă la temă.

Problema rucsac cere să se calculeze câte subsecvențe distincte (necontigue) au suma egală cu un număr dat.

Problema este echivalentă cu cea a rucsacului: numerele de la intrare reprezintă atât greutatea cât și valoarea obiectelor. Însă trebuie să selectăm obiecte astfel încât suma greutăților să fie exact K, numărul dat.

Exemplu

Fie numerele: 8 3 6 5 2 și numărul dat K = 11.

Vom avea trei subsecvențe distincte a căror sumă este 11:

8 3
3 6 2
6 5

Soluție

Observație importantă:

Nu putem folosi definiția anterioară a problemei, deoarece ea admite soluții care nu "umplu" exact rucsacul. Aceste soluții nu sunt admisibile.

Vom defini problema ușor diferit:

V[i][g] = valoarea maximă ce se poate obține cu primele i greutăți într-un rucsac de mărime g complet umplut. Valoarea va fi zero dacă nu putem umple greutatea g.

În cazul nostru, deoarece valoarea este egală cu greutatea acea valoare va fi chiar greutatea g. Problema se transformă în există un mod de a forma o greutate g cu primele i obiecte? Răspunsul este unu dacă este afirmativ, sau zero dacă nu se poate forma o greutate. Matricea va fi o matrice de zero și unu.

Formula de recurență se modifică și ea, puțin:

\( V[i][g] = \begin{cases} 0, & \mbox{dacă } i = 0 \text{ și } g > 0 \\ 1, & \text{dacă } g = 0 \\ or(V[i-1][g], V[i-1][g-G_{i}]) & \text{în caz contrar}. \end{cases} \)

unde or(x, y) este 1 dacă măcar unul dintre x, y este 1, sau zero în caz contrar.

Pe ultima linie a matricei V vom avea 1 pentru greutățile ce se pot obține.

Acum: cum modificăm soluția să calculeze nu doar dacă o greutate se poate obține, ci în câte moduri distincte?

Vom calcula:

NSOL[i][g] = numărul de moduri în care putem forma greutatea g folosind primele i numere. Acest număr va fi zero dacă greutatea nu se poate obține.

Formula de recurență este aproape identică cu cea anterioară.

\( NSOL[i][g] = \begin{cases} 0, & \text{dacă } i = 0 \mbox{ și } g > 0 \\ 1, & \text{dacă } g = 0 \\ NSOL[i-1][g] + NSOL[i-1][g-G_{i}] & \text{în caz contrar}. \end{cases} \)

Numărul de moduri în care putem alege numere de sumă K este NSOL[N][K], elementul din colțul din dreapta-jos al matricei NSOL.

Exemplu

Pentru exemplul anterior, avem numerele: 8 3 6 5 2

și numărul dat K = 11.

Vom calcula tabelul:

01234567891011010000000000011000000010002100100001001310010010110141001011021025101102113123

Avem, deci, trei moduri de a obține suma 11.

Analiză

Algoritmul are aceeași complexitate în timp și memorie ca și problema originală, anume O(N·K) timp și O(K) memorie, dacă memorăm doar o linie a matricei.

Cifreco

Atenție: veți avea această problemă la temă.

Problema cifreco a fost dată la ONI 2012 baraj gimnaziu. Deși se poate rezolva cu alte metode, ea are o rezolvare foarte eficientă și simplu de implementat folosind numărarea prin probleme suprapuse.

Problema cere ca, dîndu-se două numere x și y, să se găsească cîte numere există între aceste valori cu proprietățile:

Au N cifre, tot atîtea cifre cîte au și numerele x și y.

Suma cifrelor lor este N+8 (la fel ca și x și y).

Soluție

Să ne propunem mai întîi să rezolvăm o problemă mai simplă: cîte numere de N cifre au suma cifrelor N+8? Cu alte cuvinte nu vom ține cont de valorile x și y.

Descompunerea în subprobleme suprapuse nu este foarte evidentă. Vom introduce o dimensiune auxiliară: vom varia suma cifrelor. Astfel, definim:

NSOL[N][S] = numărul de numere de N cifre a căror sumă este S.

Ce formulă de recurență avem?

Cum se poate forma un număr de N cifre? Punînd pe prima poziție toate cifrele permise și apoi formând un număr cu N-1 cifre. Vom avea, deci:

NSOL[N][S] = NSOL[N-1][S-1] + NSOL[N-1][S-2] + ... + NSOL[N-1][N-1]

Astfel:

Primul termen este numărul de numere care încep cu 1

Al doilea termen este numărul de numere care încep cu 2

...

Ultimul termen este numărul de numere care încep cu S - N + 1, aceasta fiind cea mai mare cifră pentru care cifrele rămase mai pot forma suma N-1.

Am putea să pornim la implementare. Însă mai putem face o optimizare. Să observăm că, conform definiției:

NSOL[N][S-1] = NSOL[N-1][S-2] + ... + NSOL[N-1][N-1]

De aici rezultă o formulă mai simplă de calcul pentru NSOL[N][S]:

NSOL[N][S] = NSOL[N-1][S-1] + NSOL[N][S-1]

Vom completa acest tabel pentru valori maxime. Astfel vom putea răspunde în O(1) la întrebări de forma:

Câte numere de N cifre au suma S?

Acum revenim la problema noastră. Trebuie să calculăm câte numere de N cifre au suma N+8 între x și y. Cum o rezolvăm?

Ne propunem să calculăm câte numere sunt mai mici sau egale cu k. Fie, de exemplu, k = 623. Vom proceda astfel:

Vom calcula câte numere încep cu 1 și au suma cifrelor 11. Ele sunt toate mai mici strict ca 623. Vom folosi NSOL[2][10].

Vom calcula câte numere încep cu 2 și au suma cifrelor 11. Vom folosi NSOL[2][9].

...

Vom calcula câte numere încep cu 5 și au suma cifrelor 11. Vom folosi NSOL[2][6].

În acest moment ne-au rămas doar numere care încep cu 6. Câte vor fi ele? Atâtea câte numere există mai mici ca 23, a căror sumă a cifrelor să fie 5. Reluăm, deci, problema de mai sus cu alți parametri, continuând să adunăm.

Putem acum calcula:

NN(k) = numărul de numere mai mici sau egale cu un număr k.

Pentru a răspunde la problemă vom calcula:

NN(x, y) = NN(y) - NN(x) + 1

Ce complexitate are această soluție?

Calculul tabelului este O(N·Σ) - un număr foarte mic, circa 162. Mărimea tabelului va fi aceeași.

Calculul răspunsului necesită o plimbare prin cifre, efectuată pentru fiecare cifră a numărului x sau y. Este, deci O(suma cifrelor) = O(N) - un număr și mai mic, circa 54.

Aveți această problemă la temă.

Atenție! Calculul numărului de numere mai mici sau egale cu k se poate face mai ușor pornind de la cea mai din dreapta cifră, în loc de cea mai din stânga. Ideea este aceeași, doar ordinea de calcul se inversează.

Șir2

Problema șir2 este o problemă tipică de numărare folosind probleme suprapuse. Ne vom ocupa doar de al doilea subpunct care cere să se calculeze în câte feluri se poate scrie un număr N ca sumă de M numere nenule. Ordinea termenilor contează.

Vom avea o recurență similară cu cea de la cifreco:

NSOL[M][S] = numărul de secvențe de numere nenule de lungime M a căror sumă este S.

Recurența nu este foarte grea. Similar cu cifreco avem:

NSOL[M][S] = NSOL[M-1][S-1] + NSOL[M-1][S-2] + ... + NSOL[M-1][M-1]

Astfel:

Primul termen este numărul de secvențe care încep cu 1.

Al doilea termen este numărul de secvențe care încep cu 2.

...

Ultimul termen este numărul de secvențe care încep cu S-M+1, aceasta fiind cel mai mare număr pentru care cifrele rămase mai pot forma suma M.

La fel ca la cifreco, putem reduce această recurență la una mai simplă:

NSOL[M][S] = NSOL[M-1][S-1] + NSOL[M][S-1]

Soluția problemei va fi elementul NSOL[M][N].

Observații:

Aveți grijă la calcule, ele trebuie făcute modulo 104729.

Din toate elementele unei sume putem scădea 1. Obținem un șir de elemente naturale, posibil nule, a căror sumă echivalentă trebuie micșorată cu M.

Astfel, problema se simplifică dacă:

Considerați că numerele pot fi nule

Reduceți suma cerută, N, înlocuind-o cu N-M.

Numărul de posibilități rămâne același, dar tabelul se simplifică.

Ce complexitate are acest algoritm?

El este O(M·(N-M)) ca timp și memorie.

== Tema 26 - cercul de informatică pentru performanță clasa a șaptea ==
Tema 26 presupune să se rezolve următoarele probleme (program C trimis la NerdArena):

rucsac1 ca aplicație la problema rucsacului.

șiruri2 ca aplicație la distanța edit.

rucsac ca aplicație de numărare cu probleme suprapuse

cifreco dată la ONI 2012 baraj gimnaziu, ca aplicație de numărare cu probleme suprapuse

Tema opțională

Tema 26 opțională presupune să rezolvați următoarele probleme (program C trimis la NerdArena):

pdm ca aplicație la înmulțirea optimală de matrice

cutii problemă simpatică

Clasa a 7-a Lecția 29: Discutarea problemelor de la OJI 2024

2025-06-10T10:41:35Z

Mihai:

== Înregistrare video lecție ==

{{#ev:youtube|https://youtu.be/z4433kBdq2A|||||start=1&end=3540&loop=1}}

== Problema Parking ==

Problema [https://www.nerdarena.ro/problema/parking Parking] a fost dată la OJI 2024 Clasa a 7-a.

Când vedem o astfel de problemă primul gând trebuie să fie: oricât de simplă ar fi soluția, chiar și cea mai simplă soluție va fi delicat de implementat și nu va fi scurtă. Este genul de problemă care, la concurs, ia timp. Dacă avem o altă problemă mai simplu de implementat, este bine să lăsăm parking la urmă.

Deoarece enunțul este semi-încâlcit, să clarificăm anumite lucruri:

* O mașină iese într-o serie dacă și numai dacă în direcția aleasă de deplasare nu există nici o altă mașină, până la ieșire.
* Decizia de ieșire sau nu se face static: într-o configurație de mașini toate ''se uită'' către ieșire în același timp. Dacă o văd, adică nu este blocată de o altă mașină, atunci ies.
* Mașinile care pot ieși, ies. Nu ne punem probleme că se pot intersecta cu alte mașini pe drum. Din punctul nostru de vedere este ca și cum ele dispar din parcare subit.

Concluzie: în fiecare serie trebuie să decidem ce mașini ''văd'' o ieșire. Ele vor dispărea din parcare, apoi trecem la următoarea serie.

=== Soluție forță brută ===

Sper că o soluție rezonabilă, ce va lua multe puncte, este accesibilă. O idee imediată este să reprezentăm totul într-o matrice bordată, cu numere diferite pentru vid (nimic), mașină orizontală, mașină verticală sau zid. Apoi vedem ce putem rezolva parcurgând matricea. Pentru o mașină oarecare din matrice vrem să răspundem la întrebările:

* Există ieșire în vreun capăt al liniei/coloanei mele? Putem răspunde în ''O(1)'' la această întrebare, verificând valorile de pe bordură, în cele două capete.
* Există vreo altă mașină între mine și capetele de zid? Și la această întrebare putem răspunde în ''O(1)'', dacă în parcurgerea matricei memorăm numărul de mașini întâlnite pe drum pe acea direcție. Conceptual, cel mai simplu, ne putem imagina că facem patru parcurgeri, câte una pentru fiecare direcție.

Combinănd cele două întrebări putem răspunde la întrebarea dacă o mașină iese sau nu: o mașină iese dacă există ieșire și numărul de mașini din față este zero.

Bun, deci putem calcula mașinile ce ies într-o serie în ''O(n2)''. Le putem apoi șterge din matrice.

Deoarece avem maxim <tt>s = 10 000</tt> serii rezultă un algoritm ''O(n2·s)'' care va efectua circa 10 miliarde de operații. E clar că va depăși timpul pentru teste mari, dar probabil va lua peste 40p dacă îl implementăm eficient. De exemplu observăm că matricea poate fi memorată cu elemente caracter, ceea ce reduce memoria necesară la 1MB, destul de puțin.

=== Soluție ===

Este clar că orice soluție care va parcurge matricea la fiecare serie nu este bună. Mai mult, nu putem nici să parcurgem toate mașinile la fiecare serie. Reducem complexitatea de zece ori, deoarece mașinile sunt de zece ori mai puține decât elementele matricei, dar și un miliard de operații este prea mult. Cu toate acestea, dacă nu ne vine altă idee, e clar că vom lua mai multe teste cu această optimizare.

Pentru o soluție mai bună să observăm următoarele:

* Pe orice ieșire din parcare va ieși cel mult o mașină pe serie.
* Numărul de ieșiri din parcare este ''O(n)''.
* Drept care numărul de mașini ce poate ieși într-o serie este ''O(n)''.

În lumina acestor observații pare foarte risipitor să parcurgem ''O(n2)'' mașini pentru a alege ''O(n)'' dintre ele. Oare nu putem să verificăm doar acele ''O(n)'' mașini care au șanse să iasă?

Ba da, dacă procedăm invers: în loc să ne uităm din mașină către ieșire, ne vom uita dinspre ieșire spre mașini. Mai exact, pentru a determina ce mașini ies într-o serie, folosind matricea anterioară, procedăm astfel: pentru fiecare ieșire posibilă vom parcurge linia sau coloana ei până ce dăm de o mașină sau de un zid.

Ce complexitate are acest algoritm? Din păcate costul unei serii este tot ''O(n2)''. Pare că nu am avansat. Sau poate da?

Ce observăm? Că de la o serie la alta, când ne "uităm" dinspre ieșire, vom vedea fie aceeași mașină ca în seria trecută, fie o mașină mai departe, în spate. Deci nu are sens să repetăm căutarea pornind de la ieșire, din nou. Vom porni de unde am rămas la seria anterioară! Pentru aceasta avem nevoie de patru vectori de indici în linia sau coloana respectivă. Astfel, fiecare ieșire va genera ''O(n)'' calcule pe tot parcursul simulării (analiză amortizată).

''' Detalii importante de implementare: '''

* Nu putem șterge mașinile din matrice imediat ce constatăm că pot ieși. De ce? Deoarece s-ar putea să deschidem drumul unei mașini care nu ar fi ieșit în acea serie.
* Nu putem nici să le numărăm pur și simplu. Aceeași mașină poate ieși atât prin stânga cât și prin dreapta. Mașinile trebuie marcate cumva pentru a nu le contoriza de două ori.
* La final de serie ele trebuie cumva șterse din matrice.

O soluție rezonabilă este ca, atunci când dăm peste o mașină ce poate ieși, să o memorăm într-un vector de perechi linie/coloană și să o marcăm în matrice ca zid. La final de serie numărul de elemente din vector este numărul de mașini care iese. Parcurgem acel vector și zeroizăm elementele de la acea linie și coloană.

Pentru fiecare serie vom avea obligatoriu ''O(n)'' calcule, pentru parcurgerea ieșirilor, în total ''O(n·s)'' operații. La aceste calcule se adaugă cele ''O(n2)'' generate de jocul indicilor (analiza amortizată). Complexitatea totală este, deci, ''O(n·s + n2)'', circa 40 milioane de operații deoarece vom parcurge 4000 de elemente pe bordură. Partea frumoasă este că memoria nu se mărește semnificativ, avem nevoie doar de patru vectori de câte o mie de elemente de tip <source lang="C" enclose="none">short</source>, circa 8KB și de un vector de 4000 de perechi de elemente de tip <source lang="C" enclose="none">short</source>, circa 16KB.

O soluție posibilă în timp de concurs, nefactorizată tocmai pentru simplitatea codului, va avea circa 75 de linii de cod efectiv.

== Problema Ron ==

Problema [https://www.nerdarena.ro/problema/ron Ron] a fost dată la OJI 2024 Clasa a 7-a.

Este o problemă ''două în una'', cele două cerințe neavând nici o legătură una cu alta. Să le enunțăm cât mai simplu:

Dându-se <source lang="C" enclose="none">n</source> maxim 50 000 de intervale cu capete numere până în două miliarde să se determine:

# Numărul maxim de pătrate de numere prime ce se află în interiorul unui interval.
# Numărul de intervale contigue formate de intervale.

Ambele probleme sunt ''de manual''. Nu prea avem ce gândi la ele, implementăm soluția studiată la curs.

=== Soluție cerința 1 ===

O primă idee ar fi să calculăm un ciur al elementelor pătrate de numere prime. Dar acest ciur este prea mare, până în două miliarde.

A doua idee este să calculăm doar ciurul numerelor prime pâna la radical din două miliarde, apoi să extragem numerele prime și să stocăm într-un alt vector pătratele lor. Vom avea circa 45000 de astfel de numere. Apoi, pentru un interval dat, vom căuta binar capetele lui în acest vector. Este clar că această soluție se va încadra în timp, iar memoria necesară este mică.

La acest moment majoritatea se vor apuca de lucru, pe principiul ''n-am gândit aproape deloc, deci e bine''. Și poate au și dreptate, la un concurs. Însă în viața reală ar fi bine să ne întrebăm: oare se poate mai bine?

Desigur, iar implementarea va fi și mult mai lejeră. Ce-ar fi să studiem capetele de interval, folosind bruma de matematică necesară? Oare ce se întâmplă dacă extragem radical din capete? Nu cumva noul interval va acoperi exact aceleași numere prime al căror pătrate sunt acoperite de vechiul interval? Matematica grea este ușoară! Doar ce ușoară este grea 🙂.

Soluția simplă: după calculul ciurului vom calcula sume parțiale pe acel ciur, pentru a putea răspunde repede la întrebări de forma câte numere prime se află într-un interval. Apoi, pentru fiecare interval de la intrare, vom întreba câte numere prime se află între radicalii capetelor.

Ce complexitate are această soluție? ''<math>O(\sqrt{x} \log \log \sqrt{x})</math>'' pentru ciur, unde x este coordonata maximă, 2 miliarde și ''O(n)'' pentru răspunsuri, total <math>(O(\sqrt{x} \log \log \sqrt{x} + n)</math>. Vom avea circa 180 000 de operații pentru ciur și circa 2 milioane pentru întrebări (am considerat că radicalul se calculează în 200 de operații elementare). Deoarece citim circa 1MB de date, este clar că citirea va fi o mare parte din timpul de execuție.

Memoria necesară? Cea pentru sume parțiale pe ciur, <math>O(\sqrt{x})</math>, mai exact 90KB.

=== Soluție cerința 2 ===

Am văzut aici soluții nenecesar de complicate. Printre ele se află și soluția comisiei.

Să considerăm capetele de intervale ca fiind paranteze deschise sau închise. Dacă le vom plasa pe o axă la coordonata corectă, ce vom vedea? Că un interval contiguu va avea tot atâtea paranteze deschise cât și închise. Un interval neacoperit are proprietatea că numărul de parateze deschise de la stânga lui este egal cu cele închise.

Problema este echivalentă cu cea a parantezelor imbricate, făcută prin clasa a cincea, cred: câtă vreme numărul parantezelor deschise și încă neînchise este strict mai mare ca zero, suntem în interiorul unui interval contiguu. În momentul când cele două numere devin egale, se închide un interval contiguu și trebuie să adăugăm unu la soluție.

Avem, deci, un algoritm banal:

# Sortăm capetele de intervale, memorând cumva tipul de capăt, închis sau deschis.
# Pornim cu un contor de paranteze neînchise inițializat cu zero.
# Parcurgem capetele în ordine crescătoare și pentru fiecare paranteză deschisă adunăm 1, pentru fiecare paranteză închisă scădem 1.
# De fiecare dată când contorul devine zero adunăm 1 la rezultat.

Se pune întrebarea ce facem atunci când la aceeași poziție avem și paranteze deschise și închise. Dacă urmărim enunțul, capetele stânga sunt inclusive, cele dreapta exclusive. Ceea ce înseamnă că dacă un interval se termină la poziția <tt>x</tt> și altul începe la poziția <tt>x</tt>, ele vor fi unul în continuarea altuia și segmentul curent se continuă. Pentru a nu trece prin zero cu contorul nostru este necesar să tratăm capetele deschise înaintea celor închise.

Ca detaliu de implementare, pentru a nu sorta perechi, având nevoie de o valoare 0 sau 1, o putem adăuga la capătul de interval: îl înmulțim cu 2 și adunăm valoarea 0/1. Atenție, aceasta înseamnă că putem ajunge la valori de patru miliarde, depășind întregul. <source lang="C" enclose="none">unsigned int</source> to the rescue! 🙂

Ce complexitate are această soluție? E clar că timpul cel mai mare este cel de sortare: ''O(n log n)''. Din nou, numărul de operații fiind de circa 1.7 milioane operații, citirea va fi parte majoră din timpul de execuție.

Iar memoria? Stocăm 2n capete de interval, deci ''O(n)'', mai exact 400KB.

O soluție implementabilă în timp de concurs va avea circa 65 de linii de cod efectiv, din care circa 20 de linii pentru quick sort.

== Tema 29 ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/parking Parking] dată la OJI 2024 clasa a 7-a
* [https://www.nerdarena.ro/problema/ron Ron] dată la OJI 2024 clasa a 7-a

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_29:_Discutarea_problemelor_de_la_OJI_2024 Accesează rezolvarea problemelor de la lecția 29]

Clasa a 7-a Lecția 29: Discutarea problemelor de la OJI 2024

2025-06-10T10:39:02Z

Mihai: Created page with "== Înregistrare video lecție == {{#ev:youtube|https://youtu.be/z4433kBdq2A|||||start=1&end=3540&loop=1}} == Problema Parking == Problema [https://www.nerdarena.ro/problema/parking Parking] a fost dată la OJI 2024 Clasa a 7-a. Când vedem o astfel de problemă primul gând trebuie să fie: oricât de simplă ar fi soluția, chiar și cea mai simplă soluție va fi delicat de implementat și nu va fi scurtă. Este genul de problemă care, la concurs, ia timp. Da..."

Clasa a 7-a Lecția 24: Programare dinamică (1)

2025-06-10T10:04:32Z

Mihai: /* Tema 24 */

== Înregistrare video lecție ==

{{#ev:youtube|https://www.youtube.com/watch?v=a0wFdh8DInQ|||||start=7600&end=11100&loop=1}}

== Conceptul de programare dinamică ==

=== Introducere ===

Wikipedia definește [http://en.wikipedia.org/wiki/Dynamic_programming programarea dinamică] drept o metodă pentru rezolvarea unor probleme complexe prin descompunerea lor în subprobleme mai simple. Se poate aplica problemelor care prezintă proprietățile de ''suprapunere a subproblemelor'' și de ''substructură optimală''. Atunci când se poate aplica, metoda ia mult mai puțin timp decât alte soluții naive.

[[Image:Shortest_path_optimal_substructure.svg|frame|right|300px|Drumul cel mai scurt între două orașe poate fi rezolvat cu programare dinamică]]

''Substructura optimală'' înseamnă că soluția unei problemei de optimizare date poate fi obținută prin combinarea unor soluții optimale ale subproblemelor. Ca atare, primul pas către găsirea unei rezolvări prin această metodă este verificarea dacă problema are proprietatea substructurii optimale.

Drumul cel mai scurt între două orașe poate fi rezolvat cu programare dinamică

Astfel de substructuri optimale sunt în mod uzual descrise prin recurență. De exemplu, date niște orașe și distanțele între ele, drumul cel mai scurt de la orașul <tt>u</tt> la orașul <tt>v</tt> are proprietatea de substructură optimală: să luăm orice oraș intermediar <tt>w</tt> pe drumul cel mai scurt, <tt>d</tt>. Dacă <tt>d</tt> este cu adevărat drumul cel mai scurt, atunci drumul <tt>d1</tt> de la <tt>u</tt> la <tt>w</tt> și <tt>d2</tt> de la <tt>w</tt> la <tt>v</tt> sunt cu adevărat cele mai scurte drumuri între orașele corespunzătoare. Dacă drumul de la <tt>u</tt> la <tt>w</tt> nu ar fi cel mai scurt posibil ar însemna că am avea un alt drum mai scurt, ceea ce ar duce la un drum total <tt>d</tt>, de la <tt>u</tt> la <tt>v</tt>, mai scurt decât cel original. Așadar, putem formula soluția problemei găsirii celui mai scurt drum într-o manieră recursivă, ceea ce fac algoritmii [https://en.wikipedia.org/wiki/Bellman-Ford_algorithm Bellman-Ford] și [https://en.wikipedia.org/wiki/Floyd-Warshall_algorithm Floyd-Warshall].

Suprapunerea subproblemelor înseamnă că ele nu sunt independente, adică subproblemele au în comun alte subprobleme. Nu vom insista pe această proprietate decât atât cât să menționăm că dacă subproblemele nu se suprapun dar prezintă substructură optimală atunci putem aplica tehnica de [https://www.algopedia.ro/wiki/index.php/Clasa_a_7-a_Lec%C8%9Bia_18:_Divide_et_impera,_mergesort,_quicksort programare divide et impera (divide and conquer)]. De aceea [http://en.wikipedia.org/wiki/Quicksort quicksort] și [http://en.wikipedia.org/wiki/Mergesort mergesort] nu sunt clasificate ca probleme de programare dinamică.

=== Metodă ===

Când încercăm să rezolvăm o problemă de programare dinamică întrebarea crucială la care trebuie să răspundem este ''putem calcula soluția finală pe baza unor subprobleme care sunt la rândul lor '''optimale''' ''? Pentru a răspunde la întrebare trebuie mai întâi să formulăm subproblemele. Dar pentru a formula subproblemele trebuie să avem în minte principiul substructurii optimale. Altfel s-ar putea să împărțim problema în subprobleme care nu au substructură optimală.

Să recapitulăm: pentru a putea răspunde la întrebarea dacă o problemă admite o soluție prin programare dinamică trebuie să aflăm dacă are substructură optimală. Dar pentru a afla dacă are substructură optimală trebuie să găsim subproblemele. Pe care încercăm să le găsim folosind programarea dinamică.

Nu cumva ne învârtim în cerc? Așa pare și așa și este, într-o oarecare măsură. Experiența este cea care ne învață cum să căutăm împărțirea în subprobleme astfel încât să obținem proprietatea de optimalitate. Tot experiența este cea care ne ajută să ne dăm seama rapid dacă împărțirea găsită are această proprietate sau nu.

Odată ce demonstrăm că o împărțire în subprobleme se bazează doar pe subprobleme optimale, restul decurge, de obicei, destul de simplu: găsim o formulă de recurență, apoi o implementăm de jos în sus (sau bottom-up), pornind de la cele mai mici probleme, către cele mai mari, până la soluția cerută.

În continuare vom lua câteva exemple.

== Subsecvența crescătoare de lungime maximă ==

Această problemă cere să găsim o subsecvență a unei secvențe de numere în care elementele sunt în ordine crescătoare, iar subsecvența este de lungime maximă. Subsecvența nu este neapărat contiguă, nici unică.

Exemplu

În secvența

0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15

o secvență crescătoare de lungime maximă este

0, 2, 6, 9, 13, 15

Această secvență are lungime șase. Nu există nici o secvență crescătoare de lungime șapte. Cea mai lungă subsecvență crescătoare nu este unică. De exemplu

0, 4, 6, 9, 11, 15

este o altă subsecvență crescătoare de aceeași lungime, în secvența de intrare.

=== Soluție ===

Cum împărțim problema în subprobleme? Să încercăm astfel:

L[i] = lungimea celei mai lungi subsecvențe care începe la poziția i

Are această împărțire proprietatea de optimalitate? Să presupunem că avem o subsecvență optimală crescătoare care trece prin indicii

i1, i2, i3, …, ik

Astfel

L[i1] = k

Este secvența <tt>i2, ..., ik</tt> optimală? Cu alte cuvinte lungimea secvenței optime care începe la <tt>i2</tt> este <tt>k-1</tt>? Răspunsul este da, secvența care începe la i2, anume i2, ..., ik este o secvență maximă, deoarece altfel am putea-o înlocui cu o secvență mai lungă, ceea ce ar duce la o subsecvență <tt>L[i1]</tt> mai lungă decât cea inițială, care era optimală. Obținem o contradicție.

Următorul pas este să găsim relația de recurență:

L[i] = max(L[j]+1), j > i și V[j] ≥ V[i]

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula vectorul <source lang="C" enclose="none">L</source> de la coadă la cap, căutând pentru fiecare element <source lang="C" enclose="none">L[i]</source> cel mai mare element <source lang="C" enclose="none">L[j]</source> de după el <tt>(j > i)</tt> astfel încât <source lang="C" enclose="none">V[j] ≥ V[i]</source>.

Soluția problemei este maximul din vectorul <source lang="C" enclose="none">L</source>.

=== Exemplu ===

Să calculăm cea mai lungă secvență crescătoare în secvența:

0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15

Vom calcula lungimile secvențelor maximale de la coadă la cap: <source lang="C" enclose="none">L[15]</source>, apoi <source lang="C" enclose="none">L[14]</source> și așa mai departe. Când ajungem la calculul lui <tt>L[6]</tt> avem următoarea situație:

[[File:max-increasing-seq.png|frame|none|Exemplu de calcul pentru elementul ''L[6]'' - cea mai lungă secvență crescătoare care începe la poziția 6.]]

Pentru a calcula lungimea secvenței maximale care începe la poziția 6 vom căuta toate pozițiile mai mari <tt>(7, 8, 9, ...)</tt>. Le vom lua în considerare doar pe acelea în care <source lang="C" enclose="none">V[i] >= V[6]</source>. Dintre ele vom alege poziția unde <source lang="C" enclose="none">L[i]</source> este maximă. Astfel vom găsi că <source lang="C" enclose="none">V[9] = 9</source> și <source lang="C" enclose="none">L[9] = 3</source>. Vom avea, deci, o secvență de lungime 4. Ea este:

6, 9, 11, 15

Exemplu de calcul pentru elementul <source lang="C" enclose="none">L[6]</source> - cea mai lungă secvență crescătoare care începe la poziția 6.

=== Analiză ===

Acest algoritm are complexitate ''O(n2)'', unde n este lungimea secvenței. Memoria folosită este ''O(n)''.

Există și un algoritm mai rapid, de complexitate ''O(n log n)'', bazat pe căutare binară a valorilor de început.

=== Reconstrucția soluției ===

Putem reconstrui o subsecvență maximală folosind încă un vector, <source lang="C" enclose="none">N[]</source>. El memorează pentru fiecare indice <tt>i</tt> un alt indice <tt>j</tt> care urmează în secvență după <tt>j</tt>. Atunci când calculăm elementul curent, vom nota nu doar maximul găsit (plus unu) ci și poziția lui în vector, el fiind elementul următor în secvență.

== Subșirul de sumă maximală ==
Această problemă cere să găsim un subșir de sumă maximă într-un șir de numere. Un subșir este contiguu.

=== Exemplu ===

Să considerăm șirul:

12, 14, 0, -4, 61, -39

subșirul de sumă maximală este:

12, 14, 0, -4, 61

și are sumă 83.

=== Soluție ===

Cum împărțim problema în subprobleme? Să încercăm astfel:

S[i] este suma maximală a unui șir care se termină la poziția i

Are această împărțire proprietatea de optimalitate?

Să presupunem că avem un subșir de sumă maximă și că el se află între indicii <tt>i</tt> și <tt>j</tt>. Cu alte cuvine suma maximală este

S[j] = V[i] + V[i+1] + ... + V[j-1] + V[j]

Are șirul care se termină în <tt>j-1</tt>, sumă maximală? Cu alte cuvinte este suma

S[j-1] = V[i] + V[i+1] + ... + V[j-1]

maximală?

Răspunsul este da, deoarece altfel am putea-o înlocui cu o sumă mai mare, ceea ce ar duce la o sumă mai mare decît cea inițială, care era optimală. Obținem o contradicție.

Următorul pas este să găsim relația de recurență. Observăm că pentru o poziție <tt>i</tt> avem două variante: fie continuăm secvența anterioară, care se termină în <tt>i-1</tt>, fie începem una nouă, care pornește în <tt>i</tt>. Vom continua secvența anterioară dacă adunând numărul curent obținem o sumă mai mare strict decât numărul curent. Altfel vom porni o sumă nouă. Relația de recurență este:

S[i] = max(V[i], S[i-1] + V[i])

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula vectorul <source lang="C" enclose="none">S</source> calculând pentru fiecare element <source lang="C" enclose="none">S[i]</source> maximul dintre <source lang="C" enclose="none">S[i-1] + V[i]</source> și <source lang="C" enclose="none">V[i]</source>. Observăm că, în realitate, vom compara <source lang="C" enclose="none">S[i-1]</source> cu zero.

Soluția problemei este maximul din vectorul <source lang="C" enclose="none">S</source>.

=== Exemplu ===

Fie secvența anterioară:

12, 14, 0, -4, 61, -39

Vom calcula de la stânga la dreapta sumele maximale ce se termină la pozițiile respective:

{| class="wikitable"
! V
| 12
| 14
| 0
| -4
| 61
| -39
|-
! S
| 12
| 26 = max(14, 12 + 14)
| 26 = max(0, 0 + 26)
| 22 = max(-4, -4 + 26)
| 83 = max(61, 61 + 22)
| 44 = max(-39, -39 + 83)
|}

=== Analiză ===

Acest algoritm are complexitate ''O(n)'', unde n este lungimea șirului. Memoria folosită este ''O(1)'', deoarece nu avem nevoie să stocăm elementele, ci doar ultima sumă calculată.

=== Reconstrucția soluției ===

Putem ține minte șirul maximal ținând minte începutul și sfârșitul subșirului maximal atunci când îl găsim.

=== Soluții alternative ===

Această problemă poate fi rezolvată fără programare dinamică. Ne propunem același lucru, ca la pasul <tt>i</tt> să calculăm <source lang="C" enclose="none">S[i]</source> cu aceeași semnificație. Acest <source lang="C" enclose="none">S[i]</source> se poate calcula cu cunoștințe de nivel mic: sume parțiale. <source lang="C" enclose="none">S[i]</source> va fi suma unei secvențe de la <tt>k</tt> la <tt>i</tt>, cu <tt>k ≤ i</tt>. Deci, dacă vom calcula <source lang="C" enclose="none">P[]</source>, sumele parțiale pe vector putem spune că <source lang="C" enclose="none">S[i] = P[i] - P[k]</source>. Să ne uităm puțin la această expresie: cine variază în ea? <source lang="C" enclose="none">P[i]</source> este constant, este suma elementelor până la <tt>i</tt>. Putem varia doar <source lang="C" enclose="none">P[k]</source>. Este evident că dorim să alegem un <source lang="C" enclose="none">P[k]</source> cât mai mic, nu?

Algoritmul este unul banal: calculează sume parțiale, avansând <tt>i</tt>. Suma minimă care se termină în <tt>i</tt> este suma parțială curentă minus suma parțială minimă din trecut. La fiecare avans actualizează suma parțială minimă cu cea curentă, dacă este cazul.

Acest algoritm are aceleași complexități ca cel cu programare dinamică. El este însă un algoritm mai flexibil de adaptat unor modificări, cum ar fi suma maximă de lungime cel puțin <tt>K</tt> sau suma maximă de lungime cel mult <tt>K</tt>.

== Subșirul comun maximal al două șiruri ==

Această problemă cere să găsim lungimea unui subșir de lungime maximă (contiguu) inclus în două șiruri.

=== Exemplu ===

Date șirurile

ABABC

și

CBABA

un subșir maximal are lungime 3 și este

BAB

=== Soluție ===

Cum împărțim problema în subprobleme? Să observăm că deoarece subșirul maximal face parte din ambele șiruri el se va termina la o poziție <tt>i</tt> în șirul <tt>X</tt> și la o poziție <tt>j</tt> în șirul <tt>Y</tt>. Și atunci să încercăm astfel:

M[i][j] = lungimea celui mai lung subșir care se termină la poziția i în X și la poziția j în Y.

Are această împărțire proprietatea de optimalitate?

Să presupunem că avem un subșir optimal care se termină la pozițiile <tt>i</tt>, respectiv <tt>j</tt>. Atunci este subșirul <tt>M[i-1][j-1]</tt> la rândul lui optimal? Cu alte cuvinte subșirul mai scurt cu unu, care se termină la pozițiile anterioare în <tt>X</tt>, respectiv <tt>Y</tt>, este optimal? Da, el este optimal, caci altfel l-am putea înlocui cu un șir mai lung, care ar duce la o soluție mai bună, ceea ce ar însemna că soluția originală nu a fost optimă.

Următorul pas este să găsim relația de recurență:

:<math>M[i][j] = \begin{cases} M[i-1][j-1]+1, & \mbox{dacă } X[i] = Y[j] \\0, & \mbox{în caz contrar }. \end{cases}</math>

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula matricea <source lang="C" enclose="none">M</source> pe linii, folosind formula de recurență.

Soluția problemei este maximul din matrice.

=== Exemplu ===

Pentru cele două șiruri de mai sus,

ABABC

și

CBABA

Vom calcula o matrice <source lang="C" enclose="none">M[5][5]</source> care arată astfel:

{| class="wikitable"
!
! C
! B
! A
! B
! A
|-
! A
| 0
| 0
| 1
| 0
| 1
|-
! B
| 0
| 1
| 0
| 2
| 0
|-
! A
| 0
| 0
| 2
| 0
| 3
|-
! B
| 0
| 1
| 0
| 3
| 0
|-
! C
| 1
| 0
| 0
| 0
| 0
|}

Observăm că avem două subșiruri comune de lungime 3: ABA și BAB.

=== Analiză ===

Acest algoritm are complexitate ''O(m·n)'', unde <tt>m</tt> și <tt>n</tt> sunt lungimile șirurilor. Memoria folosită este, la prima vedere, ''O(m·n)''. În realitate, parcurgând matricea pe linii, nu avem nevoie să memorăm decât o linie din matrice pentru a calcula toate valorile. De aceea memoria necesară este ''O(min(m, n))''.

Există și algoritmi mai eficienți bazați pe arbori sufix, despre care nu vom discuta aici.

=== Reconstrucția soluției ===

Cum facem să aflăm nu doar lungimea ci și care este șirul comun maximal și unde apare el în cele două șiruri?

Vom face calculul matricei noastre printr-o parcurgere pe linii. La fiecare pas ne vom întreba dacă elementul calculat (lungimea) este mai mare decât maximul curent. Dacă da, vom memora acel maxim împreună cu indicii <tt>i</tt> și <tt>j</tt> la care s-a obținut el.

La final vom avea poziția de start în primul șir ca fiind <tt>i - max + 1</tt> și în al doilea șir ca fiind <tt>j - max + 1</tt>.

== Subsecvența comună maximală a două șiruri ==

Această problemă cere să găsim lungimea unei subsecvențe de lungime maximă inclusă în două secvențe. Prin secvență înțelegem caractere în ordinea originală, nu neapărat consecutive ca poziție.

=== Exemplu ===

Date secvențele

X: ACDEGIKMPR
Y: CMEFPGHRK

o secvență maximală are lungime 4 și este

CEGK

o altă secvență maximală este

CMPR

=== Soluție ===

Cum împărțim problema în subprobleme? Să încercăm să o împărțim în mod similar cu subșirul comun maximal:

M[i][j] = lungimea celei mai lungi subsecvențe incluse în șirurile X[1..i] și Y[1..j]

Are această împărțire proprietatea de optimalitate?

Să presupunem că avem o secvență optimală a prefixelor care se termină la pozițiile <tt>i</tt>, respectiv <tt>j</tt>. Ea va trece prin anumite perechi <tt>(ik, jk)</tt>, strict crescătoare, cu proprietatea că <tt>X[ik] = Y[jk]</tt>:

Si,j = (i1, j1) (i2, j2) ... (ik, jk)

cu proprietatea că:

Xi1Xi2... Xik-1Xik = Yj1Yj2... Yjk-1Yjk

Atunci este lungimea <tt>M[ik-1][jk-1]</tt> la rândul ei optimală? Cu alte cuvinte subsecvența mai scurtă cu unu, care se termină la poziția <tt>ik-1</tt> în <tt>X</tt>, respectiv poziția <tt>jk-1</tt> în <tt>Y</tt>, este optimală? Da, ea este optimală, căci altfel am putea-o înlocui cu o secvență mai lungă, care ar duce la o soluție mai bună, ceea ce ar însemna că soluția originală nu a fost optimă.

Următorul pas este să găsim relația de recurență:

<math>M[i][j] = \begin{cases} 0, & \mbox{dacă } i = 0 \mbox{ sau } j = 0\\M[i-1][j-1]+1, & \mbox{dacă } X[i] = Y[j]\\max(M[i-1][j],M[i][j-1]) & \mbox{dacă } X[i] \neq Y[j]. \end{cases}</math>

Cum demonstrăm această relație de recurență? Avem două cazuri de demonstrat:

==== Egalitate ====

Prefixele <tt>X[1..i]</tt> și <tt>Y[1..j]</tt> se termină în același caracter. În acest caz o subsecvență maximală a celor două prefixe se poate obține selectând acel ultim caracter. Putem, deci exclude acel caracter și calcula subsecvența maximală în prefixele <tt>X[1..i-1]</tt> și <tt>Y[1..j-1]</tt>. La lungimea ei vom aduna unu.

==== Diferență ====

Prefixele <tt>X[1..i]</tt> și <tt>Y[1..j]</tt> se termină în caractere diferite. Să luăm cazul anterior, avem secvențele:

X: ACDEGIKMPR
Y: CMEFPGHRK

Avem iarăși două cazuri:

* '''Cazul 1''': subsecvența optimă se termină în <tt>R</tt>. În acest caz ea nu se poate termina și în <tt>K</tt>. Deci putem elimina ultimul caracter din <tt>Y</tt> și calcula <tt>M[i][j-1]</tt>.
* '''Cazul 2''': subsecvența optimă nu se termină în <tt>R</tt>. În acest caz putem elimina acest <tt>R</tt> și calcula <tt>M[i-1][j]</tt>.

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula matricea <source lang="C" enclose="none">M</source> pe linii, folosind formula de recurență.

Soluția problemei este <source lang="C" enclose="none">M[n][m]</source>.

=== Exemplu ===

Pentru cele două șiruri de mai sus,

ACDEGIKMPR

și

CMEFPGHRK

Vom calcula o matrice <source lang="C" enclose="none">M[10][9]</source> care arată astfel:

{| class="wikitable"
!
! C !! M !! E !! F !! P !! G !! H !! R !! K
|-
!A
|0||0||0||0||0||0||0||0||0
|-
!C
|1||1||1||1||1||1||1||1||1
|-
!D
|1||1||1||1||1||1||1||1||1
|-
!E
|1||1||2||2||2||2||2||2||2
|-
!G
|1||1||2||2||2||3||3||3||3
|-
!I
|1||1||2||2||2||3||3||3||3
|-
!K
|1||1||2||2||2||3||3||3||4
|-
!M
|1||2||2||2||2||3||3||3||4
|-
!P
|1||2||2||2||3||3||3||3||4
|-
!R
|1||2||2||2||3||3||3||4||4
|}

Cea mai lungă secvență este de lungime 4, valoarea maximă ce apare în tabel.

=== Analiză ===

Acest algoritm are complexitate ''O(m · n)'', unde <tt>m</tt> și <tt>n</tt> sunt lungimile șirurilor. Memoria folosită este ''O(min(m,n))'' dacă memorăm doar o linie din matrice. Dacă dorim să aflăm și o secvență maximală, nu doar lungimea ei, vom avea nevoie de memorie ''O(m · n)'', precum vom vedea mai jos.

Există un algoritm care reduce necesarul de memorie la ''O(min(m, n))''.

=== Reconstrucția soluției ===

Dorim să aflăm nu doar lungimea, ci și o secvență maximală inclusă în ambele șiruri. Cum procedăm?

Observăm că literele ce fac parte din secvențele maximale se obțin acolo unde, în matrice, avem ramura doi de calcul, când literele de la pozițiile respective sunt egale.

Pentru a putea reconstrui soluția vom memora în fiecare căsuță, pe lângă lungimea maximă și direcția din care provine ea, adică din care am calculat acel maxim. Direcția poate fi spre stânga, spre în sus, sau în diagonală stânga-sus. Apoi vom porni din elementul <source lang="C" enclose="none">M[m][n]</source> și vom urma aceste direcții până ce ieșim din matrice. De fiecare dată când urmăm o diagonală reținem litera. Astfel, descoperirea secvenței se face în ordine inversă.

== Tema 24 ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/dreptunghiuri Dreptunghiuri] pentru subsecvența crescătoare maximală. '''Atenţie:''' puteți pica teste cu TLE, este în regulă.
* [https://www.nerdarena.ro/problema/ssm Subsecvența de sumă maximă]
* [https://www.nerdarena.ro/problema/sclm Subșirul comun de lungime maximă]
* [https://www.nerdarena.ro/problema/cmlsc Cel mai lung subșir comun]

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_24:_Programare_dinamic%C4%83_(1) Accesează rezolvarea temei 24]

Clasa a 7-a Lecția 24: Programare dinamică (1)

2025-06-10T10:02:42Z

Mihai: /* Tema 24 */

== Înregistrare video lecție ==

{{#ev:youtube|https://www.youtube.com/watch?v=a0wFdh8DInQ|||||start=7600&end=11100&loop=1}}

== Conceptul de programare dinamică ==

=== Introducere ===

Wikipedia definește [http://en.wikipedia.org/wiki/Dynamic_programming programarea dinamică] drept o metodă pentru rezolvarea unor probleme complexe prin descompunerea lor în subprobleme mai simple. Se poate aplica problemelor care prezintă proprietățile de ''suprapunere a subproblemelor'' și de ''substructură optimală''. Atunci când se poate aplica, metoda ia mult mai puțin timp decât alte soluții naive.

[[Image:Shortest_path_optimal_substructure.svg|frame|right|300px|Drumul cel mai scurt între două orașe poate fi rezolvat cu programare dinamică]]

''Substructura optimală'' înseamnă că soluția unei problemei de optimizare date poate fi obținută prin combinarea unor soluții optimale ale subproblemelor. Ca atare, primul pas către găsirea unei rezolvări prin această metodă este verificarea dacă problema are proprietatea substructurii optimale.

Drumul cel mai scurt între două orașe poate fi rezolvat cu programare dinamică

Astfel de substructuri optimale sunt în mod uzual descrise prin recurență. De exemplu, date niște orașe și distanțele între ele, drumul cel mai scurt de la orașul <tt>u</tt> la orașul <tt>v</tt> are proprietatea de substructură optimală: să luăm orice oraș intermediar <tt>w</tt> pe drumul cel mai scurt, <tt>d</tt>. Dacă <tt>d</tt> este cu adevărat drumul cel mai scurt, atunci drumul <tt>d1</tt> de la <tt>u</tt> la <tt>w</tt> și <tt>d2</tt> de la <tt>w</tt> la <tt>v</tt> sunt cu adevărat cele mai scurte drumuri între orașele corespunzătoare. Dacă drumul de la <tt>u</tt> la <tt>w</tt> nu ar fi cel mai scurt posibil ar însemna că am avea un alt drum mai scurt, ceea ce ar duce la un drum total <tt>d</tt>, de la <tt>u</tt> la <tt>v</tt>, mai scurt decât cel original. Așadar, putem formula soluția problemei găsirii celui mai scurt drum într-o manieră recursivă, ceea ce fac algoritmii [https://en.wikipedia.org/wiki/Bellman-Ford_algorithm Bellman-Ford] și [https://en.wikipedia.org/wiki/Floyd-Warshall_algorithm Floyd-Warshall].

Suprapunerea subproblemelor înseamnă că ele nu sunt independente, adică subproblemele au în comun alte subprobleme. Nu vom insista pe această proprietate decât atât cât să menționăm că dacă subproblemele nu se suprapun dar prezintă substructură optimală atunci putem aplica tehnica de [https://www.algopedia.ro/wiki/index.php/Clasa_a_7-a_Lec%C8%9Bia_18:_Divide_et_impera,_mergesort,_quicksort programare divide et impera (divide and conquer)]. De aceea [http://en.wikipedia.org/wiki/Quicksort quicksort] și [http://en.wikipedia.org/wiki/Mergesort mergesort] nu sunt clasificate ca probleme de programare dinamică.

=== Metodă ===

Când încercăm să rezolvăm o problemă de programare dinamică întrebarea crucială la care trebuie să răspundem este ''putem calcula soluția finală pe baza unor subprobleme care sunt la rândul lor '''optimale''' ''? Pentru a răspunde la întrebare trebuie mai întâi să formulăm subproblemele. Dar pentru a formula subproblemele trebuie să avem în minte principiul substructurii optimale. Altfel s-ar putea să împărțim problema în subprobleme care nu au substructură optimală.

Să recapitulăm: pentru a putea răspunde la întrebarea dacă o problemă admite o soluție prin programare dinamică trebuie să aflăm dacă are substructură optimală. Dar pentru a afla dacă are substructură optimală trebuie să găsim subproblemele. Pe care încercăm să le găsim folosind programarea dinamică.

Nu cumva ne învârtim în cerc? Așa pare și așa și este, într-o oarecare măsură. Experiența este cea care ne învață cum să căutăm împărțirea în subprobleme astfel încât să obținem proprietatea de optimalitate. Tot experiența este cea care ne ajută să ne dăm seama rapid dacă împărțirea găsită are această proprietate sau nu.

Odată ce demonstrăm că o împărțire în subprobleme se bazează doar pe subprobleme optimale, restul decurge, de obicei, destul de simplu: găsim o formulă de recurență, apoi o implementăm de jos în sus (sau bottom-up), pornind de la cele mai mici probleme, către cele mai mari, până la soluția cerută.

În continuare vom lua câteva exemple.

== Subsecvența crescătoare de lungime maximă ==

Această problemă cere să găsim o subsecvență a unei secvențe de numere în care elementele sunt în ordine crescătoare, iar subsecvența este de lungime maximă. Subsecvența nu este neapărat contiguă, nici unică.

Exemplu

În secvența

0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15

o secvență crescătoare de lungime maximă este

0, 2, 6, 9, 13, 15

Această secvență are lungime șase. Nu există nici o secvență crescătoare de lungime șapte. Cea mai lungă subsecvență crescătoare nu este unică. De exemplu

0, 4, 6, 9, 11, 15

este o altă subsecvență crescătoare de aceeași lungime, în secvența de intrare.

=== Soluție ===

Cum împărțim problema în subprobleme? Să încercăm astfel:

L[i] = lungimea celei mai lungi subsecvențe care începe la poziția i

Are această împărțire proprietatea de optimalitate? Să presupunem că avem o subsecvență optimală crescătoare care trece prin indicii

i1, i2, i3, …, ik

Astfel

L[i1] = k

Este secvența <tt>i2, ..., ik</tt> optimală? Cu alte cuvinte lungimea secvenței optime care începe la <tt>i2</tt> este <tt>k-1</tt>? Răspunsul este da, secvența care începe la i2, anume i2, ..., ik este o secvență maximă, deoarece altfel am putea-o înlocui cu o secvență mai lungă, ceea ce ar duce la o subsecvență <tt>L[i1]</tt> mai lungă decât cea inițială, care era optimală. Obținem o contradicție.

Următorul pas este să găsim relația de recurență:

L[i] = max(L[j]+1), j > i și V[j] ≥ V[i]

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula vectorul <source lang="C" enclose="none">L</source> de la coadă la cap, căutând pentru fiecare element <source lang="C" enclose="none">L[i]</source> cel mai mare element <source lang="C" enclose="none">L[j]</source> de după el <tt>(j > i)</tt> astfel încât <source lang="C" enclose="none">V[j] ≥ V[i]</source>.

Soluția problemei este maximul din vectorul <source lang="C" enclose="none">L</source>.

=== Exemplu ===

Să calculăm cea mai lungă secvență crescătoare în secvența:

0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15

Vom calcula lungimile secvențelor maximale de la coadă la cap: <source lang="C" enclose="none">L[15]</source>, apoi <source lang="C" enclose="none">L[14]</source> și așa mai departe. Când ajungem la calculul lui <tt>L[6]</tt> avem următoarea situație:

[[File:max-increasing-seq.png|frame|none|Exemplu de calcul pentru elementul ''L[6]'' - cea mai lungă secvență crescătoare care începe la poziția 6.]]

Pentru a calcula lungimea secvenței maximale care începe la poziția 6 vom căuta toate pozițiile mai mari <tt>(7, 8, 9, ...)</tt>. Le vom lua în considerare doar pe acelea în care <source lang="C" enclose="none">V[i] >= V[6]</source>. Dintre ele vom alege poziția unde <source lang="C" enclose="none">L[i]</source> este maximă. Astfel vom găsi că <source lang="C" enclose="none">V[9] = 9</source> și <source lang="C" enclose="none">L[9] = 3</source>. Vom avea, deci, o secvență de lungime 4. Ea este:

6, 9, 11, 15

Exemplu de calcul pentru elementul <source lang="C" enclose="none">L[6]</source> - cea mai lungă secvență crescătoare care începe la poziția 6.

=== Analiză ===

Acest algoritm are complexitate ''O(n2)'', unde n este lungimea secvenței. Memoria folosită este ''O(n)''.

Există și un algoritm mai rapid, de complexitate ''O(n log n)'', bazat pe căutare binară a valorilor de început.

=== Reconstrucția soluției ===

Putem reconstrui o subsecvență maximală folosind încă un vector, <source lang="C" enclose="none">N[]</source>. El memorează pentru fiecare indice <tt>i</tt> un alt indice <tt>j</tt> care urmează în secvență după <tt>j</tt>. Atunci când calculăm elementul curent, vom nota nu doar maximul găsit (plus unu) ci și poziția lui în vector, el fiind elementul următor în secvență.

== Subșirul de sumă maximală ==
Această problemă cere să găsim un subșir de sumă maximă într-un șir de numere. Un subșir este contiguu.

=== Exemplu ===

Să considerăm șirul:

12, 14, 0, -4, 61, -39

subșirul de sumă maximală este:

12, 14, 0, -4, 61

și are sumă 83.

=== Soluție ===

Cum împărțim problema în subprobleme? Să încercăm astfel:

S[i] este suma maximală a unui șir care se termină la poziția i

Are această împărțire proprietatea de optimalitate?

Să presupunem că avem un subșir de sumă maximă și că el se află între indicii <tt>i</tt> și <tt>j</tt>. Cu alte cuvine suma maximală este

S[j] = V[i] + V[i+1] + ... + V[j-1] + V[j]

Are șirul care se termină în <tt>j-1</tt>, sumă maximală? Cu alte cuvinte este suma

S[j-1] = V[i] + V[i+1] + ... + V[j-1]

maximală?

Răspunsul este da, deoarece altfel am putea-o înlocui cu o sumă mai mare, ceea ce ar duce la o sumă mai mare decît cea inițială, care era optimală. Obținem o contradicție.

Următorul pas este să găsim relația de recurență. Observăm că pentru o poziție <tt>i</tt> avem două variante: fie continuăm secvența anterioară, care se termină în <tt>i-1</tt>, fie începem una nouă, care pornește în <tt>i</tt>. Vom continua secvența anterioară dacă adunând numărul curent obținem o sumă mai mare strict decât numărul curent. Altfel vom porni o sumă nouă. Relația de recurență este:

S[i] = max(V[i], S[i-1] + V[i])

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula vectorul <source lang="C" enclose="none">S</source> calculând pentru fiecare element <source lang="C" enclose="none">S[i]</source> maximul dintre <source lang="C" enclose="none">S[i-1] + V[i]</source> și <source lang="C" enclose="none">V[i]</source>. Observăm că, în realitate, vom compara <source lang="C" enclose="none">S[i-1]</source> cu zero.

Soluția problemei este maximul din vectorul <source lang="C" enclose="none">S</source>.

=== Exemplu ===

Fie secvența anterioară:

12, 14, 0, -4, 61, -39

Vom calcula de la stânga la dreapta sumele maximale ce se termină la pozițiile respective:

{| class="wikitable"
! V
| 12
| 14
| 0
| -4
| 61
| -39
|-
! S
| 12
| 26 = max(14, 12 + 14)
| 26 = max(0, 0 + 26)
| 22 = max(-4, -4 + 26)
| 83 = max(61, 61 + 22)
| 44 = max(-39, -39 + 83)
|}

=== Analiză ===

Acest algoritm are complexitate ''O(n)'', unde n este lungimea șirului. Memoria folosită este ''O(1)'', deoarece nu avem nevoie să stocăm elementele, ci doar ultima sumă calculată.

=== Reconstrucția soluției ===

Putem ține minte șirul maximal ținând minte începutul și sfârșitul subșirului maximal atunci când îl găsim.

=== Soluții alternative ===

Această problemă poate fi rezolvată fără programare dinamică. Ne propunem același lucru, ca la pasul <tt>i</tt> să calculăm <source lang="C" enclose="none">S[i]</source> cu aceeași semnificație. Acest <source lang="C" enclose="none">S[i]</source> se poate calcula cu cunoștințe de nivel mic: sume parțiale. <source lang="C" enclose="none">S[i]</source> va fi suma unei secvențe de la <tt>k</tt> la <tt>i</tt>, cu <tt>k ≤ i</tt>. Deci, dacă vom calcula <source lang="C" enclose="none">P[]</source>, sumele parțiale pe vector putem spune că <source lang="C" enclose="none">S[i] = P[i] - P[k]</source>. Să ne uităm puțin la această expresie: cine variază în ea? <source lang="C" enclose="none">P[i]</source> este constant, este suma elementelor până la <tt>i</tt>. Putem varia doar <source lang="C" enclose="none">P[k]</source>. Este evident că dorim să alegem un <source lang="C" enclose="none">P[k]</source> cât mai mic, nu?

Algoritmul este unul banal: calculează sume parțiale, avansând <tt>i</tt>. Suma minimă care se termină în <tt>i</tt> este suma parțială curentă minus suma parțială minimă din trecut. La fiecare avans actualizează suma parțială minimă cu cea curentă, dacă este cazul.

Acest algoritm are aceleași complexități ca cel cu programare dinamică. El este însă un algoritm mai flexibil de adaptat unor modificări, cum ar fi suma maximă de lungime cel puțin <tt>K</tt> sau suma maximă de lungime cel mult <tt>K</tt>.

== Subșirul comun maximal al două șiruri ==

Această problemă cere să găsim lungimea unui subșir de lungime maximă (contiguu) inclus în două șiruri.

=== Exemplu ===

Date șirurile

ABABC

și

CBABA

un subșir maximal are lungime 3 și este

BAB

=== Soluție ===

Cum împărțim problema în subprobleme? Să observăm că deoarece subșirul maximal face parte din ambele șiruri el se va termina la o poziție <tt>i</tt> în șirul <tt>X</tt> și la o poziție <tt>j</tt> în șirul <tt>Y</tt>. Și atunci să încercăm astfel:

M[i][j] = lungimea celui mai lung subșir care se termină la poziția i în X și la poziția j în Y.

Are această împărțire proprietatea de optimalitate?

Să presupunem că avem un subșir optimal care se termină la pozițiile <tt>i</tt>, respectiv <tt>j</tt>. Atunci este subșirul <tt>M[i-1][j-1]</tt> la rândul lui optimal? Cu alte cuvinte subșirul mai scurt cu unu, care se termină la pozițiile anterioare în <tt>X</tt>, respectiv <tt>Y</tt>, este optimal? Da, el este optimal, caci altfel l-am putea înlocui cu un șir mai lung, care ar duce la o soluție mai bună, ceea ce ar însemna că soluția originală nu a fost optimă.

Următorul pas este să găsim relația de recurență:

:<math>M[i][j] = \begin{cases} M[i-1][j-1]+1, & \mbox{dacă } X[i] = Y[j] \\0, & \mbox{în caz contrar }. \end{cases}</math>

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula matricea <source lang="C" enclose="none">M</source> pe linii, folosind formula de recurență.

Soluția problemei este maximul din matrice.

=== Exemplu ===

Pentru cele două șiruri de mai sus,

ABABC

și

CBABA

Vom calcula o matrice <source lang="C" enclose="none">M[5][5]</source> care arată astfel:

{| class="wikitable"
!
! C
! B
! A
! B
! A
|-
! A
| 0
| 0
| 1
| 0
| 1
|-
! B
| 0
| 1
| 0
| 2
| 0
|-
! A
| 0
| 0
| 2
| 0
| 3
|-
! B
| 0
| 1
| 0
| 3
| 0
|-
! C
| 1
| 0
| 0
| 0
| 0
|}

Observăm că avem două subșiruri comune de lungime 3: ABA și BAB.

=== Analiză ===

Acest algoritm are complexitate ''O(m·n)'', unde <tt>m</tt> și <tt>n</tt> sunt lungimile șirurilor. Memoria folosită este, la prima vedere, ''O(m·n)''. În realitate, parcurgând matricea pe linii, nu avem nevoie să memorăm decât o linie din matrice pentru a calcula toate valorile. De aceea memoria necesară este ''O(min(m, n))''.

Există și algoritmi mai eficienți bazați pe arbori sufix, despre care nu vom discuta aici.

=== Reconstrucția soluției ===

Cum facem să aflăm nu doar lungimea ci și care este șirul comun maximal și unde apare el în cele două șiruri?

Vom face calculul matricei noastre printr-o parcurgere pe linii. La fiecare pas ne vom întreba dacă elementul calculat (lungimea) este mai mare decât maximul curent. Dacă da, vom memora acel maxim împreună cu indicii <tt>i</tt> și <tt>j</tt> la care s-a obținut el.

La final vom avea poziția de start în primul șir ca fiind <tt>i - max + 1</tt> și în al doilea șir ca fiind <tt>j - max + 1</tt>.

== Subsecvența comună maximală a două șiruri ==

Această problemă cere să găsim lungimea unei subsecvențe de lungime maximă inclusă în două secvențe. Prin secvență înțelegem caractere în ordinea originală, nu neapărat consecutive ca poziție.

=== Exemplu ===

Date secvențele

X: ACDEGIKMPR
Y: CMEFPGHRK

o secvență maximală are lungime 4 și este

CEGK

o altă secvență maximală este

CMPR

=== Soluție ===

Cum împărțim problema în subprobleme? Să încercăm să o împărțim în mod similar cu subșirul comun maximal:

M[i][j] = lungimea celei mai lungi subsecvențe incluse în șirurile X[1..i] și Y[1..j]

Are această împărțire proprietatea de optimalitate?

Să presupunem că avem o secvență optimală a prefixelor care se termină la pozițiile <tt>i</tt>, respectiv <tt>j</tt>. Ea va trece prin anumite perechi <tt>(ik, jk)</tt>, strict crescătoare, cu proprietatea că <tt>X[ik] = Y[jk]</tt>:

Si,j = (i1, j1) (i2, j2) ... (ik, jk)

cu proprietatea că:

Xi1Xi2... Xik-1Xik = Yj1Yj2... Yjk-1Yjk

Atunci este lungimea <tt>M[ik-1][jk-1]</tt> la rândul ei optimală? Cu alte cuvinte subsecvența mai scurtă cu unu, care se termină la poziția <tt>ik-1</tt> în <tt>X</tt>, respectiv poziția <tt>jk-1</tt> în <tt>Y</tt>, este optimală? Da, ea este optimală, căci altfel am putea-o înlocui cu o secvență mai lungă, care ar duce la o soluție mai bună, ceea ce ar însemna că soluția originală nu a fost optimă.

Următorul pas este să găsim relația de recurență:

<math>M[i][j] = \begin{cases} 0, & \mbox{dacă } i = 0 \mbox{ sau } j = 0\\M[i-1][j-1]+1, & \mbox{dacă } X[i] = Y[j]\\max(M[i-1][j],M[i][j-1]) & \mbox{dacă } X[i] \neq Y[j]. \end{cases}</math>

Cum demonstrăm această relație de recurență? Avem două cazuri de demonstrat:

==== Egalitate ====

Prefixele <tt>X[1..i]</tt> și <tt>Y[1..j]</tt> se termină în același caracter. În acest caz o subsecvență maximală a celor două prefixe se poate obține selectând acel ultim caracter. Putem, deci exclude acel caracter și calcula subsecvența maximală în prefixele <tt>X[1..i-1]</tt> și <tt>Y[1..j-1]</tt>. La lungimea ei vom aduna unu.

==== Diferență ====

Prefixele <tt>X[1..i]</tt> și <tt>Y[1..j]</tt> se termină în caractere diferite. Să luăm cazul anterior, avem secvențele:

X: ACDEGIKMPR
Y: CMEFPGHRK

Avem iarăși două cazuri:

* '''Cazul 1''': subsecvența optimă se termină în <tt>R</tt>. În acest caz ea nu se poate termina și în <tt>K</tt>. Deci putem elimina ultimul caracter din <tt>Y</tt> și calcula <tt>M[i][j-1]</tt>.
* '''Cazul 2''': subsecvența optimă nu se termină în <tt>R</tt>. În acest caz putem elimina acest <tt>R</tt> și calcula <tt>M[i-1][j]</tt>.

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula matricea <source lang="C" enclose="none">M</source> pe linii, folosind formula de recurență.

Soluția problemei este <source lang="C" enclose="none">M[n][m]</source>.

=== Exemplu ===

Pentru cele două șiruri de mai sus,

ACDEGIKMPR

și

CMEFPGHRK

Vom calcula o matrice <source lang="C" enclose="none">M[10][9]</source> care arată astfel:

{| class="wikitable"
!
! C !! M !! E !! F !! P !! G !! H !! R !! K
|-
!A
|0||0||0||0||0||0||0||0||0
|-
!C
|1||1||1||1||1||1||1||1||1
|-
!D
|1||1||1||1||1||1||1||1||1
|-
!E
|1||1||2||2||2||2||2||2||2
|-
!G
|1||1||2||2||2||3||3||3||3
|-
!I
|1||1||2||2||2||3||3||3||3
|-
!K
|1||1||2||2||2||3||3||3||4
|-
!M
|1||2||2||2||2||3||3||3||4
|-
!P
|1||2||2||2||3||3||3||3||4
|-
!R
|1||2||2||2||3||3||3||4||4
|}

Cea mai lungă secvență este de lungime 4, valoarea maximă ce apare în tabel.

=== Analiză ===

Acest algoritm are complexitate ''O(m · n)'', unde <tt>m</tt> și <tt>n</tt> sunt lungimile șirurilor. Memoria folosită este ''O(min(m,n))'' dacă memorăm doar o linie din matrice. Dacă dorim să aflăm și o secvență maximală, nu doar lungimea ei, vom avea nevoie de memorie ''O(m · n)'', precum vom vedea mai jos.

Există un algoritm care reduce necesarul de memorie la ''O(min(m, n))''.

=== Reconstrucția soluției ===

Dorim să aflăm nu doar lungimea, ci și o secvență maximală inclusă în ambele șiruri. Cum procedăm?

Observăm că literele ce fac parte din secvențele maximale se obțin acolo unde, în matrice, avem ramura doi de calcul, când literele de la pozițiile respective sunt egale.

Pentru a putea reconstrui soluția vom memora în fiecare căsuță, pe lângă lungimea maximă și direcția din care provine ea, adică din care am calculat acel maxim. Direcția poate fi spre stânga, spre în sus, sau în diagonală stânga-sus. Apoi vom porni din elementul <source lang="C" enclose="none">M[m][n]</source> și vom urma aceste direcții până ce ieșim din matrice. De fiecare dată când urmăm o diagonală reținem litera. Astfel, descoperirea secvenței se face în ordine inversă.

== Tema 24 ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/dreptunghiuri Dreptunghiuri] pentru subsecvența crescătoare maximală. '''Atenţie:''' puteți pica teste cu TLE, este în regulă.
* [https://www.nerdarena.ro/problema/ssm Subsecvența de sumă maximă]
* [https://www.nerdarena.ro/problema/sclm Subsecvența comun maximal]
* [https://www.nerdarena.ro/problema/cmlsc Subsecvența comună maximală]

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_24:_Programare_dinamic%C4%83_(1) Accesează rezolvarea temei 24]

Clasa a 7-a Lecția 24: Programare dinamică (1)

2025-06-10T09:23:15Z

Mihai:

== Înregistrare video lecție ==

{{#ev:youtube|https://www.youtube.com/watch?v=a0wFdh8DInQ|||||start=7600&end=11100&loop=1}}

== Conceptul de programare dinamică ==

=== Introducere ===

Wikipedia definește [http://en.wikipedia.org/wiki/Dynamic_programming programarea dinamică] drept o metodă pentru rezolvarea unor probleme complexe prin descompunerea lor în subprobleme mai simple. Se poate aplica problemelor care prezintă proprietățile de ''suprapunere a subproblemelor'' și de ''substructură optimală''. Atunci când se poate aplica, metoda ia mult mai puțin timp decât alte soluții naive.

[[Image:Shortest_path_optimal_substructure.svg|frame|right|300px|Drumul cel mai scurt între două orașe poate fi rezolvat cu programare dinamică]]

''Substructura optimală'' înseamnă că soluția unei problemei de optimizare date poate fi obținută prin combinarea unor soluții optimale ale subproblemelor. Ca atare, primul pas către găsirea unei rezolvări prin această metodă este verificarea dacă problema are proprietatea substructurii optimale.

Drumul cel mai scurt între două orașe poate fi rezolvat cu programare dinamică

Astfel de substructuri optimale sunt în mod uzual descrise prin recurență. De exemplu, date niște orașe și distanțele între ele, drumul cel mai scurt de la orașul <tt>u</tt> la orașul <tt>v</tt> are proprietatea de substructură optimală: să luăm orice oraș intermediar <tt>w</tt> pe drumul cel mai scurt, <tt>d</tt>. Dacă <tt>d</tt> este cu adevărat drumul cel mai scurt, atunci drumul <tt>d1</tt> de la <tt>u</tt> la <tt>w</tt> și <tt>d2</tt> de la <tt>w</tt> la <tt>v</tt> sunt cu adevărat cele mai scurte drumuri între orașele corespunzătoare. Dacă drumul de la <tt>u</tt> la <tt>w</tt> nu ar fi cel mai scurt posibil ar însemna că am avea un alt drum mai scurt, ceea ce ar duce la un drum total <tt>d</tt>, de la <tt>u</tt> la <tt>v</tt>, mai scurt decât cel original. Așadar, putem formula soluția problemei găsirii celui mai scurt drum într-o manieră recursivă, ceea ce fac algoritmii [https://en.wikipedia.org/wiki/Bellman-Ford_algorithm Bellman-Ford] și [https://en.wikipedia.org/wiki/Floyd-Warshall_algorithm Floyd-Warshall].

Suprapunerea subproblemelor înseamnă că ele nu sunt independente, adică subproblemele au în comun alte subprobleme. Nu vom insista pe această proprietate decât atât cât să menționăm că dacă subproblemele nu se suprapun dar prezintă substructură optimală atunci putem aplica tehnica de [https://www.algopedia.ro/wiki/index.php/Clasa_a_7-a_Lec%C8%9Bia_18:_Divide_et_impera,_mergesort,_quicksort programare divide et impera (divide and conquer)]. De aceea [http://en.wikipedia.org/wiki/Quicksort quicksort] și [http://en.wikipedia.org/wiki/Mergesort mergesort] nu sunt clasificate ca probleme de programare dinamică.

=== Metodă ===

Când încercăm să rezolvăm o problemă de programare dinamică întrebarea crucială la care trebuie să răspundem este ''putem calcula soluția finală pe baza unor subprobleme care sunt la rândul lor '''optimale''' ''? Pentru a răspunde la întrebare trebuie mai întâi să formulăm subproblemele. Dar pentru a formula subproblemele trebuie să avem în minte principiul substructurii optimale. Altfel s-ar putea să împărțim problema în subprobleme care nu au substructură optimală.

Să recapitulăm: pentru a putea răspunde la întrebarea dacă o problemă admite o soluție prin programare dinamică trebuie să aflăm dacă are substructură optimală. Dar pentru a afla dacă are substructură optimală trebuie să găsim subproblemele. Pe care încercăm să le găsim folosind programarea dinamică.

Nu cumva ne învârtim în cerc? Așa pare și așa și este, într-o oarecare măsură. Experiența este cea care ne învață cum să căutăm împărțirea în subprobleme astfel încât să obținem proprietatea de optimalitate. Tot experiența este cea care ne ajută să ne dăm seama rapid dacă împărțirea găsită are această proprietate sau nu.

Odată ce demonstrăm că o împărțire în subprobleme se bazează doar pe subprobleme optimale, restul decurge, de obicei, destul de simplu: găsim o formulă de recurență, apoi o implementăm de jos în sus (sau bottom-up), pornind de la cele mai mici probleme, către cele mai mari, până la soluția cerută.

În continuare vom lua câteva exemple.

== Subsecvența crescătoare de lungime maximă ==

Această problemă cere să găsim o subsecvență a unei secvențe de numere în care elementele sunt în ordine crescătoare, iar subsecvența este de lungime maximă. Subsecvența nu este neapărat contiguă, nici unică.

Exemplu

În secvența

0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15

o secvență crescătoare de lungime maximă este

0, 2, 6, 9, 13, 15

Această secvență are lungime șase. Nu există nici o secvență crescătoare de lungime șapte. Cea mai lungă subsecvență crescătoare nu este unică. De exemplu

0, 4, 6, 9, 11, 15

este o altă subsecvență crescătoare de aceeași lungime, în secvența de intrare.

=== Soluție ===

Cum împărțim problema în subprobleme? Să încercăm astfel:

L[i] = lungimea celei mai lungi subsecvențe care începe la poziția i

Are această împărțire proprietatea de optimalitate? Să presupunem că avem o subsecvență optimală crescătoare care trece prin indicii

i1, i2, i3, …, ik

Astfel

L[i1] = k

Este secvența <tt>i2, ..., ik</tt> optimală? Cu alte cuvinte lungimea secvenței optime care începe la <tt>i2</tt> este <tt>k-1</tt>? Răspunsul este da, secvența care începe la i2, anume i2, ..., ik este o secvență maximă, deoarece altfel am putea-o înlocui cu o secvență mai lungă, ceea ce ar duce la o subsecvență <tt>L[i1]</tt> mai lungă decât cea inițială, care era optimală. Obținem o contradicție.

Următorul pas este să găsim relația de recurență:

L[i] = max(L[j]+1), j > i și V[j] ≥ V[i]

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula vectorul <source lang="C" enclose="none">L</source> de la coadă la cap, căutând pentru fiecare element <source lang="C" enclose="none">L[i]</source> cel mai mare element <source lang="C" enclose="none">L[j]</source> de după el <tt>(j > i)</tt> astfel încât <source lang="C" enclose="none">V[j] ≥ V[i]</source>.

Soluția problemei este maximul din vectorul <source lang="C" enclose="none">L</source>.

=== Exemplu ===

Să calculăm cea mai lungă secvență crescătoare în secvența:

0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15

Vom calcula lungimile secvențelor maximale de la coadă la cap: <source lang="C" enclose="none">L[15]</source>, apoi <source lang="C" enclose="none">L[14]</source> și așa mai departe. Când ajungem la calculul lui <tt>L[6]</tt> avem următoarea situație:

[[File:max-increasing-seq.png|frame|none|Exemplu de calcul pentru elementul ''L[6]'' - cea mai lungă secvență crescătoare care începe la poziția 6.]]

Pentru a calcula lungimea secvenței maximale care începe la poziția 6 vom căuta toate pozițiile mai mari <tt>(7, 8, 9, ...)</tt>. Le vom lua în considerare doar pe acelea în care <source lang="C" enclose="none">V[i] >= V[6]</source>. Dintre ele vom alege poziția unde <source lang="C" enclose="none">L[i]</source> este maximă. Astfel vom găsi că <source lang="C" enclose="none">V[9] = 9</source> și <source lang="C" enclose="none">L[9] = 3</source>. Vom avea, deci, o secvență de lungime 4. Ea este:

6, 9, 11, 15

Exemplu de calcul pentru elementul <source lang="C" enclose="none">L[6]</source> - cea mai lungă secvență crescătoare care începe la poziția 6.

=== Analiză ===

Acest algoritm are complexitate ''O(n2)'', unde n este lungimea secvenței. Memoria folosită este ''O(n)''.

Există și un algoritm mai rapid, de complexitate ''O(n log n)'', bazat pe căutare binară a valorilor de început.

=== Reconstrucția soluției ===

Putem reconstrui o subsecvență maximală folosind încă un vector, <source lang="C" enclose="none">N[]</source>. El memorează pentru fiecare indice <tt>i</tt> un alt indice <tt>j</tt> care urmează în secvență după <tt>j</tt>. Atunci când calculăm elementul curent, vom nota nu doar maximul găsit (plus unu) ci și poziția lui în vector, el fiind elementul următor în secvență.

== Subșirul de sumă maximală ==
Această problemă cere să găsim un subșir de sumă maximă într-un șir de numere. Un subșir este contiguu.

=== Exemplu ===

Să considerăm șirul:

12, 14, 0, -4, 61, -39

subșirul de sumă maximală este:

12, 14, 0, -4, 61

și are sumă 83.

=== Soluție ===

Cum împărțim problema în subprobleme? Să încercăm astfel:

S[i] este suma maximală a unui șir care se termină la poziția i

Are această împărțire proprietatea de optimalitate?

Să presupunem că avem un subșir de sumă maximă și că el se află între indicii <tt>i</tt> și <tt>j</tt>. Cu alte cuvine suma maximală este

S[j] = V[i] + V[i+1] + ... + V[j-1] + V[j]

Are șirul care se termină în <tt>j-1</tt>, sumă maximală? Cu alte cuvinte este suma

S[j-1] = V[i] + V[i+1] + ... + V[j-1]

maximală?

Răspunsul este da, deoarece altfel am putea-o înlocui cu o sumă mai mare, ceea ce ar duce la o sumă mai mare decît cea inițială, care era optimală. Obținem o contradicție.

Următorul pas este să găsim relația de recurență. Observăm că pentru o poziție <tt>i</tt> avem două variante: fie continuăm secvența anterioară, care se termină în <tt>i-1</tt>, fie începem una nouă, care pornește în <tt>i</tt>. Vom continua secvența anterioară dacă adunând numărul curent obținem o sumă mai mare strict decât numărul curent. Altfel vom porni o sumă nouă. Relația de recurență este:

S[i] = max(V[i], S[i-1] + V[i])

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula vectorul <source lang="C" enclose="none">S</source> calculând pentru fiecare element <source lang="C" enclose="none">S[i]</source> maximul dintre <source lang="C" enclose="none">S[i-1] + V[i]</source> și <source lang="C" enclose="none">V[i]</source>. Observăm că, în realitate, vom compara <source lang="C" enclose="none">S[i-1]</source> cu zero.

Soluția problemei este maximul din vectorul <source lang="C" enclose="none">S</source>.

=== Exemplu ===

Fie secvența anterioară:

12, 14, 0, -4, 61, -39

Vom calcula de la stânga la dreapta sumele maximale ce se termină la pozițiile respective:

{| class="wikitable"
! V
| 12
| 14
| 0
| -4
| 61
| -39
|-
! S
| 12
| 26 = max(14, 12 + 14)
| 26 = max(0, 0 + 26)
| 22 = max(-4, -4 + 26)
| 83 = max(61, 61 + 22)
| 44 = max(-39, -39 + 83)
|}

=== Analiză ===

Acest algoritm are complexitate ''O(n)'', unde n este lungimea șirului. Memoria folosită este ''O(1)'', deoarece nu avem nevoie să stocăm elementele, ci doar ultima sumă calculată.

=== Reconstrucția soluției ===

Putem ține minte șirul maximal ținând minte începutul și sfârșitul subșirului maximal atunci când îl găsim.

=== Soluții alternative ===

Această problemă poate fi rezolvată fără programare dinamică. Ne propunem același lucru, ca la pasul <tt>i</tt> să calculăm <source lang="C" enclose="none">S[i]</source> cu aceeași semnificație. Acest <source lang="C" enclose="none">S[i]</source> se poate calcula cu cunoștințe de nivel mic: sume parțiale. <source lang="C" enclose="none">S[i]</source> va fi suma unei secvențe de la <tt>k</tt> la <tt>i</tt>, cu <tt>k ≤ i</tt>. Deci, dacă vom calcula <source lang="C" enclose="none">P[]</source>, sumele parțiale pe vector putem spune că <source lang="C" enclose="none">S[i] = P[i] - P[k]</source>. Să ne uităm puțin la această expresie: cine variază în ea? <source lang="C" enclose="none">P[i]</source> este constant, este suma elementelor până la <tt>i</tt>. Putem varia doar <source lang="C" enclose="none">P[k]</source>. Este evident că dorim să alegem un <source lang="C" enclose="none">P[k]</source> cât mai mic, nu?

Algoritmul este unul banal: calculează sume parțiale, avansând <tt>i</tt>. Suma minimă care se termină în <tt>i</tt> este suma parțială curentă minus suma parțială minimă din trecut. La fiecare avans actualizează suma parțială minimă cu cea curentă, dacă este cazul.

Acest algoritm are aceleași complexități ca cel cu programare dinamică. El este însă un algoritm mai flexibil de adaptat unor modificări, cum ar fi suma maximă de lungime cel puțin <tt>K</tt> sau suma maximă de lungime cel mult <tt>K</tt>.

== Subșirul comun maximal al două șiruri ==

Această problemă cere să găsim lungimea unui subșir de lungime maximă (contiguu) inclus în două șiruri.

=== Exemplu ===

Date șirurile

ABABC

și

CBABA

un subșir maximal are lungime 3 și este

BAB

=== Soluție ===

Cum împărțim problema în subprobleme? Să observăm că deoarece subșirul maximal face parte din ambele șiruri el se va termina la o poziție <tt>i</tt> în șirul <tt>X</tt> și la o poziție <tt>j</tt> în șirul <tt>Y</tt>. Și atunci să încercăm astfel:

M[i][j] = lungimea celui mai lung subșir care se termină la poziția i în X și la poziția j în Y.

Are această împărțire proprietatea de optimalitate?

Să presupunem că avem un subșir optimal care se termină la pozițiile <tt>i</tt>, respectiv <tt>j</tt>. Atunci este subșirul <tt>M[i-1][j-1]</tt> la rândul lui optimal? Cu alte cuvinte subșirul mai scurt cu unu, care se termină la pozițiile anterioare în <tt>X</tt>, respectiv <tt>Y</tt>, este optimal? Da, el este optimal, caci altfel l-am putea înlocui cu un șir mai lung, care ar duce la o soluție mai bună, ceea ce ar însemna că soluția originală nu a fost optimă.

Următorul pas este să găsim relația de recurență:

:<math>M[i][j] = \begin{cases} M[i-1][j-1]+1, & \mbox{dacă } X[i] = Y[j] \\0, & \mbox{în caz contrar }. \end{cases}</math>

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula matricea <source lang="C" enclose="none">M</source> pe linii, folosind formula de recurență.

Soluția problemei este maximul din matrice.

=== Exemplu ===

Pentru cele două șiruri de mai sus,

ABABC

și

CBABA

Vom calcula o matrice <source lang="C" enclose="none">M[5][5]</source> care arată astfel:

{| class="wikitable"
!
! C
! B
! A
! B
! A
|-
! A
| 0
| 0
| 1
| 0
| 1
|-
! B
| 0
| 1
| 0
| 2
| 0
|-
! A
| 0
| 0
| 2
| 0
| 3
|-
! B
| 0
| 1
| 0
| 3
| 0
|-
! C
| 1
| 0
| 0
| 0
| 0
|}

Observăm că avem două subșiruri comune de lungime 3: ABA și BAB.

=== Analiză ===

Acest algoritm are complexitate ''O(m·n)'', unde <tt>m</tt> și <tt>n</tt> sunt lungimile șirurilor. Memoria folosită este, la prima vedere, ''O(m·n)''. În realitate, parcurgând matricea pe linii, nu avem nevoie să memorăm decât o linie din matrice pentru a calcula toate valorile. De aceea memoria necesară este ''O(min(m, n))''.

Există și algoritmi mai eficienți bazați pe arbori sufix, despre care nu vom discuta aici.

=== Reconstrucția soluției ===

Cum facem să aflăm nu doar lungimea ci și care este șirul comun maximal și unde apare el în cele două șiruri?

Vom face calculul matricei noastre printr-o parcurgere pe linii. La fiecare pas ne vom întreba dacă elementul calculat (lungimea) este mai mare decât maximul curent. Dacă da, vom memora acel maxim împreună cu indicii <tt>i</tt> și <tt>j</tt> la care s-a obținut el.

La final vom avea poziția de start în primul șir ca fiind <tt>i - max + 1</tt> și în al doilea șir ca fiind <tt>j - max + 1</tt>.

== Subsecvența comună maximală a două șiruri ==

Această problemă cere să găsim lungimea unei subsecvențe de lungime maximă inclusă în două secvențe. Prin secvență înțelegem caractere în ordinea originală, nu neapărat consecutive ca poziție.

=== Exemplu ===

Date secvențele

X: ACDEGIKMPR
Y: CMEFPGHRK

o secvență maximală are lungime 4 și este

CEGK

o altă secvență maximală este

CMPR

=== Soluție ===

Cum împărțim problema în subprobleme? Să încercăm să o împărțim în mod similar cu subșirul comun maximal:

M[i][j] = lungimea celei mai lungi subsecvențe incluse în șirurile X[1..i] și Y[1..j]

Are această împărțire proprietatea de optimalitate?

Să presupunem că avem o secvență optimală a prefixelor care se termină la pozițiile <tt>i</tt>, respectiv <tt>j</tt>. Ea va trece prin anumite perechi <tt>(ik, jk)</tt>, strict crescătoare, cu proprietatea că <tt>X[ik] = Y[jk]</tt>:

Si,j = (i1, j1) (i2, j2) ... (ik, jk)

cu proprietatea că:

Xi1Xi2... Xik-1Xik = Yj1Yj2... Yjk-1Yjk

Atunci este lungimea <tt>M[ik-1][jk-1]</tt> la rândul ei optimală? Cu alte cuvinte subsecvența mai scurtă cu unu, care se termină la poziția <tt>ik-1</tt> în <tt>X</tt>, respectiv poziția <tt>jk-1</tt> în <tt>Y</tt>, este optimală? Da, ea este optimală, căci altfel am putea-o înlocui cu o secvență mai lungă, care ar duce la o soluție mai bună, ceea ce ar însemna că soluția originală nu a fost optimă.

Următorul pas este să găsim relația de recurență:

<math>M[i][j] = \begin{cases} 0, & \mbox{dacă } i = 0 \mbox{ sau } j = 0\\M[i-1][j-1]+1, & \mbox{dacă } X[i] = Y[j]\\max(M[i-1][j],M[i][j-1]) & \mbox{dacă } X[i] \neq Y[j]. \end{cases}</math>

Cum demonstrăm această relație de recurență? Avem două cazuri de demonstrat:

==== Egalitate ====

Prefixele <tt>X[1..i]</tt> și <tt>Y[1..j]</tt> se termină în același caracter. În acest caz o subsecvență maximală a celor două prefixe se poate obține selectând acel ultim caracter. Putem, deci exclude acel caracter și calcula subsecvența maximală în prefixele <tt>X[1..i-1]</tt> și <tt>Y[1..j-1]</tt>. La lungimea ei vom aduna unu.

==== Diferență ====

Prefixele <tt>X[1..i]</tt> și <tt>Y[1..j]</tt> se termină în caractere diferite. Să luăm cazul anterior, avem secvențele:

X: ACDEGIKMPR
Y: CMEFPGHRK

Avem iarăși două cazuri:

* '''Cazul 1''': subsecvența optimă se termină în <tt>R</tt>. În acest caz ea nu se poate termina și în <tt>K</tt>. Deci putem elimina ultimul caracter din <tt>Y</tt> și calcula <tt>M[i][j-1]</tt>.
* '''Cazul 2''': subsecvența optimă nu se termină în <tt>R</tt>. În acest caz putem elimina acest <tt>R</tt> și calcula <tt>M[i-1][j]</tt>.

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula matricea <source lang="C" enclose="none">M</source> pe linii, folosind formula de recurență.

Soluția problemei este <source lang="C" enclose="none">M[n][m]</source>.

=== Exemplu ===

Pentru cele două șiruri de mai sus,

ACDEGIKMPR

și

CMEFPGHRK

Vom calcula o matrice <source lang="C" enclose="none">M[10][9]</source> care arată astfel:

{| class="wikitable"
!
! C !! M !! E !! F !! P !! G !! H !! R !! K
|-
!A
|0||0||0||0||0||0||0||0||0
|-
!C
|1||1||1||1||1||1||1||1||1
|-
!D
|1||1||1||1||1||1||1||1||1
|-
!E
|1||1||2||2||2||2||2||2||2
|-
!G
|1||1||2||2||2||3||3||3||3
|-
!I
|1||1||2||2||2||3||3||3||3
|-
!K
|1||1||2||2||2||3||3||3||4
|-
!M
|1||2||2||2||2||3||3||3||4
|-
!P
|1||2||2||2||3||3||3||3||4
|-
!R
|1||2||2||2||3||3||3||4||4
|}

Cea mai lungă secvență este de lungime 4, valoarea maximă ce apare în tabel.

=== Analiză ===

Acest algoritm are complexitate ''O(m · n)'', unde <tt>m</tt> și <tt>n</tt> sunt lungimile șirurilor. Memoria folosită este ''O(min(m,n))'' dacă memorăm doar o linie din matrice. Dacă dorim să aflăm și o secvență maximală, nu doar lungimea ei, vom avea nevoie de memorie ''O(m · n)'', precum vom vedea mai jos.

Există un algoritm care reduce necesarul de memorie la ''O(min(m, n))''.

=== Reconstrucția soluției ===

Dorim să aflăm nu doar lungimea, ci și o secvență maximală inclusă în ambele șiruri. Cum procedăm?

Observăm că literele ce fac parte din secvențele maximale se obțin acolo unde, în matrice, avem ramura doi de calcul, când literele de la pozițiile respective sunt egale.

Pentru a putea reconstrui soluția vom memora în fiecare căsuță, pe lângă lungimea maximă și direcția din care provine ea, adică din care am calculat acel maxim. Direcția poate fi spre stânga, spre în sus, sau în diagonală stânga-sus. Apoi vom porni din elementul <source lang="C" enclose="none">M[m][n]</source> și vom urma aceste direcții până ce ieșim din matrice. De fiecare dată când urmăm o diagonală reținem litera. Astfel, descoperirea secvenței se face în ordine inversă.

== Tema 24 ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/dreptunghiuri Dreptunghiuri] pentru subsecvența crescătoare maximală. '''Atenţie:''' puteți pica teste cu TLE, este în regulă.
* [https://www.nerdarena.ro/problema/ssm Subșirul de sumă maximă]
* [https://www.nerdarena.ro/problema/sclm Subșirul comun maximal]
* [https://www.nerdarena.ro/problema/cmlsc Subsecvența comună maximală]

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_24:_Programare_dinamic%C4%83_(1) Accesează rezolvarea temei 24]

Clasa a 7-a Lecția 24: Programare dinamică (1)

2025-06-10T09:20:50Z

Mihai:

== Înregistrare video lecție ==

{{#ev:youtube|https://www.youtube.com/watch?v=a0wFdh8DInQ|||||start=7600&end=11100&loop=1}}

== Conceptul de programare dinamică ==

=== Introducere ===

Wikipedia definește [http://en.wikipedia.org/wiki/Dynamic_programming programarea dinamică] drept o metodă pentru rezolvarea unor probleme complexe prin descompunerea lor în subprobleme mai simple. Se poate aplica problemelor care prezintă proprietățile de ''suprapunere a subproblemelor'' și de ''substructură optimală''. Atunci când se poate aplica, metoda ia mult mai puțin timp decât alte soluții naive.

[[Image:Shortest_path_optimal_substructure.svg|frame|right|300px|Drumul cel mai scurt între două orașe poate fi rezolvat cu programare dinamică]]

''Substructura optimală'' înseamnă că soluția unei problemei de optimizare date poate fi obținută prin combinarea unor soluții optimale ale subproblemelor. Ca atare, primul pas către găsirea unei rezolvări prin această metodă este verificarea dacă problema are proprietatea substructurii optimale.

Drumul cel mai scurt între două orașe poate fi rezolvat cu programare dinamică

Astfel de substructuri optimale sunt în mod uzual descrise prin recurență. De exemplu, date niște orașe și distanțele între ele, drumul cel mai scurt de la orașul <tt>u</tt> la orașul <tt>v</tt> are proprietatea de substructură optimală: să luăm orice oraș intermediar <tt>w</tt> pe drumul cel mai scurt, <tt>d</tt>. Dacă <tt>d</tt> este cu adevărat drumul cel mai scurt, atunci drumul <tt>d1</tt> de la <tt>u</tt> la <tt>w</tt> și <tt>d2</tt> de la <tt>w</tt> la <tt>v</tt> sunt cu adevărat cele mai scurte drumuri între orașele corespunzătoare. Dacă drumul de la <tt>u</tt> la <tt>w</tt> nu ar fi cel mai scurt posibil ar însemna că am avea un alt drum mai scurt, ceea ce ar duce la un drum total <tt>d</tt>, de la <tt>u</tt> la <tt>v</tt>, mai scurt decât cel original. Așadar, putem formula soluția problemei găsirii celui mai scurt drum într-o manieră recursivă, ceea ce fac algoritmii [https://en.wikipedia.org/wiki/Bellman-Ford_algorithm Bellman-Ford] și [https://en.wikipedia.org/wiki/Floyd-Warshall_algorithm Floyd-Warshall].

Suprapunerea subproblemelor înseamnă că ele nu sunt independente, adică subproblemele au în comun alte subprobleme. Nu vom insista pe această proprietate decât atât cât să menționăm că dacă subproblemele nu se suprapun dar prezintă substructură optimală atunci putem aplica tehnica de [https://www.algopedia.ro/wiki/index.php/Clasa_a_7-a_Lec%C8%9Bia_18:_Divide_et_impera,_mergesort,_quicksort programare divide et impera (divide and conquer)]. De aceea [http://en.wikipedia.org/wiki/Quicksort quicksort] și [http://en.wikipedia.org/wiki/Mergesort mergesort] nu sunt clasificate ca probleme de programare dinamică.

=== Metodă ===

Când încercăm să rezolvăm o problemă de programare dinamică întrebarea crucială la care trebuie să răspundem este ''putem calcula soluția finală pe baza unor subprobleme care sunt la rândul lor '''optimale''' ''? Pentru a răspunde la întrebare trebuie mai întâi să formulăm subproblemele. Dar pentru a formula subproblemele trebuie să avem în minte principiul substructurii optimale. Altfel s-ar putea să împărțim problema în subprobleme care nu au substructură optimală.

Să recapitulăm: pentru a putea răspunde la întrebarea dacă o problemă admite o soluție prin programare dinamică trebuie să aflăm dacă are substructură optimală. Dar pentru a afla dacă are substructură optimală trebuie să găsim subproblemele. Pe care încercăm să le găsim folosind programarea dinamică.

Nu cumva ne învârtim în cerc? Așa pare și așa și este, într-o oarecare măsură. Experiența este cea care ne învață cum să căutăm împărțirea în subprobleme astfel încât să obținem proprietatea de optimalitate. Tot experiența este cea care ne ajută să ne dăm seama rapid dacă împărțirea găsită are această proprietate sau nu.

Odată ce demonstrăm că o împărțire în subprobleme se bazează doar pe subprobleme optimale, restul decurge, de obicei, destul de simplu: găsim o formulă de recurență, apoi o implementăm de jos în sus (sau bottom-up), pornind de la cele mai mici probleme, către cele mai mari, până la soluția cerută.

În continuare vom lua câteva exemple.

== Subsecvența crescătoare de lungime maximă ==

Această problemă cere să găsim o subsecvență a unei secvențe de numere în care elementele sunt în ordine crescătoare, iar subsecvența este de lungime maximă. Subsecvența nu este neapărat contiguă, nici unică.

Exemplu

În secvența

0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15

o secvență crescătoare de lungime maximă este

0, 2, 6, 9, 13, 15

Această secvență are lungime șase. Nu există nici o secvență crescătoare de lungime șapte. Cea mai lungă subsecvență crescătoare nu este unică. De exemplu

0, 4, 6, 9, 11, 15

este o altă subsecvență crescătoare de aceeași lungime, în secvența de intrare.

=== Soluție ===

Cum împărțim problema în subprobleme? Să încercăm astfel:

L[i] = lungimea celei mai lungi subsecvențe care începe la poziția i

Are această împărțire proprietatea de optimalitate? Să presupunem că avem o subsecvență optimală crescătoare care trece prin indicii

i1, i2, i3, …, ik

Astfel

L[i1] = k

Este secvența <tt>i2, ..., ik</tt> optimală? Cu alte cuvinte lungimea secvenței optime care începe la <tt>i2</tt> este <tt>k-1</tt>? Răspunsul este da, secvența care începe la i2, anume i2, ..., ik este o secvență maximă, deoarece altfel am putea-o înlocui cu o secvență mai lungă, ceea ce ar duce la o subsecvență <tt>L[i1]</tt> mai lungă decât cea inițială, care era optimală. Obținem o contradicție.

Următorul pas este să găsim relația de recurență:

L[i] = max(L[j]+1), j > i și V[j] ≥ V[i]

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula vectorul <source lang="C" enclose="none">L<source lang="C" enclose="none"> de la coadă la cap, căutând pentru fiecare element <source lang="C" enclose="none">L[i]</source> cel mai mare element <source lang="C" enclose="none">L[j]</source> de după el <tt>(j > i)</tt> astfel încât <source lang="C" enclose="none">V[j] ≥ V[i]</source>.

Soluția problemei este maximul din vectorul <source lang="C" enclose="none">L</source>.

=== Exemplu ===

Să calculăm cea mai lungă secvență crescătoare în secvența:

0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15

Vom calcula lungimile secvențelor maximale de la coadă la cap: <source lang="C" enclose="none">L[15]</source>, apoi <source lang="C" enclose="none">L[14]</source> și așa mai departe. Când ajungem la calculul lui <tt>L[6]</tt> avem următoarea situație:

[[File:max-increasing-seq.png|frame|none|Exemplu de calcul pentru elementul ''L[6]'' - cea mai lungă secvență crescătoare care începe la poziția 6.]]

Pentru a calcula lungimea secvenței maximale care începe la poziția 6 vom căuta toate pozițiile mai mari <tt>(7, 8, 9, ...)</tt>. Le vom lua în considerare doar pe acelea în care <source lang="C" enclose="none">V[i] >= V[6]</source>. Dintre ele vom alege poziția unde <source lang="C" enclose="none">L[i]</source> este maximă. Astfel vom găsi că <source lang="C" enclose="none">V[9] = 9</source> și <source lang="C" enclose="none">L[9] = 3</source>. Vom avea, deci, o secvență de lungime 4. Ea este:

6, 9, 11, 15

Exemplu de calcul pentru elementul <source lang="C" enclose="none">L[6]</source> - cea mai lungă secvență crescătoare care începe la poziția 6.

=== Analiză ===

Acest algoritm are complexitate ''O(n2)'', unde n este lungimea secvenței. Memoria folosită este ''O(n)''.

Există și un algoritm mai rapid, de complexitate ''O(n log n)'', bazat pe căutare binară a valorilor de început.

=== Reconstrucția soluției ===

Putem reconstrui o subsecvență maximală folosind încă un vector, <source lang="C" enclose="none">N[]</source>. El memorează pentru fiecare indice <tt>i</tt> un alt indice <tt>j</tt> care urmează în secvență după <tt>j</tt>. Atunci când calculăm elementul curent, vom nota nu doar maximul găsit (plus unu) ci și poziția lui în vector, el fiind elementul următor în secvență.

== Subșirul de sumă maximală ==
Această problemă cere să găsim un subșir de sumă maximă într-un șir de numere. Un subșir este contiguu.

=== Exemplu ===

Să considerăm șirul:

12, 14, 0, -4, 61, -39

subșirul de sumă maximală este:

12, 14, 0, -4, 61

și are sumă 83.

=== Soluție ===

Cum împărțim problema în subprobleme? Să încercăm astfel:

S[i] este suma maximală a unui șir care se termină la poziția i

Are această împărțire proprietatea de optimalitate?

Să presupunem că avem un subșir de sumă maximă și că el se află între indicii <tt>i</tt> și <tt>j</tt>. Cu alte cuvine suma maximală este

S[j] = V[i] + V[i+1] + ... + V[j-1] + V[j]

Are șirul care se termină în <tt>j-1</tt>, sumă maximală? Cu alte cuvinte este suma

S[j-1] = V[i] + V[i+1] + ... + V[j-1]

maximală?

Răspunsul este da, deoarece altfel am putea-o înlocui cu o sumă mai mare, ceea ce ar duce la o sumă mai mare decît cea inițială, care era optimală. Obținem o contradicție.

Următorul pas este să găsim relația de recurență. Observăm că pentru o poziție <tt>i</tt> avem două variante: fie continuăm secvența anterioară, care se termină în <tt>i-1</tt>, fie începem una nouă, care pornește în <tt>i</tt>. Vom continua secvența anterioară dacă adunând numărul curent obținem o sumă mai mare strict decât numărul curent. Altfel vom porni o sumă nouă. Relația de recurență este:

S[i] = max(V[i], S[i-1] + V[i])

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula vectorul <source lang="C" enclose="none">S</source> calculând pentru fiecare element <source lang="C" enclose="none">S[i]</source> maximul dintre <source lang="C" enclose="none">S[i-1] + V[i]</source> și <source lang="C" enclose="none">V[i]</source>. Observăm că, în realitate, vom compara <source lang="C" enclose="none">S[i-1]</source> cu zero.

Soluția problemei este maximul din vectorul <source lang="C" enclose="none">S</source>.

=== Exemplu ===

Fie secvența anterioară:

12, 14, 0, -4, 61, -39

Vom calcula de la stânga la dreapta sumele maximale ce se termină la pozițiile respective:

{| class="wikitable"
! V
| 12
| 14
| 0
| -4
| 61
| -39
|-
! S
| 12
| 26 = max(14, 12 + 14)
| 26 = max(0, 0 + 26)
| 22 = max(-4, -4 + 26)
| 83 = max(61, 61 + 22)
| 44 = max(-39, -39 + 83)
|}

=== Analiză ===

Acest algoritm are complexitate ''O(n)'', unde n este lungimea șirului. Memoria folosită este ''O(1)'', deoarece nu avem nevoie să stocăm elementele, ci doar ultima sumă calculată.

=== Reconstrucția soluției ===

Putem ține minte șirul maximal ținând minte începutul și sfârșitul subșirului maximal atunci când îl găsim.

=== Soluții alternative ===

Această problemă poate fi rezolvată fără programare dinamică. Ne propunem același lucru, ca la pasul <tt>i</tt> să calculăm <source lang="C" enclose="none">S[i]</source> cu aceeași semnificație. Acest <source lang="C" enclose="none">S[i]</source> se poate calcula cu cunoștințe de nivel mic: sume parțiale. <source lang="C" enclose="none">S[i]</source> va fi suma unei secvențe de la <tt>k</tt> la <tt>i</tt>, cu <tt>k ≤ i</tt>. Deci, dacă vom calcula <source lang="C" enclose="none">P[]</source>, sumele parțiale pe vector putem spune că <source lang="C" enclose="none">S[i] = P[i] - P[k]</source>. Să ne uităm puțin la această expresie: cine variază în ea? <source lang="C" enclose="none">P[i]</source> este constant, este suma elementelor până la <tt>i</tt>. Putem varia doar <source lang="C" enclose="none">P[k]</source>. Este evident că dorim să alegem un <source lang="C" enclose="none">P[k]</source> cât mai mic, nu?

Algoritmul este unul banal: calculează sume parțiale, avansând <tt>i</tt>. Suma minimă care se termină în <tt>i</tt> este suma parțială curentă minus suma parțială minimă din trecut. La fiecare avans actualizează suma parțială minimă cu cea curentă, dacă este cazul.

Acest algoritm are aceleași complexități ca cel cu programare dinamică. El este însă un algoritm mai flexibil de adaptat unor modificări, cum ar fi suma maximă de lungime cel puțin <tt>K</tt> sau suma maximă de lungime cel mult <tt>K</tt>.

== Subșirul comun maximal al două șiruri ==

Această problemă cere să găsim lungimea unui subșir de lungime maximă (contiguu) inclus în două șiruri.

=== Exemplu ===

Date șirurile

ABABC

și

CBABA

un subșir maximal are lungime 3 și este

BAB

=== Soluție ===

Cum împărțim problema în subprobleme? Să observăm că deoarece subșirul maximal face parte din ambele șiruri el se va termina la o poziție <tt>i</tt> în șirul <tt>X</tt> și la o poziție <tt>j</tt> în șirul <tt>Y</tt>. Și atunci să încercăm astfel:

M[i][j] = lungimea celui mai lung subșir care se termină la poziția i în X și la poziția j în Y.

Are această împărțire proprietatea de optimalitate?

Să presupunem că avem un subșir optimal care se termină la pozițiile <tt>i</tt>, respectiv <tt>j</tt>. Atunci este subșirul <tt>M[i-1][j-1]</tt> la rândul lui optimal? Cu alte cuvinte subșirul mai scurt cu unu, care se termină la pozițiile anterioare în <tt>X</tt>, respectiv <tt>Y</tt>, este optimal? Da, el este optimal, caci altfel l-am putea înlocui cu un șir mai lung, care ar duce la o soluție mai bună, ceea ce ar însemna că soluția originală nu a fost optimă.

Următorul pas este să găsim relația de recurență:

:<math>M[i][j] = \begin{cases} M[i-1][j-1]+1, & \mbox{dacă } X[i] = Y[j] \\0, & \mbox{în caz contrar }. \end{cases}</math>

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula matricea <source lang="C" enclose="none">M</source> pe linii, folosind formula de recurență.

Soluția problemei este maximul din matrice.

=== Exemplu ===

Pentru cele două șiruri de mai sus,

ABABC

și

CBABA

Vom calcula o matrice <source lang="C" enclose="none">M[5][5]</source> care arată astfel:

{| class="wikitable"
!
! C
! B
! A
! B
! A
|-
! A
| 0
| 0
| 1
| 0
| 1
|-
! B
| 0
| 1
| 0
| 2
| 0
|-
! A
| 0
| 0
| 2
| 0
| 3
|-
! B
| 0
| 1
| 0
| 3
| 0
|-
! C
| 1
| 0
| 0
| 0
| 0
|}

Observăm că avem două subșiruri comune de lungime 3: ABA și BAB.

=== Analiză ===

Acest algoritm are complexitate ''O(m·n)'', unde <tt>m</tt> și <tt>n</tt> sunt lungimile șirurilor. Memoria folosită este, la prima vedere, ''O(m·n)''. În realitate, parcurgând matricea pe linii, nu avem nevoie să memorăm decât o linie din matrice pentru a calcula toate valorile. De aceea memoria necesară este ''O(min(m, n))''.

Există și algoritmi mai eficienți bazați pe arbori sufix, despre care nu vom discuta aici.

=== Reconstrucția soluției ===

Cum facem să aflăm nu doar lungimea ci și care este șirul comun maximal și unde apare el în cele două șiruri?

Vom face calculul matricei noastre printr-o parcurgere pe linii. La fiecare pas ne vom întreba dacă elementul calculat (lungimea) este mai mare decât maximul curent. Dacă da, vom memora acel maxim împreună cu indicii <tt>i</tt> și <tt>j</tt> la care s-a obținut el.

La final vom avea poziția de start în primul șir ca fiind <tt>i - max + 1</tt> și în al doilea șir ca fiind <tt>j - max + 1</tt>.

== Subsecvența comună maximală a două șiruri ==

Această problemă cere să găsim lungimea unei subsecvențe de lungime maximă inclusă în două secvențe. Prin secvență înțelegem caractere în ordinea originală, nu neapărat consecutive ca poziție.

=== Exemplu ===

Date secvențele

X: ACDEGIKMPR
Y: CMEFPGHRK

o secvență maximală are lungime 4 și este

CEGK

o altă secvență maximală este

CMPR

=== Soluție ===

Cum împărțim problema în subprobleme? Să încercăm să o împărțim în mod similar cu subșirul comun maximal:

M[i][j] = lungimea celei mai lungi subsecvențe incluse în șirurile X[1..i] și Y[1..j]

Are această împărțire proprietatea de optimalitate?

Să presupunem că avem o secvență optimală a prefixelor care se termină la pozițiile <tt>i</tt>, respectiv <tt>j</tt>. Ea va trece prin anumite perechi <tt>(ik, jk)</tt>, strict crescătoare, cu proprietatea că <tt>X[ik] = Y[jk]</tt>:

Si,j = (i1, j1) (i2, j2) ... (ik, jk)

cu proprietatea că:

Xi1Xi2... Xik-1Xik = Yj1Yj2... Yjk-1Yjk

Atunci este lungimea <tt>M[ik-1][jk-1]</tt> la rândul ei optimală? Cu alte cuvinte subsecvența mai scurtă cu unu, care se termină la poziția <tt>ik-1</tt> în <tt>X</tt>, respectiv poziția <tt>jk-1</tt> în <tt>Y</tt>, este optimală? Da, ea este optimală, căci altfel am putea-o înlocui cu o secvență mai lungă, care ar duce la o soluție mai bună, ceea ce ar însemna că soluția originală nu a fost optimă.

Următorul pas este să găsim relația de recurență:

<math>M[i][j] = \begin{cases} 0, & \mbox{dacă } i = 0 \mbox{ sau } j = 0\\M[i-1][j-1]+1, & \mbox{dacă } X[i] = Y[j]\\max(M[i-1][j],M[i][j-1]) & \mbox{dacă } X[i] \neq Y[j]. \end{cases}</math>

Cum demonstrăm această relație de recurență? Avem două cazuri de demonstrat:

==== Egalitate ====

Prefixele <tt>X[1..i]</tt> și <tt>Y[1..j]</tt> se termină în același caracter. În acest caz o subsecvență maximală a celor două prefixe se poate obține selectând acel ultim caracter. Putem, deci exclude acel caracter și calcula subsecvența maximală în prefixele <tt>X[1..i-1]</tt> și <tt>Y[1..j-1]</tt>. La lungimea ei vom aduna unu.

==== Diferență ====

Prefixele <tt>X[1..i]</tt> și <tt>Y[1..j]</tt> se termină în caractere diferite. Să luăm cazul anterior, avem secvențele:

X: ACDEGIKMPR
Y: CMEFPGHRK

Avem iarăși două cazuri:

* '''Cazul 1''': subsecvența optimă se termină în <tt>R</tt>. În acest caz ea nu se poate termina și în <tt>K</tt>. Deci putem elimina ultimul caracter din <tt>Y</tt> și calcula <tt>M[i][j-1]</tt>.
* '''Cazul 2''': subsecvența optimă nu se termină în <tt>R</tt>. În acest caz putem elimina acest <tt>R</tt> și calcula <tt>M[i-1][j]</tt>.

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula matricea <source lang="C" enclose="none">M</source> pe linii, folosind formula de recurență.

Soluția problemei este <source lang="C" enclose="none">M[n][m]</source>.

=== Exemplu ===

Pentru cele două șiruri de mai sus,

ACDEGIKMPR

și

CMEFPGHRK

Vom calcula o matrice <source lang="C" enclose="none">M[10][9]</source> care arată astfel:

{| class="wikitable"
!
! C !! M !! E !! F !! P !! G !! H !! R !! K
|-
!A
|0||0||0||0||0||0||0||0||0
|-
!C
|1||1||1||1||1||1||1||1||1
|-
!D
|1||1||1||1||1||1||1||1||1
|-
!E
|1||1||2||2||2||2||2||2||2
|-
!G
|1||1||2||2||2||3||3||3||3
|-
!I
|1||1||2||2||2||3||3||3||3
|-
!K
|1||1||2||2||2||3||3||3||4
|-
!M
|1||2||2||2||2||3||3||3||4
|-
!P
|1||2||2||2||3||3||3||3||4
|-
!R
|1||2||2||2||3||3||3||4||4
|}

Cea mai lungă secvență este de lungime 4, valoarea maximă ce apare în tabel.

=== Analiză ===

Acest algoritm are complexitate ''O(m · n)'', unde <tt>m</tt> și <tt>n</tt> sunt lungimile șirurilor. Memoria folosită este ''O(min(m,n))'' dacă memorăm doar o linie din matrice. Dacă dorim să aflăm și o secvență maximală, nu doar lungimea ei, vom avea nevoie de memorie ''O(m · n)'', precum vom vedea mai jos.

Există un algoritm care reduce necesarul de memorie la ''O(min(m, n))''.

=== Reconstrucția soluției ===

Dorim să aflăm nu doar lungimea, ci și o secvență maximală inclusă în ambele șiruri. Cum procedăm?

Observăm că literele ce fac parte din secvențele maximale se obțin acolo unde, în matrice, avem ramura doi de calcul, când literele de la pozițiile respective sunt egale.

Pentru a putea reconstrui soluția vom memora în fiecare căsuță, pe lângă lungimea maximă și direcția din care provine ea, adică din care am calculat acel maxim. Direcția poate fi spre stânga, spre în sus, sau în diagonală stânga-sus. Apoi vom porni din elementul <source lang="C" enclose="none">M[m][n]</source> și vom urma aceste direcții până ce ieșim din matrice. De fiecare dată când urmăm o diagonală reținem litera. Astfel, descoperirea secvenței se face în ordine inversă.

== Tema 24 ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/dreptunghiuri Dreptunghiuri] pentru subsecvența crescătoare maximală. '''Atenţie:''' puteți pica teste cu TLE, este în regulă.
* [https://www.nerdarena.ro/problema/ssm Subșirul de sumă maximă]
* [https://www.nerdarena.ro/problema/sclm Subșirul comun maximal]
* [https://www.nerdarena.ro/problema/cmlsc Subsecvența comună maximală]

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_24:_Programare_dinamic%C4%83_(1) Accesează rezolvarea temei 24]

Clasa a 7-a Lecția 24: Programare dinamică (1)

2025-06-10T09:18:27Z

Mihai:

== Înregistrare video lecție ==

{{#ev:youtube|https://www.youtube.com/watch?v=a0wFdh8DInQ|||||start=7600&end=11100&loop=1}}

== Conceptul de programare dinamică ==

=== Introducere ===

Wikipedia definește [http://en.wikipedia.org/wiki/Dynamic_programming programarea dinamică] drept o metodă pentru rezolvarea unor probleme complexe prin descompunerea lor în subprobleme mai simple. Se poate aplica problemelor care prezintă proprietățile de ''suprapunere a subproblemelor'' și de ''substructură optimală''. Atunci când se poate aplica, metoda ia mult mai puțin timp decât alte soluții naive.

[[Image:Shortest_path_optimal_substructure.svg|frame|right|300px|Drumul cel mai scurt între două orașe poate fi rezolvat cu programare dinamică]]

''Substructura optimală'' înseamnă că soluția unei problemei de optimizare date poate fi obținută prin combinarea unor soluții optimale ale subproblemelor. Ca atare, primul pas către găsirea unei rezolvări prin această metodă este verificarea dacă problema are proprietatea substructurii optimale.

Drumul cel mai scurt între două orașe poate fi rezolvat cu programare dinamică

Astfel de substructuri optimale sunt în mod uzual descrise prin recurență. De exemplu, date niște orașe și distanțele între ele, drumul cel mai scurt de la orașul <tt>u</tt> la orașul <tt>v</tt> are proprietatea de substructură optimală: să luăm orice oraș intermediar <tt>w</tt> pe drumul cel mai scurt, <tt>d</tt>. Dacă <tt>d</tt> este cu adevărat drumul cel mai scurt, atunci drumul <tt>d1</tt> de la <tt>u</tt> la <tt>w</tt> și <tt>d2</tt> de la <tt>w</tt> la <tt>v</tt> sunt cu adevărat cele mai scurte drumuri între orașele corespunzătoare. Dacă drumul de la <tt>u</tt> la <tt>w</tt> nu ar fi cel mai scurt posibil ar însemna că am avea un alt drum mai scurt, ceea ce ar duce la un drum total <tt>d</tt>, de la <tt>u</tt> la <tt>v</tt>, mai scurt decât cel original. Așadar, putem formula soluția problemei găsirii celui mai scurt drum într-o manieră recursivă, ceea ce fac algoritmii [https://en.wikipedia.org/wiki/Bellman-Ford_algorithm Bellman-Ford] și [https://en.wikipedia.org/wiki/Floyd-Warshall_algorithm Floyd-Warshall].

Suprapunerea subproblemelor înseamnă că ele nu sunt independente, adică subproblemele au în comun alte subprobleme. Nu vom insista pe această proprietate decât atât cât să menționăm că dacă subproblemele nu se suprapun dar prezintă substructură optimală atunci putem aplica tehnica de [https://www.algopedia.ro/wiki/index.php/Clasa_a_7-a_Lec%C8%9Bia_18:_Divide_et_impera,_mergesort,_quicksort programare divide et impera (divide and conquer)]. De aceea [http://en.wikipedia.org/wiki/Quicksort quicksort] și [http://en.wikipedia.org/wiki/Mergesort mergesort] nu sunt clasificate ca probleme de programare dinamică.

=== Metodă ===

Când încercăm să rezolvăm o problemă de programare dinamică întrebarea crucială la care trebuie să răspundem este ''putem calcula soluția finală pe baza unor subprobleme care sunt la rândul lor '''optimale''' ''? Pentru a răspunde la întrebare trebuie mai întâi să formulăm subproblemele. Dar pentru a formula subproblemele trebuie să avem în minte principiul substructurii optimale. Altfel s-ar putea să împărțim problema în subprobleme care nu au substructură optimală.

Să recapitulăm: pentru a putea răspunde la întrebarea dacă o problemă admite o soluție prin programare dinamică trebuie să aflăm dacă are substructură optimală. Dar pentru a afla dacă are substructură optimală trebuie să găsim subproblemele. Pe care încercăm să le găsim folosind programarea dinamică.

Nu cumva ne învârtim în cerc? Așa pare și așa și este, într-o oarecare măsură. Experiența este cea care ne învață cum să căutăm împărțirea în subprobleme astfel încât să obținem proprietatea de optimalitate. Tot experiența este cea care ne ajută să ne dăm seama rapid dacă împărțirea găsită are această proprietate sau nu.

Odată ce demonstrăm că o împărțire în subprobleme se bazează doar pe subprobleme optimale, restul decurge, de obicei, destul de simplu: găsim o formulă de recurență, apoi o implementăm de jos în sus (sau bottom-up), pornind de la cele mai mici probleme, către cele mai mari, până la soluția cerută.

În continuare vom lua câteva exemple.

== Subsecvența crescătoare de lungime maximă ==

Această problemă cere să găsim o subsecvență a unei secvențe de numere în care elementele sunt în ordine crescătoare, iar subsecvența este de lungime maximă. Subsecvența nu este neapărat contiguă, nici unică.

Exemplu

În secvența

0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15

o secvență crescătoare de lungime maximă este

0, 2, 6, 9, 13, 15

Această secvență are lungime șase. Nu există nici o secvență crescătoare de lungime șapte. Cea mai lungă subsecvență crescătoare nu este unică. De exemplu

0, 4, 6, 9, 11, 15

este o altă subsecvență crescătoare de aceeași lungime, în secvența de intrare.

=== Soluție ===

Cum împărțim problema în subprobleme? Să încercăm astfel:

L[i] = lungimea celei mai lungi subsecvențe care începe la poziția i

Are această împărțire proprietatea de optimalitate? Să presupunem că avem o subsecvență optimală crescătoare care trece prin indicii

i1, i2, i3, …, ik

Astfel

L[i1] = k

Este secvența <tt>i2, ..., ik</tt> optimală? Cu alte cuvinte lungimea secvenței optime care începe la <tt>i2</tt> este <tt>k-1</tt>? Răspunsul este da, secvența care începe la i2, anume i2, ..., ik este o secvență maximă, deoarece altfel am putea-o înlocui cu o secvență mai lungă, ceea ce ar duce la o subsecvență <tt>L[i1]</tt> mai lungă decât cea inițială, care era optimală. Obținem o contradicție.

Următorul pas este să găsim relația de recurență:

L[i] = max(L[j]+1), j > i și V[j] ≥ V[i]

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula vectorul <source lang="C" enclose="none">L<source lang="C" enclose="none"> de la coadă la cap, căutând pentru fiecare element <source lang="C" enclose="none">L[i]<source lang="C" enclose="none"> cel mai mare element <source lang="C" enclose="none">L[j]<source lang="C" enclose="none"> de după el <tt>(j > i)</tt> astfel încât <source lang="C" enclose="none">V[j] ≥ V[i]<source lang="C" enclose="none">.

Soluția problemei este maximul din vectorul <source lang="C" enclose="none">L</source>.

=== Exemplu ===

Să calculăm cea mai lungă secvență crescătoare în secvența:

0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15

Vom calcula lungimile secvențelor maximale de la coadă la cap: <source lang="C" enclose="none">L[15]</source>, apoi <source lang="C" enclose="none">L[14]</source> și așa mai departe. Când ajungem la calculul lui <tt>L[6]</tt> avem următoarea situație:

[[File:max-increasing-seq.png|frame|none|Exemplu de calcul pentru elementul ''L[6]'' - cea mai lungă secvență crescătoare care începe la poziția 6.]]

Pentru a calcula lungimea secvenței maximale care începe la poziția 6 vom căuta toate pozițiile mai mari <tt>(7, 8, 9, ...)</tt>. Le vom lua în considerare doar pe acelea în care <source lang="C" enclose="none">V[i] >= V[6]</source>. Dintre ele vom alege poziția unde <source lang="C" enclose="none">L[i]</source> este maximă. Astfel vom găsi că <source lang="C" enclose="none">V[9] = 9</source> și <source lang="C" enclose="none">L[9] = 3</source>. Vom avea, deci, o secvență de lungime 4. Ea este:

6, 9, 11, 15

Exemplu de calcul pentru elementul <source lang="C" enclose="none">L[6]</source> - cea mai lungă secvență crescătoare care începe la poziția 6.

=== Analiză ===

Acest algoritm are complexitate ''O(n2)'', unde n este lungimea secvenței. Memoria folosită este ''O(n)''.

Există și un algoritm mai rapid, de complexitate ''O(n log n)'', bazat pe căutare binară a valorilor de început.

=== Reconstrucția soluției ===

Putem reconstrui o subsecvență maximală folosind încă un vector, <source lang="C" enclose="none">N[]</source>. El memorează pentru fiecare indice <tt>i</tt> un alt indice <tt>j</tt> care urmează în secvență după <tt>j</tt>. Atunci când calculăm elementul curent, vom nota nu doar maximul găsit (plus unu) ci și poziția lui în vector, el fiind elementul următor în secvență.

== Subșirul de sumă maximală ==
Această problemă cere să găsim un subșir de sumă maximă într-un șir de numere. Un subșir este contiguu.

=== Exemplu ===

Să considerăm șirul:

12, 14, 0, -4, 61, -39

subșirul de sumă maximală este:

12, 14, 0, -4, 61

și are sumă 83.

=== Soluție ===

Cum împărțim problema în subprobleme? Să încercăm astfel:

S[i] este suma maximală a unui șir care se termină la poziția i

Are această împărțire proprietatea de optimalitate?

Să presupunem că avem un subșir de sumă maximă și că el se află între indicii <tt>i</tt> și <tt>j</tt>. Cu alte cuvine suma maximală este

S[j] = V[i] + V[i+1] + ... + V[j-1] + V[j]

Are șirul care se termină în <tt>j-1</tt>, sumă maximală? Cu alte cuvinte este suma

S[j-1] = V[i] + V[i+1] + ... + V[j-1]

maximală?

Răspunsul este da, deoarece altfel am putea-o înlocui cu o sumă mai mare, ceea ce ar duce la o sumă mai mare decît cea inițială, care era optimală. Obținem o contradicție.

Următorul pas este să găsim relația de recurență. Observăm că pentru o poziție <tt>i</tt> avem două variante: fie continuăm secvența anterioară, care se termină în <tt>i-1</tt>, fie începem una nouă, care pornește în <tt>i</tt>. Vom continua secvența anterioară dacă adunând numărul curent obținem o sumă mai mare strict decât numărul curent. Altfel vom porni o sumă nouă. Relația de recurență este:

S[i] = max(V[i], S[i-1] + V[i])

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula vectorul <source lang="C" enclose="none">S</source> calculând pentru fiecare element <source lang="C" enclose="none">S[i]</source> maximul dintre <source lang="C" enclose="none">S[i-1] + V[i]</source> și <source lang="C" enclose="none">V[i]</source>. Observăm că, în realitate, vom compara <source lang="C" enclose="none">S[i-1]</source> cu zero.

Soluția problemei este maximul din vectorul <source lang="C" enclose="none">S</source>.

=== Exemplu ===

Fie secvența anterioară:

12, 14, 0, -4, 61, -39

Vom calcula de la stânga la dreapta sumele maximale ce se termină la pozițiile respective:

{| class="wikitable"
! V
| 12
| 14
| 0
| -4
| 61
| -39
|-
! S
| 12
| 26 = max(14, 12 + 14)
| 26 = max(0, 0 + 26)
| 22 = max(-4, -4 + 26)
| 83 = max(61, 61 + 22)
| 44 = max(-39, -39 + 83)
|}

=== Analiză ===

Acest algoritm are complexitate ''O(n)'', unde n este lungimea șirului. Memoria folosită este ''O(1)'', deoarece nu avem nevoie să stocăm elementele, ci doar ultima sumă calculată.

=== Reconstrucția soluției ===

Putem ține minte șirul maximal ținând minte începutul și sfârșitul subșirului maximal atunci când îl găsim.

=== Soluții alternative ===

Această problemă poate fi rezolvată fără programare dinamică. Ne propunem același lucru, ca la pasul <tt>i</tt> să calculăm <source lang="C" enclose="none">S[i]</source> cu aceeași semnificație. Acest <source lang="C" enclose="none">S[i]</source> se poate calcula cu cunoștințe de nivel mic: sume parțiale. <source lang="C" enclose="none">S[i]</source> va fi suma unei secvențe de la <tt>k</tt> la <tt>i</tt>, cu <tt>k ≤ i</tt>. Deci, dacă vom calcula <source lang="C" enclose="none">P[]</source>, sumele parțiale pe vector putem spune că <source lang="C" enclose="none">S[i] = P[i] - P[k]</source>. Să ne uităm puțin la această expresie: cine variază în ea? <source lang="C" enclose="none">P[i]</source> este constant, este suma elementelor până la <tt>i</tt>. Putem varia doar <source lang="C" enclose="none">P[k]</source>. Este evident că dorim să alegem un <source lang="C" enclose="none">P[k]</source> cât mai mic, nu?

Algoritmul este unul banal: calculează sume parțiale, avansând <tt>i</tt>. Suma minimă care se termină în <tt>i</tt> este suma parțială curentă minus suma parțială minimă din trecut. La fiecare avans actualizează suma parțială minimă cu cea curentă, dacă este cazul.

Acest algoritm are aceleași complexități ca cel cu programare dinamică. El este însă un algoritm mai flexibil de adaptat unor modificări, cum ar fi suma maximă de lungime cel puțin <tt>K</tt> sau suma maximă de lungime cel mult <tt>K</tt>.

== Subșirul comun maximal al două șiruri ==

Această problemă cere să găsim lungimea unui subșir de lungime maximă (contiguu) inclus în două șiruri.

=== Exemplu ===

Date șirurile

ABABC

și

CBABA

un subșir maximal are lungime 3 și este

BAB

=== Soluție ===

Cum împărțim problema în subprobleme? Să observăm că deoarece subșirul maximal face parte din ambele șiruri el se va termina la o poziție <tt>i</tt> în șirul <tt>X</tt> și la o poziție <tt>j</tt> în șirul <tt>Y</tt>. Și atunci să încercăm astfel:

M[i][j] = lungimea celui mai lung subșir care se termină la poziția i în X și la poziția j în Y.

Are această împărțire proprietatea de optimalitate?

Să presupunem că avem un subșir optimal care se termină la pozițiile <tt>i</tt>, respectiv <tt>j</tt>. Atunci este subșirul <tt>M[i-1][j-1]</tt> la rândul lui optimal? Cu alte cuvinte subșirul mai scurt cu unu, care se termină la pozițiile anterioare în <tt>X</tt>, respectiv <tt>Y</tt>, este optimal? Da, el este optimal, caci altfel l-am putea înlocui cu un șir mai lung, care ar duce la o soluție mai bună, ceea ce ar însemna că soluția originală nu a fost optimă.

Următorul pas este să găsim relația de recurență:

:<math>M[i][j] = \begin{cases} M[i-1][j-1]+1, & \mbox{dacă } X[i] = Y[j] \\0, & \mbox{în caz contrar }. \end{cases}</math>

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula matricea <source lang="C" enclose="none">M</source> pe linii, folosind formula de recurență.

Soluția problemei este maximul din matrice.

=== Exemplu ===

Pentru cele două șiruri de mai sus,

ABABC

și

CBABA

Vom calcula o matrice <source lang="C" enclose="none">M[5][5]</source> care arată astfel:

{| class="wikitable"
!
! C
! B
! A
! B
! A
|-
! A
| 0
| 0
| 1
| 0
| 1
|-
! B
| 0
| 1
| 0
| 2
| 0
|-
! A
| 0
| 0
| 2
| 0
| 3
|-
! B
| 0
| 1
| 0
| 3
| 0
|-
! C
| 1
| 0
| 0
| 0
| 0
|}

Observăm că avem două subșiruri comune de lungime 3: ABA și BAB.

=== Analiză ===

Acest algoritm are complexitate ''O(m·n)'', unde <tt>m</tt> și <tt>n</tt> sunt lungimile șirurilor. Memoria folosită este, la prima vedere, ''O(m·n)''. În realitate, parcurgând matricea pe linii, nu avem nevoie să memorăm decât o linie din matrice pentru a calcula toate valorile. De aceea memoria necesară este ''O(min(m, n))''.

Există și algoritmi mai eficienți bazați pe arbori sufix, despre care nu vom discuta aici.

=== Reconstrucția soluției ===

Cum facem să aflăm nu doar lungimea ci și care este șirul comun maximal și unde apare el în cele două șiruri?

Vom face calculul matricei noastre printr-o parcurgere pe linii. La fiecare pas ne vom întreba dacă elementul calculat (lungimea) este mai mare decât maximul curent. Dacă da, vom memora acel maxim împreună cu indicii <tt>i</tt> și <tt>j</tt> la care s-a obținut el.

La final vom avea poziția de start în primul șir ca fiind <tt>i - max + 1</tt> și în al doilea șir ca fiind <tt>j - max + 1</tt>.

== Subsecvența comună maximală a două șiruri ==

Această problemă cere să găsim lungimea unei subsecvențe de lungime maximă inclusă în două secvențe. Prin secvență înțelegem caractere în ordinea originală, nu neapărat consecutive ca poziție.

=== Exemplu ===

Date secvențele

X: ACDEGIKMPR
Y: CMEFPGHRK

o secvență maximală are lungime 4 și este

CEGK

o altă secvență maximală este

CMPR

=== Soluție ===

Cum împărțim problema în subprobleme? Să încercăm să o împărțim în mod similar cu subșirul comun maximal:

M[i][j] = lungimea celei mai lungi subsecvențe incluse în șirurile X[1..i] și Y[1..j]

Are această împărțire proprietatea de optimalitate?

Să presupunem că avem o secvență optimală a prefixelor care se termină la pozițiile <tt>i</tt>, respectiv <tt>j</tt>. Ea va trece prin anumite perechi <tt>(ik, jk)</tt>, strict crescătoare, cu proprietatea că <tt>X[ik] = Y[jk]</tt>:

Si,j = (i1, j1) (i2, j2) ... (ik, jk)

cu proprietatea că:

Xi1Xi2... Xik-1Xik = Yj1Yj2... Yjk-1Yjk

Atunci este lungimea <tt>M[ik-1][jk-1]</tt> la rândul ei optimală? Cu alte cuvinte subsecvența mai scurtă cu unu, care se termină la poziția <tt>ik-1</tt> în <tt>X</tt>, respectiv poziția <tt>jk-1</tt> în <tt>Y</tt>, este optimală? Da, ea este optimală, căci altfel am putea-o înlocui cu o secvență mai lungă, care ar duce la o soluție mai bună, ceea ce ar însemna că soluția originală nu a fost optimă.

Următorul pas este să găsim relația de recurență:

<math>M[i][j] = \begin{cases} 0, & \mbox{dacă } i = 0 \mbox{ sau } j = 0\\M[i-1][j-1]+1, & \mbox{dacă } X[i] = Y[j]\\max(M[i-1][j],M[i][j-1]) & \mbox{dacă } X[i] \neq Y[j]. \end{cases}</math>

Cum demonstrăm această relație de recurență? Avem două cazuri de demonstrat:

=== Egalitate ===

Prefixele <tt>X[1..i]</tt> și <tt>Y[1..j]</tt> se termină în același caracter. În acest caz o subsecvență maximală a celor două prefixe se poate obține selectând acel ultim caracter. Putem, deci exclude acel caracter și calcula subsecvența maximală în prefixele <tt>X[1..i-1]</tt> și <tt>Y[1..j-1]</tt>. La lungimea ei vom aduna unu.

=== Diferență ===

Prefixele <tt>X[1..i]</tt> și <tt>Y[1..j]</tt> se termină în caractere diferite. Să luăm cazul anterior, avem secvențele:

X: ACDEGIKMPR
Y: CMEFPGHRK

Avem iarăși două cazuri:

* '''Cazul 1''': subsecvența optimă se termină în <tt>R</tt>. În acest caz ea nu se poate termina și în <tt>K</tt>. Deci putem elimina ultimul caracter din <tt>Y</tt> și calcula <tt>M[i][j-1]</tt>.
* '''Cazul 2''': subsecvența optimă nu se termină în <tt>R</tt>. În acest caz putem elimina acest <tt>R</tt> și calcula <tt>M[i-1][j]</tt>.

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula matricea <source lang="C" enclose="none">M</source> pe linii, folosind formula de recurență.

Soluția problemei este <source lang="C" enclose="none">M[n][m]</source>.

=== Exemplu ===

Pentru cele două șiruri de mai sus,

ACDEGIKMPR

și

CMEFPGHRK

Vom calcula o matrice <source lang="C" enclose="none">M[10][9]</source> care arată astfel:

{| class="wikitable"
!
! C !! M !! E !! F !! P !! G !! H !! R !! K
|-
!A
|0||0||0||0||0||0||0||0||0
|-
!C
|1||1||1||1||1||1||1||1||1
|-
!D
|1||1||1||1||1||1||1||1||1
|-
!E
|1||1||2||2||2||2||2||2||2
|-
!G
|1||1||2||2||2||3||3||3||3
|-
!I
|1||1||2||2||2||3||3||3||3
|-
!K
|1||1||2||2||2||3||3||3||4
|-
!M
|1||2||2||2||2||3||3||3||4
|-
!P
|1||2||2||2||3||3||3||3||4
|-
!R
|1||2||2||2||3||3||3||4||4
|}

Cea mai lungă secvență este de lungime 4, valoarea maximă ce apare în tabel.

=== Analiză ===

Acest algoritm are complexitate ''O(m · n)'', unde <tt>m</tt> și <tt>n</tt> sunt lungimile șirurilor. Memoria folosită este ''O(min(m,n))'' dacă memorăm doar o linie din matrice. Dacă dorim să aflăm și o secvență maximală, nu doar lungimea ei, vom avea nevoie de memorie ''O(m · n)'', precum vom vedea mai jos.

Există un algoritm care reduce necesarul de memorie la ''O(min(m, n))''.

=== Reconstrucția soluției ===

Dorim să aflăm nu doar lungimea, ci și o secvență maximală inclusă în ambele șiruri. Cum procedăm?

Observăm că literele ce fac parte din secvențele maximale se obțin acolo unde, în matrice, avem ramura doi de calcul, când literele de la pozițiile respective sunt egale.

Pentru a putea reconstrui soluția vom memora în fiecare căsuță, pe lângă lungimea maximă și direcția din care provine ea, adică din care am calculat acel maxim. Direcția poate fi spre stânga, spre în sus, sau în diagonală stânga-sus. Apoi vom porni din elementul <source lang="C" enclose="none">M[m][n]</source> și vom urma aceste direcții până ce ieșim din matrice. De fiecare dată când urmăm o diagonală reținem litera. Astfel, descoperirea secvenței se face în ordine inversă.

== Tema 24 ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/dreptunghiuri Dreptunghiuri] pentru subsecvența crescătoare maximală. '''Atenţie:''' puteți pica teste cu TLE, este în regulă.
* [https://www.nerdarena.ro/problema/ssm Subșirul de sumă maximă]
* [https://www.nerdarena.ro/problema/sclm Subșirul comun maximal]
* [https://www.nerdarena.ro/problema/cmlsc Subsecvența comună maximală]

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_24:_Programare_dinamic%C4%83_(1) Accesează rezolvarea temei 24]

Clasa a 7-a Lecția 24: Programare dinamică (1)

2025-06-08T21:10:21Z

Mihai: Created page with "== Înregistrare video lecție == {{#ev:youtube|https://www.youtube.com/watch?v=a0wFdh8DInQ|||||start=7600&end=11100&loop=1}} == Conceptul de programare dinamică == Introducere Wikipedia definește programarea dinamică drept o metodă pentru rezolvarea unor probleme complexe prin descompunerea lor în subprobleme mai simple. Se poate aplica problemelor care prezintă proprietățile de suprapunere a subproblemelor și de substructură optimală. Atunci când s..."

== Înregistrare video lecție ==

{{#ev:youtube|https://www.youtube.com/watch?v=a0wFdh8DInQ|||||start=7600&end=11100&loop=1}}

== Conceptul de programare dinamică ==
Introducere

Wikipedia definește programarea dinamică drept o metodă pentru rezolvarea unor probleme complexe prin descompunerea lor în subprobleme mai simple. Se poate aplica problemelor care prezintă proprietățile de suprapunere a subproblemelor și de substructură optimală. Atunci când se poate aplica, metoda ia mult mai puțin timp decât alte soluții naive.

Substructura optimală înseamnă că soluția unei problemei de optimizare date poate fi obținută prin combinarea unor soluții optimale ale subproblemelor. Ca atare, primul pas către găsirea unei rezolvări prin această metodă este verificarea dacă problema are proprietatea substructurii optimale.

Drumul cel mai scurt între două orașe poate fi rezolvat cu programare dinamică

Astfel de substructuri optimale sunt în mod uzual descrise prin recurență. De exemplu, date niște orașe și distanțele între ele, drumul cel mai scurt de la orașul u la orașul v are proprietatea de substructură optimală: să luăm orice oraș intermediar w pe drumul cel mai scurt, d. Dacă d este cu adevărat drumul cel mai scurt, atunci drumul d1 de la u la w și d2 de la w la v sunt cu adevărat cele mai scurte drumuri între orașele corespunzătoare. Dacă drumul de la u la w nu ar fi cel mai scurt posibil ar însemna că am avea un alt drum mai scurt, ceea ce ar duce la un drum total d, de la u la v, mai scurt decât cel original. Așadar, putem formula soluția problemei găsirii celui mai scurt drum într-o manieră recursivă, ceea ce fac algoritmii Bellman-Ford și Floyd-Warshall.

Suprapunerea subproblemelor înseamnă că ele nu sunt independente, adică subproblemele au în comun alte subprobleme. Nu vom insista pe această proprietate decât atât cât să menționăm că dacă subproblemele nu se suprapun dar prezintă substructură optimală atunci putem aplica tehnica de programare divide et impera (divide and conquer). De aceea quicksort și mergesort nu sunt clasificate ca probleme de programare dinamică.

Metodă

Când încercăm să rezolvăm o problemă de programare dinamică întrebarea crucială la care trebuie să răspundem este putem calcula soluția finală pe baza unor subprobleme care sunt la rândul lor optimale? Pentru a răspunde la întrebare trebuie mai întâi să formulăm subproblemele. Dar pentru a formula subproblemele trebuie să avem în minte principiul substructurii optimale. Altfel s-ar putea să împărțim problema în subprobleme care nu au substructură optimală.

Să recapitulăm: pentru a putea răspunde la întrebarea dacă o problemă admite o soluție prin programare dinamică trebuie să aflăm dacă are substructură optimală. Dar pentru a afla dacă are substructură optimală trebuie să găsim subproblemele. Pe care încercăm să le găsim folosind programarea dinamică.

Nu cumva ne învârtim în cerc? Așa pare și așa și este, într-o oarecare măsură. Experiența este cea care ne învață cum să căutăm împărțirea în subprobleme astfel încât să obținem proprietatea de optimalitate. Tot experiența este cea care ne ajută să ne dăm seama rapid dacă împărțirea găsită are această proprietate sau nu.

Odată ce demonstrăm că o împărțire în subprobleme se bazează doar pe subprobleme optimale, restul decurge, de obicei, destul de simplu: găsim o formulă de recurență, apoi o implementăm de jos în sus (sau bottom-up), pornind de la cele mai mici probleme, către cele mai mari, până la soluția cerută.

În continuare vom lua câteva exemple.

== Subsecvența crescătoare de lungime maximă ==
Această problemă cere să găsim o subsecvență a unei secvențe de numere în care elementele sunt în ordine crescătoare, iar subsecvența este de lungime maximă. Subsecvența nu este neapărat contiguă, nici unică.

Exemplu

În secvența

0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15

o secvență crescătoare de lungime maximă este

0, 2, 6, 9, 13, 15

Această secvență are lungime șase. Nu există nici o secvență crescătoare de lungime șapte. Cea mai lungă subsecvență crescătoare nu este unică. De exemplu

0, 4, 6, 9, 11, 15

este o altă subsecvență crescătoare de aceeași lungime, în secvența de intrare.

Soluție

Cum împărțim problema în subprobleme? Să încercăm astfel:

L[i] = lungimea celei mai lungi subsecvențe care începe la poziția i

Are această împărțire proprietatea de optimalitate? Să presupunem că avem o subsecvență optimală crescătoare care trece prin indicii

i1, i2, i3, …, ik

Astfel

L[i1] = k

Este secvența i2, ..., ik optimală? Cu alte cuvinte lungimea secvenței optime care începe la i2 este k-1? Răspunsul este da, secvența care începe la i2, anume i2, ..., ik este o secvență maximă, deoarece altfel am putea-o înlocui cu o secvență mai lungă, ceea ce ar duce la o subsecvență L[i1] mai lungă decât cea inițială, care era optimală. Obținem o contradicție.

Următorul pas este să găsim relația de recurență:

L[i] = max(L[j]+1), j > i și V[j] ≥ V[i]

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula vectorul L de la coadă la cap, căutând pentru fiecare element L[i] cel mai mare element L[j] de după el (j > i) astfel încât V[j] ≥ V[i].

Soluția problemei este maximul din vectorul L.

Exemplu

Să calculăm cea mai lungă secvență crescătoare în secvența:

0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15

Vom calcula lungimile secvențelor maximale de la coadă la cap: L[15], apoi L[14] și așa mai departe. Când ajungem la calculul lui L[6] avem următoarea situație:

Pentru a calcula lungimea secvenței maximale care începe la poziția 6 vom căuta toate pozițiile mai mari (7, 8, 9, ...). Le vom lua în considerare doar pe acelea în care V[i] >= V[6]. Dintre ele vom alege poziția unde L[i] este maximă. Astfel vom găsi că V[9] = 9 și L[9] = 3. Vom avea, deci, o secvență de lungime 4. Ea este:

6, 9, 11, 15

Exemplu de calcul pentru elementul L[6] - cea mai lungă secvență crescătoare care începe la poziția 6.

Analiză

Acest algoritm are complexitate O(n2), unde n este lungimea secvenței. Memoria folosită este O(n).

Există și un algoritm mai rapid, de complexitate O(n log n), bazat pe căutare binară a valorilor de început.

Reconstrucția soluției

Putem reconstrui o subsecvență maximală folosind încă un vector, N[]. El memorează pentru fiecare indice i un alt indice j care urmează în secvență după j. Atunci când calculăm elementul curent, vom nota nu doar maximul găsit (plus unu) ci și poziția lui în vector, el fiind elementul următor în secvență.

== Subșirul de sumă maximală ==
Această problemă cere să găsim un subșir de sumă maximă într-un șir de numere. Un subșir este contiguu.

Exemplu

Să considerăm șirul:

12, 14, 0, -4, 61, -39

subșirul de sumă maximală este:

12, 14, 0, -4, 61

și are sumă 83.

Soluție

Cum împărțim problema în subprobleme? Să încercăm astfel:

S[i] este suma maximală a unui șir care se termină la poziția i

Are această împărțire proprietatea de optimalitate?

Să presupunem că avem un subșir de sumă maximă și că el se află între indicii i și j. Cu alte cuvine suma maximală este

S[j] = V[i] + V[i+1] + ... + V[j-1] + V[j]

Are șirul care se termină în j-1, sumă maximală? Cu alte cuvinte este suma

S[j-1] = V[i] + V[i+1] + ... + V[j-1]

maximală?

Răspunsul este da, deoarece altfel am putea-o înlocui cu o sumă mai mare, ceea ce ar duce la o sumă mai mare decît cea inițială, care era optimală. Obținem o contradicție.

Următorul pas este să găsim relația de recurență. Observăm că pentru o poziție i avem două variante: fie continuăm secvența anterioară, care se termină în i-1, fie începem una nouă, care pornește în i. Vom continua secvența anterioară dacă adunând numărul curent obținem o sumă mai mare strict decât numărul curent. Altfel vom porni o sumă nouă. Relația de recurență este:

S[i] = max(V[i], S[i-1] + V[i])

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula vectorul S calculînd pentru fiecare element S[i] maximul dintre S[i-1] + V[i] și V[i]. Observăm că, în realitate, vom compara S[i-1] cu zero.

Soluția problemei este maximul din vectorul S.

Exemplu

Fie secvența anterioară:

12, 14, 0, -4, 61, -39

Vom calcula de la stânga la dreapta sumele maximale ce se termină la pozițiile respective:

V12140-461-39S1226 =
max(14, 12 + 14)26 =
max(0, 0 + 26)22 =
max(-4, -4 + 26)83 =
max(61, 61 + 22)44 =
max(-39, -39 + 83)

Analiză

Acest algoritm are complexitate O(n), unde n este lungimea șirului. Memoria folosită este O(1), deoarece nu avem nevoie să stocăm elementele, ci doar ultima sumă calculată.

Reconstrucția soluției

Putem ține minte șirul maximal ținând minte începutul și sfârșitul subșirului maximal atunci când îl găsim.

Soluții alternative

Această problemă poate fi rezolvată fără programare dinamică. Ne propunem același lucru, ca la pasul i să calculăm S[i] cu aceeași semnificație. Acest S[i] se poate calcula cu cunoștințe de nivel mic: sume parțiale. S[i] va fi suma unei secvențe de la k la i, cu k ≤ i. Deci, dacă vom calcula P[], sumele parțiale pe vector putem spune că S[i] = P[i] - P[k]. Să ne uităm puțin la această expresie: cine variază în ea? P[i] este constant, este suma elementelor până la i. Putem varia doar P[k]. Este evident că dorim să alegem un P[k] cât mai mic, nu?

Algoritmul este unul banal: calculează sume parțiale, avansând i. Suma minimă care se termină în i este suma parțială curentă minus suma parțială minimă din trecut. La fiecare avans actualizează suma parțială minimă cu cea curentă, dacă este cazul.

Acest algoritm are aceleași complexități ca cel cu programare dinamică. El este însă un algoritm mai flexibil de adaptat unor modificări, cum ar fi suma maximă de lungime cel puțin K sau suma maximă de lungime cel mult K.

== Subșirul comun maximal al două șiruri ==
Această problemă cere să găsim lungimea unui subșir de lungime maximă (contiguu) inclus în două șiruri.

Exemplu

Date șirurile

ABABC

și

CBABA

un subșir maximal are lungime 3 și este

BAB

Soluție

Cum împărțim problema în subprobleme? Să observăm că deoarece subșirul maximal face parte din ambele șiruri el se va termina la o poziție i în șirul X și la o poziție j în șirul Y. Și atunci să încercăm astfel:

M[i][j] = lungimea celui mai lung subșir care se termină la poziția i în X și la poziția j în Y.

Are această împărțire proprietatea de optimalitate?

Să presupunem că avem un subșir optimal care se termină la pozițiile i, respectiv j. Atunci este subșirul M[i-1][j-1] la rândul lui optimal? Cu alte cuvinte subșirul mai scurt cu unu, care se termină la pozițiile anterioare în X, respectiv Y, este optimal? Da, el este optimal, caci altfel l-am putea înlocui cu un șir mai lung, care ar duce la o soluție mai bună, ceea ce ar însemna că soluția originală nu a fost optimă.

Următorul pas este să găsim relația de recurență:

\( M[i][j] =\begin{cases}M[i-1][j-1]+1, & \text{dacă X[i]=Y[j]} \\ 0, & \text{în caz contrar} \end{cases} \)

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula matricea M pe linii, folosind formula de recurență.

Soluția problemei este maximul din matrice.

Exemplu

Pentru cele două șiruri de mai sus,

ABABC

și

CBABA

Vom calcula o matrice M[5][5] care arată astfel:

CBABAA00101B01020A00203B01030C10000

Observăm că avem două subșiruri comune de lungime 3: ABA și BAB.

Analiză

Acest algoritm are complexitate O(m·n), unde m și n sunt lungimile șirurilor. Memoria folosită este, la prima vedere, O(m·n). În realitate, parcurgând matricea pe linii, nu avem nevoie să memorăm decât o linie din matrice pentru a calcula toate valorile. De aceea memoria necesară este O(min(m, n)).

Există și algoritmi mai eficienți bazați pe arbori sufix, despre care nu vom discuta aici.

Reconstrucția soluției

Cum facem să aflăm nu doar lungimea ci și care este șirul comun maximal și unde apare el în cele două șiruri?

Vom face calculul matricei noastre printr-o parcurgere pe linii. La fiecare pas ne vom întreba dacă elementul calculat (lungimea) este mai mare decât maximul curent. Dacă da, vom memora acel maxim împreună cu indicii i și j la care s-a obținut el.

La final vom avea poziția de start în primul șir ca fiind i - max + 1 și în al doilea șir ca fiind j - max + 1.

[mathjax]

== Subsecvența comună maximală a două șiruri ==
Această problemă cere să găsim lungimea unei subsecvențe de lungime maximă inclusă în două secvențe. Prin secvență înțelegem caractere în ordinea originală, nu neapărat consecutive ca poziție.

Exemplu

Date secvențele

X: ACDEGIKMPR
Y: CMEFPGHRK

o secvență maximală are lungime 4 și este

CEGK

o altă secvență maximală este

CMPR

Soluție

Cum împărțim problema în subprobleme? Să încercăm să o împărțim în mod similar cu subșirul comun maximal:

M[i][j] = lungimea celei mai lungi subsecvențe incluse în șirurile X[1..i] și Y[1..j]

Are această împărțire proprietatea de optimalitate?

Să presupunem că avem o secvență optimală a prefixelor care se termină la pozițiile i, respectiv j. Ea va trece prin anumite perechi (ik, jk), strict crescătoare, cu proprietatea că X[ik] = Y[jk]:

Si,j = (i1, j1) (i2, j2) ... (ik, jk)

cu proprietatea că:

Xi1Xi2... Xik-1Xik = Yj1Yj2... Yjk-1Yjk

Atunci este lungimea M[ik-1][jk-1] la rândul ei optimală? Cu alte cuvinte subsecvența mai scurtă cu unu, care se termină la poziția ik-1 în X, respectiv poziția jk-1 în Y, este optimală? Da, ea este optimală, căci altfel am putea-o înlocui cu o secvență mai lungă, care ar duce la o soluție mai bună, ceea ce ar însemna că soluția originală nu a fost optimă.

Următorul pas este să găsim relația de recurență:

\( M[i][j] =\begin{cases}0, & \text{dacă i = 0 sau j = 0} \\ M[i-1][j-1]+1, & \text{dacă X[i]=Y[j]} \\ max(M[i-1][j], M[i][j-1]), & \text{dacă X[i] ≠ Y[j]} \end{cases} \)

Cum demonstrăm această relație de recurență? Avem două cazuri de demonstrat:

Egalitate

Prefixele X[1..i] și Y[1..j] se termină în același caracter. În acest caz o subsecvență maximală a celor două prefixe se poate obține selectând acel ultim caracter. Putem, deci exclude acel caracter și calcula subsecvența maximală în prefixele X[1..i-1] și Y[1..j-1]. La lungimea ei vom aduna unu.

Diferență

Prefixele X[1..i] și Y[1..j] se termină în caractere diferite. Să luăm cazul anterior, avem secvențele:

X: ACDEGIKMPR
Y: CMEFPGHRK

Avem iarăși două cazuri:

Cazul 1: subsecvența optimă se termină în R. În acest caz ea nu se poate termina și în K. Deci putem elimina ultimul caracter din Y și calcula M[i][j-1].

Cazul 2: subsecvența optimă nu se termină în R. În acest caz putem elimina acest R și calcula M[i-1][j].

Următorul pas este să construim subproblemele bottom-up, de la problemele mai mici la cele mai mari. Pentru aceasta vom calcula matricea M pe linii, folosind formula de recurență.

Soluția problemei este M[n][m].

Exemplu

Pentru cele două șiruri de mai sus,

ACDEGIKMPR

și

CMEFPGHRK

Vom calcula o matrice M[10][9] care arată astfel:

CMEFPGHRKA000000000C111111111D111111111E112222222G112223333I112223333K112223334M122223334P122233334R122233344

Cea mai lungă secvență este de lungime 4, valoarea maximă ce apare în tabel.

Analiză

Acest algoritm are complexitate O(m · n), unde m și n sunt lungimile șirurilor. Memoria folosită este O(min(m,n)) dacă memorăm doar o linie din matrice. Dacă dorim să aflăm și o secvență maximală, nu doar lungimea ei, vom avea nevoie de memorie O(m · n), precum vom vedea mai jos.

Există un algoritm care reduce necesarul de memorie la O(min(m, n)).

Reconstrucția soluției

Dorim să aflăm nu doar lungimea, ci și o secvență maximală inclusă în ambele șiruri. Cum procedăm?

Observăm că literele ce fac parte din secvențele maximale se obțin acolo unde, în matrice, avem ramura doi de calcul, când literele de la pozițiile respective sunt egale.

Pentru a putea reconstrui soluția vom memora în fiecare căsuță, pe lângă lungimea maximă și direcția din care provine ea, adică din care am calculat acel maxim. Direcția poate fi spre stânga, spre în sus, sau în diagonală stânga-sus. Apoi vom porni din elementul M[m][n] și vom urma aceste direcții până ce ieșim din matrice. De fiecare dată când urmăm o diagonală reținem litera. Astfel, descoperirea secvenței se face în ordine inversă.

== Tema 25 - cercul de informatică pentru performanță clasa a șaptea ==
Tema 25 presupune să se rezolve următoarele probleme (program C trimis la nerdarena):

dreptunghiuri pentru subsecvența crescătoare maximală. Atenţie: puteți pica teste cu TLE, este în regulă.

subșirul de sumă maximă

subșirul comun maximal

subsecvența comună maximală

Clasa a 7-a Lecția 28: Sfaturi pentru concursuri / olimpiadă

2025-06-08T20:24:28Z

Mihai:

== Înregistrare video lecție ==

{{#ev:youtube|https://www.youtube.com/watch?v=a0wFdh8DInQ|||||start=11100&loop=1}}

== Ce să faceți / ce să nu faceți ==

=== Ce să faceți ===

* '''Odihnă:''' odihniți-vă cu o zi înainte. Relaxați-vă cu activitatea favorită. Mergeți la un film, jucați jocul vostru preferat, etc. Încercați să nu vă gândiți la concurs.

* '''Ceas:''' aveți un ceas la voi. Nu ceasul calculatorului sau al smartphone-ului. Fiți conștienți de trecerea timpului, nu vă treziți din visare când mai este un sfert de oră. Pentru aceasta un ceas așezat pe banca de lucru este ideal. Nu uitați: toate celelalte ceasuri pot fi incorecte, sau să moară.

* '''Țineți socoteala timpului:''' notați ora începerii concursului pe foaie. Verificați la final că ați avut tot timpul promis. Dacă aveți probleme cu calculatorul și cereți ajutorul supraveghetorului notați timpul când ați fost întrerupți și apoi timpul când reveniți la un calculator funcțional. Aveți dreptul la o prelungire a timpului egală cu timpul pierdut. ''Acest sfat nu mai este atât de valabil de când concursul se desfășoară online. Nu veți putea cere zece minute pierdute, deci încercați să faceți ceva în acele minute, de exemplu să vă gândiți la o altă problemă, pe hârtie. Dacă totuși pierdeți timp semnificativ, cum ar fi 30 minute, atunci aveți baze să faceți contestație ulterior. Cel mai probabil nu veți câștiga puncte, dar e posibil să facă o excepție dacă punctajul vostru e la limită.''

* '''Cereți-vă drepturile:''' Dacă nu înțelegeți textul unei probleme, după ce l-ați citit cu mare atenție, puneți întrebări pentru clarificare. Încercați să formulați cât mai clar întrebările! Sunt preferabile cele al căror răspuns este ''DA'' sau ''NU''. Puteți da și exemple în întrebările voastre, ''dacă intrarea ar fi așa atunci răspund așa, sau așa?''. Dacă exemplul este prea relevant este posibil să nu vă răspundă, dar nu aveți nimic de pierdut.

* '''Low hanging fruit:''' rezolvați problema mai ușoară prima. Citiți toate problemele la început și hotărâți-vă care este mai ușoară. Cu ea începeți. Puteți inclusiv să rezolvați subpunctele mai ușoare primele. De exemplu puteți să rezolvați problema 1 punctul a), apoi problema 2 punctul b).

* '''Moral ridicat:''' intrați în sală încrezători în voi. Sunteți printre cei mai buni din țară, aveți puterea să vă clasați printre primii din țară. Propuneți-vă să luați punctaj maxim și reamintiți-vă că puteți acest lucru.

* '''Probleme grele:''' atunci când constatați că problemele sunt grele nu vă speriați. Bucurați-vă! Este cea mai bună situație pentru voi. Aveți numai de câștigat: fie știți să faceți problema, caz în care este perfect, căci problema fiind grea v-ați asigurat că veți fi mai sus ca ceilalți. Fie nu știți să faceți problema și atunci care este șansa ca cei mai slabi ca voi să știe să o facă? Temeți-vă de problemele ușoare, pe care știu toți să le facă. Voi le veți gândi, consumând timp, ceilalți le vor picta la perfecție.

* '''Atenție:''' fiți foarte atenți la detalii: la numele fișierelor de intrare/ieșire; la numele sub care trebuie să salvați programul C; la setările de proiect CodeBlocks de care am vorbit: '''-Wall''' și '''-O2'''; la locul unde ați salvat proiectul, și numele proiectului în caz că aveți nevoie să le copiați în altă parte, dacă, de exemplu, vă schimbă calculatorul.

=== Ce să NU faceți ===

* Nu îngrășați porcul în ajun: nu faceți probleme în ultima clipă . Vă veți extenua inutil. În urma stresului s-ar putea să nu reușiți să le faceți, ceea ce vă va demoraliza. Aveți nevoie de moral ridicat la concurs.

* '''Nu vă panicați: panica ucide creierul'''. Panica vă face să gândiți mai încet și să doriți în subconștient să ieșiți din sală. Controlați-o. Nu uitați că o problemă grea, pe care nu știți să o faceți, vă avantajează, pentru că probabil nici ceilalți nu știu, pe când voi aveți o șansă să luați puncte pe ea.

* '''Nu-i băgați în seamă pe cei ce se dau mari''': unii elevi spun cu voce suficient de tare să fie auziți, în timpul concursului, lucruri de genul ''aaah, am făcut-o și pe asta, super'' sau ''am rupt, sigur iau suta'', etc. Este modul lor inconștient de a vă demoraliza. De obicei ei se clasează slab. Ignorați-i. De asemenea veți vedea că unii dintre concurenți părăsesc sala mai devreme cu o oră cu un aer fericit, eventual spunând ''sigur mă calific'' sau ''am făcut bine, yesss''. Ignorați-i. Și ei se clasează slab. Nu vă demoralizați indiferent câți elevi ies din sală. Lupta voastră nu este cu ei, ci cu problemele și punctele.

* '''Nu ieșiți mai devreme din sală''': dacă nu ați terminat problemele continuați să vă gândiți la o soluție. Dacă nu mai aveți idei, creați mai multe teste pe care să le testați. Puteți scrie programe care să vă genereze teste. Puteți cere la CMS să vi se evalueze acele teste. Nu uitați: nimănui nu-i pasă cât de repede ați ieșit. Nu luați puncte suplimentare pentru asta.

* '''Nu modificați și trimiteți în ultima clipă un program care funcționează''': riscați să nu aveți timp să-l testați și să luați zero puncte la acea problemă. În principiu punctajul este maximul din toate sursele trimise. Nu riscați, dacă schimbă regula în ultima clipă? N-ar fi prima oară.

* '''Nu vă îngrijorați de părerea noastră''': noi, instructorii, știm bine care este valoarea voastră. Nu avem nevoie de un rezultat la olimpiadă să aflăm. Nu o să ne vedeți vreodată supărați pe voi pentru că nu ați luat punctaj bun. Dimpotrivă, orice veți face vom fi mândri de voi pentru cât de departe ați ajuns. Grija voastră trebuie să fie rezolvarea problemelor, nu noi. Noi suntem de partea voastră. Chiar dacă la cerc sau la clasă, când suntem între noi, vă certăm sau ne mai supărăm pe voi, în momentul când ați ieșit din școală să vă ''luptați'' cu olimpiada suntem de aceeași parte a baricadei.

=== Diferenţa dintre olimpiadă şi viaţa reală ===

Nu uitaţi că olimpiada este un concurs de verificare a cunoştinţelor, nimic mai mult, nimic mai puţin. Ea nu este evaluarea supremă a unui elev, la fel cum nu este nici ceva de ignorat cu dispreţ. Este cel mai mare concurs de la clasa a 7a, drept pentru care îl vom trata cu respect. Dar nu ne vom spânzura de grindă, considerând că viaţa s-a sfârşit, dacă nu obţinem rezultatul dorit. '''Olimpiada nu ne defineşte ca oameni'''.

Acestea fiind spuse, dacă mergem la olimpiadă, ne dorim un scor cât mai bun. De aceea consider utilă următoarea analogie între arte marţiale si informatică:

* '''În viaţa reală''': în arte marţiale învăţăm pe viaţă. Procedee noi, ce trebuie aplicate cât mai corect, perfect dacă se poate. Filozofie, mod de comportament, respect faţă de artă şi luptă. Atunci când mişcarea nu este perfectă, instructorul vă va corecta. Lupta este interzisă cu excepţia cazului când sunteţi în legitimă apărare. Este imoral şi foarte urât să câştigaţi avantaje în viaţa reală bătându-i pe cei mai slabi. Artele marţiale au ca scop îmbunătăţirea organismului. La fel și informatica, în viața reală trebuie să inventăm un algoritm cât mai bun și să îl implementăm cât mai frumos, mai precis, fără a repeta cod, cât mai clar de citit și de alții, cu comentarii, etc.

* '''La olimpiadă''': olimpiada este ca legitima apărare. Ca şi când sunteţi cu fratele mai mic după voi şi vă atacă golanii. În acel moment nu vă verifică nimeni cât de frumos aţi executat procedeul pentru a scăpa teferi. Tot ce contează este să învingeţi. Pentru aceasta vă veţi folosi de orice! Dacă găsiţi un bolovan, îl aruncaţi în adversar. O chiuvetă spartă, bună şi aceea! La fel şi la olimpiadă, tot ce contează sunt punctele. Nu cât de frumoasă este metoda folosită, nici cât de frumos aţi scris codul. Dacă puteţi lua puncte afişând mereu "0", o faceţi. Această practică nu ar fi acceptată nici la cercul nostru şi nici în viaţa reală. Din păcate, însă, la olimpiadă nu se punctează stilul şi perfecţionismul, ci numai punctele.

'''Atenţie însă!''' Olimpiada este o excepţie, nu o regulă! Aşa cum în viaţa reală nu puteţi să smulgeţi chiuveta din perete pentru a o arunca în colegul de clasă, nici la cerc, la companii, sau unde se va întâmpla să rezolvaţi probleme de informatică, nu puteţi trişa, sau scrie cod ineficient.

== Tema 28 ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/foto1 Foto1] dată la OJI 2020 clasa a 7-a
* [https://www.nerdarena.ro/problema/cursuri Cursuri] dată la OJI 2017, clasa a 7-a
* [https://www.nerdarena.ro/problema/pseudocomp Pseudocomp] dată la ONI 2011 clasa a 8-a

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_28:_Sfaturi_pentru_concursuri_/_olimpiad%C4%83 Accesează rezolvarea temei 28]

Clasa a 7-a Lecția 28: Sfaturi pentru concursuri / olimpiadă

2025-06-08T20:18:06Z

Mihai:

{{#evt:
service=youtube
|id=https://www.youtube.com/watch?v=eAORm-8b1Eg
|alignment=right
}}

== Ce să faceți / ce să nu faceți ==

=== Ce să faceți ===

* '''Odihnă:''' odihniți-vă cu o zi înainte. Relaxați-vă cu activitatea favorită. Mergeți la un film, jucați jocul vostru preferat, etc. Încercați să nu vă gândiți la concurs.

* '''Ceas:''' aveți un ceas la voi. Nu ceasul calculatorului sau al smartphone-ului. Fiți conștienți de trecerea timpului, nu vă treziți din visare când mai este un sfert de oră. Pentru aceasta un ceas așezat pe banca de lucru este ideal. Nu uitați: toate celelalte ceasuri pot fi incorecte, sau să moară.

* '''Țineți socoteala timpului:''' notați ora începerii concursului pe foaie. Verificați la final că ați avut tot timpul promis. Dacă aveți probleme cu calculatorul și cereți ajutorul supraveghetorului notați timpul când ați fost întrerupți și apoi timpul când reveniți la un calculator funcțional. Aveți dreptul la o prelungire a timpului egală cu timpul pierdut. ''Acest sfat nu mai este atât de valabil de când concursul se desfășoară online. Nu veți putea cere zece minute pierdute, deci încercați să faceți ceva în acele minute, de exemplu să vă gândiți la o altă problemă, pe hârtie. Dacă totuși pierdeți timp semnificativ, cum ar fi 30 minute, atunci aveți baze să faceți contestație ulterior. Cel mai probabil nu veți câștiga puncte, dar e posibil să facă o excepție dacă punctajul vostru e la limită.''

* '''Cereți-vă drepturile:''' Dacă nu înțelegeți textul unei probleme, după ce l-ați citit cu mare atenție, puneți întrebări pentru clarificare. Încercați să formulați cât mai clar întrebările! Sunt preferabile cele al căror răspuns este ''DA'' sau ''NU''. Puteți da și exemple în întrebările voastre, ''dacă intrarea ar fi așa atunci răspund așa, sau așa?''. Dacă exemplul este prea relevant este posibil să nu vă răspundă, dar nu aveți nimic de pierdut.

* '''Low hanging fruit:''' rezolvați problema mai ușoară prima. Citiți toate problemele la început și hotărâți-vă care este mai ușoară. Cu ea începeți. Puteți inclusiv să rezolvați subpunctele mai ușoare primele. De exemplu puteți să rezolvați problema 1 punctul a), apoi problema 2 punctul b).

* '''Moral ridicat:''' intrați în sală încrezători în voi. Sunteți printre cei mai buni din țară, aveți puterea să vă clasați printre primii din țară. Propuneți-vă să luați punctaj maxim și reamintiți-vă că puteți acest lucru.

* '''Probleme grele:''' atunci când constatați că problemele sunt grele nu vă speriați. Bucurați-vă! Este cea mai bună situație pentru voi. Aveți numai de câștigat: fie știți să faceți problema, caz în care este perfect, căci problema fiind grea v-ați asigurat că veți fi mai sus ca ceilalți. Fie nu știți să faceți problema și atunci care este șansa ca cei mai slabi ca voi să știe să o facă? Temeți-vă de problemele ușoare, pe care știu toți să le facă. Voi le veți gândi, consumând timp, ceilalți le vor picta la perfecție.

* '''Atenție:''' fiți foarte atenți la detalii: la numele fișierelor de intrare/ieșire; la numele sub care trebuie să salvați programul C; la setările de proiect CodeBlocks de care am vorbit: '''-Wall''' și '''-O2'''; la locul unde ați salvat proiectul, și numele proiectului în caz că aveți nevoie să le copiați în altă parte, dacă, de exemplu, vă schimbă calculatorul.

=== Ce să NU faceți ===

* Nu îngrășați porcul în ajun: nu faceți probleme în ultima clipă . Vă veți extenua inutil. În urma stresului s-ar putea să nu reușiți să le faceți, ceea ce vă va demoraliza. Aveți nevoie de moral ridicat la concurs.

* '''Nu vă panicați: panica ucide creierul'''. Panica vă face să gândiți mai încet și să doriți în subconștient să ieșiți din sală. Controlați-o. Nu uitați că o problemă grea, pe care nu știți să o faceți, vă avantajează, pentru că probabil nici ceilalți nu știu, pe când voi aveți o șansă să luați puncte pe ea.

* '''Nu-i băgați în seamă pe cei ce se dau mari''': unii elevi spun cu voce suficient de tare să fie auziți, în timpul concursului, lucruri de genul ''aaah, am făcut-o și pe asta, super'' sau ''am rupt, sigur iau suta'', etc. Este modul lor inconștient de a vă demoraliza. De obicei ei se clasează slab. Ignorați-i. De asemenea veți vedea că unii dintre concurenți părăsesc sala mai devreme cu o oră cu un aer fericit, eventual spunând ''sigur mă calific'' sau ''am făcut bine, yesss''. Ignorați-i. Și ei se clasează slab. Nu vă demoralizați indiferent câți elevi ies din sală. Lupta voastră nu este cu ei, ci cu problemele și punctele.

* '''Nu ieșiți mai devreme din sală''': dacă nu ați terminat problemele continuați să vă gândiți la o soluție. Dacă nu mai aveți idei, creați mai multe teste pe care să le testați. Puteți scrie programe care să vă genereze teste. Puteți cere la CMS să vi se evalueze acele teste. Nu uitați: nimănui nu-i pasă cât de repede ați ieșit. Nu luați puncte suplimentare pentru asta.

* '''Nu modificați și trimiteți în ultima clipă un program care funcționează''': riscați să nu aveți timp să-l testați și să luați zero puncte la acea problemă. În principiu punctajul este maximul din toate sursele trimise. Nu riscați, dacă schimbă regula în ultima clipă? N-ar fi prima oară.

* '''Nu vă îngrijorați de părerea noastră''': noi, instructorii, știm bine care este valoarea voastră. Nu avem nevoie de un rezultat la olimpiadă să aflăm. Nu o să ne vedeți vreodată supărați pe voi pentru că nu ați luat punctaj bun. Dimpotrivă, orice veți face vom fi mândri de voi pentru cât de departe ați ajuns. Grija voastră trebuie să fie rezolvarea problemelor, nu noi. Noi suntem de partea voastră. Chiar dacă la cerc sau la clasă, când suntem între noi, vă certăm sau ne mai supărăm pe voi, în momentul când ați ieșit din școală să vă ''luptați'' cu olimpiada suntem de aceeași parte a baricadei.

=== Diferenţa dintre olimpiadă şi viaţa reală ===

Nu uitaţi că olimpiada este un concurs de verificare a cunoştinţelor, nimic mai mult, nimic mai puţin. Ea nu este evaluarea supremă a unui elev, la fel cum nu este nici ceva de ignorat cu dispreţ. Este cel mai mare concurs de la clasa a 7a, drept pentru care îl vom trata cu respect. Dar nu ne vom spânzura de grindă, considerând că viaţa s-a sfârşit, dacă nu obţinem rezultatul dorit. '''Olimpiada nu ne defineşte ca oameni'''.

Acestea fiind spuse, dacă mergem la olimpiadă, ne dorim un scor cât mai bun. De aceea consider utilă următoarea analogie între arte marţiale si informatică:

* '''În viaţa reală''': în arte marţiale învăţăm pe viaţă. Procedee noi, ce trebuie aplicate cât mai corect, perfect dacă se poate. Filozofie, mod de comportament, respect faţă de artă şi luptă. Atunci când mişcarea nu este perfectă, instructorul vă va corecta. Lupta este interzisă cu excepţia cazului când sunteţi în legitimă apărare. Este imoral şi foarte urât să câştigaţi avantaje în viaţa reală bătându-i pe cei mai slabi. Artele marţiale au ca scop îmbunătăţirea organismului. La fel și informatica, în viața reală trebuie să inventăm un algoritm cât mai bun și să îl implementăm cât mai frumos, mai precis, fără a repeta cod, cât mai clar de citit și de alții, cu comentarii, etc.

* '''La olimpiadă''': olimpiada este ca legitima apărare. Ca şi când sunteţi cu fratele mai mic după voi şi vă atacă golanii. În acel moment nu vă verifică nimeni cât de frumos aţi executat procedeul pentru a scăpa teferi. Tot ce contează este să învingeţi. Pentru aceasta vă veţi folosi de orice! Dacă găsiţi un bolovan, îl aruncaţi în adversar. O chiuvetă spartă, bună şi aceea! La fel şi la olimpiadă, tot ce contează sunt punctele. Nu cât de frumoasă este metoda folosită, nici cât de frumos aţi scris codul. Dacă puteţi lua puncte afişând mereu "0", o faceţi. Această practică nu ar fi acceptată nici la cercul nostru şi nici în viaţa reală. Din păcate, însă, la olimpiadă nu se punctează stilul şi perfecţionismul, ci numai punctele.

'''Atenţie însă!''' Olimpiada este o excepţie, nu o regulă! Aşa cum în viaţa reală nu puteţi să smulgeţi chiuveta din perete pentru a o arunca în colegul de clasă, nici la cerc, la companii, sau unde se va întâmpla să rezolvaţi probleme de informatică, nu puteţi trişa, sau scrie cod ineficient.

== Tema 28 ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/foto1 Foto1] dată la OJI 2020 clasa a 7-a
* [https://www.nerdarena.ro/problema/cursuri Cursuri] dată la OJI 2017, clasa a 7-a
* [https://www.nerdarena.ro/problema/pseudocomp Pseudocomp] dată la ONI 2011 clasa a 8-a

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_28:_Sfaturi_pentru_concursuri_/_olimpiad%C4%83 Accesează rezolvarea temei 28]

Clasa a 7-a Lecția 28: Sfaturi pentru concursuri / olimpiadă

2025-06-08T20:17:04Z

Mihai:

== Ce să faceți / ce să nu faceți ==

=== Ce să faceți ===

* '''Odihnă:''' odihniți-vă cu o zi înainte. Relaxați-vă cu activitatea favorită. Mergeți la un film, jucați jocul vostru preferat, etc. Încercați să nu vă gândiți la concurs.

* '''Ceas:''' aveți un ceas la voi. Nu ceasul calculatorului sau al smartphone-ului. Fiți conștienți de trecerea timpului, nu vă treziți din visare când mai este un sfert de oră. Pentru aceasta un ceas așezat pe banca de lucru este ideal. Nu uitați: toate celelalte ceasuri pot fi incorecte, sau să moară.

* '''Țineți socoteala timpului:''' notați ora începerii concursului pe foaie. Verificați la final că ați avut tot timpul promis. Dacă aveți probleme cu calculatorul și cereți ajutorul supraveghetorului notați timpul când ați fost întrerupți și apoi timpul când reveniți la un calculator funcțional. Aveți dreptul la o prelungire a timpului egală cu timpul pierdut. ''Acest sfat nu mai este atât de valabil de când concursul se desfășoară online. Nu veți putea cere zece minute pierdute, deci încercați să faceți ceva în acele minute, de exemplu să vă gândiți la o altă problemă, pe hârtie. Dacă totuși pierdeți timp semnificativ, cum ar fi 30 minute, atunci aveți baze să faceți contestație ulterior. Cel mai probabil nu veți câștiga puncte, dar e posibil să facă o excepție dacă punctajul vostru e la limită.''

* '''Cereți-vă drepturile:''' Dacă nu înțelegeți textul unei probleme, după ce l-ați citit cu mare atenție, puneți întrebări pentru clarificare. Încercați să formulați cât mai clar întrebările! Sunt preferabile cele al căror răspuns este ''DA'' sau ''NU''. Puteți da și exemple în întrebările voastre, ''dacă intrarea ar fi așa atunci răspund așa, sau așa?''. Dacă exemplul este prea relevant este posibil să nu vă răspundă, dar nu aveți nimic de pierdut.

* '''Low hanging fruit:''' rezolvați problema mai ușoară prima. Citiți toate problemele la început și hotărâți-vă care este mai ușoară. Cu ea începeți. Puteți inclusiv să rezolvați subpunctele mai ușoare primele. De exemplu puteți să rezolvați problema 1 punctul a), apoi problema 2 punctul b).

* '''Moral ridicat:''' intrați în sală încrezători în voi. Sunteți printre cei mai buni din țară, aveți puterea să vă clasați printre primii din țară. Propuneți-vă să luați punctaj maxim și reamintiți-vă că puteți acest lucru.

* '''Probleme grele:''' atunci când constatați că problemele sunt grele nu vă speriați. Bucurați-vă! Este cea mai bună situație pentru voi. Aveți numai de câștigat: fie știți să faceți problema, caz în care este perfect, căci problema fiind grea v-ați asigurat că veți fi mai sus ca ceilalți. Fie nu știți să faceți problema și atunci care este șansa ca cei mai slabi ca voi să știe să o facă? Temeți-vă de problemele ușoare, pe care știu toți să le facă. Voi le veți gândi, consumând timp, ceilalți le vor picta la perfecție.

* '''Atenție:''' fiți foarte atenți la detalii: la numele fișierelor de intrare/ieșire; la numele sub care trebuie să salvați programul C; la setările de proiect CodeBlocks de care am vorbit: '''-Wall''' și '''-O2'''; la locul unde ați salvat proiectul, și numele proiectului în caz că aveți nevoie să le copiați în altă parte, dacă, de exemplu, vă schimbă calculatorul.

=== Ce să NU faceți ===

* Nu îngrășați porcul în ajun: nu faceți probleme în ultima clipă . Vă veți extenua inutil. În urma stresului s-ar putea să nu reușiți să le faceți, ceea ce vă va demoraliza. Aveți nevoie de moral ridicat la concurs.

* '''Nu vă panicați: panica ucide creierul'''. Panica vă face să gândiți mai încet și să doriți în subconștient să ieșiți din sală. Controlați-o. Nu uitați că o problemă grea, pe care nu știți să o faceți, vă avantajează, pentru că probabil nici ceilalți nu știu, pe când voi aveți o șansă să luați puncte pe ea.

* '''Nu-i băgați în seamă pe cei ce se dau mari''': unii elevi spun cu voce suficient de tare să fie auziți, în timpul concursului, lucruri de genul ''aaah, am făcut-o și pe asta, super'' sau ''am rupt, sigur iau suta'', etc. Este modul lor inconștient de a vă demoraliza. De obicei ei se clasează slab. Ignorați-i. De asemenea veți vedea că unii dintre concurenți părăsesc sala mai devreme cu o oră cu un aer fericit, eventual spunând ''sigur mă calific'' sau ''am făcut bine, yesss''. Ignorați-i. Și ei se clasează slab. Nu vă demoralizați indiferent câți elevi ies din sală. Lupta voastră nu este cu ei, ci cu problemele și punctele.

* '''Nu ieșiți mai devreme din sală''': dacă nu ați terminat problemele continuați să vă gândiți la o soluție. Dacă nu mai aveți idei, creați mai multe teste pe care să le testați. Puteți scrie programe care să vă genereze teste. Puteți cere la CMS să vi se evalueze acele teste. Nu uitați: nimănui nu-i pasă cât de repede ați ieșit. Nu luați puncte suplimentare pentru asta.

* '''Nu modificați și trimiteți în ultima clipă un program care funcționează''': riscați să nu aveți timp să-l testați și să luați zero puncte la acea problemă. În principiu punctajul este maximul din toate sursele trimise. Nu riscați, dacă schimbă regula în ultima clipă? N-ar fi prima oară.

* '''Nu vă îngrijorați de părerea noastră''': noi, instructorii, știm bine care este valoarea voastră. Nu avem nevoie de un rezultat la olimpiadă să aflăm. Nu o să ne vedeți vreodată supărați pe voi pentru că nu ați luat punctaj bun. Dimpotrivă, orice veți face vom fi mândri de voi pentru cât de departe ați ajuns. Grija voastră trebuie să fie rezolvarea problemelor, nu noi. Noi suntem de partea voastră. Chiar dacă la cerc sau la clasă, când suntem între noi, vă certăm sau ne mai supărăm pe voi, în momentul când ați ieșit din școală să vă ''luptați'' cu olimpiada suntem de aceeași parte a baricadei.

=== Diferenţa dintre olimpiadă şi viaţa reală ===

Nu uitaţi că olimpiada este un concurs de verificare a cunoştinţelor, nimic mai mult, nimic mai puţin. Ea nu este evaluarea supremă a unui elev, la fel cum nu este nici ceva de ignorat cu dispreţ. Este cel mai mare concurs de la clasa a 7a, drept pentru care îl vom trata cu respect. Dar nu ne vom spânzura de grindă, considerând că viaţa s-a sfârşit, dacă nu obţinem rezultatul dorit. '''Olimpiada nu ne defineşte ca oameni'''.

Acestea fiind spuse, dacă mergem la olimpiadă, ne dorim un scor cât mai bun. De aceea consider utilă următoarea analogie între arte marţiale si informatică:

* '''În viaţa reală''': în arte marţiale învăţăm pe viaţă. Procedee noi, ce trebuie aplicate cât mai corect, perfect dacă se poate. Filozofie, mod de comportament, respect faţă de artă şi luptă. Atunci când mişcarea nu este perfectă, instructorul vă va corecta. Lupta este interzisă cu excepţia cazului când sunteţi în legitimă apărare. Este imoral şi foarte urât să câştigaţi avantaje în viaţa reală bătându-i pe cei mai slabi. Artele marţiale au ca scop îmbunătăţirea organismului. La fel și informatica, în viața reală trebuie să inventăm un algoritm cât mai bun și să îl implementăm cât mai frumos, mai precis, fără a repeta cod, cât mai clar de citit și de alții, cu comentarii, etc.

* '''La olimpiadă''': olimpiada este ca legitima apărare. Ca şi când sunteţi cu fratele mai mic după voi şi vă atacă golanii. În acel moment nu vă verifică nimeni cât de frumos aţi executat procedeul pentru a scăpa teferi. Tot ce contează este să învingeţi. Pentru aceasta vă veţi folosi de orice! Dacă găsiţi un bolovan, îl aruncaţi în adversar. O chiuvetă spartă, bună şi aceea! La fel şi la olimpiadă, tot ce contează sunt punctele. Nu cât de frumoasă este metoda folosită, nici cât de frumos aţi scris codul. Dacă puteţi lua puncte afişând mereu "0", o faceţi. Această practică nu ar fi acceptată nici la cercul nostru şi nici în viaţa reală. Din păcate, însă, la olimpiadă nu se punctează stilul şi perfecţionismul, ci numai punctele.

'''Atenţie însă!''' Olimpiada este o excepţie, nu o regulă! Aşa cum în viaţa reală nu puteţi să smulgeţi chiuveta din perete pentru a o arunca în colegul de clasă, nici la cerc, la companii, sau unde se va întâmpla să rezolvaţi probleme de informatică, nu puteţi trişa, sau scrie cod ineficient.

== Tema 28 ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/foto1 Foto1] dată la OJI 2020 clasa a 7-a
* [https://www.nerdarena.ro/problema/cursuri Cursuri] dată la OJI 2017, clasa a 7-a
* [https://www.nerdarena.ro/problema/pseudocomp Pseudocomp] dată la ONI 2011 clasa a 8-a

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_28:_Sfaturi_pentru_concursuri_/_olimpiad%C4%83 Accesează rezolvarea temei 28]

Clasa a 7-a Lecția 28: Sfaturi pentru concursuri / olimpiadă

2025-06-08T20:11:08Z

Mihai:

== Înregistrare video lecție ==

<youtube height="720" width="1280">https://youtu.be/a0wFdh8DInQ?start=11100</youtube>

== Ce să faceți / ce să nu faceți ==

=== Ce să faceți ===

* '''Odihnă:''' odihniți-vă cu o zi înainte. Relaxați-vă cu activitatea favorită. Mergeți la un film, jucați jocul vostru preferat, etc. Încercați să nu vă gândiți la concurs.

* '''Ceas:''' aveți un ceas la voi. Nu ceasul calculatorului sau al smartphone-ului. Fiți conștienți de trecerea timpului, nu vă treziți din visare când mai este un sfert de oră. Pentru aceasta un ceas așezat pe banca de lucru este ideal. Nu uitați: toate celelalte ceasuri pot fi incorecte, sau să moară.

* '''Țineți socoteala timpului:''' notați ora începerii concursului pe foaie. Verificați la final că ați avut tot timpul promis. Dacă aveți probleme cu calculatorul și cereți ajutorul supraveghetorului notați timpul când ați fost întrerupți și apoi timpul când reveniți la un calculator funcțional. Aveți dreptul la o prelungire a timpului egală cu timpul pierdut. ''Acest sfat nu mai este atât de valabil de când concursul se desfășoară online. Nu veți putea cere zece minute pierdute, deci încercați să faceți ceva în acele minute, de exemplu să vă gândiți la o altă problemă, pe hârtie. Dacă totuși pierdeți timp semnificativ, cum ar fi 30 minute, atunci aveți baze să faceți contestație ulterior. Cel mai probabil nu veți câștiga puncte, dar e posibil să facă o excepție dacă punctajul vostru e la limită.''

* '''Cereți-vă drepturile:''' Dacă nu înțelegeți textul unei probleme, după ce l-ați citit cu mare atenție, puneți întrebări pentru clarificare. Încercați să formulați cât mai clar întrebările! Sunt preferabile cele al căror răspuns este ''DA'' sau ''NU''. Puteți da și exemple în întrebările voastre, ''dacă intrarea ar fi așa atunci răspund așa, sau așa?''. Dacă exemplul este prea relevant este posibil să nu vă răspundă, dar nu aveți nimic de pierdut.

* '''Low hanging fruit:''' rezolvați problema mai ușoară prima. Citiți toate problemele la început și hotărâți-vă care este mai ușoară. Cu ea începeți. Puteți inclusiv să rezolvați subpunctele mai ușoare primele. De exemplu puteți să rezolvați problema 1 punctul a), apoi problema 2 punctul b).

* '''Moral ridicat:''' intrați în sală încrezători în voi. Sunteți printre cei mai buni din țară, aveți puterea să vă clasați printre primii din țară. Propuneți-vă să luați punctaj maxim și reamintiți-vă că puteți acest lucru.

* '''Probleme grele:''' atunci când constatați că problemele sunt grele nu vă speriați. Bucurați-vă! Este cea mai bună situație pentru voi. Aveți numai de câștigat: fie știți să faceți problema, caz în care este perfect, căci problema fiind grea v-ați asigurat că veți fi mai sus ca ceilalți. Fie nu știți să faceți problema și atunci care este șansa ca cei mai slabi ca voi să știe să o facă? Temeți-vă de problemele ușoare, pe care știu toți să le facă. Voi le veți gândi, consumând timp, ceilalți le vor picta la perfecție.

* '''Atenție:''' fiți foarte atenți la detalii: la numele fișierelor de intrare/ieșire; la numele sub care trebuie să salvați programul C; la setările de proiect CodeBlocks de care am vorbit: '''-Wall''' și '''-O2'''; la locul unde ați salvat proiectul, și numele proiectului în caz că aveți nevoie să le copiați în altă parte, dacă, de exemplu, vă schimbă calculatorul.

=== Ce să NU faceți ===

* Nu îngrășați porcul în ajun: nu faceți probleme în ultima clipă . Vă veți extenua inutil. În urma stresului s-ar putea să nu reușiți să le faceți, ceea ce vă va demoraliza. Aveți nevoie de moral ridicat la concurs.

* '''Nu vă panicați: panica ucide creierul'''. Panica vă face să gândiți mai încet și să doriți în subconștient să ieșiți din sală. Controlați-o. Nu uitați că o problemă grea, pe care nu știți să o faceți, vă avantajează, pentru că probabil nici ceilalți nu știu, pe când voi aveți o șansă să luați puncte pe ea.

* '''Nu-i băgați în seamă pe cei ce se dau mari''': unii elevi spun cu voce suficient de tare să fie auziți, în timpul concursului, lucruri de genul ''aaah, am făcut-o și pe asta, super'' sau ''am rupt, sigur iau suta'', etc. Este modul lor inconștient de a vă demoraliza. De obicei ei se clasează slab. Ignorați-i. De asemenea veți vedea că unii dintre concurenți părăsesc sala mai devreme cu o oră cu un aer fericit, eventual spunând ''sigur mă calific'' sau ''am făcut bine, yesss''. Ignorați-i. Și ei se clasează slab. Nu vă demoralizați indiferent câți elevi ies din sală. Lupta voastră nu este cu ei, ci cu problemele și punctele.

* '''Nu ieșiți mai devreme din sală''': dacă nu ați terminat problemele continuați să vă gândiți la o soluție. Dacă nu mai aveți idei, creați mai multe teste pe care să le testați. Puteți scrie programe care să vă genereze teste. Puteți cere la CMS să vi se evalueze acele teste. Nu uitați: nimănui nu-i pasă cât de repede ați ieșit. Nu luați puncte suplimentare pentru asta.

* '''Nu modificați și trimiteți în ultima clipă un program care funcționează''': riscați să nu aveți timp să-l testați și să luați zero puncte la acea problemă. În principiu punctajul este maximul din toate sursele trimise. Nu riscați, dacă schimbă regula în ultima clipă? N-ar fi prima oară.

* '''Nu vă îngrijorați de părerea noastră''': noi, instructorii, știm bine care este valoarea voastră. Nu avem nevoie de un rezultat la olimpiadă să aflăm. Nu o să ne vedeți vreodată supărați pe voi pentru că nu ați luat punctaj bun. Dimpotrivă, orice veți face vom fi mândri de voi pentru cât de departe ați ajuns. Grija voastră trebuie să fie rezolvarea problemelor, nu noi. Noi suntem de partea voastră. Chiar dacă la cerc sau la clasă, când suntem între noi, vă certăm sau ne mai supărăm pe voi, în momentul când ați ieșit din școală să vă ''luptați'' cu olimpiada suntem de aceeași parte a baricadei.

=== Diferenţa dintre olimpiadă şi viaţa reală ===

Nu uitaţi că olimpiada este un concurs de verificare a cunoştinţelor, nimic mai mult, nimic mai puţin. Ea nu este evaluarea supremă a unui elev, la fel cum nu este nici ceva de ignorat cu dispreţ. Este cel mai mare concurs de la clasa a 7a, drept pentru care îl vom trata cu respect. Dar nu ne vom spânzura de grindă, considerând că viaţa s-a sfârşit, dacă nu obţinem rezultatul dorit. '''Olimpiada nu ne defineşte ca oameni'''.

Acestea fiind spuse, dacă mergem la olimpiadă, ne dorim un scor cât mai bun. De aceea consider utilă următoarea analogie între arte marţiale si informatică:

* '''În viaţa reală''': în arte marţiale învăţăm pe viaţă. Procedee noi, ce trebuie aplicate cât mai corect, perfect dacă se poate. Filozofie, mod de comportament, respect faţă de artă şi luptă. Atunci când mişcarea nu este perfectă, instructorul vă va corecta. Lupta este interzisă cu excepţia cazului când sunteţi în legitimă apărare. Este imoral şi foarte urât să câştigaţi avantaje în viaţa reală bătându-i pe cei mai slabi. Artele marţiale au ca scop îmbunătăţirea organismului. La fel și informatica, în viața reală trebuie să inventăm un algoritm cât mai bun și să îl implementăm cât mai frumos, mai precis, fără a repeta cod, cât mai clar de citit și de alții, cu comentarii, etc.

* '''La olimpiadă''': olimpiada este ca legitima apărare. Ca şi când sunteţi cu fratele mai mic după voi şi vă atacă golanii. În acel moment nu vă verifică nimeni cât de frumos aţi executat procedeul pentru a scăpa teferi. Tot ce contează este să învingeţi. Pentru aceasta vă veţi folosi de orice! Dacă găsiţi un bolovan, îl aruncaţi în adversar. O chiuvetă spartă, bună şi aceea! La fel şi la olimpiadă, tot ce contează sunt punctele. Nu cât de frumoasă este metoda folosită, nici cât de frumos aţi scris codul. Dacă puteţi lua puncte afişând mereu "0", o faceţi. Această practică nu ar fi acceptată nici la cercul nostru şi nici în viaţa reală. Din păcate, însă, la olimpiadă nu se punctează stilul şi perfecţionismul, ci numai punctele.

'''Atenţie însă!''' Olimpiada este o excepţie, nu o regulă! Aşa cum în viaţa reală nu puteţi să smulgeţi chiuveta din perete pentru a o arunca în colegul de clasă, nici la cerc, la companii, sau unde se va întâmpla să rezolvaţi probleme de informatică, nu puteţi trişa, sau scrie cod ineficient.

== Tema 28 ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/foto1 Foto1] dată la OJI 2020 clasa a 7-a
* [https://www.nerdarena.ro/problema/cursuri Cursuri] dată la OJI 2017, clasa a 7-a
* [https://www.nerdarena.ro/problema/pseudocomp Pseudocomp] dată la ONI 2011 clasa a 8-a

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_28:_Sfaturi_pentru_concursuri_/_olimpiad%C4%83 Accesează rezolvarea temei 28]

Clasa a 7-a Lecția 28: Sfaturi pentru concursuri / olimpiadă

2025-06-08T20:08:59Z

Mihai:

== Înregistrare video lecție ==

<youtube height="720" width="1280">https://youtu.be/a0wFdh8DInQ?start=1&end=7207</youtube>

== Ce să faceți / ce să nu faceți ==

=== Ce să faceți ===

* '''Odihnă:''' odihniți-vă cu o zi înainte. Relaxați-vă cu activitatea favorită. Mergeți la un film, jucați jocul vostru preferat, etc. Încercați să nu vă gândiți la concurs.

* '''Ceas:''' aveți un ceas la voi. Nu ceasul calculatorului sau al smartphone-ului. Fiți conștienți de trecerea timpului, nu vă treziți din visare când mai este un sfert de oră. Pentru aceasta un ceas așezat pe banca de lucru este ideal. Nu uitați: toate celelalte ceasuri pot fi incorecte, sau să moară.

* '''Țineți socoteala timpului:''' notați ora începerii concursului pe foaie. Verificați la final că ați avut tot timpul promis. Dacă aveți probleme cu calculatorul și cereți ajutorul supraveghetorului notați timpul când ați fost întrerupți și apoi timpul când reveniți la un calculator funcțional. Aveți dreptul la o prelungire a timpului egală cu timpul pierdut. ''Acest sfat nu mai este atât de valabil de când concursul se desfășoară online. Nu veți putea cere zece minute pierdute, deci încercați să faceți ceva în acele minute, de exemplu să vă gândiți la o altă problemă, pe hârtie. Dacă totuși pierdeți timp semnificativ, cum ar fi 30 minute, atunci aveți baze să faceți contestație ulterior. Cel mai probabil nu veți câștiga puncte, dar e posibil să facă o excepție dacă punctajul vostru e la limită.''

* '''Cereți-vă drepturile:''' Dacă nu înțelegeți textul unei probleme, după ce l-ați citit cu mare atenție, puneți întrebări pentru clarificare. Încercați să formulați cât mai clar întrebările! Sunt preferabile cele al căror răspuns este ''DA'' sau ''NU''. Puteți da și exemple în întrebările voastre, ''dacă intrarea ar fi așa atunci răspund așa, sau așa?''. Dacă exemplul este prea relevant este posibil să nu vă răspundă, dar nu aveți nimic de pierdut.

* '''Low hanging fruit:''' rezolvați problema mai ușoară prima. Citiți toate problemele la început și hotărâți-vă care este mai ușoară. Cu ea începeți. Puteți inclusiv să rezolvați subpunctele mai ușoare primele. De exemplu puteți să rezolvați problema 1 punctul a), apoi problema 2 punctul b).

* '''Moral ridicat:''' intrați în sală încrezători în voi. Sunteți printre cei mai buni din țară, aveți puterea să vă clasați printre primii din țară. Propuneți-vă să luați punctaj maxim și reamintiți-vă că puteți acest lucru.

* '''Probleme grele:''' atunci când constatați că problemele sunt grele nu vă speriați. Bucurați-vă! Este cea mai bună situație pentru voi. Aveți numai de câștigat: fie știți să faceți problema, caz în care este perfect, căci problema fiind grea v-ați asigurat că veți fi mai sus ca ceilalți. Fie nu știți să faceți problema și atunci care este șansa ca cei mai slabi ca voi să știe să o facă? Temeți-vă de problemele ușoare, pe care știu toți să le facă. Voi le veți gândi, consumând timp, ceilalți le vor picta la perfecție.

* '''Atenție:''' fiți foarte atenți la detalii: la numele fișierelor de intrare/ieșire; la numele sub care trebuie să salvați programul C; la setările de proiect CodeBlocks de care am vorbit: '''-Wall''' și '''-O2'''; la locul unde ați salvat proiectul, și numele proiectului în caz că aveți nevoie să le copiați în altă parte, dacă, de exemplu, vă schimbă calculatorul.

=== Ce să NU faceți ===

* Nu îngrășați porcul în ajun: nu faceți probleme în ultima clipă . Vă veți extenua inutil. În urma stresului s-ar putea să nu reușiți să le faceți, ceea ce vă va demoraliza. Aveți nevoie de moral ridicat la concurs.

* '''Nu vă panicați: panica ucide creierul'''. Panica vă face să gândiți mai încet și să doriți în subconștient să ieșiți din sală. Controlați-o. Nu uitați că o problemă grea, pe care nu știți să o faceți, vă avantajează, pentru că probabil nici ceilalți nu știu, pe când voi aveți o șansă să luați puncte pe ea.

* '''Nu-i băgați în seamă pe cei ce se dau mari''': unii elevi spun cu voce suficient de tare să fie auziți, în timpul concursului, lucruri de genul ''aaah, am făcut-o și pe asta, super'' sau ''am rupt, sigur iau suta'', etc. Este modul lor inconștient de a vă demoraliza. De obicei ei se clasează slab. Ignorați-i. De asemenea veți vedea că unii dintre concurenți părăsesc sala mai devreme cu o oră cu un aer fericit, eventual spunând ''sigur mă calific'' sau ''am făcut bine, yesss''. Ignorați-i. Și ei se clasează slab. Nu vă demoralizați indiferent câți elevi ies din sală. Lupta voastră nu este cu ei, ci cu problemele și punctele.

* '''Nu ieșiți mai devreme din sală''': dacă nu ați terminat problemele continuați să vă gândiți la o soluție. Dacă nu mai aveți idei, creați mai multe teste pe care să le testați. Puteți scrie programe care să vă genereze teste. Puteți cere la CMS să vi se evalueze acele teste. Nu uitați: nimănui nu-i pasă cât de repede ați ieșit. Nu luați puncte suplimentare pentru asta.

* '''Nu modificați și trimiteți în ultima clipă un program care funcționează''': riscați să nu aveți timp să-l testați și să luați zero puncte la acea problemă. În principiu punctajul este maximul din toate sursele trimise. Nu riscați, dacă schimbă regula în ultima clipă? N-ar fi prima oară.

* '''Nu vă îngrijorați de părerea noastră''': noi, instructorii, știm bine care este valoarea voastră. Nu avem nevoie de un rezultat la olimpiadă să aflăm. Nu o să ne vedeți vreodată supărați pe voi pentru că nu ați luat punctaj bun. Dimpotrivă, orice veți face vom fi mândri de voi pentru cât de departe ați ajuns. Grija voastră trebuie să fie rezolvarea problemelor, nu noi. Noi suntem de partea voastră. Chiar dacă la cerc sau la clasă, când suntem între noi, vă certăm sau ne mai supărăm pe voi, în momentul când ați ieșit din școală să vă ''luptați'' cu olimpiada suntem de aceeași parte a baricadei.

=== Diferenţa dintre olimpiadă şi viaţa reală ===

Nu uitaţi că olimpiada este un concurs de verificare a cunoştinţelor, nimic mai mult, nimic mai puţin. Ea nu este evaluarea supremă a unui elev, la fel cum nu este nici ceva de ignorat cu dispreţ. Este cel mai mare concurs de la clasa a 7a, drept pentru care îl vom trata cu respect. Dar nu ne vom spânzura de grindă, considerând că viaţa s-a sfârşit, dacă nu obţinem rezultatul dorit. '''Olimpiada nu ne defineşte ca oameni'''.

Acestea fiind spuse, dacă mergem la olimpiadă, ne dorim un scor cât mai bun. De aceea consider utilă următoarea analogie între arte marţiale si informatică:

* '''În viaţa reală''': în arte marţiale învăţăm pe viaţă. Procedee noi, ce trebuie aplicate cât mai corect, perfect dacă se poate. Filozofie, mod de comportament, respect faţă de artă şi luptă. Atunci când mişcarea nu este perfectă, instructorul vă va corecta. Lupta este interzisă cu excepţia cazului când sunteţi în legitimă apărare. Este imoral şi foarte urât să câştigaţi avantaje în viaţa reală bătându-i pe cei mai slabi. Artele marţiale au ca scop îmbunătăţirea organismului. La fel și informatica, în viața reală trebuie să inventăm un algoritm cât mai bun și să îl implementăm cât mai frumos, mai precis, fără a repeta cod, cât mai clar de citit și de alții, cu comentarii, etc.

* '''La olimpiadă''': olimpiada este ca legitima apărare. Ca şi când sunteţi cu fratele mai mic după voi şi vă atacă golanii. În acel moment nu vă verifică nimeni cât de frumos aţi executat procedeul pentru a scăpa teferi. Tot ce contează este să învingeţi. Pentru aceasta vă veţi folosi de orice! Dacă găsiţi un bolovan, îl aruncaţi în adversar. O chiuvetă spartă, bună şi aceea! La fel şi la olimpiadă, tot ce contează sunt punctele. Nu cât de frumoasă este metoda folosită, nici cât de frumos aţi scris codul. Dacă puteţi lua puncte afişând mereu "0", o faceţi. Această practică nu ar fi acceptată nici la cercul nostru şi nici în viaţa reală. Din păcate, însă, la olimpiadă nu se punctează stilul şi perfecţionismul, ci numai punctele.

'''Atenţie însă!''' Olimpiada este o excepţie, nu o regulă! Aşa cum în viaţa reală nu puteţi să smulgeţi chiuveta din perete pentru a o arunca în colegul de clasă, nici la cerc, la companii, sau unde se va întâmpla să rezolvaţi probleme de informatică, nu puteţi trişa, sau scrie cod ineficient.

== Tema 28 ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/foto1 Foto1] dată la OJI 2020 clasa a 7-a
* [https://www.nerdarena.ro/problema/cursuri Cursuri] dată la OJI 2017, clasa a 7-a
* [https://www.nerdarena.ro/problema/pseudocomp Pseudocomp] dată la ONI 2011 clasa a 8-a

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_28:_Sfaturi_pentru_concursuri_/_olimpiad%C4%83 Accesează rezolvarea temei 28]

Clasa a 7-a Lecția 28: Sfaturi pentru concursuri / olimpiadă

2025-06-08T19:58:45Z

Mihai:

Clasa a 7-a Lecția 28: Sfaturi pentru concursuri / olimpiadă

2025-06-08T19:52:55Z

Mihai:

== Ce să faceți / ce să nu faceți ==

=== Ce să faceți ===

* '''Odihnă:''' odihniți-vă cu o zi înainte. Relaxați-vă cu activitatea favorită. Mergeți la un film, jucați jocul vostru preferat, etc. Încercați să nu vă gândiți la concurs.

* '''Ceas:''' aveți un ceas la voi. Nu ceasul calculatorului sau al smartphone-ului. Fiți conștienți de trecerea timpului, nu vă treziți din visare când mai este un sfert de oră. Pentru aceasta un ceas așezat pe banca de lucru este ideal. Nu uitați: toate celelalte ceasuri pot fi incorecte, sau să moară.

* '''Țineți socoteala timpului:''' notați ora începerii concursului pe foaie. Verificați la final că ați avut tot timpul promis. Dacă aveți probleme cu calculatorul și cereți ajutorul supraveghetorului notați timpul când ați fost întrerupți și apoi timpul când reveniți la un calculator funcțional. Aveți dreptul la o prelungire a timpului egală cu timpul pierdut. Acest sfat nu mai este atât de valabil de când concursul se desfășoară online. Nu veți putea cere zece minute pierdute, deci încercați să faceți ceva în acele minute, de exemplu să vă gândiți la o altă problemă, pe hârtie. Dacă totuși pierdeți timp semnificativ, cum ar fi 30 minute, atunci aveți baze să faceți contestație ulterior. Cel mai probabil nu veți câștiga puncte, dar e posibil să facă o excepție dacă punctajul vostru e la limită.

* '''Cereți-vă drepturile:''' Dacă nu înțelegeți textul unei probleme, după ce l-ați citit cu mare atenție, puneți întrebări pentru clarificare. Încercați să formulați cât mai clar întrebările! Sunt preferabile cele al căror răspuns este DA sau NU. Puteți da și exemple în întrebările voastre, "dacă intrarea ar fi așa atunci răspund așa, sau așa?". Dacă exemplul este prea relevant este posibil să nu vă răspundă, dar nu aveți nimic de pierdut.

* '''Low hanging fruit:''' rezolvați problema mai ușoară prima. Citiți toate problemele la început și hotărâți-vă care este mai ușoară. Cu ea începeți. Puteți inclusiv să rezolvați subpunctele mai ușoare primele. De exemplu puteți să rezolvați problema 1 punctul a), apoi problema 2 punctul b).

* '''Moral ridicat:''' intrați în sală încrezători în voi. Sunteți printre cei mai buni din țară, aveți puterea să vă clasați printre primii din țară. Propuneți-vă să luați punctaj maxim și reamintiți-vă că puteți acest lucru.

* '''Probleme grele:''' atunci când constatați că problemele sunt grele nu vă speriați. Bucurați-vă! Este cea mai bună situație pentru voi. Aveți numai de câștigat: fie știți să faceți problema, caz în care este perfect, căci problema fiind grea v-ați asigurat că veți fi mai sus ca ceilalți. Fie nu știți să faceți problema și atunci care este șansa ca cei mai slabi ca voi să știe să o facă? Temeți-vă de problemele ușoare, pe care știu toți să le facă. Voi le veți gândi, consumând timp, ceilalți le vor picta la perfecție.

* '''Atenție:''' fiți foarte atenți la detalii: la numele fișierelor de intrare/ieșire; la numele sub care trebuie să salvați programul C; la setările de proiect CodeBlocks de care am vorbit: -Wall și -O2; la locul unde ați salvat proiectul, și numele proiectului în caz că aveți nevoie să le copiați în altă parte, dacă, de exemplu, vă schimbă calculatorul.

=== Ce să NU faceți ===

* Nu îngrășați porcul în ajun: nu faceți probleme în ultima clipă . Vă veți extenua inutil. În urma stresului s-ar putea să nu reușiți să le faceți, ceea ce vă va demoraliza. Aveți nevoie de moral ridicat la concurs.

* '''Nu vă panicați: panica ucide creierul'''. Panica vă face să gândiți mai încet și să doriți în subconștient să ieșiți din sală. Controlați-o. Nu uitați că o problemă grea, pe care nu știți să o faceți, vă avantajează, pentru că probabil nici ceilalți nu știu, pe când voi aveți o șansă să luați puncte pe ea.

* '''Nu-i băgați în seamă pe cei ce se dau mari''': unii elevi spun cu voce suficient de tare să fie auziți, în timpul concursului, lucruri de genul 'aaah, am făcut-o și pe asta, super' sau 'am rupt, sigur iau suta', etc. Este modul lor inconștient de a vă demoraliza. De obicei ei se clasează slab. Ignorați-i. De asemenea veți vedea că unii dintre concurenți părăsesc sala mai devreme cu o oră cu un aer fericit, eventual spunând 'sigur mă calific' sau 'am făcut bine, yesss'. Ignorați-i. Și ei se clasează slab. Nu vă demoralizați indiferent câți elevi ies din sală. Lupta voastră nu este cu ei, ci cu problemele și punctele.

* '''Nu ieșiți mai devreme din sală''': dacă nu ați terminat problemele continuați să vă gândiți la o soluție. Dacă nu mai aveți idei, creați mai multe teste pe care să le testați. Puteți scrie programe care să vă genereze teste. Puteți cere la CMS să vi se evalueze acele teste. Nu uitați: nimănui nu-i pasă cât de repede ați ieșit. Nu luați puncte suplimentare pentru asta.

* '''Nu modificați și trimiteți în ultima clipă un program care funcționează''': riscați să nu aveți timp să-l testați și să luați zero puncte la acea problemă. În principiu punctajul este maximul din toate sursele trimise. Nu riscați, dacă schimbă regula în ultima clipă? N-ar fi prima oară.

* '''Nu vă îngrijorați de părerea noastră''': noi, instructorii, știm bine care este valoarea voastră. Nu avem nevoie de un rezultat la olimpiadă să aflăm. Nu o să ne vedeți vreodată supărați pe voi pentru că nu ați luat punctaj bun. Dimpotrivă, orice veți face vom fi mândri de voi pentru cât de departe ați ajuns. Grija voastră trebuie să fie rezolvarea problemelor, nu noi. Noi suntem de partea voastră. Chiar dacă la cerc sau la clasă, când suntem între noi, vă certăm sau ne mai supărăm pe voi, în momentul când ați ieșit din școală să vă "luptați" cu olimpiada suntem de aceeași parte a baricadei.

=== Diferenţa dintre olimpiadă şi viaţa reală ===

Nu uitaţi că olimpiada este un concurs de verificare a cunoştinţelor, nimic mai mult, nimic mai puţin. Ea nu este evaluarea supremă a unui elev, la fel cum nu este nici ceva de ignorat cu dispreţ. Este cel mai mare concurs de la clasa a 7a, drept pentru care îl vom trata cu respect. Dar nu ne vom spânzura de grindă, considerând că viaţa s-a sfârşit, dacă nu obţinem rezultatul dorit. Olimpiada nu ne defineşte ca oameni.

Acestea fiind spuse, dacă mergem la olimpiadă, ne dorim un scor cât mai bun. De aceea consider utilă următoarea analogie între arte marţiale si informatică:

* '''În viaţa reală''': în arte marţiale învăţăm pe viaţă. Procedee noi, ce trebuie aplicate cât mai corect, perfect dacă se poate. Filozofie, mod de comportament, respect faţă de artă şi luptă. Atunci când mişcarea nu este perfectă, instructorul vă va corecta. Lupta este interzisă cu excepţia cazului când sunteţi în legitimă apărare. Este imoral şi foarte urât să câştigaţi avantaje în viaţa reală bătându-i pe cei mai slabi. Artele marţiale au ca scop îmbunătăţirea organismului. La fel și informatica, în viața reală trebuie să inventăm un algoritm cât mai bun și să îl implementăm cât mai frumos, mai precis, fără a repeta cod, cât mai clar de citit și de alții, cu comentarii, etc.

* '''La olimpiadă''': olimpiada este ca legitima apărare. Ca şi când sunteţi cu fratele mai mic după voi şi vă atacă golanii. În acel moment nu vă verifică nimeni cât de frumos aţi executat procedeul pentru a scăpa teferi. Tot ce contează este să învingeţi. Pentru aceasta vă veţi folosi de orice! Dacă găsiţi un bolovan, îl aruncaţi în adversar. O chiuvetă spartă, bună şi aceea! La fel şi la olimpiadă, tot ce contează sunt punctele. Nu cât de frumoasă este metoda folosită, nici cât de frumos aţi scris codul. Dacă puteţi lua puncte afişând mereu "0", o faceţi. Această practică nu ar fi acceptată nici la cercul nostru şi nici în viaţa reală. Din păcate, însă, la olimpiadă nu se punctează stilul şi perfecţionismul, ci numai punctele.

'''Atenţie însă!''' Olimpiada este o excepţie, nu o regulă! Aşa cum în viaţa reală nu puteţi să smulgeţi chiuveta din perete pentru a o arunca în colegul de clasă, nici la cerc, la companii, sau unde se va întâmpla să rezolvaţi probleme de informatică, nu puteţi trişa, sau scrie cod ineficient.

Clasa a 7-a Lecția 28: Sfaturi pentru concursuri / olimpiadă

2025-06-08T19:52:47Z

Mihai: /* Ce să NU</span faceți */

== Ce să faceți / ce să nu faceți ==

=== Ce să faceți ===

* '''Odihnă:''' odihniți-vă cu o zi înainte. Relaxați-vă cu activitatea favorită. Mergeți la un film, jucați jocul vostru preferat, etc. Încercați să nu vă gândiți la concurs.

* '''Ceas:''' aveți un ceas la voi. Nu ceasul calculatorului sau al smartphone-ului. Fiți conștienți de trecerea timpului, nu vă treziți din visare când mai este un sfert de oră. Pentru aceasta un ceas așezat pe banca de lucru este ideal. Nu uitați: toate celelalte ceasuri pot fi incorecte, sau să moară.

* '''Țineți socoteala timpului:''' notați ora începerii concursului pe foaie. Verificați la final că ați avut tot timpul promis. Dacă aveți probleme cu calculatorul și cereți ajutorul supraveghetorului notați timpul când ați fost întrerupți și apoi timpul când reveniți la un calculator funcțional. Aveți dreptul la o prelungire a timpului egală cu timpul pierdut. Acest sfat nu mai este atât de valabil de când concursul se desfășoară online. Nu veți putea cere zece minute pierdute, deci încercați să faceți ceva în acele minute, de exemplu să vă gândiți la o altă problemă, pe hârtie. Dacă totuși pierdeți timp semnificativ, cum ar fi 30 minute, atunci aveți baze să faceți contestație ulterior. Cel mai probabil nu veți câștiga puncte, dar e posibil să facă o excepție dacă punctajul vostru e la limită.

* '''Cereți-vă drepturile:''' Dacă nu înțelegeți textul unei probleme, după ce l-ați citit cu mare atenție, puneți întrebări pentru clarificare. Încercați să formulați cât mai clar întrebările! Sunt preferabile cele al căror răspuns este DA sau NU. Puteți da și exemple în întrebările voastre, "dacă intrarea ar fi așa atunci răspund așa, sau așa?". Dacă exemplul este prea relevant este posibil să nu vă răspundă, dar nu aveți nimic de pierdut.

* '''Low hanging fruit:''' rezolvați problema mai ușoară prima. Citiți toate problemele la început și hotărâți-vă care este mai ușoară. Cu ea începeți. Puteți inclusiv să rezolvați subpunctele mai ușoare primele. De exemplu puteți să rezolvați problema 1 punctul a), apoi problema 2 punctul b).

* '''Moral ridicat:''' intrați în sală încrezători în voi. Sunteți printre cei mai buni din țară, aveți puterea să vă clasați printre primii din țară. Propuneți-vă să luați punctaj maxim și reamintiți-vă că puteți acest lucru.

* '''Probleme grele:''' atunci când constatați că problemele sunt grele nu vă speriați. Bucurați-vă! Este cea mai bună situație pentru voi. Aveți numai de câștigat: fie știți să faceți problema, caz în care este perfect, căci problema fiind grea v-ați asigurat că veți fi mai sus ca ceilalți. Fie nu știți să faceți problema și atunci care este șansa ca cei mai slabi ca voi să știe să o facă? Temeți-vă de problemele ușoare, pe care știu toți să le facă. Voi le veți gândi, consumând timp, ceilalți le vor picta la perfecție.

* '''Atenție:''' fiți foarte atenți la detalii: la numele fișierelor de intrare/ieșire; la numele sub care trebuie să salvați programul C; la setările de proiect CodeBlocks de care am vorbit: -Wall și -O2; la locul unde ați salvat proiectul, și numele proiectului în caz că aveți nevoie să le copiați în altă parte, dacă, de exemplu, vă schimbă calculatorul.

=== Ce să NU faceți ===

* Nu îngrășați porcul în ajun: nu faceți probleme în ultima clipă . Vă veți extenua inutil. În urma stresului s-ar putea să nu reușiți să le faceți, ceea ce vă va demoraliza. Aveți nevoie de moral ridicat la concurs.

* '''Nu vă panicați: panica ucide creierul'''. Panica vă face să gândiți mai încet și să doriți în subconștient să ieșiți din sală. Controlați-o. Nu uitați că o problemă grea, pe care nu știți să o faceți, vă avantajează, pentru că probabil nici ceilalți nu știu, pe când voi aveți o șansă să luați puncte pe ea.

* '''Nu-i băgați în seamă pe cei ce se dau mari''': unii elevi spun cu voce suficient de tare să fie auziți, în timpul concursului, lucruri de genul 'aaah, am făcut-o și pe asta, super' sau 'am rupt, sigur iau suta', etc. Este modul lor inconștient de a vă demoraliza. De obicei ei se clasează slab. Ignorați-i. De asemenea veți vedea că unii dintre concurenți părăsesc sala mai devreme cu o oră cu un aer fericit, eventual spunând 'sigur mă calific' sau 'am făcut bine, yesss'. Ignorați-i. Și ei se clasează slab. Nu vă demoralizați indiferent câți elevi ies din sală. Lupta voastră nu este cu ei, ci cu problemele și punctele.

* '''Nu ieșiți mai devreme din sală''': dacă nu ați terminat problemele continuați să vă gândiți la o soluție. Dacă nu mai aveți idei, creați mai multe teste pe care să le testați. Puteți scrie programe care să vă genereze teste. Puteți cere la CMS să vi se evalueze acele teste. Nu uitați: nimănui nu-i pasă cât de repede ați ieșit. Nu luați puncte suplimentare pentru asta.

* '''Nu modificați și trimiteți în ultima clipă un program care funcționează''': riscați să nu aveți timp să-l testați și să luați zero puncte la acea problemă. În principiu punctajul este maximul din toate sursele trimise. Nu riscați, dacă schimbă regula în ultima clipă? N-ar fi prima oară.

* '''Nu vă îngrijorați de părerea noastră''': noi, instructorii, știm bine care este valoarea voastră. Nu avem nevoie de un rezultat la olimpiadă să aflăm. Nu o să ne vedeți vreodată supărați pe voi pentru că nu ați luat punctaj bun. Dimpotrivă, orice veți face vom fi mândri de voi pentru cât de departe ați ajuns. Grija voastră trebuie să fie rezolvarea problemelor, nu noi. Noi suntem de partea voastră. Chiar dacă la cerc sau la clasă, când suntem între noi, vă certăm sau ne mai supărăm pe voi, în momentul când ați ieșit din școală să vă "luptați" cu olimpiada suntem de aceeași parte a baricadei.

=== Diferenţa dintre olimpiadă şi viaţa reală ===

Nu uitaţi că olimpiada este un concurs de verificare a cunoştinţelor, nimic mai mult, nimic mai puţin. Ea nu este evaluarea supremă a unui elev, la fel cum nu este nici ceva de ignorat cu dispreţ. Este cel mai mare concurs de la clasa a 7a, drept pentru care îl vom trata cu respect. Dar nu ne vom spânzura de grindă, considerând că viaţa s-a sfârşit, dacă nu obţinem rezultatul dorit. Olimpiada nu ne defineşte ca oameni.

Acestea fiind spuse, dacă mergem la olimpiadă, ne dorim un scor cât mai bun. De aceea consider utilă următoarea analogie între arte marţiale si informatică:

* '''În viaţa reală''': în arte marţiale învăţăm pe viaţă. Procedee noi, ce trebuie aplicate cât mai corect, perfect dacă se poate. Filozofie, mod de comportament, respect faţă de artă şi luptă. Atunci când mişcarea nu este perfectă, instructorul vă va corecta. Lupta este interzisă cu excepţia cazului când sunteţi în legitimă apărare. Este imoral şi foarte urât să câştigaţi avantaje în viaţa reală bătându-i pe cei mai slabi. Artele marţiale au ca scop îmbunătăţirea organismului. La fel și informatica, în viața reală trebuie să inventăm un algoritm cât mai bun și să îl implementăm cât mai frumos, mai precis, fără a repeta cod, cât mai clar de citit și de alții, cu comentarii, etc.

* '''La olimpiadă''': olimpiada este ca legitima apărare. Ca şi când sunteţi cu fratele mai mic după voi şi vă atacă golanii. În acel moment nu vă verifică nimeni cât de frumos aţi executat procedeul pentru a scăpa teferi. Tot ce contează este să învingeţi. Pentru aceasta vă veţi folosi de orice! Dacă găsiţi un bolovan, îl aruncaţi în adversar. O chiuvetă spartă, bună şi aceea! La fel şi la olimpiadă, tot ce contează sunt punctele. Nu cât de frumoasă este metoda folosită, nici cât de frumos aţi scris codul. Dacă puteţi lua puncte afişând mereu "0", o faceţi. Această practică nu ar fi acceptată nici la cercul nostru şi nici în viaţa reală. Din păcate, însă, la olimpiadă nu se punctează stilul şi perfecţionismul, ci numai punctele.

'''Atenţie însă!''' Olimpiada este o excepţie, nu o regulă! Aşa cum în viaţa reală nu puteţi să smulgeţi chiuveta din perete pentru a o arunca în colegul de clasă, nici la cerc, la companii, sau unde se va întâmpla să rezolvaţi probleme de informatică, nu puteţi trişa, sau scrie cod ineficient.

Clasa a 7-a Lecția 28: Sfaturi pentru concursuri / olimpiadă

2025-06-08T19:52:37Z

Mihai: Created page with "== Ce să faceți / ce să nu faceți == === Ce să faceți === * '''Odihnă:''' odihniți-vă cu o zi înainte. Relaxați-vă cu activitatea favorită. Mergeți la un film, jucați jocul vostru preferat, etc. Încercați să nu vă gândiți la concurs. * '''Ceas:''' aveți un ceas la voi. Nu ceasul calculatorului sau al smartphone-ului. Fiți conștienți de trecerea timpului, nu vă treziți din visare când mai este un sfert de oră. Pentru aceasta un ceas așezat..."

== Ce să faceți / ce să nu faceți ==

=== Ce să faceți ===

* '''Odihnă:''' odihniți-vă cu o zi înainte. Relaxați-vă cu activitatea favorită. Mergeți la un film, jucați jocul vostru preferat, etc. Încercați să nu vă gândiți la concurs.

* '''Ceas:''' aveți un ceas la voi. Nu ceasul calculatorului sau al smartphone-ului. Fiți conștienți de trecerea timpului, nu vă treziți din visare când mai este un sfert de oră. Pentru aceasta un ceas așezat pe banca de lucru este ideal. Nu uitați: toate celelalte ceasuri pot fi incorecte, sau să moară.

* '''Țineți socoteala timpului:''' notați ora începerii concursului pe foaie. Verificați la final că ați avut tot timpul promis. Dacă aveți probleme cu calculatorul și cereți ajutorul supraveghetorului notați timpul când ați fost întrerupți și apoi timpul când reveniți la un calculator funcțional. Aveți dreptul la o prelungire a timpului egală cu timpul pierdut. Acest sfat nu mai este atât de valabil de când concursul se desfășoară online. Nu veți putea cere zece minute pierdute, deci încercați să faceți ceva în acele minute, de exemplu să vă gândiți la o altă problemă, pe hârtie. Dacă totuși pierdeți timp semnificativ, cum ar fi 30 minute, atunci aveți baze să faceți contestație ulterior. Cel mai probabil nu veți câștiga puncte, dar e posibil să facă o excepție dacă punctajul vostru e la limită.

* '''Cereți-vă drepturile:''' Dacă nu înțelegeți textul unei probleme, după ce l-ați citit cu mare atenție, puneți întrebări pentru clarificare. Încercați să formulați cât mai clar întrebările! Sunt preferabile cele al căror răspuns este DA sau NU. Puteți da și exemple în întrebările voastre, "dacă intrarea ar fi așa atunci răspund așa, sau așa?". Dacă exemplul este prea relevant este posibil să nu vă răspundă, dar nu aveți nimic de pierdut.

* '''Low hanging fruit:''' rezolvați problema mai ușoară prima. Citiți toate problemele la început și hotărâți-vă care este mai ușoară. Cu ea începeți. Puteți inclusiv să rezolvați subpunctele mai ușoare primele. De exemplu puteți să rezolvați problema 1 punctul a), apoi problema 2 punctul b).

* '''Moral ridicat:''' intrați în sală încrezători în voi. Sunteți printre cei mai buni din țară, aveți puterea să vă clasați printre primii din țară. Propuneți-vă să luați punctaj maxim și reamintiți-vă că puteți acest lucru.

* '''Probleme grele:''' atunci când constatați că problemele sunt grele nu vă speriați. Bucurați-vă! Este cea mai bună situație pentru voi. Aveți numai de câștigat: fie știți să faceți problema, caz în care este perfect, căci problema fiind grea v-ați asigurat că veți fi mai sus ca ceilalți. Fie nu știți să faceți problema și atunci care este șansa ca cei mai slabi ca voi să știe să o facă? Temeți-vă de problemele ușoare, pe care știu toți să le facă. Voi le veți gândi, consumând timp, ceilalți le vor picta la perfecție.

* '''Atenție:''' fiți foarte atenți la detalii: la numele fișierelor de intrare/ieșire; la numele sub care trebuie să salvați programul C; la setările de proiect CodeBlocks de care am vorbit: -Wall și -O2; la locul unde ați salvat proiectul, și numele proiectului în caz că aveți nevoie să le copiați în altă parte, dacă, de exemplu, vă schimbă calculatorul.

=== Ce să NU</span faceți ===

* Nu îngrășați porcul în ajun: nu faceți probleme în ultima clipă . Vă veți extenua inutil. În urma stresului s-ar putea să nu reușiți să le faceți, ceea ce vă va demoraliza. Aveți nevoie de moral ridicat la concurs.

* '''Nu vă panicați: panica ucide creierul'''. Panica vă face să gândiți mai încet și să doriți în subconștient să ieșiți din sală. Controlați-o. Nu uitați că o problemă grea, pe care nu știți să o faceți, vă avantajează, pentru că probabil nici ceilalți nu știu, pe când voi aveți o șansă să luați puncte pe ea.

* '''Nu-i băgați în seamă pe cei ce se dau mari''': unii elevi spun cu voce suficient de tare să fie auziți, în timpul concursului, lucruri de genul 'aaah, am făcut-o și pe asta, super' sau 'am rupt, sigur iau suta', etc. Este modul lor inconștient de a vă demoraliza. De obicei ei se clasează slab. Ignorați-i. De asemenea veți vedea că unii dintre concurenți părăsesc sala mai devreme cu o oră cu un aer fericit, eventual spunând 'sigur mă calific' sau 'am făcut bine, yesss'. Ignorați-i. Și ei se clasează slab. Nu vă demoralizați indiferent câți elevi ies din sală. Lupta voastră nu este cu ei, ci cu problemele și punctele.

* '''Nu ieșiți mai devreme din sală''': dacă nu ați terminat problemele continuați să vă gândiți la o soluție. Dacă nu mai aveți idei, creați mai multe teste pe care să le testați. Puteți scrie programe care să vă genereze teste. Puteți cere la CMS să vi se evalueze acele teste. Nu uitați: nimănui nu-i pasă cât de repede ați ieșit. Nu luați puncte suplimentare pentru asta.

* '''Nu modificați și trimiteți în ultima clipă un program care funcționează''': riscați să nu aveți timp să-l testați și să luați zero puncte la acea problemă. În principiu punctajul este maximul din toate sursele trimise. Nu riscați, dacă schimbă regula în ultima clipă? N-ar fi prima oară.

* '''Nu vă îngrijorați de părerea noastră''': noi, instructorii, știm bine care este valoarea voastră. Nu avem nevoie de un rezultat la olimpiadă să aflăm. Nu o să ne vedeți vreodată supărați pe voi pentru că nu ați luat punctaj bun. Dimpotrivă, orice veți face vom fi mândri de voi pentru cât de departe ați ajuns. Grija voastră trebuie să fie rezolvarea problemelor, nu noi. Noi suntem de partea voastră. Chiar dacă la cerc sau la clasă, când suntem între noi, vă certăm sau ne mai supărăm pe voi, în momentul când ați ieșit din școală să vă "luptați" cu olimpiada suntem de aceeași parte a baricadei.

=== Diferenţa dintre olimpiadă şi viaţa reală ===

Nu uitaţi că olimpiada este un concurs de verificare a cunoştinţelor, nimic mai mult, nimic mai puţin. Ea nu este evaluarea supremă a unui elev, la fel cum nu este nici ceva de ignorat cu dispreţ. Este cel mai mare concurs de la clasa a 7a, drept pentru care îl vom trata cu respect. Dar nu ne vom spânzura de grindă, considerând că viaţa s-a sfârşit, dacă nu obţinem rezultatul dorit. Olimpiada nu ne defineşte ca oameni.

Acestea fiind spuse, dacă mergem la olimpiadă, ne dorim un scor cât mai bun. De aceea consider utilă următoarea analogie între arte marţiale si informatică:

* '''În viaţa reală''': în arte marţiale învăţăm pe viaţă. Procedee noi, ce trebuie aplicate cât mai corect, perfect dacă se poate. Filozofie, mod de comportament, respect faţă de artă şi luptă. Atunci când mişcarea nu este perfectă, instructorul vă va corecta. Lupta este interzisă cu excepţia cazului când sunteţi în legitimă apărare. Este imoral şi foarte urât să câştigaţi avantaje în viaţa reală bătându-i pe cei mai slabi. Artele marţiale au ca scop îmbunătăţirea organismului. La fel și informatica, în viața reală trebuie să inventăm un algoritm cât mai bun și să îl implementăm cât mai frumos, mai precis, fără a repeta cod, cât mai clar de citit și de alții, cu comentarii, etc.

* '''La olimpiadă''': olimpiada este ca legitima apărare. Ca şi când sunteţi cu fratele mai mic după voi şi vă atacă golanii. În acel moment nu vă verifică nimeni cât de frumos aţi executat procedeul pentru a scăpa teferi. Tot ce contează este să învingeţi. Pentru aceasta vă veţi folosi de orice! Dacă găsiţi un bolovan, îl aruncaţi în adversar. O chiuvetă spartă, bună şi aceea! La fel şi la olimpiadă, tot ce contează sunt punctele. Nu cât de frumoasă este metoda folosită, nici cât de frumos aţi scris codul. Dacă puteţi lua puncte afişând mereu "0", o faceţi. Această practică nu ar fi acceptată nici la cercul nostru şi nici în viaţa reală. Din păcate, însă, la olimpiadă nu se punctează stilul şi perfecţionismul, ci numai punctele.

'''Atenţie însă!''' Olimpiada este o excepţie, nu o regulă! Aşa cum în viaţa reală nu puteţi să smulgeţi chiuveta din perete pentru a o arunca în colegul de clasă, nici la cerc, la companii, sau unde se va întâmpla să rezolvaţi probleme de informatică, nu puteţi trişa, sau scrie cod ineficient.

Clasa a 7-a

2025-06-08T19:48:51Z

Mihai:

* [[Clasa a 7-a Lecția 1: Reguli de programare în limbajul C și complexități algoritmice]]
* [[Clasa a 7-a Lecția 2: Problema selecției și stive]]
* [[Clasa a 7-a Lecția 3: Liste (1)]]
* [[Clasa a 7-a Lecția 4: Liste (2)]]
* [[Clasa a 7-a Lecția 5: Precalculare]]
* [[Clasa a 7-a Lecția 6: Evaluare (1)]]
* [[Clasa a 7-a Lecția 7: Recursivitate (1)]]
* [[Clasa a 7-a Lecția 8: Recursivitate (2)]]
* [[Clasa a 7-a Lecția 9: Evaluare (2)]]
* [[Clasa a 7-a Lecția 10: Fill recursiv (flood fill)]]
* [[Clasa a 7-a Lecția 11: Numere mari, exponențiere rapidă, element majoritar]]
* [[Clasa a 7-a Lecția 12: Analiză amortizată (1)]]
* [[Clasa a 7-a Lecția 13: Analiză amortizată (2)]]
* [[Clasa a 7-a Lecția 14: Evaluare (3)]]
* [[Clasa a 7-a Lecția 15: Citire / scriere rapidă]]
* [[Clasa a 7-a Lecția 16: Tehnica Two Pointers (doi pointeri), tipul de date struct și metoda Greedy]]
* [[Clasa a 7-a Lecția 17: Evaluare (4)]]
* [[Clasa a 7-a Lecția 18: Divide et impera, mergesort, quicksort]]
* [[Clasa a 7-a Lecția 19: Cozi și algoritmul lui Lee]]
* [[Clasa a 7-a Lecția 20: Evaluare (5)]]
* [[Clasa a 7-a Lecția 21: Cozi duble și maximul în fereastră glisantă]]
* [[Clasa a 7-a Lecția 22: Generarea elementelor combinatoriale prin algoritmi de tip succesor: submulțimi, permutări, combinări, aranjamente, next permutation]]
* [[Clasa a 7-a Lecția 23: Evaluare (6)]]
* [[Clasa a 7-a Lecția 24: Programare dinamică (1)]]
* [[Clasa a 7-a Lecția 25: Programare dinamică (2)]]
* [[Clasa a 7-a Lecția 26: Programare dinamică (3)]]
* [[Clasa a 7-a Lecția 27: Algoritmul Union-Find]]
* [[Clasa a 7-a Lecția 28: Sfaturi pentru concursuri / olimpiadă]]
* [[Clasa a 7-a Lecția 29: Discutarea problemelor de la OJI 2024]]
* [[Clasa a 7-a Lecția 30: Discutarea problemelor de la ONI 2024]]

Clasa a 7-a Lecția 23: Evaluare (6)

2025-06-08T16:24:31Z

Mihai:

Testați-vă cunoștințele și rezolvați următoarele probleme în decurs a trei ore (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://nerdarena.ro/problema/coada Coada]
* [https://nerdarena.ro/problema/plop Plop]
* [https://nerdarena.ro/problema/nraprime1 NrAPrime1]

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_23:_Evaluare_(6) Accesează rezolvarea problemelor de la lecția 23]

Clasa a 7-a

2025-06-08T14:57:09Z

Mihai:

* [[Clasa a 7-a Lecția 1: Reguli de programare în limbajul C și complexități algoritmice]]
* [[Clasa a 7-a Lecția 2: Problema selecției și stive]]
* [[Clasa a 7-a Lecția 3: Liste (1)]]
* [[Clasa a 7-a Lecția 4: Liste (2)]]
* [[Clasa a 7-a Lecția 5: Precalculare]]
* [[Clasa a 7-a Lecția 6: Evaluare (1)]]
* [[Clasa a 7-a Lecția 7: Recursivitate (1)]]
* [[Clasa a 7-a Lecția 8: Recursivitate (2)]]
* [[Clasa a 7-a Lecția 9: Evaluare (2)]]
* [[Clasa a 7-a Lecția 10: Fill recursiv (flood fill)]]
* [[Clasa a 7-a Lecția 11: Numere mari, exponențiere rapidă, element majoritar]]
* [[Clasa a 7-a Lecția 12: Analiză amortizată (1)]]
* [[Clasa a 7-a Lecția 13: Analiză amortizată (2)]]
* [[Clasa a 7-a Lecția 14: Evaluare (3)]]
* [[Clasa a 7-a Lecția 15: Citire / scriere rapidă]]
* [[Clasa a 7-a Lecția 16: Tehnica Two Pointers (doi pointeri), tipul de date struct și metoda Greedy]]
* [[Clasa a 7-a Lecția 17: Evaluare (4)]]
* [[Clasa a 7-a Lecția 18: Divide et impera, mergesort, quicksort]]
* [[Clasa a 7-a Lecția 19: Cozi și algoritmul lui Lee]]
* [[Clasa a 7-a Lecția 20: Evaluare (5)]]
* [[Clasa a 7-a Lecția 21: Cozi duble și maximul în fereastră glisantă]]
* [[Clasa a 7-a Lecția 22: Generarea elementelor combinatoriale prin algoritmi de tip succesor: submulțimi, permutări, combinări, aranjamente, next permutation]]
* [[Clasa a 7-a Lecția 23: Evaluare (6)]]
* [[Clasa a 7-a Lecția 24: Programare dinamică (1)]]
* [[Clasa a 7-a Lecția 25: Programare dinamică (2)]]
* [[Clasa a 7-a Lecția 26: Programare dinamică (3)]]
* [[Clasa a 7-a Lecția 27: Algoritmul Union-Find]]
* [[Clasa a 7-a Lecția 28: Discutarea problemelor de la OJI 2024]]
* [[Clasa a 7-a Lecția 29: Discutarea problemelor de la ONI 2024]]

Clasa a 7-a Lecția 22: Generarea elementelor combinatoriale prin algoritmi de tip succesor: submulțimi, permutări, combinări, aranjamente, next permutation

2025-06-08T14:56:59Z

Mihai: Mihai moved page Clasa a 7-a Lecția 22: Generarea elementelor combinatoriale prin algoritmi de tip succesor: submulțimi,permutări, combinări, aranjamente, next permutation to Clasa a 7-a Lecția 22: Generarea elementelor combinatoriale prin algoritmi de tip succesor: submulțimi, permutări, combinări, aranjamente, next permutation without leaving a redirect

== Înregistrare video lecție ==

<youtube height="720" width="1280">https://youtu.be/CVOXXa6i8fs</youtube>

== Permutări ==

Permutările de <source lang="C" enclose="none">N</source> elemente sunt definite ca numărul de moduri de a aranja în șir cele <source lang="C" enclose="none">N</source> elemente. Cred că formula numărului de permutări distincte este destul de ușor de demonstrat, v-o las ca exercițiu:

P(N) = N!

=== Permutările ca funcții de rearanjare ===

O permutare poate fi văzută ca o funcție de rearanjare a valorilor inițiale. Astfel, dacă permutarea noastră este

2 5 4 3 1

aceasta înseamnă că la o aplicare a permutării pe prima poziție vom avea al doilea element din șirul nepermutat, pe a doua poziție vom avea al cincilea element din șirul original și așa mai departe.

Deci, a aplica o permutare unor obiecte înseamnă a le schimba ordinea conform permutării. Fiecare număr din permutare semnifică poziţia care se va afla în final pe acea poziţie. De exemplu, dacă permutarea este <tt>(2 5 4 3 1)</tt> și o aplicăm obiectelor <tt>(1 2 3 4 5)</tt>, după prima aplicare obținem chiar permutarea, <tt>(2 5 4 3 1)</tt>, deoarece pe poziţia 1 va veni numărul de pe poziţia 2, pe pozitia 2 va veni numărul de pe poziţia 5 şi aşa mai departe. După a doua aplicare obținem <tt>(5 1 3 4 2)</tt>, după a treia <tt>(1 2 4 3 5)</tt> și așa mai departe:

<pre>
1 2 3 4 5
2 5 4 3 1
5 1 3 4 2
1 2 4 3 5
...
</pre>

Cum stocăm o permutare? Dacă dorim să o aplicăm unui vector, o putem stoca într-un alt vector, cu mențiunea că, deoarece vectorii încep de la zero, pentru ușurința codului este preferabil să stocăm numerele din permutare minus unu.

=== Cicluri ale permutărilor ===

Ne putem pune, în mod natural, o întrebare: dacă pornim cu permutarea identică și aplicăm permutarea noastră în mod repetat, vom ajunge din nou la permutarea identică?

Pentru a răspunde la această întrebare să studiem structura permutărilor. Dacă urmărim felul în care valorile își schimbă locurile vom observa că orice permutare conține cicluri, adică submulțimi ale mulțimii de valori care își schimbă circular valorile între ele. Ciclurile sunt disjuncte.

Exemplu: fie permutarea de mai sus <tt>(2 5 4 3 1)</tt>. Pornim cu poziția 1, unde <source lang="C" enclose="none">p[1]</source> este 2. Avansăm pe poziția 2, unde <source lang="C" enclose="none">p[2]</source> este 5. Avansăm pe poziția 5, unde <source lang="C" enclose="none">p[5] = 1</source>, revenind astfel pe poziția 1. Am detectat astfel primul ciclu al permutării, format din <tt>(2, 5, 1)</tt>. Continuăm cu primul element care nu face parte din ciclul găsit, care se află pe poziția 3. <source lang="C" enclose="none">p[3]</source> este 4, avansăm pe poziția 4. <source lang="C" enclose="none">p[4]</source> este 3, care încheie ciclul. Astfel, permutarea noastră se descompune în două cicluri disjuncte, <tt>(2, 5, 1)</tt> și <tt>(4, 3)</tt>. Cum putem folosi această proprietate? Iată două exemple:

==== Exemplul 1 ====

Să se spună dacă un vector de n elemente conține toate numerele de la 1 la <source lang="C" enclose="none">n</source>. Memoria suplimentară disponibilă este ''O(1)''. Avem voie să modificăm vectorul original.

O soluție bazată pe ciclurile permutărilor este să parcurgem aceste cicluri și să facem elementele 0 pe măsură ce le parcurgem. Dacă vectorul conține o permutare a numerelor <source lang="C" enclose="none">1-n</source> atunci fiecare ciclu trebuie să se încheie acolo unde a început. Dacă parcurgând ciclurile vectorului ajungem pe o poziție marcată cu 0 dar diferită de începutul ciclului înseamnă că nu avem o permutare. Ciclurile le parcurgem astfel: pornim cu primul element și parcurgem elementele până ne întoarcem. Apoi căutăm primul element diferit de 0 și reluăm. Ne oprim fie când găsim un ciclu incorect (caz în care nu avem o permutare), fie când ieșim din vector (caz în care permutarea este corectă).

==== Exemplul 2 ====

Dată o permutare, după câte aplicări obținem din nou permutarea inițială?

Observăm că la fiecare aplicare a permutării ciclurile se rotesc cu 1. Fiecare ciclu <source lang="C" enclose="none">i</source> va reveni la poziția inițială după un număr <code>li</code>, care este lungimea ciclului. De aceea va fi nevoie de <code>cmmmc(li)</code> pentru ca toate ciclurile să ajungă în poziția inițială.

=== Numerotarea permutărilor (ranking / unranking) ===

Să considerăm permutările a <source lang="C" enclose="none">n</source> elemente, în ordine lexicografică. Ele capătă astfel un număr de ordine, prima permutare fiind numărul zero. Ne propunem să facem conversii între numărul de ordine și permutarea asociată.

==== Baza factorial ====

Să luăm ca exemplu baza trei. La adunarea cu unu, o cifră pe poziția <source lang="C" enclose="none">k</source> se va mări cu unu atunci când cifra de pe poziția <source lang="C" enclose="none">k-1</source> trece din 2 în 0. Astfel:

101222 + 1 =
102000

Câte numere putem reprezenta în baza trei pe șase cifre? Deoarece fiecare cifră poate avea trei valori vom avea 36 numere posibile.

Aici ne vine ideea: noi ne-am dori ca pe 6 cifre să avem <tt>6!</tt> numere reprezentabile. E destul de clar că dacă pentru cifra cea mai din dreapta avem o valoare posibilă, pentru următoarea cifră două valori, pentru următoarea trei, și așa mai departe, numărul de posibilități va fi <tt>6·5·4·3·2·1</tt>, adică <tt>6!</tt>.

Deci, la fel cum reprezentăm numerele în baza trei, zece, sau doi, putem reprezenta numerele într-o bază variabilă, ce crește dinspre dreapta spre stânga. Vom denumi aceasta reprezentarea în baza factorial. Astfel, fiecare cifră este într-o bază diferită! Cifra <source lang="C" enclose="none">k</source> (dinspre dreapta spre stânga) se va reprezenta în baza <source lang="C" enclose="none">k!</source>.

Iată un exemplu, pe patru cifre, echivalent permutărilor de 4 elemente:

baza: 4321
0: 0000
1: 0010
2: 0100
3: 0110
4: 0200
5: 0210
6: 1000
7: 1010
8: 1100
9: 1110
10: 1200
11: 1210
12: 2000
13: 2010
14: 2100
15: 2110
16: 2200
17: 2210
18: 3000
19: 3010
20: 3100
21: 3110
22: 3200
23: 3210

''' Observații: '''

* Baza crește de la dreapta către stânga.
* Valorile cifrelor sunt între zero și baza minus unu.
* Ultima cifră este mereu zero, nu este o greșeală!
* Numărul de numere reprezentabile pe <source lang="C" enclose="none">n</source> cifre este <source lang="C" enclose="none">n!</source>.
* Numărul de permutări de <source lang="C" enclose="none">n</source> elemente este <source lang="C" enclose="none">n!</source>.
* Sperăm, deci, să putem stabili o corespondență unu la unu între aceste numere și mulțimea permutărilor (ea se cheamă bijecție în limbaj matematic).

Pare un pic complicat, dar nu este. Programele de conversie sunt aceleași ca și în baza zece, dar baza va varia de la 1 la <source lang="C" enclose="none">n</source>. Iată un exemplu de program care generează toate codurile în baza factorial pe <source lang="C" enclose="none">n</source> cifre și le și recompune, pentru exemplificare, la codul în baza zece:

<syntaxhighlight lang="c" line>
// Program demonstrativ al bazei factorial
#include <stdio.h>

char nr[11];

int main() {
int b, n, k, kc, u;

scanf( "%d", &n ); // n cifre in baza factorial
u = 1;
// calculam ultimul numar de ordine (strict mai mare)
for ( b = 2; b <= n; b++ )
u *= b;

k = kc = 0;
while ( k 0; b-- )
fputc( '0' + nr[b - 1], stdout );

// recompunem numarul de ordine k din nr[]
kc = 0;
for ( b = n; b > 0; b-- )
kc = kc * b + nr[b - 1];

printf( " %4d\n", kc );

k++;
}
return 0;
}
</syntaxhighlight>

Ce complexitate au aceste conversii?

Se observă ușor că ele sunt ''O(n)'', câtă vreme <source lang="C" enclose="none">n!</source> nu depășește un întreg.

==== Conversie număr de ordine ➔ permutare (unranking) ====

'''Problemă:''' se dă <source lang="C" enclose="none">k</source> cuprins între 0 și <source lang="C" enclose="none">n! - 1</source>, să se afișeze a <code>ka</code> permutare de <source lang="C" enclose="none">n</source> în ordine lexicografică.

'''Soluție:''' vom calcula numărul <source lang="C" enclose="none">k</source> în baza factorial cu <source lang="C" enclose="none">n</source> cifre. Apoi, pe baza acestor cifre, vom calcula permutarea.

'''Exemplu'''

Să presupunem că ne dorim permutarea de patru elemente cu numărul de ordin 11. Calculând <source lang="C" enclose="none">k</source> obținem <tt>1210</tt>. Pentru a obține permutarea vom selecta numerele de la 1 la 4, astfel:

1210, vom selecta poziția 1 din cele patru cifre, adică numărul 2
1210, vom selecta poziția 2 din cifrele rămase { 1, 3, 4 }, adică 4
1210, vom selecta poziția 1 din cifrele rămase { 1, 3 }, adică 3
1210, vom selecta poziția 0 din cifrele rămase { 1 }, adică 1

Rezultă permutarea <tt>2 4 3 1</tt>.

'''Implementare:''' cea mai simplă implementare este cea în care păstrăm un vector de frecvență al elementelor folosite în permutare, să-i spunem <source lang="C" enclose="none">folosit[]</source>, similar cu prima metodă de generare a permutărilor, cea mai simplă. Pentru fiecare cifră cf din numărul în baza factorial vom căuta al <source lang="C" enclose="none">cf</source>-lea 0 în vectorul de frecvență (al <source lang="C" enclose="none">cf</source>-lea număr nefolosit).

Ce complexitate are această implementare?

Pentru fiecare cifră putem parcurge maxim <source lang="C" enclose="none">n</source> elemente în vectorul de frecvență. Avem <source lang="C" enclose="none">n</source> cifre, deci complexitatea este ''O(n2)'' ca timp și ''O(n)'' ca memorie.

Iată un exemplu de generare a permutărilor pe baza numărului lor de ordine:

<syntaxhighlight lang="c" line>
// Program demonstrativ: generare permutari pe baza numarului lor de ordine
#include <stdio.h>

char nr[10], folosit[10];

int main() {
int b, n, k, kc, u, i;

scanf( "%d", &n ); // n cifre in baza factorial
u = 1;
// calculam ultimul numar de ordine (strict mai mare)
for ( b = 2; b <= n; b++ )
u *= b;

k = kc = 0;
while ( k 0; b-- )
fputc( '0' + nr[b - 1], stdout );

// resetam vectorul de elemente folosite
for ( b = n - 1; b >= 0; b-- )
folosit[b] = 0;

// afisam permutarea
fputc( ' ', stdout );
for ( b = n - 1; b >= 0; b-- ) { // parcurgem cifrele nr. in baza factorial
i = -1;
while ( nr[b]-- >= 0 ) // sarim peste nr[b]+1 elemente nefolosite
do
i++;
while ( folosit[i] );
folosit[i] = 1; // marcam elementul ca folosit
fputc( '1' + i, stdout ); // si il afisam
}
fputc( '\n', stdout );

k++;
}
return 0;
}
</syntaxhighlight>

Iată ce afișează programul de mai sus pentru <source lang="C" enclose="none">n = 4</source>:

0: 0000 1234
1: 0010 1243
2: 0100 1324
3: 0110 1342
4: 0200 1423
5: 0210 1432
6: 1000 2134
7: 1010 2143
8: 1100 2314
9: 1110 2341
10: 1200 2413
11: 1210 2431
12: 2000 3124
13: 2010 3142
14: 2100 3214
15: 2110 3241
16: 2200 3412
17: 2210 3421
18: 3000 4123
19: 3010 4132
20: 3100 4213
21: 3110 4231
22: 3200 4312
23: 3210 4321

==== Conversie permutare ➔ număr de ordine (ranking) ====

'''Problemă:''' se dă o permutare de <source lang="C" enclose="none">n</source>. Să se afișeze numărul ei de ordine (în ordine lexicografică), <source lang="C" enclose="none">k</source>, cuprins între 0 și <source lang="C" enclose="none">n! - 1</source>.

'''Soluție:''' vom calcula numărul <source lang="C" enclose="none">k</source> în baza factorial cu <source lang="C" enclose="none">n</source> cifre, pe baza elementelor din permutare.

'''Exemplu'''

Să presupunem că ne dorim să aflăm numărul de ordine al permutării de 4 elemente: <tt>2 4 3 1</tt>. Vom calcula cifrele numărului său de ordine în baza <tt>4!</tt>, astfel:

2 4 3 1, 2 este a doua cifră încă nefolosită, deci prima cifră va fi 1 (2-1)
2 4 3 1, 4 este a treia cifră încă nefolosită din cifrele rămase { 1, 3, 4 }, deci a doua cifră va fi 2 (3-1)
2 4 3 1, 3 este a doua cifră încă nefolosită din cifrele rămase { 1, 3 }, deci a treia cifră va fi 1 (2-1)
2 4 3 1, 1 este prima cifră încă nefolosită din cifrele rămase { 1 }, deci a treia cifră va fi 0 (1-1)

Rezultă numărul în baza factorial: <tt>1210</tt>, pe care când îl convertim la baza zece avem <source lang="C" enclose="none">k = 11</source>.

La implementare nu vom avea nevoie să memorăm cifrele în baza <source lang="C" enclose="none">n!</source>. Pe măsură ce le calculăm vom calcula direct <source lang="C" enclose="none">k</source>, numărul de ordine dorit.

Ce complexitate are această implementare?

Pentru fiecare cifră putem parcurge maxim <source lang="C" enclose="none">n</source> elemente în vectorul de frecvență. Avem <source lang="C" enclose="none">n</source> cifre, deci complexitatea este ''O(n2)'' ca timp și ''O(n)'' ca memorie.

Iată un exemplu de generare a permutărilor pe baza numărului lor de ordine:

<syntaxhighlight lang="c" line>
// Program demonstrativ: calcul numar de ordine pe baza unei permutari
#include <stdio.h>

char nr[10], folosit[10], perm[10];

int main() {
int b, n, k, kc, u, i, cf;

scanf( "%d", &n ); // n cifre in baza factorial
u = 1;
// calculam ultimul numar de ordine (strict mai mare)
for ( b = 2; b <= n; b++ )
u *= b;

k = kc = 0;
while ( k 0; b-- )
fputc( '0' + nr[b - 1], stdout );

// resetam vectorul de elemente folosite
for ( b = n - 1; b >= 0; b-- )
folosit[b] = 0;

// generam permutarea
fputc( ' ', stdout );
for ( b = n - 1; b >= 0; b-- ) { // parcurgem cifrele nr. in baza factorial
i = -1;
while ( nr[b]-- >= 0 ) // sarim peste nr[b]+1 elemente nefolosite
do
i++;
while ( folosit[i] );
folosit[i] = 1; // marcam elementul ca folosit
fputc( '1' + i, stdout ); // si il afisam
perm[b] = i; // stocam elementul in permutare
}

// resetam vectorul de elemente folosite
for ( b = n - 1; b >= 0; b-- )
folosit[b] = 0;

// calculam numarul de ordine al permutarii curente
kc = 0;
for ( b = n - 1; b >= 0; b-- ) { // parcurgem elementele permutarii
cf = 0;
for ( i = perm[b] - 1; i >= 0; i-- ) // pornim in 'folosit[]' in jos
cf += (1 - folosit[i]); // cautam cifre nefolosite
folosit[perm[b]] = 1; // marcam elementul ca folosit
kc = kc * (b + 1) + cf; // adaugam cifra curenta la numarul de ordine
}

printf( " %4d\n", kc ); // afisam numarul de ordine

k++;
}
return 0;
}
</syntaxhighlight>

Iată ce afișează programul de mai sus pentru <source lang="C" enclose="none">n = 4</source>:

0: 0000 1234 0
1: 0010 1243 1
2: 0100 1324 2
3: 0110 1342 3
4: 0200 1423 4
5: 0210 1432 5
6: 1000 2134 6
7: 1010 2143 7
8: 1100 2314 8
9: 1110 2341 9
10: 1200 2413 10
11: 1210 2431 11
12: 2000 3124 12
13: 2010 3142 13
14: 2100 3214 14
15: 2110 3241 15
16: 2200 3412 16
17: 2210 3421 17
18: 3000 4123 18
19: 3010 4132 19
20: 3100 4213 20
21: 3110 4231 21
22: 3200 4312 22
23: 3210 4321 23

==== Optimizarea conversiilor ====

Se pot face cele două conversii mai eficient? Răspunsul [https://en.wikipedia.org/wiki/Permutation#Algorithms_to_generate_permutations wikipedia] este că da, ele se pot efectua în ''O(n log n)'', dar în practică algoritmii nu sunt folosiți deoarece:

* <source lang="C" enclose="none">n</source> este de obicei prea mic pentru ca diferența între ''O(n2)'' și ''O(n log n)'' să conteze.
* De cele mai multe ori când avem nevoie de generări de permutări avem situații speciale în care avem algoritmi mai eficienți.

==== Revenire la problema Permutări1 ====

Problema [https://www.nerdarena.ro/problema/permutari1 Permutări1] a fost dată ca un exercițiu de generare eficientă a permutărilor prin algoritmul cu liste. Ea poate fi rezolvată și altfel: putem citi numerele de ordine ale permutărilor și apoi putem genera și afișa acele permutări.

Cum se compară acest algoritm cu cel original, ce generează toate permutările?

Algoritmul original are complexitate ''O(n!)'', deoarece generează toate permutările.

Algoritmul cel nou va genera <source lang="C" enclose="none">k</source> permutări. O generare execută ''O(n2)'' operații. Complexitatea totală va fi, deci, ''O(k·n2)''. Deoarece <source lang="C" enclose="none">k</source> este foarte mic (50 000) acest algoritm este mai rapid.

=== Permutări cu repetiție ===

Definiție: permutările cu repetiție sunt toate modurile distincte în care putem așeza <source lang="C" enclose="none">n</source> obiecte, atunci când anumite obiecte sunt identice. De exemplu, permutările șirului <tt>1 1 1 2 2</tt> sunt:

1 1 1 2 2
1 1 2 1 2
1 1 2 2 1
1 2 1 1 2
1 2 1 2 1
1 2 2 1 1
2 1 1 1 2
2 1 1 2 1
2 1 2 1 1
2 2 1 1 1

'''Numărul''' permutărilor cu repetiție este factorialul numărului de obiecte împărțit la factorialele numerelor de obiecte de același tip. De ce? Deoarece pentru fiecare permutare obișnuită, dacă avem t obiecte de același tip, vom avea <source lang="C" enclose="none">t!</source> permutări care ''arată la fel''.

Cum generăm permutări cu repetiție?

Am studiat doi algoritmi de generare de permutări. Ambii pot fi ușor adaptați să genereze permutări cu repetiție.

==== Algoritmul cu vector de frecvență ====

Modificarea pentru acest algoritm va fi aceea că un element în vectorul de frecvență va conține numărul de obiecte de acel tip. Atunci când așezăm un element în permutare îl scădem din vectorul de frecvență. La revenirea din recursivitate vom aduna unu la vectorul de frecvență, pentru a reveni la valoarea anterioară. Iată cele două implementări:

===== Permutări cu vector de frecvență =====

<syntaxhighlight lang="c" line>
// Generare permutari prin recursivitate (pseudo backtracking)
// Permutari in O(n) cu vector de frecventa
#include <stdio.h>

char folosit[10], sol[10];
FILE *fin, *fout;

void perm( int n, int poz ) {
int i;

if ( poz == n ) { // daca am umplut n pozitii
for ( i = 0; i < n; i++ ) // afiseaza combinarea curenta
fprintf( fout, "%d ", (int)sol[i] );
fprintf( fout, "\n" );
} else
for ( sol[poz] = 1; sol[poz] <= n; sol[poz]++ )
if ( !folosit[(int)sol[poz]] ) { // daca elementul curent nu e folosit
folosit[(int)sol[poz]] = 1; // marcheaza-l ca folosit
perm( n, poz + 1 ); // genereaza restul permutarii
folosit[(int)sol[poz]] = 0; // demarcheaza elementul
}
}

int main() {
int n;

fin = fopen( "perm.in", "r" );
fscanf( fin, "%d", &n );
fclose( fin );

fout = fopen( "perm.out", "w" );
perm( n, 0 ); // genereaza permutari de n, pornind in solutie de la poz 0
fclose( fout );

return 0;
}
</syntaxhighlight>

===== Permutări cu repetiție cu vector de frecvență =====

<syntaxhighlight lang="c" line>
// Generare permutari cu repetitie prin recursivitate (pseudo backtracking)
// Permutari in O(n) cu vector de frecventa
#include <stdio.h>

char nrel[15], sol[15];
FILE *fin, *fout;

void perm( int n, int poz ) {
int i;

if ( poz == n ) { // daca am umplut n pozitii
for ( i = 0; i < n; i++ ) // afiseaza combinarea curenta
fprintf( fout, "%d ", (int)sol[i] );
fprintf( fout, "\n" );
} else
for ( sol[poz] = 1; sol[poz] <= n; sol[poz]++ )
if ( nrel[(int)sol[poz]] ) { // daca mai avem elemente sol[poz]
nrel[(int)sol[poz]]--; // marcheaza-l ca folosit
perm( n, poz + 1 ); // genereaza restul permutarii
nrel[(int)sol[poz]]++; // adauga elementul la loc
}
}

int main() {
int n, i, e;

fin = fopen( "perm.in", "r" );
fscanf( fin, "%d", &n );
for ( i = 0; i < n; i++ ) {
fscanf( fin, "%d", &e );
nrel[e]++;
}
fclose( fin );

fout = fopen( "perm.out", "w" );
perm( n, 0 ); // genereaza permutari de n, pornind in solutie de la poz 0
fclose( fout );

return 0;
}
</syntaxhighlight>

==== Algoritmul cu listă ====

Modificarea acestui algoritm constă în faptul că un element al listei va conține o pereche (element, număr de apariții). Când parcurgem lista pentru a plasa elemente în permutare, vom scădea unu din numărul de apariții. Dacă numărul de apariții devine zero, vom scoate elementul din listă, readăugându-l la loc la revenirea din recursivitate. La revenirea din recursivitate vom aduna unu la numărul de apariții.

Cei doi algoritmi își păstrează complexitățile, în sensul în care cel cu vectori de frecvență generează permutări în ''O(n)'' per permutare amortizat, iar cel cu listă are nevoie de ''O(1)'' amortizat pentru generarea unei permutări. Iată cele două implementări:

===== Permutări cu listă =====

<syntaxhighlight lang="c" line>
// Generare permutari prin recursivitate (pseudo backtracking)
// Permutari in O(1) cu lista
#include <stdio.h>

#define NIL -1
#define MAXN 10

char next[MAXN + 1], // lista de numere 1..n
sol[MAXN]; // contine permutarea curenta
FILE *fin, *fout;

void perm( int n, int poz ) {
int i;

if ( poz == n ) {
for ( i = 0; i < n; i++ ) // afiseaza permutarea curenta
fprintf( fout, "%d ", (int)sol[i] );
fprintf( fout, "\n" );
} else {
i = 0; // pointer la elementul din-naintea elementului curent
while ( next[i] != NIL ) { // pentru fiecare element din lista
sol[poz] = next[i]; // il plasam in vectorul solutie
next[i] = next[(int)next[i]]; // il eliminam din lista
perm( n, poz + 1 ); // reapelam cu pozitia urmatoare
i = next[i] = sol[poz]; // refacem legatura si avansam i in lista
}
}
}

int main() {
int n, i;

fin = fopen( "perm.in", "r" );
fscanf( fin, "%d", &n );
fclose( fin );

// initializare lista numere
for ( i = 0; i < n; i++ )
next[i] = i + 1;
next[n] = NIL;

fout = fopen( "perm.out", "w" );
perm( n, 0 ); // genereaza permutari de n, pornind in solutie de la poz 0
fclose( fout );

return 0;
}
</syntaxhighlight>

===== Permutări cu repetiție cu listă =====

<syntaxhighlight lang="c" line>
// Generare permutari cu repetitie prin recursivitate (pseudo backtracking)
// Permutari in O(1) cu lista
#include <stdio.h>

#define NIL -1
#define MAXN 15

char nrel[MAXN + 1], next[MAXN + 1], // lista de numere 1..k
sol[MAXN]; // contine permutarea curenta
FILE *fin, *fout;

void perm( int n, int poz ) {
int i;

if ( poz == n ) {
for ( i = 0; i < n; i++ ) // afiseaza permutarea curenta
fprintf( fout, "%d ", (int)sol[i] );
fprintf( fout, "\n" );
} else {
i = 0; // pointer la elementul din-naintea elementului curent
while ( next[i] != NIL ) { // pentru fiecare element din lista
sol[poz] = next[i]; // il plasam in vectorul solutie
if ( --nrel[(int)next[i]] == 0 ) { // mai avem elemente tip next[i]?
next[i] = next[(int)next[i]]; // il eliminam din lista
perm( n, poz + 1 ); // reapelam cu pozitia urmatoare
next[i] = sol[poz]; // refacem legatura
} else
perm( n, poz + 1 ); // reapelam cu pozitia urmatoare fara sa eliminam

nrel[(int)next[i]]++; // adaugam la loc elementul
i = next[i]; // avansam i in lista de elemente
}
}
}

int main() {
int n, i, e;

fin = fopen( "perm.in", "r" );
fscanf( fin, "%d", &n );
for ( i = 0; i < n; i++ ) {
fscanf( fin, "%d", &e );
nrel[e]++;
}
fclose( fin );

// initializare lista numere
i = next[0] = 1;
while ( nrel[i] ) {
next[i] = i + 1;
i++;
}
next[i - 1] = NIL; // marcam finalul de lista

fout = fopen( "perm.out", "w" );
perm( n, 0 ); // genereaza permutari de n, pornind in solutie de la poz 0
fclose( fout );

return 0;
}
</syntaxhighlight>

=== Next permutation ===

'''Problemă:''' dată o permutare într-un șir, să se genereze următoarea permutare lexicografică.

'''Soluție:''' vom proceda ca la incrementarea unui număr mare. Vom schimba permutarea la coadă, minimal, pentru a o transforma în permutarea următoare. Vom exemplifica algoritmul pe baza [https://www.nayuki.io/page/next-lexicographical-permutation-algorithm next lexicographical permutation algorithm], folosind exemplul <tt>(0 1 2 4 3 3 0)</tt>. Pașii sunt următorii:

==== Găsirea sufixului descrescător maximal ====

Pornind de la coadă parcurgem permutarea către stânga câtă vreme elementele sunt mai mare sau egale. Ne oprim la primul element strict mai mic. În cazul nostru obținem <tt>(0 1 2 | 4 3 3 0)</tt>. În acest moment știm că sufixul este o permutare maximală, nu poate fi mărită decât aducând elemente dinspre stânga.

==== Mărirea elementului din stânga sufixului ====

Deoarece sufixul descrescător nu se mai poate mări, pentru a modifica minimal permutarea va trebui să mărim elementul imediat următor, în cazul nostru 2. Cu ce îl vom înlocui? Cu cel mai mic element strict mai mare ca el, ce se află la dreapta lui. În cazul nostru îl vom înlocui cu 3. Obținem deci prima parte a permutării:

(0 1 3 ... )

==== Rearanjarea sufixului ====

În partea din dreapta avem acum elementele din sufix, dintre care dispare un element, cel folosit în prefix, și se adaugă primul element din stânga. În cazul nostru au rămas elementele <tt>(4 3 0)</tt> și elementul 2. Cum formăm cea mai mică permutare lexicografică? Desigur ordonând crescător elementele rămase. În cazul nostru sufixul va deveni <tt>(0 2 3 4)</tt>. Va rezulta permutarea:

(0 1 3 0 2 3 4)

==== Optimizarea implementării ====

Putem scăpa de sortarea elementelor sufixului, la final, deoarece știm că sufixul este descrescător. Putem, deci, să inversăm elementele lui. Înainte de aceasta vom plasa elementul din stânga lui, cel ce a fost mărit. Unde îl plasăm? Astfel încât sufixul original să rămână descrescător (apoi crescător după inversare), deci la prima poziție dinspre dreapta spre stânga unde vom găsi un element strict mai mare.

==== Algoritmul final ====

<pre>
1. Caută la coadă sufixul descrescător maximal. El va începe la poziția k.
1. Dacă k este zero, toată permutarea este descrescătoare, deci ea este ultima, nu mai avem ce genera.
2. Caută primul element dinspre dreapta care este strict mai mare decît p[k-1].
1. El va fi la poziția i.
3. Interschimbă elementele p[k-1] și p[i].
4. Inversează vectorul p[k..n-1]
</pre>

Ce complexitate are acest algoritm?

Analiza este la fel ca la algoritmul de generare a permutărilor cu liste: la nivelul <source lang="C" enclose="none">k</source> (cu <source lang="C" enclose="none">k</source> numerotat crescător de la dreapta la stânga) se fac ''O(k)'' calcule. Va rezulta aceeași complexitate amortizată de ''O(1)'' per permutarea următoare. Surprinzător, nu?

== Combinări ==

Numim combinări de <math>N</math> luate câte <math>K</math> și notăm cu <math>C_N^K</math> submulțimile de <math>K</math> elemente dintr-o mulțime de <math>N</math> elemente.

=== Combinări - formulă ===

Cum le calculăm?

* Știm câte permutări de <math>N</math> elemente avem: <math>N!</math>.
* Primele <math>K</math> elemente ale acestor permutări vor constitui o combinare validă.
* Fiecare din prefixele de <math>K</math> elemente apare de <math>(N - K)!</math> ori, deoarece prefixul se schimbă doar după ce restul de <math>N - K</math> elemente au fost permutate în toate modurile posibile.
* Deci, numărul de prefixe distincte de <math>K</math> elemente este <math>\frac{N!}{(N-K)!}</math>.
* Prefixele au o ordine, spre deosebire de permutări. Vrem să luăm în considerare numai prefixele ordonate crescător.
* De câte ori apare un prefix ordonat crescător dar în altă permutare? De <math>K!</math> ori. Deci trebuie să împărțim numărul de prefixe la <math>K!</math>.
* Deci, formula numărului de combinări de <math>N</math> luate câte <math>K</math> este: <math>C_N^K = \frac{N!}{K! \cdot (N-K)!}</math>

=== Combinări - formule de recurență ===

Din formula combinărilor, înlocuind <math>N</math> cu <math>N-1</math> și <math>K</math> cu <math>K-1</math>, obținem ușor o primă recurență utilă în calculul rapid al unei singure permutări: <math>C_N^K =
\frac{N}{K} \cdot C_{N-1}^{K-1}</math>.

O altă formulă de recurență utilă se obține astfel:

# Avem două variante de a forma combinările de <math>N</math> luate câte <math>K</math>.
# Prima variantă este să folosim primul element, rămânând să luăm <math>K-1</math> elemente din celelalte <math>N-1</math>. Vom putea, deci, forma <math>C_{N-1}^{K-1}</math> combinări.
# A doua variantă este să nu folosim primul element, rămânând să luăm tot <math>K</math> elemente, dar din restul de <math>N-1</math> elemente rămase. Vom putea, deci, forma <math>C_{N-1}^{K}</math> combinări.
# Suma acestor două expresii este chiar numărul de combinări de <math>N</math> luate câte <math>K</math>: <math>C_N^K = C_{N-1}^{K-1} + C_{N-1}^K</math>

=== Combinări - triunghiul lui Pascal ===

Din ultima recurență obținem o formulă foarte simplă a fiecărei combinări de <math>N</math> luat câte <math>K</math>, de două combinări de <math>N-1</math>. Ele pot fi aranjate vizual într-un triunghi numit triunghiul lui Pascal:

0 1
1 1 1
2 1 2 1
3 1 3 3 1
4 1 4 6 4 1
5 1 5 10 10 5 1

Combinările de <math>N</math> luate câte zero înseamnă că nu vom lua nici un element. Există o singură astfel de submulțime, mulțimea vidă. De aceea combinările de <math>N</math> luate câte zero sunt 1.

Triunghiul lui Pascal este util atunci când avem multe calcule ce implică diverse combinări. El se poate precalcula în ''O(N2)'' și va fi memorat ca o matrice (nu-l vom centra, ca în figură 🙂 ).

Numerele din triunghiul lui Pascal se numesc și coeficienți binomiali deoarece linia <math>N</math> are ca numere coeficienții cu care se înmulțesc numerele din binomul <math>(a + b)^N</math> dacă desfacem parantezele. Pentru <math>N</math> egal doi sau trei știm formulele de calcul prescurtat, ce implică numerele de pe liniile 2 și 3:

<math>(a+b)^2 = a^2 + 2ab + b^2</math>

<math>(a+b)^3 = a^3 + 3a^2b + 3ab^2 + b^3</math>

Iată un mod lejer de a obține formula la orice putere 🙂.

Dacă înlocuim <math>a</math> și <math>b</math> cu 1 în aceste formule obținem o altă formulă:

<math>(1+1)^n = C_n^0 + C_n^1 +C_n^2 + ... + C_n^n = 2^n</math>

Suma combinărilor este <math>2^n</math>. Cu alte cuvinte suma numerelor de pe linia n din triunghiul lui Pascal este <math>2^n</math>.

Acest lucru îl știm, însă, de mai demult, de la submulțimi: știm că numărul submulțimilor unei mulțimi este <math>2^n</math>. Iar combinările luate în totalitate formează chiar toate submulțimile unei mulțimi.

=== Combinări cu repetiție ===

Combinările cu repetiție sunt similare cu cele obișnuite, doar că putem alege un obiect din mulțime de oricâte ori. De exemplu, combinările cu repetiție a patru obiecte luate câte trei sunt:

1 1 1
1 1 2
1 1 3
1 1 4
1 2 2
1 2 3
1 2 4
1 3 3
1 3 4
1 4 4
2 2 2
2 2 3
2 2 4
2 3 3
2 3 4
2 4 4
3 3 3
3 3 4
3 4 4
4 4 4

Cum deducem formula pentru combinările cu repetiție?

Să luăm cazul de mai sus. Avem de ales din elementele 1 2 3 și 4, în această ordine, putând lua un element de mai multe ori. Să ne imaginăm că dispunem de trei separatoare pe care la putem plasa oriunde între cele patru numere. Numărul după care plasez un separator este luat. Iată:

1 1 1 1 | | | 2 3 4
1 1 2 1 | | 2 | 3 4
1 1 3 1 | | 2 3 | 4
1 1 4 1 | | 2 3 4 |
1 2 2 1 | 2 | | 3 4
1 2 3 1 | 2 | 3 | 4
...

Dacă avem două separatoare unul după altul ele se referă la același număr.

Este, sper, clar, că în acest fel putem genera toate combinările cu repetiție de 4 luate câte trei. Care este egal cu numărul de moduri în care putem plasa separatoarele. Avem cu totul 6 poziții pe care putem plasa, deoarece poziția 1 nu este validă - nu este după un număr. În rest, orice plasare este bună, deci formula va fi <math>C_6^3</math>.

Pe cazul general avem formula combinărilor cu repetiție: <math>CR_n^k=C_{n+k-1}^k</math>.

Algoritmul de generare a combinărilor cu repetiție este aproape identic cu cel de generare a combinărilor fără repetiție. Diferența este că vom varia elementele începând cu elementul anterior, în loc de elementul anterior plus 1. Iată cele două implementări:

==== Combinări ====

<syntaxhighlight lang="c" line>
// Generare combinari folosind recursivitate (pseudo backtracking)
// O(1) per combinare
#include <stdio.h>

#define MAXN 15

char sol[MAXN + 1]; // santinela pe prima pozitie
FILE *fin, *fout;

void comb( int n, int k, int pos ) {
int i;

if ( pos > k ) {
for ( i = 1; i <= k; i++ )
fprintf( fout, "%d ", (int)sol[i] );
fprintf( fout, "\n" );
} else
for ( sol[pos] = sol[pos - 1] + 1; sol[pos] <= (n - (k - pos)); sol[pos]++ )
comb( n, k, pos + 1 );
}

int main() {
int n, k;

fin = fopen( "comb.in", "r" );
fscanf( fin, "%d%d", &n, &k );
fclose( fin );

sol[0] = 0; // inutil, vreau sa subliniez ca este important

fout = fopen( "comb.out", "w" );
comb( n, k, 1 );
fclose( fout );

return 0;
}
</syntaxhighlight>

==== Combinări cu repetiție ====

<syntaxhighlight lang="c" line>
// Generare combinari cu repetitie folosind recursivitate (pseudo backtracking)
// O(1) per combinare
#include <stdio.h>

#define MAXN 15

char sol[MAXN + 1]; // santinela pe prima pozitie
FILE *fin, *fout;

void comb( int n, int k, int pos ) {
int i;

if ( pos > k ) {
for ( i = 1; i <= k; i++ )
fprintf( fout, "%d ", (int)sol[i] );
fprintf( fout, "\n" );
} else
for ( sol[pos] = sol[pos - 1]; sol[pos] <= n; sol[pos]++ )
comb( n, k, pos + 1 );
}

int main() {
int n, k;

fin = fopen( "comb.in", "r" );
fscanf( fin, "%d%d", &n, &k );
fclose( fin );

sol[0] = 1; // pentru a seta primul element la 1

fout = fopen( "comb.out", "w" );
comb( n, k, 1 );
fclose( fout );

return 0;
}
</syntaxhighlight>

Algoritmul este ușor de analizat, el generând fiecare combinare în ''O(1)'' (excluzând afișarea).

=== Next combination ===

Sper deosebire de next permutation care există în C++ STL, ''next_combination'' nu există. Să-l scriem noi 🙂. Este vorba, desigur, despre generarea următoarei combinări în ordine lexicografică.

Dacă ne gândim puțin nu este prea greu: dată o combinare trebuie să generăm următoarea combinare. Să observăm:

* Dacă putem adăuga 1 la ultimul element (dacă nu este egal cu <source lang="C" enclose="none">n</source>), adăugăm și obținem următoarea combinare.
* În caz contrar, dacă putem adăuga 1 la penultimul element (dacă nu este egal cu <source lang="C" enclose="none">n-1</source>), adăugăm, apoi setăm ultimul element la valoarea acestui element plus unu.
* În caz contrar, dacă putem adăuga 1 la antepenultimul element (dacă nu este egal cu <source lang="C" enclose="none">n-2</source>), adăugăm, apoi setăm următoarele două elemente din 1 în 1.

Cred că observăm regula: vom parcurge combinarea curentă de la coadă spre cap până ce găsim un element ce poate fi mărit. Condiția ca un element pe poziția <source lang="C" enclose="none">i</source> să poată fi mărit este să putem adăuga după el <source lang="C" enclose="none">k-i</source> elemente. Pentru aceasta pe poziția <source lang="C" enclose="none">i</source> putem pune ca element maxim valoarea <source lang="C" enclose="none">n - (k - i) = n -k + i</source>. Pentru ca poziția la care ne vom opri să putem adăuga unu, trebuie ca valoarea ei sa fie strict mai mică.

Iată un program care generează combinările de n luate câte k folosind algoritmul next_combination.

<syntaxhighlight lang="c" line>
// Generare combinari folosind next_combination
// O(1) per combinare
#include <stdio.h>

#define MAXN 24

char sol[MAXN + 1]; // santinela pe prima pozitie

// primeste o combinare in sol si genereaza urmatoarea combinare
// returneaza 0 daca nu mai avem combinari sau 1 in caz de succes
int next_comb( int n, int k ) {
int i;

i = k;
while ( sol[i] == n - k + i )
i--;

if ( i > 0 ) { // daca nu am terminat combinarile
// i este pozitionat pe primul element ce poate fi marit
// toate elementele de dupa pozitia i vor fi din 1 in 1
sol[i]++;
for ( i++; i <= k; i++ )
sol[i] = sol[i - 1] + 1;
}

return i > 0;
}

int main() {
FILE *fin, *fout;
int n, k, i;

fin = fopen( "comb.in", "r" );
fscanf( fin, "%d%d", &n, &k );
fclose( fin );

for ( i = 1; i < k; i++ )
sol[i] = i;

sol[0] = 0; // inutil, vreau sa subliniez ca este important
sol[k] = k - 1; // pentru a genera prima combinare

fout = fopen( "comb.out", "w" );
while ( next_comb( n, k ) ) {
for ( i = 1; i <= k; i++ )
fprintf( fout, "%d ", sol[i] );
fprintf( fout, "\n" );
}
fclose( fout );

return 0;
}
</syntaxhighlight>

Putem demonstra că timpul de generare a următoarei combinări este ''O(1)'' amortizat (încercați să demonstrați).

== Aranjamente ==

Numim aranjamente de <math>n</math> luate câte <math>k</math> și notăm cu <math>A_N^K</math> modurile de a aranja într-un șir, în ordine, <math>k</math> elemente din cele <math>n</math>. Ele sunt, de fapt, permutări parțiale, doar de anumite obiecte din cele <math>n</math>.

=== Aranjamente - formulă ===

Cum le calculăm?

Avem mai multe moduri de a le calcula

=== Permutări de combinări ===

Generăm toate combinările posibile. Pe fiecare din ele o permutăm în toate modurile posibile. În acest fel obținem aranjamente distincte și le obținem pe toate. Rezultă o formulă cunoscută:

<math>A_N^K=C_N^K \cdot P_K</math>

=== Calcul similar cu cel al combinărilor ===

* Știm câte permutări de <math>N</math> elemente avem: <math>N!</math>.
* Primele <math>K</math> elemente ale acestor permutări vor constitui un aranjament valid.
* Fiecare din prefixele de <math>K</math> elemente apare de <math>(N - K)!</math> ori, deoarece prefixul se schimbă doar după ce restul de <math>N - K</math> elemente au fost permutate în toate modurile posibile.
* Deci, numărul de prefixe distincte de <math>K</math> elemente este <math>\frac{N!}{(N-K)!}</math>.
* Acesta va fi numărul de aranjamente cerut.

Din ambele metode rezultă aceeași formulă:
<math>A_N^K = \frac{N!}{(N-K)!}</math>

=== Proprietăți ale aranjamentelor ===

# În programare, dacă avem nevoie să calculăm aranjamente vom folosi formula <math>A_N^K=C_N^K \cdot P_K</math> . Putem precalcula combinările și permutările.
# Aranjamentele se comportă mai mult ca niște permutări decât ca niște combinări.
# Programul de generare prin funcție recursivă va semăna cu cel de permutări, nu cu cel de combinări.
# Putem aplica o procedură de ''next_arrangement''. Ea va fi o combinație între cea de la permutări cu cea de la combinări.
# Putem aplica procedura de ranking / unranking de la permutări, cu diferența că baza factorial nu pornește de la 1 ci de la <math>n-k</math>.

Puteți încerca să implementați generarea, next_arrangement și ranking/unranking, dacă vreți.

== Tema 22 ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/nnr NNr] dată la interviu de inginer software la Google Inc
* [https://www.nerdarena.ro/problema/permutari1 Permutari1] ca aplicație la unranking
* [https://www.nerdarena.ro/problema/sport Sport] dată la ONI 2011 clasa a 8a

== Tema opțională ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/taburet Taburet] dată la ONI 2011 baraj gimnaziu, ca aplicație a permutărilor descrise ca funcție (rotațiile taburetelor)
* [https://www.nerdarena.ro/problema/2numere 2 Numere] dată la ONI 2008 baraj gimnaziu, ca aplicație a ''next_permutation''
* [https://www.nerdarena.ro/problema/aranjamente Aranjamente] ca aplicație la generarea eficientă de aranjamente

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_22:_Generarea_elementelor_combinatoriale_prin_algoritmi_de_tip_succesor:_submul%C8%9Bimi,permut%C4%83ri,_combin%C4%83ri,_aranjamente,_next_permutation Accesează rezolvarea temei 22]

Clasa a 7-a Lecția 23: Evaluare (6)

2025-06-08T14:21:39Z

Mihai: Created page with "Testați-vă cunoștințele și rezolvați următoarele probleme în decurs a trei ore (program C trimis la [https://www.nerdarena.ro/ NerdArena]): * [https://nerdarena.ro/problema/coada Coada] * [https://nerdarena.ro/problema/plop Plop] * [https://nerdarena.ro/problema/nraprime1 NrPrime1] [http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_23:_Evaluare_(6) Accesează rezolvarea problemelor de la lecția 23]"

Testați-vă cunoștințele și rezolvați următoarele probleme în decurs a trei ore (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://nerdarena.ro/problema/coada Coada]
* [https://nerdarena.ro/problema/plop Plop]
* [https://nerdarena.ro/problema/nraprime1 NrPrime1]

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_23:_Evaluare_(6) Accesează rezolvarea problemelor de la lecția 23]

Clasa a 7-a Lecția 22: Generarea elementelor combinatoriale prin algoritmi de tip succesor: submulțimi, permutări, combinări, aranjamente, next permutation

2025-06-08T14:21:12Z

Mihai: /* Tema opțională */

Clasa a 7-a

2025-06-08T14:19:09Z

Mihai:

* [[Clasa a 7-a Lecția 1: Reguli de programare în limbajul C și complexități algoritmice]]
* [[Clasa a 7-a Lecția 2: Problema selecției și stive]]
* [[Clasa a 7-a Lecția 3: Liste (1)]]
* [[Clasa a 7-a Lecția 4: Liste (2)]]
* [[Clasa a 7-a Lecția 5: Precalculare]]
* [[Clasa a 7-a Lecția 6: Evaluare (1)]]
* [[Clasa a 7-a Lecția 7: Recursivitate (1)]]
* [[Clasa a 7-a Lecția 8: Recursivitate (2)]]
* [[Clasa a 7-a Lecția 9: Evaluare (2)]]
* [[Clasa a 7-a Lecția 10: Fill recursiv (flood fill)]]
* [[Clasa a 7-a Lecția 11: Numere mari, exponențiere rapidă, element majoritar]]
* [[Clasa a 7-a Lecția 12: Analiză amortizată (1)]]
* [[Clasa a 7-a Lecția 13: Analiză amortizată (2)]]
* [[Clasa a 7-a Lecția 14: Evaluare (3)]]
* [[Clasa a 7-a Lecția 15: Citire / scriere rapidă]]
* [[Clasa a 7-a Lecția 16: Tehnica Two Pointers (doi pointeri), tipul de date struct și metoda Greedy]]
* [[Clasa a 7-a Lecția 17: Evaluare (4)]]
* [[Clasa a 7-a Lecția 18: Divide et impera, mergesort, quicksort]]
* [[Clasa a 7-a Lecția 19: Cozi și algoritmul lui Lee]]
* [[Clasa a 7-a Lecția 20: Evaluare (5)]]
* [[Clasa a 7-a Lecția 21: Cozi duble și maximul în fereastră glisantă]]
* [[Clasa a 7-a Lecția 22: Generarea elementelor combinatoriale prin algoritmi de tip succesor: submulțimi,permutări, combinări, aranjamente, next permutation]]
* [[Clasa a 7-a Lecția 23: Evaluare (6)]]
* [[Clasa a 7-a Lecția 24: Programare dinamică (1)]]
* [[Clasa a 7-a Lecția 25: Programare dinamică (2)]]
* [[Clasa a 7-a Lecția 26: Programare dinamică (3)]]
* [[Clasa a 7-a Lecția 27: Algoritmul Union-Find]]
* [[Clasa a 7-a Lecția 28: Discutarea problemelor de la OJI 2024]]
* [[Clasa a 7-a Lecția 29: Discutarea problemelor de la ONI 2024]]

Clasa a 7-a Lecția 22: Generarea elementelor combinatoriale prin algoritmi de tip succesor: submulțimi, permutări, combinări, aranjamente, next permutation

2025-06-08T14:18:58Z

Mihai: Mihai moved page Clasa a 7-a Lecția 22: Generarea elementelor combinatoriale: submulțimi, permutări, combinări, aranjamente, next permutation to Clasa a 7-a Lecția 22: Generarea elementelor combinatoriale prin algoritmi de tip succesor: submulțimi,permutări, combinări, aranjamente, next permutation without leaving a redirect

Clasa a 7-a Lecția 22: Generarea elementelor combinatoriale prin algoritmi de tip succesor: submulțimi, permutări, combinări, aranjamente, next permutation

2025-06-08T14:17:29Z

Mihai: /* Tema opțională */

Clasa a 7-a Lecția 22: Generarea elementelor combinatoriale prin algoritmi de tip succesor: submulțimi, permutări, combinări, aranjamente, next permutation

2025-06-08T14:14:55Z

Mihai: Created page with "== Înregistrare video lecție == <youtube height="720" width="1280">https://youtu.be/CVOXXa6i8fs</youtube> == Permutări == Permutările de <source lang="C" enclose="none">N</source> elemente sunt definite ca numărul de moduri de a aranja în șir cele <source lang="C" enclose="none">N</source> elemente. Cred că formula numărului de permutări distincte este destul de ușor de demonstrat, v-o las ca exercițiu: P(N) = N! === Permutările ca funcții de reara..."

Clasa a 7-a

2025-06-08T10:48:17Z

Mihai:

* [[Clasa a 7-a Lecția 1: Reguli de programare în limbajul C și complexități algoritmice]]
* [[Clasa a 7-a Lecția 2: Problema selecției și stive]]
* [[Clasa a 7-a Lecția 3: Liste (1)]]
* [[Clasa a 7-a Lecția 4: Liste (2)]]
* [[Clasa a 7-a Lecția 5: Precalculare]]
* [[Clasa a 7-a Lecția 6: Evaluare (1)]]
* [[Clasa a 7-a Lecția 7: Recursivitate (1)]]
* [[Clasa a 7-a Lecția 8: Recursivitate (2)]]
* [[Clasa a 7-a Lecția 9: Evaluare (2)]]
* [[Clasa a 7-a Lecția 10: Fill recursiv (flood fill)]]
* [[Clasa a 7-a Lecția 11: Numere mari, exponențiere rapidă, element majoritar]]
* [[Clasa a 7-a Lecția 12: Analiză amortizată (1)]]
* [[Clasa a 7-a Lecția 13: Analiză amortizată (2)]]
* [[Clasa a 7-a Lecția 14: Evaluare (3)]]
* [[Clasa a 7-a Lecția 15: Citire / scriere rapidă]]
* [[Clasa a 7-a Lecția 16: Tehnica Two Pointers (doi pointeri), tipul de date struct și metoda Greedy]]
* [[Clasa a 7-a Lecția 17: Evaluare (4)]]
* [[Clasa a 7-a Lecția 18: Divide et impera, mergesort, quicksort]]
* [[Clasa a 7-a Lecția 19: Cozi și algoritmul lui Lee]]
* [[Clasa a 7-a Lecția 20: Evaluare (5)]]
* [[Clasa a 7-a Lecția 21: Cozi duble și maximul în fereastră glisantă]]
* [[Clasa a 7-a Lecția 22: Generarea elementelor combinatoriale: submulțimi, permutări, combinări, aranjamente, next permutation]]
* [[Clasa a 7-a Lecția 23: Evaluare (6)]]
* [[Clasa a 7-a Lecția 24: Programare dinamică (1)]]
* [[Clasa a 7-a Lecția 25: Programare dinamică (2)]]
* [[Clasa a 7-a Lecția 26: Programare dinamică (3)]]
* [[Clasa a 7-a Lecția 27: Algoritmul Union-Find]]
* [[Clasa a 7-a Lecția 28: Discutarea problemelor de la OJI 2024]]
* [[Clasa a 7-a Lecția 29: Discutarea problemelor de la ONI 2024]]

Clasa a 7-a

2025-06-08T10:41:44Z

Mihai:

* [[Clasa a 7-a Lecția 1: Reguli de programare în limbajul C și complexități algoritmice]]
* [[Clasa a 7-a Lecția 2: Problema selecției și stive]]
* [[Clasa a 7-a Lecția 3: Liste (1)]]
* [[Clasa a 7-a Lecția 4: Liste (2)]]
* [[Clasa a 7-a Lecția 5: Precalculare]]
* [[Clasa a 7-a Lecția 6: Evaluare (1)]]
* [[Clasa a 7-a Lecția 7: Recursivitate (1)]]
* [[Clasa a 7-a Lecția 8: Recursivitate (2)]]
* [[Clasa a 7-a Lecția 9: Evaluare (2)]]
* [[Clasa a 7-a Lecția 10: Fill recursiv (flood fill)]]
* [[Clasa a 7-a Lecția 11: Numere mari, exponențiere rapidă, element majoritar]]
* [[Clasa a 7-a Lecția 12: Analiză amortizată (1)]]
* [[Clasa a 7-a Lecția 13: Analiză amortizată (2)]]
* [[Clasa a 7-a Lecția 14: Evaluare (3)]]
* [[Clasa a 7-a Lecția 15: Citire / scriere rapidă]]
* [[Clasa a 7-a Lecția 16: Tehnica Two Pointers (doi pointeri), tipul de date struct și metoda Greedy]]
* [[Clasa a 7-a Lecția 17: Evaluare (4)]]
* [[Clasa a 7-a Lecția 18: Divide et impera, mergesort, quicksort]]
* [[Clasa a 7-a Lecția 19: Cozi și algoritmul lui Lee]]
* [[Clasa a 7-a Lecția 20: Evaluare (5)]]
* [[Clasa a 7-a Lecția 21: Cozi duble și maximul în fereastră glisantă]]
* [[Clasa a 7-a Lecția 22: Generarea elementelor combinatoriale prin algoritmi de tip succesor: submulțimi, permutări, combinări, aranjamente, next permutation]]
* [[Clasa a 7-a Lecția 23: Evaluare (6)]]
* [[Clasa a 7-a Lecția 24: Programare dinamică (1)]]
* [[Clasa a 7-a Lecția 25: Programare dinamică (2)]]
* [[Clasa a 7-a Lecția 26: Programare dinamică (3)]]
* [[Clasa a 7-a Lecția 27: Algoritmul Union-Find]]
* [[Clasa a 7-a Lecția 28: Discutarea problemelor de la OJI 2024]]
* [[Clasa a 7-a Lecția 29: Discutarea problemelor de la ONI 2024]]

Clasa a 7-a Lecția 21: Cozi duble și maximul în fereastră glisantă

2025-06-03T14:02:44Z

Mihai:

== Tipul deque (coadă dublă) ==

Coada dublă este o coadă la care putem adăuga și scoate din ambele capete. Poate fi considerată ca o coadă și o stivă într-o singură structură de date, cu diferența că în coada dublă putem adăuga la începutul cozii.

Cum implementăm o coadă dublă?

O putem implementa la fel ca pe o coadă, într-un vector circular și folosind doi indici, <source lang="C" enclose="none">primul</source> și <source lang="C" enclose="none">ultimul</source>.

* Adăugarea unui element la final de coadă dublă, precum și eliminarea unui element de la început de coadă dublă se face întocmai ca la o coadă obișnuită.
* Eliminarea unui element de la final se face astfel:

<syntaxhighlight lang="c" line>
int pop() {
ultim = (ultim - 1 + QMAX) % QMAX;
return coada[ultim];
}
</syntaxhighlight>

* Adăugarea unui element la început se face astfel:

<syntaxhighlight lang="c" line>
void pushFront( int e ) {
prim = (prim - 1 + QMAX) % QMAX;
coada[prim] = e;
}
</syntaxhighlight>

Vom vedea că operațiunile pe biți pot simplifica puțin modificarea indicilor <source lang="C" enclose="none">primul</source> și <source lang="C" enclose="none">ultim</source>.

''' Observație:''' toate operațiunile pe o coadă dublă se fac în timp constant, ''O(1)''.

== Maximum în fereastră glisantă (maximum over a sliding window) ==

* Enunț: dându-se un șir de n numere considerăm cele <source lang="C" enclose="none">n – k + 1</source> subsecvențe de <source lang="C" enclose="none">k</source> numere consecutive în șir (denumite și ''ferestre'' de lungime <source lang="C" enclose="none">k</source>). Putem vedea aceste ferestre ca pe o singură fereastră, deplasabilă, care ne dă acces la <source lang="C" enclose="none">k</source> elemente din vector odată. Se cere ca pentru fiecare fereastră să se găsească maximul.
* Algoritmul de rezolvare trivial (forță brută) recalculează maximul pentru fiecare din ferestre, având complexitate ''O(kn)''.
* Pentru a reduce complexitatea găsirii maximului procedăm astfel: luăm prima fereastră, de la 0 la <source lang="C" enclose="none">k-1</source>. Să spunem că maximul se află pe poziția <tt>p1</tt>. Pe măsură ce vom deplasa fereastra este imposibil ca elementele dinaintea maximului să fie vreodată maximul ferestrei, deoarece ele vor face parte împreună cu maximul din această fereastră. Să considerăm poziția celui mai mare element după maxim și la dreapta lui, în fereastră. Fie ea <tt>p2</tt>. Rezultă că nici un element pe pozițiile intermediare <tt>i, p1 2</tt>, nu poate fi vreodată maxim în fereastră, deoarece aceste elemente vor fi împreună cu <tt>p2</tt> în toate ferestrele care le conțin. Similar, considerând <tt>p3</tt> poziția următorului maxim, nici un element între <tt>p2</tt> și <tt>p3</tt> nu va putea fi maxim.

[[Image:maximum-fereastra-glisanta.gif|frame|none|În figură noul maxim va elimina din coadă maximele 2 și 3. Coada rămasă va conține maximul 1 și maximul nou]]

În urma acestor observații apare următorul algoritm:

* Memorăm toate maximele descrescătoare din prima fereastră, într-o coadă dublă. Primul element din coadă este maximul ferestrei.
* Când deplasăm fereastra trebuie să actualizăm structura de maxime din coadă. Pentru aceasta dăm atenție elementului care dispare din fereastră și celui care intră în fereastră.
* Dacă elementul care iese nu este maximul curent, nu avem nimic de făcut.
* Dacă este maximul curent vom scoate primul element din coada de maxime.
* Dacă elementul proaspăt adăugat în fereastră este mai mic decât ultimul maxim din coadă se adaugă la coadă. În caz contrar el va ''arunca'' ultimul element, iar și încercăm din nou adăugarea în coadă.
* Rezultă că noul element din fereastră ''aruncă'' toate elementele de la urma cozii strict mai mici ca el, iar apoi îl adăugăm normal la coadă.

''' Observații '''

* Atunci când eliminăm de la începutul cozii maximul care iese din fereastra glisantă '''coada dublă acționează ca o coadă'''.
* Atunci când eliminăm din coadă toate elementele de la final care sunt mai mici decât elementul ce intră în fereastra glisantă, '''coada dublă acționează ca o stivă'''.
* Atunci când adăugăm la final elementul care intră în fereastra glisantă '''coada dublă acționează atât ca o stivă cât și ca o coadă'''.

=== Exemplu de cod ===

Iată un exemplu de implementare. În programul următor:

* <source lang="C" enclose="none">n</source> este numărul de elemente citit la intrare.
* <source lang="C" enclose="none">k</source> este mărimea ferestrei glisante.
* <source lang="C" enclose="none">deq[]</source> este coada dublă ce memorează <source lang="C" enclose="none">k</source> elemente, dar va fi dimensionată la următoarea putere a lui 2.
* <source lang="C" enclose="none">rasp[]</source> este vectorul de răspunsuri, dar care este folosit și la stocarea elementelor de la intrare, pentru a ști ce iese din fereastră; <source lang="C" enclose="none">rasp[]</source> este maximul din fereastra ce începe la poziția <source lang="C" enclose="none">i</source>.

<syntaxhighlight lang="c" line>
fin = fopen( "mfg.in", "r" );
fscanf( fin, "%d%d", &n, &k );
for ( i = 0; i < n; i++ ) {
if ( i >= k ) {
if ( (max = deq[prim]) == rasp[i - k] ) // daca max iese din fereastra
prim = (prim + 1) % MAXK_P2; // elimina maximul din fereastra
// stocheaza raspunsul pentru fereastra [i-k..i-1]
// este ok sa suprascriem rasp[i - k], el nu va mai fi necesar
rasp[i - k] = max;
}

rasp[i] = h = readInt(); // stocam inaltimea curenta, e nevoie la iesire
while ( ultim != prim && deq[ultim - 1] < h ) // elimina din coada
ultim = (ultim - 1 + MAXK_P2) % MAXK_P2; // cata vreme h e mai mare
deq[ultim] = h; // depunem inaltimea curenta in coada
ultim = (ultim + 1) % MAXK_P2;
}
fclose( fin );
rasp[n - k] = deq[prim]; // stocam separat ultimul maxim - caz particular
</syntaxhighlight>

=== Complexitate ===

* La prima vedere pare că, la fiecare pas, putem elimina <source lang="C" enclose="none">k</source> elemente din coada dublă, deci complexitatea ar părea ''O(kn)''.
* Folosind analiza amortizată rezultă complexitatea reală ca fiind ''O(n)''. Fiecare element este adăugat în coadă o dată și este scos cel mult o dată.
* Memoria suplimentară folosită este mărimea maximă a cozii, adică ''O(k)''.

== Aplicație: numărul maxim ce se poate forma prin eliminarea a K cifre ==

'''Enunț:''' dat un număr de ''N'' cifre, dorim să eliminăm ''K'' cifre. Să se afișeze numărul maxim ce se poate forma astfel.

Cum rezolvăm această problemă și ce legătură are ea cu maximul în fereastră glisantă?

La prima vedere problema pare complicată. Numărul este foarte mare. Și atunci încercăm să o simplificăm:

* Putem afla care este prima cifră a acestui număr?
* Știm că numărul va avea ''N-K'' cifre.
* Este clar că numărul va începe cu una din primele ''K+1'' cifre. De ce? Deoarece dacă el începe cu a ''K+2-a'' cifră, ar trebui să eliminăm ''K+1'' cifre de la începutul numărului, ceea ce nu putem.
* Vrem ca prima lui cifră să fie cât mai mare.
* Este, deci, logic, că prima cifră a numărului va fi maximul din primele ''K+1'' cifre. Să presupunem că cifra maximă este a cincea.
* Pentru ca a cincea cifră să devină prima trebuie să eliminăm primele patru cifre.
* Am rămas deci cu restul numărului, ce are ''N-5'' cifre (patru eliminate, una selectată), din care mai avem de eliminat ''K-4'' cifre.
* Putem deci relua metoda, cu un număr mai mic.

Ce facem dacă în primele ''K+1'' cifre avem mai multe maxime dintre care să alegem? Vom alege primul maxim, deoarece nu vrem să eliminăm cifre maximale.

Rezultă următorul algoritm:

=== Algoritmul 1 ===

<tt>
# Citește de la intrare primele K cifre.
# Câtă vreme mai avem cifre de eliminat (K > 0)
## Citește încă o cifră de la intrare.
## Calculează maximul dintre primele K+1 cifre. Fie cifra C pe poziția P.
## Afișează la ieșire cifra C.
## Elimină din cifrele memorate primele P-1 cifre.
## K = K - (P - 1)
# Citește cifrele rămase la intrare și afișează-le.
</tt>

''' Observații: '''

* Algoritmul selectează, pe rând, cifrele rămase, în loc să se concentreze pe cifrele eliminate.
* Algoritmul nu specifică cum găsim maximul cifrelor. O căutare liniară ar duce la un algoritm ineficient.

Cum găsim eficient maximul din primele ''K+1'' cifre? Folosind o coadă dublă. Vom avea o fereastră glisantă de lungime variabilă. Ea va avea la început lungimea ''K+1'', iar apoi va scădea pe măsură ce scade ''K''.

Rezultă algoritmul:

=== Algoritmul 2 ===

<tt>
# Depune primele K cifre de la intrare într-o coadă dublă, păstrând doar maxime consecutive descrescătoare, dar memorând și pozițiile lor.
# Câtă vreme mai avem cifre de eliminat (K > 0)
## Citește încă o cifră de la intrare și depune-o în coadă cu poziția sa, eliminând cifrele mai mici ca ea.
## Prima pereche din coadă va fi maximul C, cu poziția sa P.
## Afișează la ieșire cifra C.
## Elimină prima pereche din coadă.
## K = K - (P - 1)
# Citește cifrele rămase la intrare și afișează-le
</tt>

''' Observații: '''

* Algoritmul se poate aplica și pentru numărul minim, cu o singură diferență: nu putem alege ca primă cifră minimă o cifră zero. Următoarele cifre pot fi zero.
* În realitate, dacă urmărim acest algoritm cu atenție, coada va conține întotdeauna maximele celor ''K+1'' elemente din care dorim să găsim maximul. Explicație: cifrele eliminate sunt eliminate și din coadă. Singura cifră care dispare din coadă este cea afișată, pe care o compensăm la pasul 2.1 citind încă o cifră.

Astfel, algoritmul de mai sus se simplifică, nemaiavând nevoie să stocăm indici, ci doar valori. Să vedem.

=== Algoritmul 3 ===

<tt>
# Depune primele K cifre de la intrare într-o coadă dublă, păstrând doar maxime consecutive descrescătoare.
# Câtă vreme mai avem cifre de citit
## Citește încă o cifră de la intrare și depune-o în coadă, eliminând cifrele mai mici ca ea.
## Prima cifră din coadă va fi maximul C
## Afișează la ieșire cifra C.
## Elimină cifra C din coadă.
</tt>

== Tema 20 ==

Ambele probleme de la temă cer calculul numărului minim/maxim obținut după eliminarea unor cifre. Genul acesta de prelucrare, eliminarea unor cifre ale unui număr astfel încât numărul rămas să fie maxim (sau minim) apare des la olimpiade.

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/mfg Maxim în fereastră glisantă]
* [https://www.nerdarena.ro/problema/cuburi Cuburi] dată la ONI 2012 clasa a 8-a. Ea cere eliminarea unui număr mic de cifre, totdeauna 3, ceea ce înseamnă că nu suntem obligați să implementăm o coadă dublă pentru a o rezolva, putem calcula minimul prin forță brută.
* [https://www.nerdarena.ro/problema/maxim Maxim] dată la ONI 2007 clasa a 5-a. Este o problemă de clasa a 5-a la origine, adaptată pentru clasa a 7-a. Rezolvați-o folosind algoritmul din lecție.

'''Observații: '''

'''Atenție:''' rezolvarea voastră la problema maxim trebuie să folosească o coadă dublă și algoritmul de mai sus. Scopul este să învățăm să implementăm coada dublă.

Notă: cei cărora le plac provocările, încercați să rezolvați problema maxim cu memorie ''O(Σ)'', unde '''Σ''' este numărul de cifre, adică 10. Pentru aceasta trebuie să modificați implementarea cozii duble.

== Tema opțională ==

Să se rezolve următoarele probleme (program C trimis la [https://www.nerdarena.ro/ NerdArena]):

* [https://www.nerdarena.ro/problema/jbird JBird]
* [https://www.nerdarena.ro/problema/Valutar Valutar] dată la OJI 2019 clasa a 7-a

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_21:_Cozi_duble_%C8%99i_maximul_%C3%AEn_fereastr%C4%83_glisant%C4%83&action=edit&redlink=1 Accesează rezolvarea temei 21]