Algopedia - User contributions [en]

Main Page

2026-02-17T09:33:01Z

Cristian:

__NOTOC__
''No ''<code>break</code>'', no ''<code>continue</code>'', no ''<code>int v[1005]</code>'', no nonsense''
= Algopedia =

== [[Cercul de informatică gimnaziu]] ==
[[Cercul de informatică gimnaziu]] este o colecție de lecții de algoritmi și programare pentru clasele V-VIII. Lecțiile acoperă programa de olimpiadă, dar nu se opresc aici, scopul final fiind de a forma minți algoritmice și a crea informaticieni cu cunoștințe de bază complete. În acest sens evităm "dopajul" (predarea în avans a unor cunoștințe, fără a preda prerechizitele necesare, în scopul obținerii unor rezultate mai bune la olimpiadă). Lecțiile sînt împărțite astfel încît să acopere anul școlar în ritmul de o lecție pe săptămînă, circa 40-44 de lecții la fiecare clasă. Fiecare lecție durează două ore. Unele lecții sînt concursuri cu participare de acasă, ele dublînd lecția din acea săptămînă.

== [[Cercul de informatică IQ Academy]] ==
[[Cercul de informatică IQ Academy]] este un curs oferit de [http://iqacademy.ro/ IQ Academy], o inițiativă a [http://francu.org/ Fundației Frâncu pentru progres și educație] ce își propune formarea unor minți algoritmice, cu putere de abstractizare, cu “gândire computațională”, termen apărut relativ recent și susținut de oameni precum Mark Zuckerberg, creatorul Facebook.
 
 

== Cercul de informatică, colegiul Tudor Vianu, 2012-2020 ==
Găsiți aici detalii despre [[Cercul de informatică - Colegiul Național de Informatică Tudor Vianu]] desfășurat în perioada 2012-2020.
 
 

== Data Structures and Algorithms ==
A future translation to English. Work in progress.
* [[Introduction to Algorithms]]
* [[Introductory Exercises]]
* [[Problems Involving Sequences]]
* [[Problems Involving Arrays]]
 

== Contact ==
Puteți contacta creatorul acestui site, Cristian Frâncu, la [mailto:cristian@francu.com cristian@francu.com]

Main Page

2026-02-17T09:32:38Z

Cristian:

__NOTOC__
= Algopedia =
''No ''<code>break</code>'', no ''<code>continue</code>'', no ''<code>int v[1005]</code>'', no nonsense''

== [[Cercul de informatică gimnaziu]] ==
[[Cercul de informatică gimnaziu]] este o colecție de lecții de algoritmi și programare pentru clasele V-VIII. Lecțiile acoperă programa de olimpiadă, dar nu se opresc aici, scopul final fiind de a forma minți algoritmice și a crea informaticieni cu cunoștințe de bază complete. În acest sens evităm "dopajul" (predarea în avans a unor cunoștințe, fără a preda prerechizitele necesare, în scopul obținerii unor rezultate mai bune la olimpiadă). Lecțiile sînt împărțite astfel încît să acopere anul școlar în ritmul de o lecție pe săptămînă, circa 40-44 de lecții la fiecare clasă. Fiecare lecție durează două ore. Unele lecții sînt concursuri cu participare de acasă, ele dublînd lecția din acea săptămînă.

== [[Cercul de informatică IQ Academy]] ==
[[Cercul de informatică IQ Academy]] este un curs oferit de [http://iqacademy.ro/ IQ Academy], o inițiativă a [http://francu.org/ Fundației Frâncu pentru progres și educație] ce își propune formarea unor minți algoritmice, cu putere de abstractizare, cu “gândire computațională”, termen apărut relativ recent și susținut de oameni precum Mark Zuckerberg, creatorul Facebook.
 
 

== Cercul de informatică, colegiul Tudor Vianu, 2012-2020 ==
Găsiți aici detalii despre [[Cercul de informatică - Colegiul Național de Informatică Tudor Vianu]] desfășurat în perioada 2012-2020.
 
 

== Data Structures and Algorithms ==
A future translation to English. Work in progress.
* [[Introduction to Algorithms]]
* [[Introductory Exercises]]
* [[Problems Involving Sequences]]
* [[Problems Involving Arrays]]
 

== Contact ==
Puteți contacta creatorul acestui site, Cristian Frâncu, la [mailto:cristian@francu.com cristian@francu.com]

Clasa a 7-a Lecția 19: Cozi și algoritmul lui Lee

2026-02-16T16:23:26Z

Cristian:

== Înregistrare video lecție ==

<youtube height="720" width="1280">https://youtu.be/nja4_LDg9Xk</youtube>

== Tipul coadă ==

Coada (în engleză queue) este o ''grămadă'' de obiecte ordonate după ordinea '''FIFO''': ''first in, first out''. Aceasta înseamnă că putem adăuga obiecte în coadă, iar atunci când le vom scoate, le vom scoate în aceeași ordine în care le-am adăugat. Ne aducem aminte că, prin contrast, stiva scoate obiectele în ordine inversă față de cum au fost adăugate (ordine '''LIFO''').

=== Coada ca tip de date abstract ===

Ne aducem aminte despre ideea de tip de date abstract: ''un tip de date abstract'' este un model matematic. Acest model definește operații asupra tipului de date, precum și restricții asupra efectului acestor operații. Tipurile de date abstracte sunt utile în simplificarea algoritmilor, deoarece descompun problema în subprobleme mai mici, cunoscute și studiate.

Tipul de date abstract coadă definește operațiile:

* ''enqueue'', care adaugă un element la coadă
* ''dequeue'', care scoate un element din coadă
* ''empty'', care ne spune dacă coada este goală
* ''full'', care ne spune dacă coada este plină

Restricțiile sunt asupra ordinii de returnare a elementelor și anume ele trebuie returnate după regula ''primul venit primul plecat''. De aceea se spune că o coadă este o structură de tip '''FIFO''' (''first in, first out'').

[[Image:coada.gif|frame|none|Coada ca tip abstract de date]]

=== Implementarea cozilor cu vectori circulari ===

Precum am mai spus, tipurile de date abstracte separă funcționalitatea de implementare. În cazul cozii există mai multe implementări posibile. Noi vom studia una dintre cele mai folosite: implementarea cu vectori circulari. Această implementare:

* Folosește un vector pentru a păstra elementele și doi indici, primul și ultimul care memorează poziția primului, respectiv ultimului element din coadă. Pentru a nu deplasa elemente atunci când scoatem un element din coadă vom incrementa doar poziția primului element. Atunci când adăugăm un element în coadă incrementăm poziția ultimului element.
* Pentru a refolosi golurile rămase în urmă la scoaterea din coadă și a nu deplasa cei doi indici la infinit vom defini o mărime maximă a cozii, n. Atunci când unul din indici depășește această mărime el revine la zero. Logic vorbind după ultimul element din vector urmează din nou primul. De aceea spunem că vectorul este circular. Formula de actualizare a indicilor devine <code>primul = (primul + 1) % n</code> și <code>ultimul = (ultimul + 1) % n</code>, unde <code>n</code> este numărul maxim de elemente din coadă.

[[Image:coada-vector-circular.gif|frame|none|Implementare coadă cu vector circular]]

* Observăm că primul este poziția primului element din coadă, iar ultimul este poziția primului element liber din vector.
* Coadă goală. Cum răspundem la întrebarea ''este coada goală''? Se observă că acest lucru se întâmplă când primul == ultimul.
* Coada plină. Cum răspundem la întrebarea ''este coada plină''? Observăm că aceasta se întâmplă tot atunci când primul == ultimul. Pentru a diferenția între aceste două cazuri vom ''sacrifica'' un element din vector, folosind numai <code>n-1</code> poziții. În felul acesta testul de coadă plină va fi <code>(ultimul + 1) % n == primul</code>.

'''Observații:'''

* În această implementare cele patru operații au complexitate ''O(1)''.
* '''Important''': în practică, pentru a nu face împărțiri, dimensiunea maximă a cozii va fi o putere a lui doi, constantă definită în program.
* Unul din avantajele acestei implementări, de care veți auzi în detaliu în facultate este că scoaterea de elemente se poate face în paralel cu adăugarea, de exemplu în cazul când un proces generează elementele de adăugat și un alt proces, independent, colectează elementele spre procesare.

=== Exemple de probleme ce folosesc tipul coadă ===

Exemple de probleme ce folosesc cozi în rezolvări:

* [https://www.nerdarena.ro/problema/maxim2 Maxim2] dată la concursul ONI 2019 clasa a 6-a (punctul 2)
* [https://www.nerdarena.ro/problema/livada Livada] dată la cercul de informatică Vianu 2014 clasa a 9-a

La [http://pbinfo.ro/ pbinfo.ro]:

* [https://www.pbinfo.ro/probleme/873/vase Vase]
* [https://www.pbinfo.ro/probleme/1239/fractii3 Fracții3]
* [https://www.pbinfo.ro/probleme/2187/expand Expand] (grea)

== Algoritmul lui Lee (BFS Fill) ==

În anul 1961 C. Y. Lee a publicat un algoritm de studiu al căilor de conectare între două puncte în diagrame electronice. Algoritmul original presupune o rețea plană (un circuit electronic) în care, mulțumită proprietăților curentului electric, toate muchiile sunt de lungime unu. De-a lungul timpului (și aparent mai mult în România) acest algoritm a ajuns să fie asociat cu parcurgerea pe lățime a unei matrice, drept pentru care acesta este modul în care îl voi prezenta aici.

Deoarece algoritmul lui Lee este o parcurgere pe lățime ar trebui predat după conceptul de parcurgere pe lățime. De aceea, în această lecţie, voi încerca să prezint ambele.

=== Aplicații ale parcurgerii pe lățime ===

* Găsirea drumului minim de la un punct la un altul, sau la mai multe puncte finale.
* Mai puțin menționat: fill cu mai puțină memorie suplimentară (dar și mai lent)

Pentru exemplificare, să considerăm următoarea problemă: se dă un labirint codificat ca o matrice cu zero și unu, zero semnificând loc liber și unu fiind element obstacol (zid). Se dau de asemenea un punct de start și unul de final. În matrice ne putem deplasa pe linie sau pe coloană, cu condiția să nu avem un obstacol. Să se calculeze, lungimea drumului minim între cele două puncte, dacă există un astfel de drum.

=== Parcurgerea în adîncime ===

Când am discutat despre algoritmul ''flood fill'' am menționat că el este o parcurgere a matricei ''în adâncime'', deoarece traversarea elementelor matricei se face avansând din vecin în vecin până ce se ajunge la o fundătură (un obstacol, ieșire din matrice, sau element deja parcurs). Am denumit această parcurgere ''DFS'' (depth first search), aceasta însemnând că în alegerea noului element de vizitat preferăm adâncimea. Ne putem imagina această parcurgere cu un fir subțire de apă care curge într-o direcție oarecare, apoi, când nu mai poate schimbă direcția. Când ramura curentă se "înfundă" apa se va ramifica din firul principal undeva cel mai aproape de fundătură, acolo unde o poate lua pe altă direcție.

Am menționat atunci că pentru acest tip de parcurgere avem nevoie de o '''stivă''' pentru memorarea elementelor ce urmează a fi parcurse. Stiva este fie explicită (nu am vorbit despre aceasta), fie implicită, într-o implementare recursivă. Această stivă are consecințe: ea adaugă ''O(M x N)'' memorie suplimentară.

Folosind parcurgerea în adâncime, ''flood fill'', putem răspunde la întrebarea dacă există drum între cele două puncte, dar nu putem calcula drumul minim.

=== Parcurgerea pe lățime ===

Prin contrast, ne putem imagina o parcurgere pe ''lățime''. În această parcurgere vom traversa mai întâi elementele vecine cu elementul de start. Apoi vom continua cu elementele vecine cu ele. Și apoi cu elementele vecine cu vecinele, și așa mai departe. Putem vizualiza această parcurgere dacă ne imaginăm că turnăm apă în punctul de pornire. Ea se va împrăștia uniform în toate direcțiile. Dacă va da de obstacole ea va merge de-a lungul lor și le va ocoli. La orice moment distanța între orice punct de pe frontiera apei și punctul de start este aceeași.

Denumim această parcurgere ''BFS'' (breadth first search), deoarece în alegerea noului element de parcurs vom prefera lățimea. La fiecare iterație <code>k</code> vom trata elementele aflate la distanță <code>k</code> de punctul original. Ele formează frontiera (marginea) apei, în exemplul nostru. După fiecare iterație frontiera va fi înlocuită cu o nouă frontieră aflată la distanță mai mare cu unu decât vechea frontieră.

Precum vom vedea mai jos această parcurgere este similară cu cea în adâncime, diferența fiind că ea folosește o coadă în loc de stivă pentru memorarea elementelor ce urmează a fi parcurse. Spre deosebire de ''flood fill'', coada trebuie să fie explicită. De aceea algoritmul poate părea foarte diferit de ''flood fill'', dar, în realitate nu este.

=== Exemplificare grafică ===

Să vedem niște vizualizări ale algoritmului BFS fill preluate de la wikipedia: [https://en.wikipedia.org/wiki/Flood_fill algoritm flood fill]:

[[File:Wfm_floodfill_animation_queue_wikipedia.gif|frame|none|Exemplu de BFS fill cu 4 direcții]]

=== Implementarea parcurgerii pe lățime în matrice ===

Cum implementăm parcurgerea pe lățime? Cum memorăm frontiera? O idee imediată ar fi să ținem două frontiere: cea curentă, în curs de procesare, și cea nouă, în curs de generare. La fiecare iterație calculăm o nouă frontieră pe baza celei dinainte. Apoi comutăm pe frontiera cea nouă. Ce conțin frontierele (ce stocăm)? Vom păstra identificatorii unici ai elementelor matricei, respectiv linia și coloana. Frontierele vor fi vectori de perechi (linie, coloană). Această metodă funcționează, dar nu este nici cea mai simplă și nici cea mai economică ca memorie.

În practică nu vom face distincția între frontiera veche și cea nouă. Elementele din frontiera nouă vor fi adăugate la frontiera veche, la sfârșit. Vom avea astfel o singură frontieră de elemente de procesat. Vom procesa elementele de la începutul frontierei și vom adăuga elementele noi, vecinii, la finalul frontierei. În imaginea noastră cu apa punctele procesate vor descrie o spirală în jurul punctului de pornire.

În acest fel ajungem la structura de date pe care o vom folosi pentru stocarea punctelor de frontieră: '''coada'''. Așa cum am menționat mai sus, în loc de '''stivă''' vom folosi o '''coadă''' de perechi (''linie, coloană'') pentru stocarea elementelor ce urmează a fi parcurse. La un pas vom extrage din coadă primul element și vom adăuga elementele vecine lui la finalul cozii, câtă vreme ele nu se află deja în '''coadă''' (coada conține numai elemente unice).

=== Algoritmul de parcurgere BFS ===

Iată o schiță de algoritm, care nu este neapărat universal valabil, dar poate fi adaptat diverselor situații. Această versiune de algoritm își propune să găsească cel mai scurt drum de la ''(lstart, cstart)'' la ''(lend, cend)'':

<tt>
# Inițializează matricea labirint L[][] cu 0 pentru loc liber și -1 pentru obstacol
# Inițializează coada cu elementul de pornire (lstart, cstart)
# Setează L[lstart][cstart] // distanța inițială
# Execută:
## Scoate primul element din coadă. Fie el linia (lin, col)
## Setează dist // distanța acestui element
## Pentru fiecare vecin (l, c) al lui (lin, col)
### Dacă L[l][c] = 0 // nu se află în coadă și nici nu este obstacol
#### Adaugă (l, c) în coadă
#### Setează L[l][c]
# Câtă vreme coada nu este vidă și (lin, col) nu este destinația (lend, cend)
# Afișează L[lin][col] // distanța până la cel mai apropiat punct destinație
</tt>

''' Note de implementare '''

* Vecinii unui element din matrice pot fi fie cei adiacenți pe linie și coloană, fie și cei pe diagonală, algoritmul funcționează la fel.
* De obicei vom folosi tehnicile învățate:
** Bordarea matricelor pentru a scăpa de testul de ieșire din matrice
** Vectorii de direcție pentru a genera ușor vecinii
* Problema poate fi considerată una de simulare: simulăm parcurgerea tuturor traseelor optime în același timp.
* Dacă nu există drum între cele două puncte algoritmul se va termina când coada devine goală.
* În funcție de ceea ce se cere (drum minim până la destinație, drum minim până la anumite puncte, sau drum minim până la toate elementele matricei) coada poate fi parcursă până la final, sau ne putem opri când anumite condiții ale simulării au fost îndeplinite, cum ar fi atingerea punctului destinație.
* Cum știm dacă un element se află deja în coadă? Printr-o matrice de frecvență: la momentul adăugării în coadă vom marca aceasta în matrice. De cele mai multe ori putem combina matricea de frecvență cu matricea de distanțe (ca în algoritmul de mai sus): un element diferit de zero semnifică distanța acelui element la punctul de start. În această notație obstacolele trebuie memorate ca numere negative pentru a nu fi confundate cu distanțe.
* Cum știm că am ajuns în punctul final? Putem să testăm explicit linia și coloana. Dar dacă avem mai multe puncte finale trebuie să le marcăm într-o matrice. Această matrice se poate de obicei combina cu matricea de frecvență și cu cea de distanțe, deoarece avem nevoie doar de un bit unu sau zero.
* Algoritmul poate fi adaptat să calculeze drumul minim de la mai multe puncte de pornire la mai multe puncte destinație. În acest caz vom inițializa coada cu toate punctele de pornire.

=== Reconstrucția drumului minim ===

Pentru a reconstitui un drum minim între sursă și destinație vom porni invers: de la destinație și vom avansa în <code>L[][]</code> pe elemente descrescătoare din unu în unu, până ce ajungem la sursă. '''Atenție''', drumul nu este neapărat unic.

=== Implementarea cozii de coordonate ===

Pentru coadă vom folosi un vector circular de mărime ''2(M+N)'' (vezi explicația la capitolul de complexități). Vom avea o variabilă, <code>prim</code> care păstrează indicele de adăugare în coadă, precum și o variabilă ultim care păstrează poziția primului element ''gol'', în afara cozii. Acești doi indici vor avansa circular, modulo mărimea cozii.

Coada poate să fie un vector de elemente tip <code>struct</code>, sau doi vectori separați. Prima variantă este mai bună din punct de vedere ''cache'', dar poate duce la risipă de memorie în anumite situații, dacă elementul de tip <code>struct</code> nu ocupă un număr de octeți divizibil cu patru (sau cu lungimea cuvântului de memorie).

Vom folosi trei funcții:

* <code>enqueue( lin, col )</code> care adaugă elementul ''(lin, col)'' în coadă.
* <code>dequeue()</code> care extrage elementul ''(lin, col)'' din coadă.
* <code>emptyqueue()</code> care returnează 1 dacă coada este vidă.

Iată o posibilă implementare ce presupune că numărul de linii și coloane este maxim 255:

<syntaxhighlight lang="c" line>
int prim, ultim;
unsigned char coadal[NCOADA], coadac[NCOADA]; // coordonate mici

// adauga coordonate in coada
static inline void enqueue( int l, int c ) {
coadal[ultim] = l;
coadac[ultim] = c;
ultim = (ultim + 1) % NCOADA;
}

// scoate coordonate din coada
static inline int dequeue() {
int retval = coadal[prim] * 256 + coadac[prim];

prim = (prim + 1) % NCOADA;

return retval;
}

// returneaza 1 cand coada este goala
static inline int emptyqueue() {
return prim == ultim;
}
</syntaxhighlight>

''' Observații: '''

* Funcția <code>dequeue()</code> returnează două valori, linie și coloană. Ele fiind mici le-am combinat într-un singur întreg. Acest lucru este posibil în general, deoarece putem combina două valori <code>unsigned short</code> într-un <code>unsigned int</code>, ceea ce ne permite linii și coloane până în 65535, număr în general acoperitor pentru o matrice stocată în memorie.
* Astfel am putea să stocăm în coadă direct produsul returnat de funcția <code>dequeue()</code>. Avantajele se datorează, în mare, ''cache-ului''.

=== Complexități în timp și spațiu ===

Timpul de execuție este ''O(M x N)'' deoarece fiecare element al matricei va fi luat în calcul cel mult o dată.

Memoria necesară este ''O(M x N)'' deoarece avem nevoie de matricea de distanțe, matricea de frecvențe și cea de puncte terminale, precum și memoria ocupată de coadă. În realitate, de cele mai multe ori putem unifica matricele suplimentare, unindu-le cu matricea labirint. În acest caz memoria suplimentară este cea a cozii. La momentul când scriu aceste rânduri nu am găsit o estimare asupra dimensiunii maxime a cozii necesare. Intuitiv ea este ''O(M + N)'', deoarece frontiera, într-un labirint fără obstacole, când punctul de pornire este în mijloc, nu va depăși M+N. Este neclar dacă o altă matrice și un alt punct de pornire o poate face să depășească ''M + N'' și cu cât. Ca practică de implementare sfatul meu este să o dimensionați de ''2(M + N)'', acoperitor, deoarece este un număr oricum mult mai mic decât matricea deja stocată, ''M x N''.

Datorită consumului atât de mic de memorie suplimentară, algoritmul lui Lee poate fi folosit ca și ca algoritm de fill pe matrice mari, sau când memoria suplimentară este mică. El va fi însă mai lent decât ''flood fill'', de obicei de multe ori (20-30 de ori), ceea ce dovedește încă o dată că, pentru unii algoritmi, memoria suplimentară se traduce în timp de execuție mai mic.

=== Aplicații ===

Algoritmul lui Lee este necesar când dorim să aflăm informații despre drumuri și distanțe:

* Găsirea ieșirii dintr-un labirint / castel / hartă.
* Găsirea celui mai scurt drum între două puncte dintr-o matrice.
* În lumea reală, proiectarea de circuite electronice.

=== Exemple de probleme ce folosesc algoritmul lui Lee ===

Orice problemă rezolvabilă prin ''flood fill'' este, desigur, rezolvabilă și cu ''Lee'', folosind mai puțină memorie, dar consumând mai mult timp pentru executarea programului. N-am găsit foarte multe exemple de probleme ce necesită ''Lee'', dar nu se pot rezolva cu ''flood fill''. Iată câteva exemple:

Exemple de probleme ce folosesc algoritmul lui Lee în rezolvări:

La [https://www.nerdarena.ro/ NerdArena]:

* [https://www.nerdarena.ro/problema/alee Alee] dată la OJI 2007 clasa a 10-a
* [https://www.nerdarena.ro/problema/insule Insule] dată la OJI 2009 clasa a 10-a
* [https://www.nerdarena.ro/problema/miting Miting] dată la OJI 2016 clasa a 10-a (grea)

La [http://infoarena.ro/ InfoArena]:

* [https://www.infoarena.ro/algoritmul-lee Articolul de la Infoarena] include câteva exemple
* [https://www.infoarena.ro/problema/muzeu Muzeu]
* [https://www.infoarena.ro/problema/traseu3 Traseu3] dată la ONI 2014, clasa a 9-a (Lee 3D, relativ ușoară)
* [https://www.infoarena.ro/problema/gheizere Gheizere] dată la ONI 2012, clasa a 10-a (problemă grea)
* [https://www.infoarena.ro/problema/ai AI] dată la OJI 2011, clasa a 10-a (enunț complex)

== Tema 19 ==

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

* [https://www.nerdarena.ro/problema/livada Livada]
* [https://www.nerdarena.ro/problema/alee Alee] alee dată la OJI 2007 clasa a 10-a

== Tema opțională ==

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

* [https://www.nerdarena.ro/problema/insule Insule] dată la OJI 2009 clasa a 10-a

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_19:_Cozi_%C8%99i_algoritmul_lui_Lee&action=edit&redlink=1 Accesează rezolvarea temei 19]

Clasa a 7-a Lecția 19: Cozi și algoritmul lui Lee

2026-02-16T15:12:42Z

Cristian:

== Înregistrare video lecție ==

<youtube height="720" width="1280">https://youtu.be/nja4_LDg9Xk</youtube>

== Tipul coadă ==

Coada (în engleză queue) este o ''grămadă'' de obiecte ordonate după ordinea '''FIFO''': ''first in, first out''. Aceasta înseamnă că putem adăuga obiecte în coadă, iar atunci când le vom scoate, le vom scoate în aceeași ordine în care le-am adăugat. Ne aducem aminte că, prin contrast, stiva scoate obiectele în ordine inversă față de cum au fost adăugate (ordine '''LIFO''').

=== Coada ca tip de date abstract ===

Ne aducem aminte despre ideea de tip de date abstract: ''un tip de date abstract'' este un model matematic. Acest model definește operații asupra tipului de date, precum și restricții asupra efectului acestor operații. Tipurile de date abstracte sunt utile în simplificarea algoritmilor, deoarece descompun problema în subprobleme mai mici, cunoscute și studiate.

Tipul de date abstract coadă definește operațiile:

* ''enqueue'', care adaugă un element la coadă
* ''dequeue'', care scoate un element din coadă
* ''empty'', care ne spune dacă coada este goală
* ''full'', care ne spune dacă coada este plină

Restricțiile sunt asupra ordinii de returnare a elementelor și anume ele trebuie returnate după regula ''primul venit primul plecat''. De aceea se spune că o coadă este o structură de tip '''FIFO''' (''first in, first out'').

[[Image:coada.gif|frame|none|Coada ca tip abstract de date]]

=== Implementarea cozilor cu vectori circulari ===

Precum am mai spus, tipurile de date abstracte separă funcționalitatea de implementare. În cazul cozii există mai multe implementări posibile. Noi vom studia una dintre cele mai folosite: implementarea cu vectori circulari. Această implementare:

* Folosește un vector pentru a păstra elementele și doi indici, primul și ultimul care memorează poziția primului, respectiv ultimului element din coadă. Pentru a nu deplasa elemente atunci când scoatem un element din coadă vom incrementa doar poziția primului element. Atunci când adăugăm un element în coadă incrementăm poziția ultimului element.
* Pentru a refolosi golurile rămase în urmă la scoaterea din coadă și a nu deplasa cei doi indici la infinit vom defini o mărime maximă a cozii, n. Atunci când unul din indici depășește această mărime el revine la zero. Logic vorbind după ultimul element din vector urmează din nou primul. De aceea spunem că vectorul este circular. Formula de actualizare a indicilor devine <code>primul = (primul + 1) % n</code> și <code>ultimul = (ultimul + 1) % n</code>, unde <code>n</code> este numărul maxim de elemente din coadă.

[[Image:coada-vector-circular.gif|frame|none|Implementare coadă cu vector circular]]

* Observăm că primul este poziția primului element din coadă, iar ultimul este poziția primului element liber din vector.
* Coadă goală. Cum răspundem la întrebarea ''este coada goală''? Se observă că acest lucru se întâmplă când primul == ultimul.
* Coada plină. Cum răspundem la întrebarea ''este coada plină''? Observăm că aceasta se întâmplă tot atunci când primul == ultimul. Pentru a diferenția între aceste două cazuri vom ''sacrifica'' un element din vector, folosind numai <code>n-1</code> poziții. În felul acesta testul de coadă plină va fi <code>(ultimul + 1) % n == primul</code>.

'''Observații:'''

* În această implementare cele patru operații au complexitate ''O(1)''.
* '''Important''': în practică, pentru a nu face împărțiri, dimensiunea maximă a cozii va fi o putere a lui doi, constantă definită în program.
* Unul din avantajele acestei implementări, de care veți auzi în detaliu în facultate este că scoaterea de elemente se poate face în paralel cu adăugarea, de exemplu în cazul când un proces generează elementele de adăugat și un alt proces, independent, colectează elementele spre procesare.

=== Exemple de probleme ce folosesc tipul coadă ===

Exemple de probleme ce folosesc cozi în rezolvări:

* [https://www.nerdarena.ro/problema/maxim2 Maxim] dată la concursul ONI 2019 clasa a 6-a (punctul 2)
* [https://www.nerdarena.ro/problema/livada Livada] dată la cercul de informatică Vianu 2014 clasa a 9-a

La [http://pbinfo.ro/ pbinfo.ro]:

* [https://www.pbinfo.ro/probleme/873/vase Vase]
* [https://www.pbinfo.ro/probleme/1239/fractii3 Fracții3]
* [https://www.pbinfo.ro/probleme/2187/expand Expand] (grea)

== Algoritmul lui Lee (BFS Fill) ==

În anul 1961 C. Y. Lee a publicat un algoritm de studiu al căilor de conectare între două puncte în diagrame electronice. Algoritmul original presupune o rețea plană (un circuit electronic) în care, mulțumită proprietăților curentului electric, toate muchiile sunt de lungime unu. De-a lungul timpului (și aparent mai mult în România) acest algoritm a ajuns să fie asociat cu parcurgerea pe lățime a unei matrice, drept pentru care acesta este modul în care îl voi prezenta aici.

Deoarece algoritmul lui Lee este o parcurgere pe lățime ar trebui predat după conceptul de parcurgere pe lățime. De aceea, în această lecţie, voi încerca să prezint ambele.

=== Aplicații ale parcurgerii pe lățime ===

* Găsirea drumului minim de la un punct la un altul, sau la mai multe puncte finale.
* Mai puțin menționat: fill cu mai puțină memorie suplimentară (dar și mai lent)

Pentru exemplificare, să considerăm următoarea problemă: se dă un labirint codificat ca o matrice cu zero și unu, zero semnificând loc liber și unu fiind element obstacol (zid). Se dau de asemenea un punct de start și unul de final. În matrice ne putem deplasa pe linie sau pe coloană, cu condiția să nu avem un obstacol. Să se calculeze, lungimea drumului minim între cele două puncte, dacă există un astfel de drum.

=== Parcurgerea în adîncime ===

Când am discutat despre algoritmul ''flood fill'' am menționat că el este o parcurgere a matricei ''în adâncime'', deoarece traversarea elementelor matricei se face avansând din vecin în vecin până ce se ajunge la o fundătură (un obstacol, ieșire din matrice, sau element deja parcurs). Am denumit această parcurgere ''DFS'' (depth first search), aceasta însemnând că în alegerea noului element de vizitat preferăm adâncimea. Ne putem imagina această parcurgere cu un fir subțire de apă care curge într-o direcție oarecare, apoi, când nu mai poate schimbă direcția. Când ramura curentă se "înfundă" apa se va ramifica din firul principal undeva cel mai aproape de fundătură, acolo unde o poate lua pe altă direcție.

Am menționat atunci că pentru acest tip de parcurgere avem nevoie de o '''stivă''' pentru memorarea elementelor ce urmează a fi parcurse. Stiva este fie explicită (nu am vorbit despre aceasta), fie implicită, într-o implementare recursivă. Această stivă are consecințe: ea adaugă ''O(M x N)'' memorie suplimentară.

Folosind parcurgerea în adâncime, ''flood fill'', putem răspunde la întrebarea dacă există drum între cele două puncte, dar nu putem calcula drumul minim.

=== Parcurgerea pe lățime ===

Prin contrast, ne putem imagina o parcurgere pe ''lățime''. În această parcurgere vom traversa mai întâi elementele vecine cu elementul de start. Apoi vom continua cu elementele vecine cu ele. Și apoi cu elementele vecine cu vecinele, și așa mai departe. Putem vizualiza această parcurgere dacă ne imaginăm că turnăm apă în punctul de pornire. Ea se va împrăștia uniform în toate direcțiile. Dacă va da de obstacole ea va merge de-a lungul lor și le va ocoli. La orice moment distanța între orice punct de pe frontiera apei și punctul de start este aceeași.

Denumim această parcurgere ''BFS'' (breadth first search), deoarece în alegerea noului element de parcurs vom prefera lățimea. La fiecare iterație <code>k</code> vom trata elementele aflate la distanță <code>k</code> de punctul original. Ele formează frontiera (marginea) apei, în exemplul nostru. După fiecare iterație frontiera va fi înlocuită cu o nouă frontieră aflată la distanță mai mare cu unu decât vechea frontieră.

Precum vom vedea mai jos această parcurgere este similară cu cea în adâncime, diferența fiind că ea folosește o coadă în loc de stivă pentru memorarea elementelor ce urmează a fi parcurse. Spre deosebire de ''flood fill'', coada trebuie să fie explicită. De aceea algoritmul poate părea foarte diferit de ''flood fill'', dar, în realitate nu este.

=== Exemplificare grafică ===

Să vedem niște vizualizări ale algoritmului BFS fill preluate de la wikipedia: [https://en.wikipedia.org/wiki/Flood_fill algoritm flood fill]:

[[File:Wfm_floodfill_animation_queue_wikipedia.gif|frame|none|Exemplu de BFS fill cu 4 direcții]]

=== Implementarea parcurgerii pe lățime în matrice ===

Cum implementăm parcurgerea pe lățime? Cum memorăm frontiera? O idee imediată ar fi să ținem două frontiere: cea curentă, în curs de procesare, și cea nouă, în curs de generare. La fiecare iterație calculăm o nouă frontieră pe baza celei dinainte. Apoi comutăm pe frontiera cea nouă. Ce conțin frontierele (ce stocăm)? Vom păstra identificatorii unici ai elementelor matricei, respectiv linia și coloana. Frontierele vor fi vectori de perechi (linie, coloană). Această metodă funcționează, dar nu este nici cea mai simplă și nici cea mai economică ca memorie.

În practică nu vom face distincția între frontiera veche și cea nouă. Elementele din frontiera nouă vor fi adăugate la frontiera veche, la sfârșit. Vom avea astfel o singură frontieră de elemente de procesat. Vom procesa elementele de la începutul frontierei și vom adăuga elementele noi, vecinii, la finalul frontierei. În imaginea noastră cu apa punctele procesate vor descrie o spirală în jurul punctului de pornire.

În acest fel ajungem la structura de date pe care o vom folosi pentru stocarea punctelor de frontieră: '''coada'''. Așa cum am menționat mai sus, în loc de '''stivă''' vom folosi o '''coadă''' de perechi (''linie, coloană'') pentru stocarea elementelor ce urmează a fi parcurse. La un pas vom extrage din coadă primul element și vom adăuga elementele vecine lui la finalul cozii, câtă vreme ele nu se află deja în '''coadă''' (coada conține numai elemente unice).

=== Algoritmul de parcurgere BFS ===

Iată o schiță de algoritm, care nu este neapărat universal valabil, dar poate fi adaptat diverselor situații. Această versiune de algoritm își propune să găsească cel mai scurt drum de la ''(lstart, cstart)'' la ''(lend, cend)'':

<tt>
# Inițializează matricea labirint L[][] cu 0 pentru loc liber și -1 pentru obstacol
# Inițializează coada cu elementul de pornire (lstart, cstart)
# Setează L[lstart][cstart] // distanța inițială
# Execută:
## Scoate primul element din coadă. Fie el linia (lin, col)
## Setează dist // distanța acestui element
## Pentru fiecare vecin (l, c) al lui (lin, col)
### Dacă L[l][c] = 0 // nu se află în coadă și nici nu este obstacol
#### Adaugă (l, c) în coadă
#### Setează L[l][c]
# Câtă vreme coada nu este vidă și (lin, col) nu este destinația (lend, cend)
# Afișează L[lin][col] // distanța până la cel mai apropiat punct destinație
</tt>

''' Note de implementare '''

* Vecinii unui element din matrice pot fi fie cei adiacenți pe linie și coloană, fie și cei pe diagonală, algoritmul funcționează la fel.
* De obicei vom folosi tehnicile învățate:
** Bordarea matricelor pentru a scăpa de testul de ieșire din matrice
** Vectorii de direcție pentru a genera ușor vecinii
* Problema poate fi considerată una de simulare: simulăm parcurgerea tuturor traseelor optime în același timp.
* Dacă nu există drum între cele două puncte algoritmul se va termina când coada devine goală.
* În funcție de ceea ce se cere (drum minim până la destinație, drum minim până la anumite puncte, sau drum minim până la toate elementele matricei) coada poate fi parcursă până la final, sau ne putem opri când anumite condiții ale simulării au fost îndeplinite, cum ar fi atingerea punctului destinație.
* Cum știm dacă un element se află deja în coadă? Printr-o matrice de frecvență: la momentul adăugării în coadă vom marca aceasta în matrice. De cele mai multe ori putem combina matricea de frecvență cu matricea de distanțe (ca în algoritmul de mai sus): un element diferit de zero semnifică distanța acelui element la punctul de start. În această notație obstacolele trebuie memorate ca numere negative pentru a nu fi confundate cu distanțe.
* Cum știm că am ajuns în punctul final? Putem să testăm explicit linia și coloana. Dar dacă avem mai multe puncte finale trebuie să le marcăm într-o matrice. Această matrice se poate de obicei combina cu matricea de frecvență și cu cea de distanțe, deoarece avem nevoie doar de un bit unu sau zero.
* Algoritmul poate fi adaptat să calculeze drumul minim de la mai multe puncte de pornire la mai multe puncte destinație. În acest caz vom inițializa coada cu toate punctele de pornire.

=== Reconstrucția drumului minim ===

Pentru a reconstitui un drum minim între sursă și destinație vom porni invers: de la destinație și vom avansa în <code>L[][]</code> pe elemente descrescătoare din unu în unu, până ce ajungem la sursă. '''Atenție''', drumul nu este neapărat unic.

=== Implementarea cozii de coordonate ===

Pentru coadă vom folosi un vector circular de mărime ''2(M+N)'' (vezi explicația la capitolul de complexități). Vom avea o variabilă, <code>prim</code> care păstrează indicele de adăugare în coadă, precum și o variabilă ultim care păstrează poziția primului element ''gol'', în afara cozii. Acești doi indici vor avansa circular, modulo mărimea cozii.

Coada poate să fie un vector de elemente tip <code>struct</code>, sau doi vectori separați. Prima variantă este mai bună din punct de vedere ''cache'', dar poate duce la risipă de memorie în anumite situații, dacă elementul de tip <code>struct</code> nu ocupă un număr de octeți divizibil cu patru (sau cu lungimea cuvântului de memorie).

Vom folosi trei funcții:

* <code>enqueue( lin, col )</code> care adaugă elementul ''(lin, col)'' în coadă.
* <code>dequeue()</code> care extrage elementul ''(lin, col)'' din coadă.
* <code>emptyqueue()</code> care returnează 1 dacă coada este vidă.

Iată o posibilă implementare ce presupune că numărul de linii și coloane este maxim 255:

<syntaxhighlight lang="c" line>
int prim, ultim;
unsigned char coadal[NCOADA], coadac[NCOADA]; // coordonate mici

// adauga coordonate in coada
static inline void enqueue( int l, int c ) {
coadal[ultim] = l;
coadac[ultim] = c;
ultim = (ultim + 1) % NCOADA;
}

// scoate coordonate din coada
static inline int dequeue() {
int retval = coadal[prim] * 256 + coadac[prim];

prim = (prim + 1) % NCOADA;

return retval;
}

// returneaza 1 cand coada este goala
static inline int emptyqueue() {
return prim == ultim;
}
</syntaxhighlight>

''' Observații: '''

* Funcția <code>dequeue()</code> returnează două valori, linie și coloană. Ele fiind mici le-am combinat într-un singur întreg. Acest lucru este posibil în general, deoarece putem combina două valori <code>unsigned short</code> într-un <code>unsigned int</code>, ceea ce ne permite linii și coloane până în 65535, număr în general acoperitor pentru o matrice stocată în memorie.
* Astfel am putea să stocăm în coadă direct produsul returnat de funcția <code>dequeue()</code>. Avantajele se datorează, în mare, ''cache-ului''.

=== Complexități în timp și spațiu ===

Timpul de execuție este ''O(M x N)'' deoarece fiecare element al matricei va fi luat în calcul cel mult o dată.

Memoria necesară este ''O(M x N)'' deoarece avem nevoie de matricea de distanțe, matricea de frecvențe și cea de puncte terminale, precum și memoria ocupată de coadă. În realitate, de cele mai multe ori putem unifica matricele suplimentare, unindu-le cu matricea labirint. În acest caz memoria suplimentară este cea a cozii. La momentul când scriu aceste rânduri nu am găsit o estimare asupra dimensiunii maxime a cozii necesare. Intuitiv ea este ''O(M + N)'', deoarece frontiera, într-un labirint fără obstacole, când punctul de pornire este în mijloc, nu va depăși M+N. Este neclar dacă o altă matrice și un alt punct de pornire o poate face să depășească ''M + N'' și cu cât. Ca practică de implementare sfatul meu este să o dimensionați de ''2(M + N)'', acoperitor, deoarece este un număr oricum mult mai mic decât matricea deja stocată, ''M x N''.

Datorită consumului atât de mic de memorie suplimentară, algoritmul lui Lee poate fi folosit ca și ca algoritm de fill pe matrice mari, sau când memoria suplimentară este mică. El va fi însă mai lent decât ''flood fill'', de obicei de multe ori (20-30 de ori), ceea ce dovedește încă o dată că, pentru unii algoritmi, memoria suplimentară se traduce în timp de execuție mai mic.

=== Aplicații ===

Algoritmul lui Lee este necesar când dorim să aflăm informații despre drumuri și distanțe:

* Găsirea ieșirii dintr-un labirint / castel / hartă.
* Găsirea celui mai scurt drum între două puncte dintr-o matrice.
* În lumea reală, proiectarea de circuite electronice.

=== Exemple de probleme ce folosesc algoritmul lui Lee ===

Orice problemă rezolvabilă prin ''flood fill'' este, desigur, rezolvabilă și cu ''Lee'', folosind mai puțină memorie, dar consumând mai mult timp pentru executarea programului. N-am găsit foarte multe exemple de probleme ce necesită ''Lee'', dar nu se pot rezolva cu ''flood fill''. Iată câteva exemple:

Exemple de probleme ce folosesc algoritmul lui Lee în rezolvări:

La [https://www.nerdarena.ro/ NerdArena]:

* [https://www.nerdarena.ro/problema/alee Alee] dată la OJI 2007 clasa a 10-a
* [https://www.nerdarena.ro/problema/insule Insule] dată la OJI 2009 clasa a 10-a
* [https://www.nerdarena.ro/problema/miting Miting] dată la OJI 2016 clasa a 10-a (grea)

La [http://infoarena.ro/ InfoArena]:

* [https://www.infoarena.ro/algoritmul-lee Articolul de la Infoarena] include câteva exemple
* [https://www.infoarena.ro/problema/muzeu Muzeu]
* [https://www.infoarena.ro/problema/traseu3 Traseu3] dată la ONI 2014, clasa a 9-a (Lee 3D, relativ ușoară)
* [https://www.infoarena.ro/problema/gheizere Gheizere] dată la ONI 2012, clasa a 10-a (problemă grea)
* [https://www.infoarena.ro/problema/ai AI] dată la OJI 2011, clasa a 10-a (enunț complex)

== Tema 19 ==

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

* [https://www.nerdarena.ro/problema/livada Livada]
* [https://www.nerdarena.ro/problema/alee Alee] alee dată la OJI 2007 clasa a 10-a

== Tema opțională ==

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

* [https://www.nerdarena.ro/problema/insule Insule] dată la OJI 2009 clasa a 10-a

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_19:_Cozi_%C8%99i_algoritmul_lui_Lee&action=edit&redlink=1 Accesează rezolvarea temei 19]

Clasa a 7-a Lecția 18: Divide et impera, mergesort, quicksort

2026-02-10T17:40:31Z

Cristian:

== Înregistrare video lecție ==

<youtube height="720" width="1280">https://youtu.be/bgMxb050keA</youtube>

== Tehnici de programare: divide et impera ==

Denumită și divide and conquer sau dezbină și stăpânește, este o tehnică cunoscută de mii de ani conducătorilor. Este o tehnică de cucerire sau menținere a puterii asupra unui grup care ar avea putere mai mare dacă s-ar uni. Ținând acel grup dezbinat, fiecare facțiune în parte are putere mică și poate fi cucerită, sau condusă. Tehnica a fost aplicată de Cezar, Napoleon, iar, mai recent, de către Britanici în Africa și de către Stalin în Rusia. Dintre tehnicile folosite în lumea reală putem menționa:

* Ajutorarea și promovarea celor care cooperează cu puterea, pedepsirea celor ce nu cooperează.
* Încurajarea cheltuielilor prostești, pentru a reduce capitalul disponibil organizării sau luptei.
* Încurajarea divizării oamenilor pentru a preveni formarea alianțelor.
* Încurajarea turnătorilor, cei care trâmbițează orice alianță posibil periculoasă.
* Sădirea de neîncredere între oameni.

O parte din aceste tehnici se regăsesc și în țara noastră, precum și în majoritatea țărilor lumii, inclusiv cele dezvoltate. De exemplu, toate țările lumii folosesc un număr uriaș de taxe și impozite, fiecare din ele relativ mici. Când le însumăm constatăm că în jur de 90% din banii noștri se duc pe aceste taxe și impozite. Dacă ar exista o taxă unică de 90%, oamenii s-ar revolta. Astfel, tehnica de împărțire a unor taxe mari în mai multe taxe mici îi face pe oameni să nu le observe și să nu se revolte.

Pentru exemple clasice de folosire a acestei tehnici în lumea reală vizitați pagina de [http://en.wikipedia.org/wiki/Divide_and_rule divide et impera] a wikipediei.

== Tehnica divide et impera (divide and conquer) în informatică ==

În informatică divide et impera constă în împărțirea problemei în subprobleme mai mici, nesuprapuse (o tehnică în care subproblemele sunt suprapuse este programarea dinamică). Fiecare din aceste subprobleme se rezolvă separat, mai ușor, deoarece sunt mai mici. Rezultatul final se obține din combinarea rezultatelor subproblemelor.

== Tehnica divide et impera simplă (decrease and conquer) ==

În următoarele exemple de divide et impera problema se reduce la o singură problemă, mai mică. Este un caz degenerat, în care implementarea poate fi iterativă (nu necesită recursivitate).

''' Algoritmul lui Euclid '''

Și acest bine cunoscut algoritm poate fi văzut ca un exemplu de divide et impera. El reduce problema de la <code>cmmdc(a, b)</code> la o problemă mai mică, <code>cmmdc(b, a mod b)</code>. Complexitate: ''O(log min(a, b))''.

''' Căutare binară '''

Precum știm, căutarea binară împarte vectorul original în două, apoi decide care din cele două jumătăți ar putea să conțină elementul căutat. Apoi rezolvă problema mai mică. Complexitate: ''O(log n)''.

''' Căutare punct fix'''

Se dă un vector sortat de <code>n</code> elemente întregi distincte. Să se găsească dacă există indicele <code>i</code> astfel încât <code>v[i] == i</code>. Găsiți un algoritm divide et impera care are complexitate ''O(log n)''.

''' Puzzle balanță '''

Avem 25 de bile care arată identic, una este ceva mai ușoară. Avem la dispoziție o balanță. Găsiți bila mai ușoară din trei cântăriri.

''' Selecția '''

Complexitate: pe medie ''O(n)'', în cel mai rău caz ''O(n2)''. Este necesară la problema [https://www.nerdarena.ro/problema/antitir AntiTir].

=== Probleme NerdArena ===

Următoarele probleme de la [https://www.nerdarena.ro/ NerdArena] sunt de divide et impera degenerat:

* [https://www.nerdarena.ro/problema/z ZParcurgere]
* [https://www.nerdarena.ro/problema/tabela Tabela]
* [https://www.nerdarena.ro/problema/antitir AntiTir] dată la Shumen 2012

== Tehnica divide et impera propriu zisă ==

În următoarele exemple de divide et impera problema se reduce la două sau mai multe probleme mai mici. Implementarea este mult mai simplă dacă folosim recursivitate.

=== Puzzle pavare ===

Se dă o grilă de 2n x 2n pătrate din care lipsește un pătrat. Să se acopere cu piese formate din 3 pătrate aranjate în formă de litera L.

[[File:pav2.jpg|frame|none|Exemplu de pavare cu L-uri]]

Problema pare destul de grea, nu? În realitate, odată ce încercăm să folosim divide et impera ea devine destul de ușoară. Cum putem împărți problema în probleme mai mici?

Să definim o problemă astfel:

''P(n, gol)'' = pavează un pătrat de latură 2n care are un pătrățel lipsă (un gol).

O primă idee ar fi să încercăm să împărțim pătratul în patru pătrate de latură 2n-1 și să rezolvăm acele probleme. Avem, însă, o dificultate: doar unul din pătrate va avea un pătrățel lipsă. Celelalte trei vor fi pline. Ce ne facem?

Am putea încerca să eliminăm artificial câte un pătrățel din celelalte trei pătrate. Cum putem face acest lucru? Cu condiția ca cele trei pătrățele să fie în formă de L și să le acoperim cu o piesă elementară. Ei bine avem cum să alegem pătratele în acest fel: le vom selecta pe cele de la centru! Astfel vom obține subproblemele:

''P(n, l, c)'' se descompune în:
''P(n-1, gol)'' (golul original)
''P(n-1, gol1)''
''P(n-1, gol2)''
''P(n-1, gol3)''

=== Mergesort ===

Algoritmul ''mergesort'', sau sortare prin interclasare, funcționează astfel:

* Divide vectorul de sortat în două părți egale (sau aproape egale)
* Reapelează ''mergesort'' pe acele părți
* La revenire avem două jumătăți sortate, deci putem sorta vectorul interclasând cei doi vectori în timp liniar

Iată un algoritm:

<pre>
mergesort( V[], i, j )
mij = (i + j) / 2;
daca i < mij
mergesort( V[], i, mij )
daca mij + 1 < j
mergesort( V[], mij + 1, j )
merge( V[], i, mij, j )
</pre>

<code>merge( V[], i, mij, j )</code> interclasează vectorii sortați <code>V[i..mij]</code> și <code>V[mij+1..j]</code>.

Ce complexitate are ''mergesort''?

Să calculăm numărul de operații, T(N), pentru a sorta un vector de N elemente:

<pre>
T(N) = 2 · T(N/2) + N
T(N) = 2 · (2 · T(N/4) + N/2) + N
T(N) = 4 · T(N/4) + 2 · N
T(N) = 4 · (2 · T(N/8) + N/4) + 2 · N
T(N) = 8 · T(N/8) + 3 · N
...
T(N) = N · T(N/N) + log N · N
T(N) = N · T(1) + log N · N
</pre>

Deoarece ''T(1)'' este ''O(1)'' rezultă o complexitate ''O(N + N log N) = O(N log N)''.

Câtă memorie suplimentară folosește algoritmul?

Pentru interclasarea clasică avem nevoie de un alt vector, deci ''O(N)''.

În concluzie avem complexitățile:

* timp: ''O(n log n)''
* memorie suplimentară: ''O(n)'' (aceasta e problema principală a algoritmului).

Există variante ale algoritmului care folosesc mai puțină memorie (o idee evidentă este să folosim doar jumate din memorie deoarece în timpul interclasării putem suprascrie una din jumătăți).

=== Aplicație mergesort - inversiunile unei permutări ===

O problemă care apare uneori la concursuri este următoarea: se dă o permutare a numerelor de la 1 la ''N''. Să se numere câte inversiuni are ea. O inversiune este o pereche de indici ''(i, j)'' astfel încât <code>i < j</code> și <code>P[i] > P[j]</code>.

În linii mari, algoritmul este următorul:

* Sortăm prima jumate a vectorului folosind un ''mergesort'' special, care ne returnează numărul de inversiuni din vectorul de sortat.
* Sortăm a doua jumate a vectorului.
* În acest moment știm inversiunile din cele două jumătăți - le adunăm.
* Interclasăm cele două jumătăți. În timpul interclasării când selectăm un număr din prima jumătate știm că numerele deja selectate din jumătatea a doua sunt mai mici, deci putem aduna numărul lor la numărul total de inversiuni.

=== Quicksort ===

Algoritmul quicksort, sau sortare rapidă, inventat în 1959 de informaticianul britanic Tony Hoare, funcționează astfel:

* Alege o poziție la întâmplare din vectorul de sortat. Vom denumi valoarea de la acea poziție pivot.
* Rearanjează vectorul astfel încât în prima parte să avem elemente mai mici sau egale cu pivotul iar în a doua parte elemente mai mari sau egale cu pivotul. Vom denumi acest pas pivotare.
* Reapelează quicksort pe acele două părți.

Din acest algoritm avem de lămurit pasul de pivotare. El este același ca la quickselect, prezentat într-o lecție anterioară. El procedează astfel:

* Pornește cu doi indici, unul la începutul vectorului și unul la final de vector, să le spunem <code>b</code> și <code>e</code>.
* Avansează indicele b până la primul element mai mare sau egal cu pivotul.
* Devansează (merge înapoi) indicele e până la primul element mai mic sau egal cu pivotul.
* Interschimbă elementele din vector de la pozițiile <code>b</code> și <code>e</code>.
* Repetă până ce indicii se ating, <code>b >= e</code>.

Iată o implementare posibilă. Ea este implementarea originală a lui Hoare, transformată pentru a fi structurată:

<syntaxhighlight lang="c" line>
void myqsort( int begin, int end ) {
int aux, b = begin, e = end,
pivot = v[(begin + end) / 2]; // poate fi orice pozitie intre begin si end - 1

while (v[b] < pivot) // cauta primul element mai mare sau egal cu pivotul
b++;

while (v[e] > pivot) // cauta primul element mai mic sau egal cu pivotul
e--;

while( b < e ) { // daca indicii nu s-au atins
aux = v[b]; // interschimba elementele la pozitiile b si e
v[b] = v[e];
v[e] = aux;

do // cauta primul element mai mare sau egal cu pivotul
b++;
while (v[b] < pivot);

do // cauta primul element mai mic sau egal cu pivotul
e--;
while (v[e] > pivot);
}

// acum [begin..e] sunt mai mici sau egale cu pivotul
if ( begin < e )
myqsort(begin, e);
// si [e+1..end] sunt mai mari sau egale cu pivotul
if ( e + 1 < end )
myqsort(e + 1, end);
}
</syntaxhighlight>

Ce complexitate are quicksort?

Deoarece pivotarea este liniară, calculele sunt similare cu cele de la ''mergesort''. Avem două diferențe:

* Procesarea liniară se face la început, înainte de recursie.
* Împărțirea vectorului nu este neapărat în două părți egale, ceea ce duce la o complexitate ''O(N2)'' pe cazul cel mai rău.

Pentru cazul mediu, când împărțirea este în două părți aproximativ egale, rezultă aceeași complexitate ''O(N log N)''.

Câtă memorie suplimentară folosește algoritmul?

Memoria este cea necesară stivei. Ea va fi, deci, proporțională cu cel mai lung lanț de apeluri recursive imbricate. Pe cazul cel mai rău el este ''O(N)'', iar pe cazul mediu este ''O(log N)''.

'''Optimizare:''' putem reduce cazul cel mai rău astfel:

* Observăm că al doilea apel recursiv este recursiv la coadă.
* Precum știm, el nu va consuma memorie.
* Putem reduce memoria stivei apelând mai întâi pentru partea mai mică ce rezultă după pivotare.

În acest fel chiar și în cazul cel mai rău memoria suplimentară necesară va fi ''O(log N)''.

În concluzie avem complexitățile:

* timp: ''O(N log N)''
* memorie suplimentară: ''O(log N)''

'''Atenție:''' deși putem selecta ca pivot orice element din vector, nu putem selecta ca pivot ultimul element. Aceasta ar duce la o buclă infinită.

=== Pivotarea Lomuto ===

În școli, de multe ori se predă un alt algoritm de pivotare, probabil deoarece este considerat mai simplu. Nu o vom discuta aici, deoarece este foarte ineficientă. Iată diferențele față de pivotarea Hoare:

* Lomuto este ceva mai simplu de reținut și ceva mai scurtă.
* Ambii algoritmi sunt cache friendly deoarece parcurg liniar vectorul.
* Lomuto face de trei ori mai multe interschimburi.
* Lomuto face ''O(N2)'' operații pe un vector sortat, Hoare doar ''O(N log N)''.
* Lomuto face ''O(N2)'' operații pe un vector cu elemente egale, Hoare doar ''O(N log N)''.

'''Concluzie''': Pivotarea Lomuto este un algoritm didactic, bun pentru înțelegerea pivotării, dar este contraindicat într-o implementare practică.

''' Randomizarea pivotului '''

Dacă alegem ca pivot prima poziție din vector, sau cea din mijloc, ''adversarul'' poate, studiind algoritmul, să găsească un vector special pe care implementarea noastră să intre pe cazul cel mai rău, ''O(N2)''. Putem lupta cu aceasta, alegând pivotul pe o poziție aleatoare din intervalul <code>[begin..end-1]</code>.

''' Probleme quicksort '''

'''Atenție!''' Algoritmul este celebru pentru bug-urile pe care le putem introduce la implementare. Un semn mai mic transformat în mai mic sau egal poate duce la bucle infinite sau la un vector nesortat.

'''Soluție''': pentru olimpiadă este bine să memorați algoritmul pe din-afară.

Ați putea spune ''hei, dar la olimpiadă pot folosi algorithms!'' Este opțiunea voastră, dar eu nu aș risca. Motivele împotriva folosirii funcției de sortare de bibliotecă:

* Ea primește ca parametru o funcție de comparație. Apelul acelei funcții este lent, fiind vorba de accesul unui pointer pentru a obține adresa funcției, apoi de punerea pe stivă a parametrilor. Toate acestea se reduc la o comparație sau două în codul nostru.
* Funcția de bibliotecă este o cutie neagră. Ea depinde de compilator și de biblioteca de funcții a acestuia. Ea este scrisă de alți oameni. Aveți mai multă încredere în cod scris de alții, care variază în funcție de calculatorul pe care se face evaluarea?
* În mod uzual funcțiile de bibliotecă consumă mai multă memorie, iar uneori mult mai multă. De ce? Bună întrebare. Nu știu.
* Algoritmul de mai sus are 23 de linii de cod efectiv. El este simplu și eficient și poate fi adaptat să sorteze orice tip de date, cu mici modificări. De ce am risca să apelăm o funcție de bibliotecă despre care nu știm nimic, când în 3 minute am scris acest cod?

=== Ziua regelui ===

Un rege organizează o petrecere mare de ziua lui. Petrecerea începe peste 24 de ore. Regele află că una din cele 1000 de sticle de vin pe care le va servi este otrăvită. Otrava acționează ciudat: omul care bea chiar și cea mai mică cantitate din această otravă nu are nici un simptom vreme de 24 de ore, apoi moare subit. Regele are sclavi la dispoziție pe care îi poate folosi. Lui nu îi pasă câți sclavi mor, dar îi pasă câți sclavi beau vin, deoarece un sclav care a băut vin nu poate fi folosit la treabă, ci trebuie izolat spre observare. Care este numărul minim de sclavi cu care regele poate afla sticla otrăvită?

== Tema 18 ==

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

* [https://www.nerdarena.ro/problema/latin Latin] dată la cercul de informatică Vianu, gimnaziu 2013
* [https://www.nerdarena.ro/problema/pav Pav] dată la Lot IS 2008
* [https://www.nerdarena.ro/problema/forma Forma] dată la olimpiada pe sector 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/z ZParcurgere]
* [https://www.nerdarena.ro/problema/tabela Tabela]
* [https://www.nerdarena.ro/problema/antitir AntiTir] dată la Shumen 2012
* [https://www.nerdarena.ro/problema/hanoi1 Hanoi1]

Clasa a VII-a lecția 6 - 17 oct 2019

2026-02-07T10:13:53Z

Cristian:

= Tema - rezolvări =
== Intervale ==
Problema [http://varena.ro/problema/intervale intervale] este o problemă de precalculare. Ea cere să se răspundă la maxim 100 000 de întrebări de forma "cîte numere naturale cu exact ''K'' divizori primi se află în intervalul ''[A, B]''".

=== Comentarii generale ===
* Mențiuni speciale lui '''Mircea Rebengiuc''' și '''Teo Tatomir''', singurii care a reușit o soluție optimă, ce folosește două precalculări și liste!
* Felicitări celor ce au reușit o soluție foarte bună și ordonată: '''Tudor Voicu''', '''Fares''', '''Ilie''', '''Petrescu''', '''Rebengiuc''', '''Tatomir'''.
* Încă nu știți ''fscanf'', rău! Majoritatea ați avut probleme la citire, dar v-ați descurcat cu o complicație.
* Mulți dintre voi ați declarat vectorul ciur de întregi. El putea fi de caractere. Este o risipă de 3MB de memorie, vă poate duce la 0p la problemă la olimpiadă. Mare atenție!
* Mulți dintre voi ați risipit 14% din memorie, un milion de întregi = 4MB. Cum? Memorînd un vector de sume parțiale cu elemente 1, pentru ''K=0''. Nice :-)
* Unii dintre voi ați dat o rezolvare ineficientă, răspunzînd la întrebări prin parcurgerea ciurului de la ''A'' la ''B''. Era clar că o asemenea soluție va depăși timpul. Trebuia să folosiți sume parțiale, precalculare, pentru a răspunde la întrebări în ''O(1)''.

=== Comentarii individuale ===
==== Prima grupă ====
* '''Aizic''': Program foarte bun, bravo! Observații minore: puteai să faci citirea cu un singur ''fscanf'', citind trei valori și întrebînd dacă valoarea de return este 3. Doi, ai folosit o linie a matricei pentru ''K=0'', cînd doar 1 va avea 0 divizori. Ai risipit 14% din memorie stocînd un vector cu unu-uri.
* '''Badea''': Program foarte bun, bravo! Observații minore: puteai să faci citirea cu un singur ''fscanf'', citind trei valori și întrebînd dacă valoarea de return este 3. Doi, ai folosit o linie a matricei pentru ''K=0'', cînd doar 1 va avea 0 divizori. Ai risipit 14% din memorie stocînd un vector cu unu-uri.
* '''Benescu''': Program foarte bun, bravo! Observație importantă: ciurul putea fi de tip caracter, dar tu ai folosit tip întreg! Atenție la genul acesta de erori, te pot descalifica! Observații minore: puteai să faci citirea cu un singur ''fscanf'', citind trei valori și întrebînd dacă valoarea de return este 3. Doi, ai folosit o linie a matricei pentru ''K=0'', cînd doar 1 va avea 0 divizori. Ai risipit 14% din memorie stocînd un vector cu unu-uri.
* '''Burac''': Program foarte bun, bravo! Observații minore: puteai să faci citirea cu un singur ''fscanf'', citind trei valori și întrebînd dacă valoarea de return este 3. Doi, ai folosit o linie a matricei pentru ''K=0'', cînd doar 1 va avea 0 divizori. Ai risipit 14% din memorie stocînd un vector cu unu-uri.
* '''Calotă''': Program foarte bun, bravo! Observație importantă: ciurul putea fi de tip caracter, dar tu ai folosit tip întreg! Atenție la genul acesta de erori, te pot descalifica la olimpiadă! Observații minore: puteai să faci citirea cu un singur ''fscanf'', citind trei valori și întrebînd dacă valoarea de return este 3. Doi, ai folosit o linie a matricei pentru ''K=0'', cînd doar 1 va avea 0 divizori. Ai risipit 14% din memorie stocînd un vector cu unu-uri.
* '''Chivu''': Ideea programului tău este foarte interesantă: memorezi întrebările pe liste după ''K''. Pînă aici este foarte bine, deoarece folosești puțină memorie. Dar apoi ai o greșeală, nu observi că ''K'' este, în fapt, limitat la 7. Valoarea 1000 este aruncată la păcăleală. Atenție la matematică! Dar asta nu e grav, deoarece nu afectează algoritmul, doar ocupi ceva mai multă memorie în vectorul de liste. Algoritmul tău este ceva mai lent deoarece faci o căutare liniară în liste pentru fiecare element al ciurului. Trebuia să faci invers, să parcurgi listele și să răspunzi la întrebări în ''O(1)''. Pentru aceasta aveai nevoie de sume parțiale pe vectorul ciur. Vezi soluția. Observații: ciurul nu este vector de întregi, ci de caractere! Atenție! puteai să faci citirea cu un singur ''fscanf'', citind trei valori și întrebînd dacă valoarea de return este 3. Vectorii ''a[], b[], r[] și next[]'' au toți aceeași dimensiune, dar tu ai declarat ''a[]'' mult mai mare.
* '''Cojocariu''': Program foarte bun, bravo! Observații minore: puteai să faci citirea cu un singur ''fscanf'', citind trei valori și întrebînd dacă valoarea de return este 3. Doi, ai folosit o linie a matricei pentru ''K=0'', cînd doar 1 va avea 0 divizori. Ai risipit 14% din memorie stocînd un vector cu unu-uri.
* '''Dobre''': Program bun, bravo! Citire corectă și simplă cu ''fscanf'', bravo! Observație importantă: ciurul putea fi de tip caracter, dar tu ai folosit tip întreg! Atenție la genul acesta de erori, te pot descalifica la olimpiadă! Tu nu folosești linia 0 a matricei ''v[]''. Deci risipeși 14% din memorie. Cam urît, nu? Te-ai complicat și la afișare, nu ai de ce să testezi dacă ''ciur[a]==k''. În sumele parțiale scădem elementul din-naintea capătului de interval, adică ''v[k][a-1]''. Motivul pentru care ratezi un test este pentru că te oprești cu calculul sumelor parțiale la ''BMAX-1''. Trebuia să mergi pînă la ''BMAX'' inclusiv! Atenție la neatenție, te costă!
* '''Hossu''': Programul este OK ca idee, dar, precum ți-ai dat seama, are complexitate prea mare. Pentru a răspunde la o întrebare parcurgi ciurul de la ''a'' la ''b'', complexitate ''O(MAXB)'', adică circa un milion. Trebuia să folosești sume parțiale pentru a răspunde la întrebări în ''O(1)''. Citire corectă și simplă cu ''fscanf'', bravo! Observație importantă: ciurul putea fi de tip caracter, dar tu ai folosit tip întreg! Atenție la genul acesta de erori, te pot descalifica la olimpiadă!
* '''Iordache''': Program foarte bun, bravo! Observații minore: puteai să faci citirea cu un singur ''fscanf'', fără ''feof()'', care este periculos de folosit (de aceea nici nu l-am predat). Citeai trei valori și întrebai dacă valoarea de return este 3. Doi, ai folosit o linie a matricei pentru ''K=0'', cînd doar 1 va avea 0 divizori. Ai risipit 14% din memorie stocînd un vector cu unu-uri.
* '''Mocanu''': Program foarte bun, bravo! Observații minore: puteai să faci citirea cu un singur ''fscanf'', fără ''feof()'', care este periculos de folosit (de aceea nici nu l-am predat). Citeai trei valori și întrebai dacă valoarea de return este 3. Doi, ai folosit o linie a matricei pentru ''K=0'', cînd doar 1 va avea 0 divizori. Ai risipit 14% din memorie stocînd un vector cu unu-uri.
* '''Mușat''': Program bun, păcat că dimensionezi greșit matricea de sume parțiale. Interesant că iei 100p. ''K'' poate fi maxim 1000, iar tu ai dimensionat matricea de 9 elemente, deci ieși cu mult afară din ea. Observație importantă: ciurul putea fi de tip caracter, dar tu ai folosit tip întreg! Atenție la genul acesta de erori, te pot descalifica la olimpiadă! Puteai să faci citirea cu un singur ''fscanf'', citind trei valori și întrebînd dacă valoarea de return este 3.
* '''Nicola''': Program foarte bun, bravo! Observații minore: ai folosit o linie a matricei pentru ''K=0'', cînd doar 1 va avea 0 divizori. Ai risipit 14% din memorie stocînd un vector cu unu-uri. Observație majoră: programul nu funcționează corect deoarece ciurul se oprește la ''i * i <= n''. Trebuia să mergi pînă la ''n''.
* '''Petcu''': Program foarte bun, bravo! Observație minoră: ai folosit o linie a matricei pentru ''K=0'', cînd doar 1 va avea 0 divizori. Ai risipit 14% din memorie stocînd un vector cu unu-uri. Observație majoră: numărul maxim de divizori este 7, nu 9! Matematica!
* '''Ștefănescu''': Program bun, bravo! Observații minore: te-ai complicat cu citirea. Puteai să faci citirea cu un singur ''fscanf'', citind trei valori și întrebînd dacă valoarea de return este 3. Doi, ai folosit o linie a matricei pentru ''K=0'', cînd doar 1 va avea 0 divizori. Ai risipit 14% din memorie stocînd un vector cu unu-uri. Observație majoră: programul nu funcționează corect deoarece ciurul se oprește la ''d*d<=1000000''. Trebuia să mergi pînă la ''d<=1000000''.
* '''Togan''': Program foarte bun, bravo! Citire corectă și simplă cu ''fscanf'', bravo! Observație minoră: ai folosit o linie a matricei pentru ''K=0'', cînd doar 1 va avea 0 divizori. Ai risipit 14% din memorie stocînd un vector cu unu-uri. Observație majoră: la final, la afișări, testezi ''k<9'', în vreme ce peste tot în restul programului ai ''k<8''. De mirare că nu pierzi puncte! Folosește constante pentru ca nu te mai încurca!
* '''Voicu''': Program foarte bun, bravo!

==== A doua grupă ====
* '''Asgari''': Program foarte bun, bravo! Observații minore: citirea cu ''fgetc()'' e o idee bună, pentru viteză. Dar e ineficientă. Pe de o parte folosești ''isdigit()'' pentru viteză, pe de altă parte testezi în buclă dacă dai de EOF. Există și o funcție ''isspace()'' pentru a sări peste caractere spațiu și \n. Doi, ai folosit o linie a matricei pentru ''K=0'', cînd doar 1 va avea 0 divizori. Ai risipit 14% din memorie stocînd un vector cu unu-uri. De ce ai mai rezolvat separat intervale, dacă ai rezolvat reginald?
* '''Cadîr''': Nu închizi fișiere! Foarte urît! Observație importantă: ciurul putea fi de tip caracter, dar tu ai folosit tip întreg! Atenție la genul acesta de erori, te pot descalifica la olimpiadă! Programul este OK ca idee, dar, precum ți-ai dat seama, are complexitate prea mare. Pentru a răspunde la o întrebare parcurgi ciurul de la ''a'' la ''b'', complexitate ''O(MAXB)'', adică circa un milion. Trebuia să folosești sume parțiale pentru a răspunde la întrebări în ''O(1)''.
* '''Dimulescu''': Indentarea e bună, variabilele au denumiri bune, bravo, bun! Observații importante: ciurul putea fi de tip caracter, dar tu ai folosit tip întreg! Atenție la genul acesta de erori, te pot descalifica la olimpiadă! Doi, calculezi ciurul pînă la 500 000. Trebuia să îl calculezi pînă la 1 000 000. Programul este OK ca idee, dar, precum ți-ai dat seama, are complexitate prea mare. Pentru a răspunde la o întrebare parcurgi ciurul de la ''a'' la ''b'', complexitate ''O(MAXB)'', adică circa un milion. Trebuia să folosești sume parțiale pentru a răspunde la întrebări în ''O(1)''.
* '''Fares''': Program foarte bun, bravo! Ai folosit soluția de la reginald ;-) Observații minore: puteai să faci citirea cu un singur ''fscanf'', citind trei valori și întrebînd dacă valoarea de return este 3.
* '''Ghica''': Program foarte bun, bravo! Citire corectă și simplă cu ''fscanf'', bravo! Atenție, nu închizi fișierul output! Numărul maxim de divizori este 7, nu 9, atenție la dimensionări! Atenție, ''k'' este maxim 1000! Indicele va depăși matricea ''v[][]''! De mirare că ai luat 100p. Trebuia să testezi dacă valoarea lui ''k'' depășește 9, caz în care răspundeai cu 0.
* '''Grecu''': Program foarte bun, bravo! Observație importantă: ciurul putea fi de tip caracter, dar tu ai folosit tip întreg! Atenție la genul acesta de erori, te pot descalifica la olimpiadă! Doi, ai folosit o linie a matricei pentru ''K=0'', cînd doar 1 va avea 0 divizori. Ai risipit 14% din memorie stocînd un vector cu unu-uri.
* '''Ilie''': Program foarte bun, bravo! Ai folosit soluția de la reginald ;-)
* '''Ipate''': Program foarte bun, bravo! Nu închizi fișiere! Ne supărăm! Ai folosit o linie a matricei pentru ''K=0'', cînd doar 1 va avea 0 divizori. Ai risipit 14% din memorie stocînd un vector cu unu-uri.
* '''Marcu''': Observații importante: ciurul putea fi de tip caracter, dar tu ai folosit tip întreg! Atenție la genul acesta de erori, te pot descalifica la olimpiadă! Programul este OK ca idee, dar, precum ți-ai dat seama, are complexitate prea mare. Pentru a răspunde la o întrebare parcurgi ciurul de la ''a'' la ''b'', complexitate ''O(MAXB)'', adică circa un milion. Trebuia să folosești sume parțiale pentru a răspunde la întrebări în ''O(1)''.
* '''Moroșan''': Soluție forță brută, care nu folosește nici ciurul lui Eratostene, nici sume parțiale pe vector. În plus, nici nu este corectă.
* '''Nicu''': Program foarte bun, bravo! Observație minoră: ai folosit o linie a matricei pentru ''K=0'', cînd doar 1 va avea 0 divizori. Ai risipit 14% din memorie stocînd un vector cu unu-uri.
* '''Petrescu''': Program foarte bun, bravo! Observație minoră: puteai să faci citirea cu un singur ''fscanf'', citind trei valori și întrebînd dacă valoarea de return este EOF, sau 3.
* '''Popescu''': <strike>Te rog nu trimite soluții la arhivă! Atenție!</strike> ''(le-ai trimis înainte să înceapă tema, nu ești un bun oracol, nu prevezi viitorul - sau îl prevezi prea bine :-)'' Program foarte bun, bravo! Ai folosit o linie a matricei pentru ''K=0'', cînd doar 1 va avea 0 divizori (așa cum ai și testat în program). Ai risipit 14% din memorie stocînd un vector cu zerouri.
* '''Rebengiuc''': Rezolvare excepțională, bravo! Optimă, folosind rezolvarea de la reginald. Atenție la readInt(). Dacă vrei să fii eficient trebuie să folosești ''isdigit()'', iar, în cazul acesta și ''isspace()''.
* '''Rughiniș''': Observație importantă: ciurul putea fi de tip caracter, dar tu ai folosit tip întreg! Atenție la genul acesta de erori, te pot descalifica la olimpiadă! Programul este OK ca idee, dar, precum ți-ai dat seama, are complexitate prea mare. Pentru a răspunde la o întrebare parcurgi ciurul de la ''a'' la ''b'', complexitate ''O(MAXB)'', adică circa un milion. Trebuia să folosești sume parțiale pentru a răspunde la întrebări în ''O(1)''. Măcar dacă programul ar fi funcționat...
* '''Stancu''': Soluție care nu folosește ciurul lui Eratostene decît pentru calculul numerelor prime, nu pentru calculul numărului de divizori primi. Nu folosește nici sume parțiale pe vector. David, tu poți mai mult de atît, dă-ți te rog silința. Rezolvarea asta nu îți face cinste.
* '''Tatomir''': Rezolvare excepțională, bravo! Optimă, folosind soluția de la Reginald. Te-ai chinuit puțin la citire, recapitulează ''fscanf()''. Vezi ce înseamnă să nu folosești constante? Ai modificat una din limite, dar nu și a doua, numărul de întrebări nu este un milion, ci 100 000.
* '''Teodorescu''': Program foarte bun, bravo! Citire corectă și simplă cu ''fscanf'', bravo! Observație importantă: ciurul putea fi de tip caracter, dar tu ai folosit tip întreg! Atenție la genul acesta de erori, te pot descalifica la olimpiadă! Ai folosit o linie a matricei pentru ''K=0'', cînd doar 1 va avea 0 divizori. Ai risipit 14% din memorie stocînd un vector cu unu-uri.
* '''Voicu''': Program bun, bravo! Îmi place că te gîndești la optimizări. Dar înainte să te apuci de ele, ce-ar fi să optimizezi lucrurile simple? Cum ar fi faptul că ciurul este un vector de elemente caracter, nu întregi! Sau cum ar fi faptul că tu folosești o matrice cu o linie în plus: linia zero nu este folosită. Asta duce la o risipă de memorie de 14%! Ideea de memoizare, calcul la cerere, nu e rea! Te-ai complicat la calculul diferențelor de sume parțiale, ai scris:
<syntaxhighlight lang="C" line>
_included=0;
if(part[k][a]!=part[k][a-1])
_included=1;///astfel, a se include in [a,b]
fprintf(out,"%d\n",_included+part[k][b]-part[k][a]);
</syntaxhighlight>

Dacă ai fi scris cum am învățat la oră, era deajuns să scrii:

<syntaxhighlight lang="C" line>
fprintf(out,"%d\n", part[k][b]-part[k][a-1]);
</syntaxhighlight>
Mihai, încearcă să aplici întîi cunoștințele de bază. Nu te complica. Abia la final optimizezi.

== Pătrate1 ==
Problema [http://varena.ro/problema/patrate1 pătrate1] de la vianuarena cere ca, dîndu-se o matrice pătrată de latură maxim 200 cu elemente 0 și 1, să se calculeze numărul de submatrice pătrate pline cu elemente 1.

=== Comentarii generale ===
* Avertismente: '''Cadîr''' (nici o sursă).

== Extratereștri ==
=== Comentarii generale ===
* Avertismente: '''Nicola''' (nici o sursă).

= Tema opțională - rezolvări =
== Reginald ==
Problema [http://varena.ro/problema/reginald Reginald] este exact problema [http://varena.ro/problema/intervale intervale], cu mai puţină memorie disponibilă. Mai exact, nu mai putem stoca matricea de sume parțiale. Capetele intervalelor sînt maxim 4 milioane în loc de 1 milion, iar numărul de întrebări este 1 milion în loc de 100 000.

== Flori 1 ==
Problema [http://varena.ro/problema/flori1 flori 1] este intenţionată ca o continuare a problemei [http://varena.ro/problema/flori flori], în care memoria a fost restricţionată drastic, de la 16MB la 2.5MB.

= Tema opțională de gîndire - discuții =
Am discutat idei pentru cele două probleme de gîndire.

Rezolvări aici [http://solpedia.francu.com/wiki/index.php/Clasa_a_VII-a_lec%C8%9Bia_5_-_10_oct_2019]

= Lecție: recursivitate =

<html5media height="720" width="1280">https://www.algopedia.ro/video/2019-2020/2019-10-17-clasa-7-lectie-info-06-720p.mp4</html5media>

O funcție este recursivă dacă se autoapelează. A scrie o funcție recursivă necesită, inițial, o încredere în faptul că funcția funcționează. În fapt, cînd pornim să scriem o funcție recursivă este bine să considerăm că ea deja funcționează!

Reguli de scriere a unei funcții recursive:
* Înainte de a scrie cod este bine să ne clarificăm formula recurentă.
* Tratăm mai întîi cazurile simple, atunci cînd funcția poate returna o valoare fără a se autoapela.
* În final tratăm cazul de recursie, considerînd că funcția este deja scrisă pentru cazurile "mai mici", folosindu-ne de formula recurentă găsită la început.

== Exemple introductive ==
=== Factorial ===
Calcul n! Ne vom folosi de definiția recursivă: <math>n! = \begin{cases} 1, & \mbox{dacă } n = 1 \\ n \cdot (n - 1)!, & \mbox{dacă } n > 1. \end{cases}</math>

<syntaxhighlight lang="C" line>int fact( int n ) {
if ( n == 1 )
return 1;
return n * fact( n - 1 );
}</syntaxhighlight>

=== Putere ===
Calcul an. Ne vom folosi de definiția recurentă: <math>a^{n} = \begin{cases} 1, & \mbox{dacă } n = 0 \\ a \cdot a^{n-1}, & \mbox{dacă } n > 0. \end{cases}</math>

<syntaxhighlight lang="C" line>int putere( int a, int n ) {
if ( n == 0 )
return 1;
return a * putere( a, n - 1 );
}</syntaxhighlight>

=== Cmmdc ===
Calcul cmmdc a două numere. Ne vom folosi de definiția recursivă a lui Euclid: <math>cmmdc(a, b) = \begin{cases} a, & \mbox{dacă } b = 0 \\ cmmdc(b, a \bmod b), & \mbox{dacă } b > 0. \end{cases}</math>

<syntaxhighlight lang="C" line>int cmmdc( int a, int b ) {
if ( b == 0 )
return a;
return cmmdc( b, a % b );
}</syntaxhighlight>

== Exerciții ==
Încercați în clasă să scrieți următoarele funcții recursive.
=== Fibonacci ===
Să se scrie o funcție recursivă care, dat <tt>n</tt>, calculează al <tt>n</tt>-lea termen din șirul lui Fibonacci: <tt>0 1 1 2 3 5 8 13...</tt>. Ne vom folosi de definiția recurentă: <math>fib(n) = \begin{cases} 0, & \mbox{dacă } n = 1 \\ 1, & \mbox{dacă } n = 2 \\ fib(n-1) + fib(n-2), & \mbox{dacă } n > 2. \end{cases}</math>

<syntaxhighlight lang="C" line>int fib( int n ) {
if ( n == 1 )
return 0;
if ( n == 2 )
return 1;
return fib( n - 1 ) + fib ( n - 2 );
}</syntaxhighlight>

=== Suma cifrelor unui număr ===
Să se scrie o funcție recursivă care calculează suma cifrelor unui număr <tt>n</tt>.

Ne vom folosi de următoarea formulă recurentă: <math>suma(n) = \begin{cases} 0, & \mbox{dacă } n = 0 \\ n % 10 + suma(n / 10), & \mbox{dacă } n > 0. \end{cases}</math>

<syntaxhighlight lang="C" line>int sumac( int n ) {
if ( n == 0 )
return 0;
return n % 10 + sumac( n / 10 );
}</syntaxhighlight>

=== Putere în O(log n) ===
Calculați <tt>an</tt> în mod cît mai eficient (a și n numere naturale). Problema este cunoscută şi sub numele de ridicare la putere în timp logaritmic. Ideea din spatele acestei rezolvări este următoarea:

*Dacă <tt>n</tt> este par, atunci <tt>an = a2*n/2 = (a2)n/2</tt>
*Dacă <tt>n</tt> este impar, atunci <tt>n-1</tt> este par și avem <tt>an = a * an-1 = a * a2*(n-1)/2 = a * (a2)(n-1)/2 = a * (a2)n/2</tt>

Rezultă formula de recurență:

<math>a^{n} = \begin{cases} 1, & \mbox{dacă } n = 0 \\ {(a^{2})}^{n/2}, & \mbox{dacă } n >0, n % 2 = 0 \\ a \times {(a^{2})}^{n/2}, & \mbox{dacă } n > 0, n % 2 = 1 \end{cases}</math>

În formulele de mai sus am considerat că <tt>/</tt> este împărțirea întreagă din limbajul C. Se observă că indiferent de paritatea lui <tt>n</tt>, la fiecare pas al iterației putem transforma <tt>a</tt> în <tt>a * a</tt> și apoi putem împărți <tt>n</tt> la <tt>2</tt>. Doar în cazurile cînd <tt>n</tt> este impar vom acumula valoarea curentă a lui <tt>a</tt> la produsul calculat. Iată soluția bazată pe această idee:

<syntaxhighlight lang="C" line>int putere( int a, int n ) {
int p;

if ( n == 0 )
return 1;
p = putere( a * a, n / 2 );
if ( n % 2 ) // n impar?
p *= a;

return p;
}</syntaxhighlight>

=== Afișare ===
Să se afișeze un șir de caractere în ordine inversă. Șirul se termină cu <tt>'\n'</tt>.

Ne vom folosi de următoarea idee: citim un caracter, apoi chemăm funcția recursivă pentru a afișa restul caracterelor, apoi afișăm caracterul.

<syntaxhighlight lang="C" line>void afisare( FILE *fin, FILE *fout ) {
char ch;

ch = fgetc( fin );
if ( ch != '\n' ) {
afisare( fin, fout );
fputc( ch, fout );
}
}</syntaxhighlight>

=== Descompunere în baza 2 ===
Să se scrie o funcție recursivă care, dat <tt>n</tt>, îl afișează în baza 2.

Similar cu exercițiul precedent, vom calcula ultima cifră a descompunerii (restul împărțirii la doi), apoi vom chema funcția cu <tt>n / 2</tt>, iar la revenire vom afișa cifra.

<syntaxhighlight lang="C" line>void baza2( int n, FILE *fout ) {
int cf2;

if ( n > 0 ) {
cf2 = n % 2;
baza2( n / 2, fout );
fprintf( fout, "%d", cf2 );
}
}</syntaxhighlight>

=== Interclasare vectori ordonați ===
Dîndu-se doi vectori ordonați să se calculeze un al treilea vector ordonat ce conține elementele lor.

Funcția va primi ca parametri cei trei vectori și pozițiile curente în ei (inițial pozițiile de start, 0). La fiecare apel va alege un element pe care îl va copia. Apoi se va reapela cu indici actualizați (i1 și i3 sau i2 și i3).

<syntaxhighlight lang="C" line>void interclaseaza( int n1, int v1[], int n2, int v2[], int v3[],
int i1, int i2, int i3 ) {
if ( i1 < n1 ) { // mai avem elemente in primul vector?
if ( i2 < n2 && v2[i2] < v1[i1] ) { // v2[i2] exista si e mai mic?
v3[i3] = v2[i2]; // copiem v2[i1]
interclaseaza( n1, v1, n2, v2, v3, i1, i2 + 1, i3 + 1 );
} else {
v3[i3] = v1[i1]; // copiem v1[i1]
interclaseaza( n1, v1, n2, v2, v3, i1 + 1, i2, i3 + 1 );
}
} else if ( i2 < n2 ) { // mai avem elemente in v2? (v1 s-a terminat)
v3[i3] = v2[i2];
interclaseaza( n1, v1, n2, v2, v3, i1, i2 + 1, i3 + 1 );
}
}</syntaxhighlight>

= Temă =
* [http://varena.ro/runda/2019-10-17-clasa-7-tema-6 Tema 6 clasa a 7a]:
** [http://varena.ro/problema/sumacfnr sumacfnr]: să se scrie o funcție recursivă care să calculeze suma cifrelor unui număr.
** [http://varena.ro/problema/sumadiv sumadiv]: să se scrie o funcție recursivă care să calculeze suma divizorilor unui număr. Ea va arăta astfel: <pre>int sumd( int n, int d ) {
 ...
}</pre> și va fi apelată inițial astfel: <pre>sum = sumd( n, 1 );</pre> Semnificaţia este ''suma divizorilor lui n care sînt mai mari sau egali cu d şi mai mici sau egali cu n / d''. Mai exact trebuie să completați funcția <tt>sumd</tt> din programul următor:<pre>#include <stdio.h>

int sumd( int n, int d ) {
 ...
}

int main() {
 FILE *fin, *fout;
 int n;

 fin = fopen( "sumadiv.in", "r" );
 fscanf( fin, "%d", &n );
 fclose( fin );

 fout = fopen( "sumadiv.out", "w" );
 fprintf( fout, "%d\n", sumd( n, 1 ) );
 fclose( fout );

 return 0;
}</pre> Atenţie mare la complexitatea algoritmului obţinut!
** [http://varena.ro/problema/nset nset]: să se scrie o un program care să calculeze numărul de cifre distincte ale unui număr, folosind recursivitate.
** [http://varena.ro/problema/invector invector] să se răstoarne un vector folosind o funcție recursivă. Vectorul trebuie modificat, nu doar afișat invers. Funcția va arăta astfel: <pre>void inv( int primul, int ultimul, int v[] ) {
 ...
}</pre> unde <tt>primul</tt> și <tt>ultimul</tt> sînt indicii de început, respecitiv sfîrșit care definesc subvectorul de răsturnat. Funcția va fi apelată inițial astfel: <pre>inv( 0, n-1, v );</pre> Mai exact trebuie să completați funcția <tt>inv</tt> din programul următor: <pre>#include <stdio.h>

int v[100000];

void inv( int primul, int ultimul, int v[] ) {
 ...
}

int main() {
 FILE *fin, *fout;
 int n, i;

 fin = fopen( "invector.in", "r" );
 fscanf( fin, "%d", &n );
 for ( i = 0; i < n; i++ )
 fscanf( fin, "%d", &v[i] );
 fclose( fin );

 inv( 0, n-1, v );

 fout = fopen( "invector.out", "w" );
 for ( i = 0; i < n; i++ )
 fprintf( fout, "%d ", v[i] );
 fprintf( fout, "\n" );
 fclose( fout );

 return 0;
}</pre>
** [http://varena.ro/problema/hanoi turnurile din Hanoi]: [http://www.puzzle.ro/ro/play_toh.htm exemplu de animație joc aici] să se scrie un program care să rezolve jocul turnurile din Hanoi (să efectueze mutările care duc la soluție).

* [http://varena.ro/runda/2019-10-17-clasa-7-tema-6-optionala Tema 6 '''opțională''' clasa a 7a]:
** [http://varena.ro/problema/combinari combinări] <math>{C}_{n}^{k}</math><nowiki>- combinări de n luate cîte k. Date numerele naturale n și k, k ≤ n, să se afișeze toate submulțimile mulțimii {1, 2, 3, ..., n} de k elemente.</nowiki>
** [http://varena.ro/problema/v v] (ONI 2004 clasa a 7-a) Problema este modificată. Puteți lua doar 50% din punctaj. Pentru 100% '''nu este nevoie de parsing'''. Dacă introduceam cerință de parsing aș fi scăzut timpul permis.

Rezolvări aici [http://solpedia.francu.com/wiki/index.php/Clasa_a_VII-a_lec%C8%9Bia_6_-_17_oct_2019]

Clasa a 7-a Lecția 29: Discutarea problemelor de la OJI 2024

2026-02-06T16:59:28Z

Cristian:

== Î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 <code>short</code>, circa 8KB și de un vector de 4000 de perechi de elemente de tip <code>short</code>, 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 <code>n</code> 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. <code>unsigned int</code> 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 27: Algoritmul Union-Find

2026-02-06T16:57:26Z

Cristian:

== Î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, <code>m[i]</code> 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 <code>m[i] = m[j]</code>, în caz contrar <code>m[i] ≠ m[j]</code>.

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

==== 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 <code>m[i]</code>!

<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 <code>m[]</code>) în care elementul <code>sef[i]</code> 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 <code>sef[i] = i</code>. 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 26: Programare dinamică (3)

2026-02-06T16:55:41Z

Cristian:

== Î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 <code>short int</code>, 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 25: Programare dinamică (2)

2026-02-06T16:53:43Z

Cristian:

== Î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 <code>V[i]</code> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă, <code>V[i]</code>. Ea va conține unele din primele <tt>i</tt> obiecte. Ultimul obiect este obiectul <tt>k ≤ i</tt>. Atunci este <code>V[k]</code> optimă?

Nu neapărat! Este posibil să găsim o soluție <code>V[k]</code> cu valoare mai mare, dar pe care să nu o putem folosi în construcția problemei <code>V[i]</code> 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 <code>V[g]</code> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă, <code>V[g]</code>. 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ă <code>V[g]</code> (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 <code>V[i][g]</code> proprietatea de optimalitate a subproblemelor?

Să considerăm o soluție optimă <code>V[i][g]</code>. 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ă, <code>V[i][g]</code>.

'''Concluzie:''' putem folosi programarea dinamică cu această definiție a problemei.

Construim formula de recurență. Pentru a calcula <code>V[i][g]</code> avem două variante:

* Fie nu folosim greutatea <tt>Gi</tt>, caz în care vom obține valoarea <code>V[i-1][g]</code> (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 <code>V[N][G]</code>.

=== 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 <code>V[N][G]</code> ș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 <code>v[]</code>D[m][n]</code> ș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 <code>MAX[i]</code> ca fiind suma tuturor <code>MAX[j]</code> 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 <code>NSOL[N][K]</code>, elementul din colțul din dreapta-jos al matricei <code>NSOL</code>.

==== 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 <code>NSOL[N][S]</code>:

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 <code>NSOL[2][10]</code>.
* Vom calcula câte numere încep cu 2 și au suma cifrelor 11. Vom folosi <code>NSOL[2][9]</code>.
* ...
* Vom calcula câte numere încep cu 5 și au suma cifrelor 11. Vom folosi <code>NSOL[2][6]</code>.

Î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 <code>NSOL[M][N]</code>.

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 24: Programare dinamică (1)

2026-02-06T16:51:45Z

Cristian:

== Î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 <code>L</code> de la coadă la cap, căutând pentru fiecare element <code>L[i]</code> cel mai mare element <code>L[j]</code> de după el <tt>(j > i)</tt> astfel încât <code>V[j] ≥ V[i]</code>.

Soluția problemei este maximul din vectorul <code>L</code>.

=== 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: <code>L[15]</code>, apoi <code>L[14]</code> ș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 <code>V[i] >= V[6]</code>. Dintre ele vom alege poziția unde <code>L[i]</code> este maximă. Astfel vom găsi că <code>V[9] = 9</code> și <code>L[9] = 3</code>. Vom avea, deci, o secvență de lungime 4. Ea este:

6, 9, 11, 15

Exemplu de calcul pentru elementul <code>L[6]</code> - 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, <code>N[]</code>. 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 <code>S</code> calculând pentru fiecare element <code>S[i]</code> maximul dintre <code>S[i-1] + V[i]</code> și <code>V[i]</code>. Observăm că, în realitate, vom compara <code>S[i-1]</code> cu zero.

Soluția problemei este maximul din vectorul <code>S</code>.

=== 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 <code>S[i]</code> cu aceeași semnificație. Acest <code>S[i]</code> se poate calcula cu cunoștințe de nivel mic: sume parțiale. <code>S[i]</code> va fi suma unei secvențe de la <tt>k</tt> la <tt>i</tt>, cu <tt>k ≤ i</tt>. Deci, dacă vom calcula <code>P[]</code>, sumele parțiale pe vector putem spune că <code>S[i] = P[i] - P[k]</code>. Să ne uităm puțin la această expresie: cine variază în ea? <code>P[i]</code> este constant, este suma elementelor până la <tt>i</tt>. Putem varia doar <code>P[k]</code>. Este evident că dorim să alegem un <code>P[k]</code> 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 <code>M</code> 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 <code>M[5][5]</code> 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 <code>M</code> pe linii, folosind formula de recurență.

Soluția problemei este <code>M[n][m]</code>.

=== Exemplu ===

Pentru cele două șiruri de mai sus,

ACDEGIKMPR

și

CMEFPGHRK

Vom calcula o matrice <code>M[10][9]</code> 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 <code>M[m][n]</code> ș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 22: Generarea elementelor combinatoriale prin algoritmi de tip succesor: submulțimi, permutări, combinări, aranjamente, next permutation

2026-02-06T16:49:54Z

Cristian:

== Înregistrare video lecție ==

<youtube height="720" width="1280">https://youtu.be/CVOXXa6i8fs</youtube>

== Permutări ==

Permutările de <code>N</code> elemente sunt definite ca numărul de moduri de a aranja în șir cele <code>N</code> 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 <code>p[1]</code> este 2. Avansăm pe poziția 2, unde <code>p[2]</code> este 5. Avansăm pe poziția 5, unde <code>p[5] = 1</code>, 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. <code>p[3]</code> este 4, avansăm pe poziția 4. <code>p[4]</code> 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 <code>n</code>. 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 <code>1-n</code> 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 <code>i</code> 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 <code>n</code> 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 <code>k</code> se va mări cu unu atunci când cifra de pe poziția <code>k-1</code> 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 <code>k</code> (dinspre dreapta spre stânga) se va reprezenta în baza <code>k!</code>.

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 <code>n</code> cifre este <code>n!</code>.
* Numărul de permutări de <code>n</code> elemente este <code>n!</code>.
* 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 <code>n</code>. Iată un exemplu de program care generează toate codurile în baza factorial pe <code>n</code> 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 <code>n!</code> nu depășește un întreg.

==== Conversie număr de ordine ➔ permutare (unranking) ====

'''Problemă:''' se dă <code>k</code> cuprins între 0 și <code>n! - 1</code>, să se afișeze a <code>ka</code> permutare de <code>n</code> în ordine lexicografică.

'''Soluție:''' vom calcula numărul <code>k</code> în baza factorial cu <code>n</code> 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 <code>k</code> 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 <code>folosit[]</code>, 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 <code>cf</code>-lea 0 în vectorul de frecvență (al <code>cf</code>-lea număr nefolosit).

Ce complexitate are această implementare?

Pentru fiecare cifră putem parcurge maxim <code>n</code> elemente în vectorul de frecvență. Avem <code>n</code> 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 <code>n = 4</code>:

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 <code>n</code>. Să se afișeze numărul ei de ordine (în ordine lexicografică), <code>k</code>, cuprins între 0 și <code>n! - 1</code>.

'''Soluție:''' vom calcula numărul <code>k</code> în baza factorial cu <code>n</code> 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 <code>k = 11</code>.

La implementare nu vom avea nevoie să memorăm cifrele în baza <code>n!</code>. Pe măsură ce le calculăm vom calcula direct <code>k</code>, numărul de ordine dorit.

Ce complexitate are această implementare?

Pentru fiecare cifră putem parcurge maxim <code>n</code> elemente în vectorul de frecvență. Avem <code>n</code> 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 <code>n = 4</code>:

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:

* <code>n</code> 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 <code>k</code> permutări. O generare execută ''O(n2)'' operații. Complexitatea totală va fi, deci, ''O(k·n2)''. Deoarece <code>k</code> 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 <code>n</code> 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 <code>t!</code> 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 <code>k</code> (cu <code>k</code> 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 <code>n</code>), 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 <code>n-1</code>), 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 <code>n-2</code>), 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 <code>i</code> să poată fi mărit este să putem adăuga după el <code>k-i</code> elemente. Pentru aceasta pe poziția <code>i</code> putem pune ca element maxim valoarea <code>n - (k - i) = n -k + i</code>. 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 21: Cozi duble și maximul în fereastră glisantă

2026-02-06T16:44:08Z

Cristian:

== 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, <code>primul</code> și <code>ultimul</code>.

* 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 <code>primul</code> și <code>ultim</code>.

''' 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 <code>n – k + 1</code> subsecvențe de <code>k</code> numere consecutive în șir (denumite și ''ferestre'' de lungime <code>k</code>). Putem vedea aceste ferestre ca pe o singură fereastră, deplasabilă, care ne dă acces la <code>k</code> 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 <code>k-1</code>. 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:

* <code>n</code> este numărul de elemente citit la intrare.
* <code>k</code> este mărimea ferestrei glisante.
* <code>deq[]</code> este coada dublă ce memorează <code>k</code> elemente, dar va fi dimensionată la următoarea putere a lui 2.
* <code>rasp[]</code> este vectorul de răspunsuri, dar care este folosit și la stocarea elementelor de la intrare, pentru a ști ce iese din fereastră; <code>rasp[]</code> este maximul din fereastra ce începe la poziția <code>i</code>.

<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 <code>k</code> 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]

Clasa a 7-a Lecția 19: Cozi și algoritmul lui Lee

2026-02-06T16:42:00Z

Cristian:

== Înregistrare video lecție ==

<youtube height="720" width="1280">https://youtu.be/nja4_LDg9Xk</youtube>

== Tipul coadă ==

Coada (în engleză queue) este o ''grămadă'' de obiecte ordonate după ordinea '''FIFO''': ''first in, first out''. Aceasta înseamnă că putem adăuga obiecte în coadă, iar atunci când le vom scoate, le vom scoate în aceeași ordine în care le-am adăugat. Ne aducem aminte că, prin contrast, stiva scoate obiectele în ordine inversă față de cum au fost adăugate (ordine '''LIFO''').

=== Coada ca tip de date abstract ===

Ne aducem aminte despre ideea de tip de date abstract: ''un tip de date abstract'' este un model matematic. Acest model definește operații asupra tipului de date, precum și restricții asupra efectului acestor operații. Tipurile de date abstracte sunt utile în simplificarea algoritmilor, deoarece descompun problema în subprobleme mai mici, cunoscute și studiate.

Tipul de date abstract coadă definește operațiile:

* ''enqueue'', care adaugă un element la coadă
* ''dequeue'', care scoate un element din coadă
* ''empty'', care ne spune dacă coada este goală
* ''full'', care ne spune dacă coada este plină

Restricțiile sunt asupra ordinii de returnare a elementelor și anume ele trebuie returnate după regula ''primul venit primul plecat''. De aceea se spune că o coadă este o structură de tip '''FIFO''' (''first in, first out'').

[[Image:coada.gif|frame|none|Coada ca tip abstract de date]]

=== Implementarea cozilor cu vectori circulari ===

Precum am mai spus, tipurile de date abstracte separă funcționalitatea de implementare. În cazul cozii există mai multe implementări posibile. Noi vom studia una dintre cele mai folosite: implementarea cu vectori circulari. Această implementare:

* Folosește un vector pentru a păstra elementele și doi indici, primul și ultimul care memorează poziția primului, respectiv ultimului element din coadă. Pentru a nu deplasa elemente atunci când scoatem un element din coadă vom incrementa doar poziția primului element. Atunci când adăugăm un element în coadă incrementăm poziția ultimului element.
* Pentru a refolosi golurile rămase în urmă la scoaterea din coadă și a nu deplasa cei doi indici la infinit vom defini o mărime maximă a cozii, n. Atunci când unul din indici depășește această mărime el revine la zero. Logic vorbind după ultimul element din vector urmează din nou primul. De aceea spunem că vectorul este circular. Formula de actualizare a indicilor devine <code>primul = (primul + 1) % n</code> și <code>ultimul = (ultimul + 1) % n</code>, unde <code>n</code> este numărul maxim de elemente din coadă.

[[Image:coada-vector-circular.gif|frame|none|Implementare coadă cu vector circular]]

* Observăm că primul este poziția primului element din coadă, iar ultimul este poziția primului element liber din vector.
* Coadă goală. Cum răspundem la întrebarea ''este coada goală''? Se observă că acest lucru se întâmplă când primul == ultimul.
* Coada plină. Cum răspundem la întrebarea ''este coada plină''? Observăm că aceasta se întâmplă tot atunci când primul == ultimul. Pentru a diferenția între aceste două cazuri vom ''sacrifica'' un element din vector, folosind numai <code>n-1</code> poziții. În felul acesta testul de coadă plină va fi <code>(ultimul + 1) % n == primul</code>.

'''Observații:'''

* În această implementare cele patru operații au complexitate ''O(1)''.
* '''Important''': în practică, pentru a nu face împărțiri, dimensiunea maximă a cozii va fi o putere a lui doi, constantă definită în program.
* Unul din avantajele acestei implementări, de care veți auzi în detaliu în facultate este că scoaterea de elemente se poate face în paralel cu adăugarea, de exemplu în cazul când un proces generează elementele de adăugat și un alt proces, independent, colectează elementele spre procesare.

=== Exemple de probleme ce folosesc tipul coadă ===

Exemple de probleme ce folosesc cozi în rezolvări:

* [https://www.nerdarena.ro/problema/maxim2 Maxim] dată la concursul ONI 2019 clasa a 6-a (punctul 2)
* [https://www.nerdarena.ro/problema/livada Livada] dată la cercul de informatică Vianu 2014 clasa a 9-a

La [http://pbinfo.ro/ pbinfo.ro]:

* [https://www.pbinfo.ro/?pagina=probleme&id=873 Vase]
* [https://www.pbinfo.ro/?pagina=probleme&id=1239 Fracții3]
* [https://www.pbinfo.ro/?pagina=probleme&id=2187 Expand] (grea)

== Algoritmul lui Lee (BFS Fill) ==

În anul 1961 C. Y. Lee a publicat un algoritm de studiu al căilor de conectare între două puncte în diagrame electronice. Algoritmul original presupune o rețea plană (un circuit electronic) în care, mulțumită proprietăților curentului electric, toate muchiile sunt de lungime unu. De-a lungul timpului (și aparent mai mult în România) acest algoritm a ajuns să fie asociat cu parcurgerea pe lățime a unei matrice, drept pentru care acesta este modul în care îl voi prezenta aici.

Deoarece algoritmul lui Lee este o parcurgere pe lățime ar trebui predat după conceptul de parcurgere pe lățime. De aceea, în această lecţie, voi încerca să prezint ambele.

=== Aplicații ale parcurgerii pe lățime ===

* Găsirea drumului minim de la un punct la un altul, sau la mai multe puncte finale.
* Mai puțin menționat: fill cu mai puțină memorie suplimentară (dar și mai lent)

Pentru exemplificare, să considerăm următoarea problemă: se dă un labirint codificat ca o matrice cu zero și unu, zero semnificând loc liber și unu fiind element obstacol (zid). Se dau de asemenea un punct de start și unul de final. În matrice ne putem deplasa pe linie sau pe coloană, cu condiția să nu avem un obstacol. Să se calculeze, lungimea drumului minim între cele două puncte, dacă există un astfel de drum.

=== Parcurgerea în adîncime ===

Când am discutat despre algoritmul ''flood fill'' am menționat că el este o parcurgere a matricei ''în adâncime'', deoarece traversarea elementelor matricei se face avansând din vecin în vecin până ce se ajunge la o fundătură (un obstacol, ieșire din matrice, sau element deja parcurs). Am denumit această parcurgere ''DFS'' (depth first search), aceasta însemnând că în alegerea noului element de vizitat preferăm adâncimea. Ne putem imagina această parcurgere cu un fir subțire de apă care curge într-o direcție oarecare, apoi, când nu mai poate schimbă direcția. Când ramura curentă se "înfundă" apa se va ramifica din firul principal undeva cel mai aproape de fundătură, acolo unde o poate lua pe altă direcție.

Am menționat atunci că pentru acest tip de parcurgere avem nevoie de o '''stivă''' pentru memorarea elementelor ce urmează a fi parcurse. Stiva este fie explicită (nu am vorbit despre aceasta), fie implicită, într-o implementare recursivă. Această stivă are consecințe: ea adaugă ''O(M x N)'' memorie suplimentară.

Folosind parcurgerea în adâncime, ''flood fill'', putem răspunde la întrebarea dacă există drum între cele două puncte, dar nu putem calcula drumul minim.

=== Parcurgerea pe lățime ===

Prin contrast, ne putem imagina o parcurgere pe ''lățime''. În această parcurgere vom traversa mai întâi elementele vecine cu elementul de start. Apoi vom continua cu elementele vecine cu ele. Și apoi cu elementele vecine cu vecinele, și așa mai departe. Putem vizualiza această parcurgere dacă ne imaginăm că turnăm apă în punctul de pornire. Ea se va împrăștia uniform în toate direcțiile. Dacă va da de obstacole ea va merge de-a lungul lor și le va ocoli. La orice moment distanța între orice punct de pe frontiera apei și punctul de start este aceeași.

Denumim această parcurgere ''BFS'' (breadth first search), deoarece în alegerea noului element de parcurs vom prefera lățimea. La fiecare iterație <code>k</code> vom trata elementele aflate la distanță <code>k</code> de punctul original. Ele formează frontiera (marginea) apei, în exemplul nostru. După fiecare iterație frontiera va fi înlocuită cu o nouă frontieră aflată la distanță mai mare cu unu decât vechea frontieră.

Precum vom vedea mai jos această parcurgere este similară cu cea în adâncime, diferența fiind că ea folosește o coadă în loc de stivă pentru memorarea elementelor ce urmează a fi parcurse. Spre deosebire de ''flood fill'', coada trebuie să fie explicită. De aceea algoritmul poate părea foarte diferit de ''flood fill'', dar, în realitate nu este.

=== Exemplificare grafică ===

Să vedem niște vizualizări ale algoritmului BFS fill preluate de la wikipedia: [https://en.wikipedia.org/wiki/Flood_fill algoritm flood fill]:

[[File:Wfm_floodfill_animation_queue_wikipedia.gif|frame|none|Exemplu de BFS fill cu 4 direcții]]

=== Implementarea parcurgerii pe lățime în matrice ===

Cum implementăm parcurgerea pe lățime? Cum memorăm frontiera? O idee imediată ar fi să ținem două frontiere: cea curentă, în curs de procesare, și cea nouă, în curs de generare. La fiecare iterație calculăm o nouă frontieră pe baza celei dinainte. Apoi comutăm pe frontiera cea nouă. Ce conțin frontierele (ce stocăm)? Vom păstra identificatorii unici ai elementelor matricei, respectiv linia și coloana. Frontierele vor fi vectori de perechi (linie, coloană). Această metodă funcționează, dar nu este nici cea mai simplă și nici cea mai economică ca memorie.

În practică nu vom face distincția între frontiera veche și cea nouă. Elementele din frontiera nouă vor fi adăugate la frontiera veche, la sfârșit. Vom avea astfel o singură frontieră de elemente de procesat. Vom procesa elementele de la începutul frontierei și vom adăuga elementele noi, vecinii, la finalul frontierei. În imaginea noastră cu apa punctele procesate vor descrie o spirală în jurul punctului de pornire.

În acest fel ajungem la structura de date pe care o vom folosi pentru stocarea punctelor de frontieră: '''coada'''. Așa cum am menționat mai sus, în loc de '''stivă''' vom folosi o '''coadă''' de perechi (''linie, coloană'') pentru stocarea elementelor ce urmează a fi parcurse. La un pas vom extrage din coadă primul element și vom adăuga elementele vecine lui la finalul cozii, câtă vreme ele nu se află deja în '''coadă''' (coada conține numai elemente unice).

=== Algoritmul de parcurgere BFS ===

Iată o schiță de algoritm, care nu este neapărat universal valabil, dar poate fi adaptat diverselor situații. Această versiune de algoritm își propune să găsească cel mai scurt drum de la ''(lstart, cstart)'' la ''(lend, cend)'':

<tt>
# Inițializează matricea labirint L[][] cu 0 pentru loc liber și -1 pentru obstacol
# Inițializează coada cu elementul de pornire (lstart, cstart)
# Setează L[lstart][cstart] // distanța inițială
# Execută:
## Scoate primul element din coadă. Fie el linia (lin, col)
## Setează dist // distanța acestui element
## Pentru fiecare vecin (l, c) al lui (lin, col)
### Dacă L[l][c] = 0 // nu se află în coadă și nici nu este obstacol
#### Adaugă (l, c) în coadă
#### Setează L[l][c]
# Câtă vreme coada nu este vidă și (lin, col) nu este destinația (lend, cend)
# Afișează L[lin][col] // distanța până la cel mai apropiat punct destinație
</tt>

''' Note de implementare '''

* Vecinii unui element din matrice pot fi fie cei adiacenți pe linie și coloană, fie și cei pe diagonală, algoritmul funcționează la fel.
* De obicei vom folosi tehnicile învățate:
** Bordarea matricelor pentru a scăpa de testul de ieșire din matrice
** Vectorii de direcție pentru a genera ușor vecinii
* Problema poate fi considerată una de simulare: simulăm parcurgerea tuturor traseelor optime în același timp.
* Dacă nu există drum între cele două puncte algoritmul se va termina când coada devine goală.
* În funcție de ceea ce se cere (drum minim până la destinație, drum minim până la anumite puncte, sau drum minim până la toate elementele matricei) coada poate fi parcursă până la final, sau ne putem opri când anumite condiții ale simulării au fost îndeplinite, cum ar fi atingerea punctului destinație.
* Cum știm dacă un element se află deja în coadă? Printr-o matrice de frecvență: la momentul adăugării în coadă vom marca aceasta în matrice. De cele mai multe ori putem combina matricea de frecvență cu matricea de distanțe (ca în algoritmul de mai sus): un element diferit de zero semnifică distanța acelui element la punctul de start. În această notație obstacolele trebuie memorate ca numere negative pentru a nu fi confundate cu distanțe.
* Cum știm că am ajuns în punctul final? Putem să testăm explicit linia și coloana. Dar dacă avem mai multe puncte finale trebuie să le marcăm într-o matrice. Această matrice se poate de obicei combina cu matricea de frecvență și cu cea de distanțe, deoarece avem nevoie doar de un bit unu sau zero.
* Algoritmul poate fi adaptat să calculeze drumul minim de la mai multe puncte de pornire la mai multe puncte destinație. În acest caz vom inițializa coada cu toate punctele de pornire.

=== Reconstrucția drumului minim ===

Pentru a reconstitui un drum minim între sursă și destinație vom porni invers: de la destinație și vom avansa în <code>L[][]</code> pe elemente descrescătoare din unu în unu, până ce ajungem la sursă. '''Atenție''', drumul nu este neapărat unic.

=== Implementarea cozii de coordonate ===

Pentru coadă vom folosi un vector circular de mărime ''2(M+N)'' (vezi explicația la capitolul de complexități). Vom avea o variabilă, <code>prim</code> care păstrează indicele de adăugare în coadă, precum și o variabilă ultim care păstrează poziția primului element ''gol'', în afara cozii. Acești doi indici vor avansa circular, modulo mărimea cozii.

Coada poate să fie un vector de elemente tip <code>struct</code>, sau doi vectori separați. Prima variantă este mai bună din punct de vedere ''cache'', dar poate duce la risipă de memorie în anumite situații, dacă elementul de tip <code>struct</code> nu ocupă un număr de octeți divizibil cu patru (sau cu lungimea cuvântului de memorie).

Vom folosi trei funcții:

* <code>enqueue( lin, col )</code> care adaugă elementul ''(lin, col)'' în coadă.
* <code>dequeue()</code> care extrage elementul ''(lin, col)'' din coadă.
* <code>emptyqueue()</code> care returnează 1 dacă coada este vidă.

Iată o posibilă implementare ce presupune că numărul de linii și coloane este maxim 255:

<syntaxhighlight lang="c" line>
int prim, ultim;
unsigned char coadal[NCOADA], coadac[NCOADA]; // coordonate mici

// adauga coordonate in coada
static inline void enqueue( int l, int c ) {
coadal[ultim] = l;
coadac[ultim] = c;
ultim = (ultim + 1) % NCOADA;
}

// scoate coordonate din coada
static inline int dequeue() {
int retval = coadal[prim] * 256 + coadac[prim];

prim = (prim + 1) % NCOADA;

return retval;
}

// returneaza 1 cand coada este goala
static inline int emptyqueue() {
return prim == ultim;
}
</syntaxhighlight>

''' Observații: '''

* Funcția <code>dequeue()</code> returnează două valori, linie și coloană. Ele fiind mici le-am combinat într-un singur întreg. Acest lucru este posibil în general, deoarece putem combina două valori <code>unsigned short</code> într-un <code>unsigned int</code>, ceea ce ne permite linii și coloane până în 65535, număr în general acoperitor pentru o matrice stocată în memorie.
* Astfel am putea să stocăm în coadă direct produsul returnat de funcția <code>dequeue()</code>. Avantajele se datorează, în mare, ''cache-ului''.

=== Complexități în timp și spațiu ===

Timpul de execuție este ''O(M x N)'' deoarece fiecare element al matricei va fi luat în calcul cel mult o dată.

Memoria necesară este ''O(M x N)'' deoarece avem nevoie de matricea de distanțe, matricea de frecvențe și cea de puncte terminale, precum și memoria ocupată de coadă. În realitate, de cele mai multe ori putem unifica matricele suplimentare, unindu-le cu matricea labirint. În acest caz memoria suplimentară este cea a cozii. La momentul când scriu aceste rânduri nu am găsit o estimare asupra dimensiunii maxime a cozii necesare. Intuitiv ea este ''O(M + N)'', deoarece frontiera, într-un labirint fără obstacole, când punctul de pornire este în mijloc, nu va depăși M+N. Este neclar dacă o altă matrice și un alt punct de pornire o poate face să depășească ''M + N'' și cu cât. Ca practică de implementare sfatul meu este să o dimensionați de ''2(M + N)'', acoperitor, deoarece este un număr oricum mult mai mic decât matricea deja stocată, ''M x N''.

Datorită consumului atât de mic de memorie suplimentară, algoritmul lui Lee poate fi folosit ca și ca algoritm de fill pe matrice mari, sau când memoria suplimentară este mică. El va fi însă mai lent decât ''flood fill'', de obicei de multe ori (20-30 de ori), ceea ce dovedește încă o dată că, pentru unii algoritmi, memoria suplimentară se traduce în timp de execuție mai mic.

=== Aplicații ===

Algoritmul lui Lee este necesar când dorim să aflăm informații despre drumuri și distanțe:

* Găsirea ieșirii dintr-un labirint / castel / hartă.
* Găsirea celui mai scurt drum între două puncte dintr-o matrice.
* În lumea reală, proiectarea de circuite electronice.

=== Exemple de probleme ce folosesc algoritmul lui Lee ===

Orice problemă rezolvabilă prin ''flood fill'' este, desigur, rezolvabilă și cu ''Lee'', folosind mai puțină memorie, dar consumând mai mult timp pentru executarea programului. N-am găsit foarte multe exemple de probleme ce necesită ''Lee'', dar nu se pot rezolva cu ''flood fill''. Iată câteva exemple:

Exemple de probleme ce folosesc algoritmul lui Lee în rezolvări:

La [https://www.nerdarena.ro/ NerdArena]:

* [https://www.nerdarena.ro/problema/alee Alee] dată la OJI 2007 clasa a 10-a
* [https://www.nerdarena.ro/problema/insule Insule] dată la OJI 2009 clasa a 10-a
* [https://www.nerdarena.ro/problema/miting Miting] dată la OJI 2016 clasa a 10-a (grea)

La [http://infoarena.ro/ InfoArena]:

* [https://www.infoarena.ro/algoritmul-lee Articolul de la Infoarena] include câteva exemple
* [https://www.infoarena.ro/problema/muzeu Muzeu]
* [https://www.infoarena.ro/problema/traseu3 Traseu3] dată la ONI 2014, clasa a 9-a (Lee 3D, relativ ușoară)
* [https://www.infoarena.ro/problema/gheizere Gheizere] dată la ONI 2012, clasa a 10-a (problemă grea)
* [https://www.infoarena.ro/problema/ai AI] dată la OJI 2011, clasa a 10-a (enunț complex)

== Tema 19 ==

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

* [https://www.nerdarena.ro/problema/livada Livada]
* [https://www.nerdarena.ro/problema/alee Alee] alee dată la OJI 2007 clasa a 10-a

== Tema opțională ==

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

* [https://www.nerdarena.ro/problema/insule Insule] dată la OJI 2009 clasa a 10-a

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_19:_Cozi_%C8%99i_algoritmul_lui_Lee&action=edit&redlink=1 Accesează rezolvarea temei 19]

Clasa a 7-a Lecția 18: Divide et impera, mergesort, quicksort

2026-02-06T16:39:45Z

Cristian:

== Înregistrare video lecție ==

<youtube height="720" width="1280">https://youtu.be/bgMxb050keA</youtube>

== Tehnici de programare: divide et impera ==

Denumită și divide and conquer sau dezbină și stăpânește, este o tehnică cunoscută de mii de ani conducătorilor. Este o tehnică de cucerire sau menținere a puterii asupra unui grup care ar avea putere mai mare dacă s-ar uni. Ținând acel grup dezbinat, fiecare facțiune în parte are putere mică și poate fi cucerită, sau condusă. Tehnica a fost aplicată de Cezar, Napoleon, iar, mai recent, de către Britanici în Africa și de către Stalin în Rusia. Dintre tehnicile folosite în lumea reală putem menționa:

* Ajutorarea și promovarea celor care cooperează cu puterea, pedepsirea celor ce nu cooperează.
* Încurajarea cheltuielilor prostești, pentru a reduce capitalul disponibil organizării sau luptei.
* Încurajarea divizării oamenilor pentru a preveni formarea alianțelor.
* Încurajarea turnătorilor, cei care trâmbițează orice alianță posibil periculoasă.
* Sădirea de neîncredere între oameni.

O parte din aceste tehnici se regăsesc și în țara noastră, precum și în majoritatea țărilor lumii, inclusiv cele dezvoltate. De exemplu, toate țările lumii folosesc un număr uriaș de taxe și impozite, fiecare din ele relativ mici. Când le însumăm constatăm că în jur de 90% din banii noștri se duc pe aceste taxe și impozite. Dacă ar exista o taxă unică de 90%, oamenii s-ar revolta. Astfel, tehnica de împărțire a unor taxe mari în mai multe taxe mici îi face pe oameni să nu le observe și să nu se revolte.

Pentru exemple clasice de folosire a acestei tehnici în lumea reală vizitați pagina de [http://en.wikipedia.org/wiki/Divide_and_rule divide et impera] a wikipediei.

== Tehnica divide et impera (divide and conquer) în informatică ==

În informatică divide et impera constă în împărțirea problemei în subprobleme mai mici, nesuprapuse (o tehnică în care subproblemele sunt suprapuse este programarea dinamică). Fiecare din aceste subprobleme se rezolvă separat, mai ușor, deoarece sunt mai mici. Rezultatul final se obține din combinația rezultatelor subproblemelor.

== Tehnica divide et impera simplă (decrease and conquer) ==

În următoarele exemple de divide et impera problema se reduce la o singură problemă, mai mică. Este un caz degenerat, în care implementarea poate fi iterativă (nu necesită recursivitate).

''' Algoritmul lui Euclid '''

Și acest bine cunoscut algoritm poate fi văzut ca un exemplu de divide et impera. El reduce problema de la <code>cmmdc(a, b)</code> la o problemă mai mică, <code>cmmdc(b, a mod b)</code>. Complexitate: ''O(log min(a, b))''.

''' Căutare binară '''

Precum știm, căutarea binară împarte vectorul original în două, apoi decide care din cele două jumătăți ar putea să conțină elementul căutat. Apoi rezolvă problema mai mică. Complexitate: ''O(log n)''.

''' Căutare punct fix'''

Se dă un vector sortat de <code>n</code> elemente întregi distincte. Să se găsească dacă există indicele <code>i</code> astfel încât <code>v[i] == i</code>. Găsiți un algoritm divide et impera care are complexitate ''O(log n)''.

''' Puzzle balanță '''

Avem 25 de bile care arată identic, una este ceva mai ușoară. Avem la dispoziție o balanță. Găsiți bila mai ușoară din trei cântăriri.

''' Selecția '''

Complexitate: pe medie ''O(n)'', în cel mai rău caz ''O(n2)''. Este necesară la problema [https://www.nerdarena.ro/problema/antitir AntiTir].

=== Probleme NerdArena ===

Următoarele probleme de la [https://www.nerdarena.ro/ NerdArena] sunt de divide et impera degenerat:

* [https://www.nerdarena.ro/problema/z ZParcurgere]
* [https://www.nerdarena.ro/problema/tabela Tabela]
* [https://www.nerdarena.ro/problema/antitir AntiTir] dată la Shumen 2012

== Tehnica divide et impera propriu zisă ==

În următoarele exemple de divide et impera problema se reduce la două sau mai multe probleme mai mici. Implementarea este mult mai simplă dacă folosim recursivitate.

=== Puzzle pavare ===

Se dă o grilă de 2n x 2n pătrate din care lipsește un pătrat. Să se acopere cu piese formate din 3 pătrate aranjate în formă de litera L.

[[File:pav2.jpg|frame|none|Exemplu de pavare cu L-uri]]

Problema pare destul de grea, nu? În realitate, odată ce încercăm să folosim divide et impera ea devine destul de ușoară. Cum putem împărți problema în probleme mai mici?

Să definim o problemă astfel:

''P(n, gol)'' = pavează un pătrat de latură 2n care are un pătrățel lipsă (un gol).

O primă idee ar fi să încercăm să împărțim pătratul în patru pătrate de latură 2n-1 și să rezolvăm acele probleme. Avem, însă, o dificultate: doar unul din pătrate va avea un pătrățel lipsă. Celelalte trei vor fi pline. Ce ne facem?

Am putea încerca să eliminăm artificial câte un pătrățel din celelalte trei pătrate. Cum putem face acest lucru? Cu condiția ca cele trei pătrățele să fie în formă de L și să le acoperim cu o piesă elementară. Ei bine avem cum să alegem pătratele în acest fel: le vom selecta pe cele de la centru! Astfel vom obține subproblemele:

''P(n, l, c)'' se descompune în:
''P(n-1, gol)'' (golul original)
''P(n-1, gol1)''
''P(n-1, gol2)''
''P(n-1, gol3)''

=== Mergesort ===

Algoritmul ''mergesort'', sau sortare prin interclasare, funcționează astfel:

* Divide vectorul de sortat în două părți egale (sau aproape egale)
* Reapelează ''mergesort'' pe acele părți
* La revenire avem două jumătăți sortate, deci putem sorta vectorul interclasând cei doi vectori în timp liniar

Iată un algoritm:

<pre>
mergesort( V[], i, j )
mij = (i + j) / 2;
daca i < mij
mergesort( V[], i, mij )
daca mij + 1 < j
mergesort( V[], mij + 1, j )
merge( V[], i, mij, j )
</pre>

<code>merge( V[], i, mij, j )</code> interclasează vectorii sortați <code>V[i..mij]</code> și <code>V[mij+1..j]</code>.

Ce complexitate are ''mergesort''?

Să calculăm numărul de operații, T(N), pentru a sorta un vector de N elemente:

<pre>
T(N) = 2 · T(N/2) + N
T(N) = 2 · (2 · T(N/4) + N/2) + N
T(N) = 4 · T(N/4) + 2 · N
T(N) = 4 · (2 · T(N/8) + N/4) + 2 · N
T(N) = 8 · T(N/8) + 3 · N
...
T(N) = N · T(N/N) + log N · N
T(N) = N · T(1) + log N · N
</pre>

Deoarece ''T(1)'' este ''O(1)'' rezultă o complexitate ''O(N + N log N) = O(N log N)''.

Câtă memorie suplimentară folosește algoritmul?

Pentru interclasarea clasică avem nevoie de un alt vector, deci ''O(N)''.

În concluzie avem complexitățile:

* timp: ''O(n log n)''
* memorie suplimentară: ''O(n)'' (aceasta e problema principală a algoritmului).

Există variante ale algoritmului care folosesc mai puțină memorie (o idee evidentă este să folosim doar jumate din memorie deoarece în timpul interclasării putem suprascrie una din jumătăți).

=== Aplicație mergesort - inversiunile unei permutări ===

O problemă care apare uneori la concursuri este următoarea: se dă o permutare a numerelor de la 1 la ''N''. Să se numere câte inversiuni are ea. O inversiune este o pereche de indici ''(i, j)'' astfel încât <code>i < j</code> și <code>P[i] > P[j]</code>.

În linii mari, algoritmul este următorul:

* Sortăm prima jumate a vectorului folosind un ''mergesort'' special, care ne returnează numărul de inversiuni din vectorul de sortat.
* Sortăm a doua jumate a vectorului.
* În acest moment știm inversiunile din cele două jumătăți - le adunăm.
* Interclasăm cele două jumătăți. În timpul interclasării când selectăm un număr din prima jumătate știm că numerele deja selectate din jumătatea a doua sunt mai mici, deci putem aduna numărul lor la numărul total de inversiuni.

=== Quicksort ===

Algoritmul quicksort, sau sortare rapidă, inventat în 1959 de informaticianul britanic Tony Hoare, funcționează astfel:

* Alege o poziție la întâmplare din vectorul de sortat. Vom denumi valoarea de la acea poziție pivot.
* Rearanjează vectorul astfel încât în prima parte să avem elemente mai mici sau egale cu pivotul iar în a doua parte elemente mai mari sau egale cu pivotul. Vom denumi acest pas pivotare.
* Reapelează quicksort pe acele două părți.

Din acest algoritm avem de lămurit pasul de pivotare. El este același ca la quickselect, prezentat într-o lecție anterioară. El procedează astfel:

* Pornește cu doi indici, unul la începutul vectorului și unul la final de vector, să le spunem <code>b</code> și <code>e</code>.
* Avansează indicele b până la primul element mai mare sau egal cu pivotul.
* Devansează (merge înapoi) indicele e până la primul element mai mic sau egal cu pivotul.
* Interschimbă elementele din vector de la pozițiile <code>b</code> și <code>e</code>.
* Repetă până ce indicii se ating, <code>b >= e</code>.

Iată o implementare posibilă. Ea este implementarea originală a lui Hoare, transformată pentru a fi structurată:

<syntaxhighlight lang="c" line>
void myqsort( int begin, int end ) {
int aux, b = begin, e = end,
pivot = v[(begin + end) / 2]; // poate fi orice pozitie intre begin si end - 1

while (v[b] < pivot) // cauta primul element mai mare sau egal cu pivotul
b++;

while (v[e] > pivot) // cauta primul element mai mic sau egal cu pivotul
e--;

while( b < e ) { // daca indicii nu s-au atins
aux = v[b]; // interschimba elementele la pozitiile b si e
v[b] = v[e];
v[e] = aux;

do // cauta primul element mai mare sau egal cu pivotul
b++;
while (v[b] < pivot);

do // cauta primul element mai mic sau egal cu pivotul
e--;
while (v[e] > pivot);
}

// acum [begin..e] sunt mai mici sau egale cu pivotul
if ( begin < e )
myqsort(begin, e);
// si [e+1..end] sunt mai mari sau egale cu pivotul
if ( e + 1 < end )
myqsort(e + 1, end);
}
</syntaxhighlight>

Ce complexitate are quicksort?

Deoarece pivotarea este liniară, calculele sunt similare cu cele de la ''mergesort''. Avem două diferențe:

* Procesarea liniară se face la început, înainte de recursie.
* Împărțirea vectorului nu este neapărat în două părți egale, ceea ce duce la o complexitate ''O(N2)'' pe cazul cel mai rău.

Pentru cazul mediu, când împărțirea este în două părți aproximativ egale, rezultă aceeași complexitate ''O(N log N)''.

Câtă memorie suplimentară folosește algoritmul?

Memoria este cea necesară stivei. Ea va fi, deci, proporțională cu cel mai lung lanț de apeluri recursive imbricate. Pe cazul cel mai rău el este ''O(N)'', iar pe cazul mediu este ''O(log N)''.

'''Optimizare:''' putem reduce cazul cel mai rău astfel:

* Observăm că al doilea apel recursiv este recursiv la coadă.
* Precum știm, el nu va consuma memorie.
* Putem reduce memoria stivei apelând mai întâi pentru partea mai mică ce rezultă după pivotare.

În acest fel chiar și în cazul cel mai rău memoria suplimentară necesară va fi ''O(log N)''.

În concluzie avem complexitățile:

* timp: ''O(N log N)''
* memorie suplimentară: ''O(log N)''

'''Atenție:''' deși putem selecta ca pivot orice element din vector, nu putem selecta ca pivot ultimul element. Aceasta ar duce la o buclă infinită.

=== Pivotarea Lomuto ===

În școli, de multe ori se predă un alt algoritm de pivotare, probabil deoarece este considerat mai simplu. Nu o vom discuta aici, deoarece este foarte ineficientă. Iată diferențele față de pivotarea Hoare:

* Lomuto este ceva mai simplu de reținut și ceva mai scurtă.
* Ambii algoritmi sunt cache friendly deoarece parcurg liniar vectorul.
* Lomuto face de trei ori mai multe interschimburi.
* Lomuto face ''O(N2)'' operații pe un vector sortat, Hoare doar ''O(N log N)''.
* Lomuto face ''O(N2)'' operații pe un vector cu elemente egale, Hoare doar ''O(N log N)''.

'''Concluzie''': Pivotarea Lomuto este un algoritm didactic, bun pentru înțelegerea pivotării, dar este contraindicat într-o implementare practică.

''' Randomizarea pivotului '''

Dacă alegem ca pivot prima poziție din vector, sau cea din mijloc, ''adversarul'' poate, studiind algoritmul, să găsească un vector special pe care implementarea noastră să intre pe cazul cel mai rău, ''O(N2)''. Putem lupta cu aceasta, alegând pivotul pe o poziție aleatoare din intervalul <code>[begin..end-1]</code>.

''' Probleme quicksort '''

'''Atenție!''' Algoritmul este celebru pentru bug-urile pe care le putem introduce la implementare. Un semn mai mic transformat în mai mic sau egal poate duce la bucle infinite sau la un vector nesortat.

'''Soluție''': pentru olimpiadă este bine să memorați algoritmul pe din-afară.

Ați putea spune ''hei, dar la olimpiadă pot folosi algorithms!'' Este opțiunea voastră, dar eu nu aș risca. Motivele împotriva folosirii funcției de sortare de bibliotecă:

* Ea primește ca parametru o funcție de comparație. Apelul acelei funcții este lent, fiind vorba de accesul unui pointer pentru a obține adresa funcției, apoi de punerea pe stivă a parametrilor. Toate acestea se reduc la o comparație sau două în codul nostru.
* Funcția de bibliotecă este o cutie neagră. Ea depinde de compilator și de biblioteca de funcții a acestuia. Ea este scrisă de alți oameni. Aveți mai multă încredere în cod scris de alții, care variază în funcție de calculatorul pe care se face evaluarea?
* În mod uzual funcțiile de bibliotecă consumă mai multă memorie, iar uneori mult mai multă. De ce? Bună întrebare. Nu știu.
* Algoritmul de mai sus are 23 de linii de cod efectiv. El este simplu și eficient și poate fi adaptat să sorteze orice tip de date, cu mici modificări. De ce am risca să apelăm o funcție de bibliotecă despre care nu știm nimic, când în 3 minute am scris acest cod?

=== Ziua regelui ===

Un rege organizează o petrecere mare de ziua lui. Petrecerea începe peste 24 de ore. Regele află că una din cele 1000 de sticle de vin pe care le va servi este otrăvită. Otrava acționează ciudat: omul care bea chiar și cea mai mică cantitate din această otravă nu are nici un simptom vreme de 24 de ore, apoi moare subit. Regele are sclavi la dispoziție pe care îi poate folosi. Lui nu îi pasă câți sclavi mor, dar îi pasă câți sclavi beau vin, deoarece un sclav care a băut vin nu poate fi folosit la treabă, ci trebuie izolat spre observare. Care este numărul minim de sclavi cu care regele poate afla sticla otrăvită?

== Tema 18 ==

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

* [https://www.nerdarena.ro/problema/latin Latin] dată la cercul de informatică Vianu, gimnaziu 2013
* [https://www.nerdarena.ro/problema/pav Pav] dată la Lot IS 2008
* [https://www.nerdarena.ro/problema/forma Forma] dată la olimpiada pe sector 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/z ZParcurgere]
* [https://www.nerdarena.ro/problema/tabela Tabela]
* [https://www.nerdarena.ro/problema/antitir AntiTir] dată la Shumen 2012
* [https://www.nerdarena.ro/problema/hanoi1 Hanoi1]

Clasa a 7-a Lecția 16: Tehnica Two Pointers (doi pointeri), tipul de date struct și metoda Greedy

2026-02-06T16:37:10Z

Cristian:

== Înregistrare video lecție ==

<youtube height="720" width="1280">https://youtu.be/W59ZLyfMZlc</youtube>

== Tehnica Two Pointers (doi pointeri) ==

În informatica de concurs avem tehnici semi-banale cărora le dăm o denumire pentru a putea să le referim ușor într-o discuție. Este și cazul acestei metode. Deși relativ evidentă, ea are un nume 🙂 Pe scurt, '''Two Pointers''' folosește doi indici într-un vector ce avansează pe rând, similar cu interclasarea, în căutarea rezultatului. Este o tehnică ce produce în general algoritmi liniari. Ea decurge în mod natural din căutarea binară, atunci când avem un algoritm relativ simplu ce folosește multiple căutări binare, ale căror rezultate sunt fie crescătoare fie descrescătoare.

Să luăm câteva exemple.

=== Pereche de sumă X ===

Dat un vector <code>v[]</code> de elemente sortate crescător, să se spună câte o perechi există de indici <code>(i, j)</code> astfel încât <code>v[i] + v[j] == X</code>.

Cum am putea rezolva problema? Pentru fiecare număr <code>v[i]</code> să căutăm un număr <code>v[j]</code> cu <code>j > i</code> astfel încât <code>v[i] + v[j] == X</code>. Dacă fixăm <code>v[i]</code> atunci <code>v[j]</code> poate fi determinat prin căutare binară, deoarece vectorul este ordonat crescător. Vom obține, deci, un algoritm ''O(N log N)'', unde '''N''' este numărul de elemente din vector.

'''Exemplu'''

Fie vectorul:

<source lang="C" line>
v[] = { 20, 25, 30, 35, 40, 50, 55, 65, 75 }
indici: 0 1 2 3 4 5 6 7 8
</code>

și <code>X = 75</code>. Pentru fiecare <code>v[i]</code> vom căuta binar ultimul număr mai mic sau egal cu <code>X - v[i]</code>. Astfel:

* Pentru <code>i = 0</code>, <code>v[i] = 20</code> căutăm valoarea <code>X - v[i] = 55</code> și găsim <code>j = 6</code>, <code>v[j] = 55</code> soluție.
* Pentru <code>i = 1</code>, <code>v[i] = 25</code> căutăm valoarea <code>50</code> și găsim <code>j = 5</code>, <code>v[j] = 50</code> soluție.
* Pentru <code>i = 2</code>, <code>v[i] = 30</code> căutăm valoarea <code>45</code> și găsim <code>j = 4</code>, <code>v[j] = 40</code> (ultima mai mică sau egală cu 45) nu este soluție.
* Pentru <code>i = 3</code>, <code>v[i] = 35</code> căutăm valoarea <code>40</code> și găsim <code>j = 4</code>, <code>v[j] = 40</code> soluție.
* Pentru <code>i = 4</code>, <code>v[i] = 40</code> ar trebui să căutăm valoarea <code>35</code> care este mai mică decât <code>v[i]</code> așa încât ne oprim.

Ce observăm? Că valorile lui <code>j</code> sunt descrescătoare. Este destul de clar că așa și trebuie să fie, nu?

'''Observație importantă'''

'''Tehnica Two Pointers''': atunci când o succesiune de '''căutări binare''' într-un vector au ca rezultat o '''secvență monotonă''' de numere (crescătoare sau descrescătoare), căutările binare pot fi înlocuite cu '''căutări liniare'''. Această înlocuire și noua metodă rezultată poartă denumirea de '''Two Pointers'''.

Ce complexitate are noul algoritm?

La prima vedere , pentru fiecare element <code>v[i]</code> vom căuta liniar perechea lui, ceea ce ar rezulta într-un algoritm ''O(N)''. În realitate, indicele <code>j</code> se va muta mereu către stânga, drept care el nu va putea parcurge mai mult de ''O(N)'' elemente în toate căutările liniare. Deci, folosind analiza amortizată, deși oricare din căutările liniare poate fi ''O(N)'', suma tuturor acestor căutări nu poate depăși ''O(N)''. Drept care metoda Two Pointers duce la un algoritm ''O(N)'', superior celui cu căutare binară, care era ''O(N log N)''.

=== Subsecvență de sumă X ===

Dat un vector <code>v[]</code> de elemente nenule, să se spună câte o perechi există de indici <code>(i, j)</code> astfel încât <code>v[i] + v[i+1] + v[i+2] + ... + v[j] == X</code>.

Și aici avem un algoritm relativ simplu: calculăm vectorul <code>s[]</code> de sume parțiale și pentru fiecare element pe poziția <code>i</code> în vector vom căuta binar în vectorul <code>s[]</code> valoarea <code>s[i-1] + X</code>. Dacă găsim această valoare la poziția <code>j</code> avem că <code>s[j] - s[i-1] == X</code> și deci suma elementelor de la <code>i</code> la <code>j</code> în vectorul <code>v[]</code> este <code>X</code>, deci avem o soluție.

Complexitatea acestui algoritm va fi, din nou, ''O(N log N)''.

Ce observăm, însă? Că rezultatele căutărilor binare (indicii <code>j</code>) vor fi în ordine crescătoare, deoarece sumele parțiale sunt strict crescătoare. Putem, deci, folosi '''Two Pointers''' pentru a căuta indicii <code>j</code> prin căutare liniară: pentru fiecare avans al lui <code>i</code> vom avansa indicele <code>j</code> până ce suma devine mai mare sau egală cu cea dorită, moment la care testăm egalitatea.

Acest algoritm are complexitate ''O(N)''. Mai mult, deoarece ne interesează doar suma subsecvenței de la <code>i</code> la <code>j</code> putem renunța la vectorul de sume parțiale și lucra direct pe vectorul original <code>v[]</code>, menținând incremental suma subsecvenței studiate.

=== Problema NrTri ===

Am discutat într-o lecție trecută problema [https://www.nerdarena.ro/problema/nrtri NrTri]. Ea cere să găsiți într-un vector numărul de tripleți ce pot forma laturile unui triunghi. Aici avem o soluție cu căutare binară: după ce sortăm elementele, pentru fiecare pereche de indici <code>(i, j)</code> vom căuta binar cel mai mare element <code>k > j</code> cu proprietatea că <code>v[k]</code>. Toate elementele între <code>j</code> și <code>k</code> (inclusiv <code>k</code>) formează un triplet valabil cu perechea <code>(i, j)</code>.

Această soluție are complexitatea ''O(N2 log N)''. Ca și în exemplele anterioare, observăm că atunci când <code>j</code> avansează căutarea binară va returna valori <code>k</code> crescătoare. Și aici putem aplica tehnica ''Two Pointers'', avansând liniar indicele <code>k</code>.

Rezultă un algoritm O(N2). Observați că tehnica aceasta reduce complexitatea cu acel factor log N. În practică nu este clar că vom putea întotdeauna diferenția între căutarea binară și Two Pointers. Cu toate acestea metoda merită, deoarece codul rezultat este mai simplu și constanta de implementare scade considerabil.

== Tipul de date struct ==

Până acum am învățat tipuri de date simple (<code>int</code>, <code>char</code>, <code>long long</code>, etc) și tipuri de date compuse (ce grupează mai multe tipuri de date simple) anume tablouri, fie ele unidimensionale (vectori), bidimensionale (matrice), sau chiar de dimensiuni mai mari.

'''Exemplu:'''

<syntaxhighlight lang="C" line>
struct nrmare { int ncf; char cf[MAXNCF]; };
...
struct nrmare n1, n2, n3;
</syntaxhighlight>

sau, mai scurt (putem declara variabile la definirea tipului <code>struct</code>):

<syntaxhighlight lang="C" line>
struct nrmare { int ncf; char cf[MAXNCF]; } n1, n2, n3;
</syntaxhighlight>

Elementele declarate în interiorul unui <code>struct</code> se numesc membri. Putem accesa membrii unei variabile tip <code>struct</code> cu operatorul punct.

'''Exemplu:'''

<syntaxhighlight lang="C" line>
t += n1.cf[i] + n2.cf[i];
n3.cf[i] = t % 10;
t /= 10;
</syntaxhighlight>

Tipul <code>struct</code> reprezintă un alt mod de a grupa date simple într-o ''structură''. Aceste date vor fi reprezentate în memorie la rând, una după alta.

'''Diferențe''' între tipul <code>struct</code> și tipul tablou:

* Tipul struct poate grupa date de tipuri diferite, tipul <code>tablou</code> nu.
* Tipul struct accesează elementele sale pe bază de denumire, tipul tablou accesează elementele numeric, pe bază de indice (poziție).
* În consecință tipul <code>struct</code> grupează un număr relativ mic de date.

'''Avantaje''' ale tipului <code>struct</code>:

* Gruparea datelor duce la o ordine a codului.
* Codul devine mai clar și mai ușor de citit, deci o depanare mai ușoară.
* Folosit corect tipul struct poate duce la un acces mai localizat al memorie (''cache friendly'') și, deci, la o scăderea a timpului de execuție.

'''Atenție:''' probleme cu tipul <code>struct</code>:

* Orice variabilă de tip <code>struct</code> va fi completată până la <code>int</code>. Actual, acest tip este pe patru octeți, ceea ce înseamnă că un struct va ocupa un număr de octeți divizibil cu patru. Dacă vom declara un struct cu un <code>int</code> și un <code>char</code> el va ocupa 8 octeți și nu 5!

* Un vector de structuri poate fi înlocuit întotdeauna cu mai mulți vectori, câte unul pentru fiecare membru. Decizia de a folosi struct trebuie luată în funcție de modul de accesare a membrilor în algoritmul nostru. O decizie proastă poate duce la deteriorarea timpului de execuție din motive de cache.

* Combinația între cele două de mai sus poate fi destul de rea: un struct care ocupă mai mult, chiar dacă nu duce la o depășire de memorie, va crește necesarul de memorie ceea ce duce la creșterea timpului de execuție din motive de ''cache''. Aceasta, combinat cu un acces prost la memorie, poate duce la o creștere semnificativă a timpului de execuție - poate chiar dublarea lui!

'''Concluzie''': folosiți tipul <code>struct</code> numai dacă știți exact ce faceți. Recomandarea mea este ca deocamdată să nu îl folosiți.

=== Studiu de caz: problema bile1 ===

Implementarea listelor se face în general bine folosind tipul <code>struct</code>. În mod natural o celulă a listei va conține o informație și o legătură la următoarea celulă (next). În particular am învățat acea structură de date, vectorul de liste, pe care îl foloseam pentru a evita sortarea, memorând pentru fiecare linie a unei matrice acele coloane care ne interesează, unde apar elemente interesante pe acea linie. Să luăm un caz concret.

În problema [https://www.nerdarena.ro/problema/bile1 Bile1] se cere să simulăm căderea unor bile printr-o matrice cu obstacole. Am rezolvat-o memorând obstacolele ca liste de coloane ''agățate'' pe liniile unde apar obstacole. Pentru aceasta am folosit doi vectori. Iată soluția de atunci:

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

#define MAXN 2000
#define NOBST 10000

short lin[MAXN + 1]; // capetele de lista
short col[NOBST + 1], next[NOBST + 1]; // celulele listelor
int bile[MAXN]; // bilele ce vor fi redistribuite

int main () {
FILE *fin, *fout;
int m, n, p, i, pc, l, c;

fin = fopen( "bile1.in", "r" );
fscanf( fin, "%d%d%d", &m, &n, &p );
for ( i = 1; i <= p; i++ ) { // citire obstacole
fscanf( fin, "%d%d", &l, &c );
col[i] = c; // asezam coloana c in lista liniei l
next[i] = lin[l]; // coloana noua vine la inceputul listei liniei l
lin[l] = i;
}
for ( i = 0; i < n; i++ ) // citire bile pe prima linie
fscanf( fin, "%d", &bile[i] );
fclose( fin );

// parcurgem liniile in ordine si cautam coloane cu obstacole
for ( l = 1; l <= m; l++ ) {
pc = lin[l];
while ( pc > 0 ) { // cita vreme mai avem elemente in lista
c = col[pc] - 1; // avem obstacol la coloana c
bile[c-1] += bile[c] / 2 + bile[c] % 2; // n/2 + 1 in stinga
bile[c+1] += bile[c] / 2; // n/2 in dreapta
bile[c] = 0;
pc = next[pc]; // trecem la urmatorul element din lista
}
}

fout = fopen( "bile1.out", "w" );
for ( i = 0; i < n; i++ )
fprintf( fout, "%d\n", bile[i] );
fclose( fout );

return 0;
}</syntaxhighlight>

Este clar că atunci când accesăm o celulă a listei vom avea nevoie atât de numărul de coloană cât și de next, pentru a avansa la elementul următor. Deci poate ar fi o idee bună să le grupăm, pentru ''cache''. Partea bună este că atât coloana cât și următorul element sunt mici, deci putem folosi tipul <code>short</code>, ceea ce înseamnă că o celulă va ocupa două elemente <code>short</code>, adică patru octeți, fiind aliniată la întreg.

Iată programul modificat să folosească tipul <code>struct</code>:

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

#define MAXN 2000
#define NOBST 10000

short lin[MAXN + 1]; // capetele de lista
struct cell { short col; short next; } obst[NOBST + 1]; // celulele listelor
int bile[MAXN]; // bilele ce vor fi redistribuite

int main () {
FILE *fin, *fout;
int m, n, p, i, pc, l, c;

fin = fopen( "bile1.in", "r" );
fscanf( fin, "%d%d%d", &m, &n, &p );
for ( i = 1; i <= p; i++ ) { // citire obstacole
fscanf( fin, "%d%d", &l, &c );
// asezam coloana c in lista liniei l
// coloana noua vine la inceputul listei liniei l
obst[i] = (struct cell){ .col = c, .next = lin[l] }; // cream noua celula
lin[l] = i;
}
for ( i = 0; i < n; i++ ) // citire bile pe prima linie
fscanf( fin, "%d", &bile[i] );
fclose( fin );

// parcurgem liniile in ordine si cautam coloane cu obstacole
for ( l = 1; l <= m; l++ ) {
pc = lin[l];
while ( pc > 0 ) { // cita vreme mai avem elemente in lista
c = obst[pc].col - 1; // avem obstacol la coloana c
bile[c-1] += bile[c] / 2 + bile[c] % 2; // n/2 + 1 in stinga
bile[c+1] += bile[c] / 2; // n/2 in dreapta
bile[c] = 0;
pc = obst[pc].next; // trecem la urmatorul element din lista
}
}

fout = fopen( "bile1.out", "w" );
for ( i = 0; i < n; i++ )
fprintf( fout, "%d\n", bile[i] );
fclose( fout );

return 0;
}
</syntaxhighlight>

Remarcați cum putem atribui o variabilă de tip <code>struct</code>, folosind denumirile membrilor săi:

<syntaxhighlight lang="C" line>
obst[i] = (struct cell){ .col = c, .next = lin[l] };
</syntaxhighlight>

=== Studiu de caz: numere mari ===

Numerele mari se pot reprezenta în mod natural ca un struct ce conține numărul de cifre și vectorul de cifre, precum am văzut mai sus. Avantajul constă în gruparea datelor și în claritatea codului ce menține numarul de cifre corect - nu mai avem nevoie să returnăm în funcția de înmulțire numărul de cifre al rezultatului, ci îl setăm chiar în numărul mare trimis ca parametru.

Atunci când trimitem un <code>struct</code> mare ca parametru (care ocupă mai mult de un întreg) este bine să-l trimitem ca pointer, deoarece evităm copierea. În acest caz accesul la <code>struct</code> se face un pic anevoios.

Iată un exemplu de funcție de adunare număr mic la număr mare:

<syntaxhighlight lang="c" line>
// aduna numarul mic a la numarul mare n
// n transmis prin referinta pentru a nu fi copiat + il modificam
void adunaNn( struct nrmare *n, int a ) {
int i;

i = 0;
while ( a > 0 ) {
a += (*n).cf[i];
(*n).cf[i] = a % 10;
a /= 10;
i++;
}

if ( i > (*n).ncf )
(*n).ncf = i;
}
</syntaxhighlight>

Remarcați că avem nevoie de două paranteze, un asterisc și un punct pentru a apela un membru al structurii trimise ca pointer. De aceea limbajul C ne oferă o alternativă mai simplă:

<syntaxhighlight lang="c" line>
// forme echivalente:
(*n).cf[i];

// este totuna cu
n->cf[i];
</syntaxhighlight>

Precum vedeți săgețica este echivalentul punctului atunci când variabila este de tip pointer la <code>struct</code>.

Iată un exemplu de implementare de numere mari:

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

#define MAXNCF 1000

struct nrmare { int ncf; char cf[MAXNCF]; } n1, n2, n3;

// aduna numarul mic a la numarul mare n
// n transmis prin referinta pentru a nu fi copiat + il modificam
void adunaNn( struct nrmare *n, int a ) {
int i;

i = 0;
while ( a > 0 ) {
a += n->cf[i];
n->cf[i] = a % 10;
a /= 10;
i++;
}

if ( i > n->ncf )
n->ncf = i;
}

// scade numarul mic a din numarul mare n
// considera ca nu se ajunge la un numar mare negativ (a <= n)
// n transmis prin referinta pentru a nu fi copiat + il modificam
void scadeNn( struct nrmare *n, int a ) {
int i;

a = -a;
i = 0;
while ( a < 0 ) {
a += n->cf[i];
n->cf[i] = a % 10;
a /= 10;
if ( n->cf[i] < 0 ) {
n->cf[i] += 10;
a--;
}
i++;
}

while ( n->ncf > 0 && n->cf[n->ncf-1] == 0 )
n->ncf--;
}

// aduna numarul mare n2 la numarul mare n1
// n1, n2 transmise prin referinta pentru a nu fi copiate + le modificam
void adunaNN( struct nrmare *n1, struct nrmare *n2 ) {
int i, max, t;

max = n1->ncf < n2->ncf ? n2->ncf : n1->ncf;
t = 0;
for ( i = 0; i < max; i++ ) {
t = t + n1->cf[i] + n2->cf[i];
n1->cf[i] = t % 10;
t /= 10;
}
if ( t > 0 ) {
n1->cf[i] = t;
max++;
}

n1->ncf = max;
}

// scade numarul mare n2 din numarul mare n1
// considera ca nu se ajunge la un numar mare negativ (n2 <= n1)
// n1, n2 transmise prin referinta pentru a nu fi copiate + le modificam
void scadeNN( struct nrmare *n1, struct nrmare *n2 ) {
int i, t;

t = i = 0;
while ( i < n2->ncf || t < 0 ) {
t = t + n1->cf[i] - n2->cf[i];
n1->cf[i] = t % 10;
t /= 10;
if ( n1->cf[i] < 0 ) {
n1->cf[i] += 10;
t--;
}
i++;
}

while ( n1->ncf > 0 && n1->cf[n1->ncf-1] == 0 )
n1->ncf--;
}

// inmulteste numarul mic a cu numarul mare n cu rezultatul in n
// n transmis prin referinta pentru a nu fi copiat + il modificam
void inmultesteNn( struct nrmare *n, int a ) {
int i;
long long t;

t = i = 0;
while ( i < n->ncf || t > 0 ) {
t = t + a * (long long)n->cf[i];
n->cf[i] = t % 10;
t /= 10;
i++;
}

if ( i > n->ncf )
n->ncf = i;
}

// tipareste un numar mare n
void printN( struct nrmare *n ) {
int i;

if ( n->ncf == 0 )
fputc( '0', stdout );
else
for ( i = n->ncf - 1; i >= 0; i-- )
fputc( '0' + n->cf[i], stdout );
fputc( '\n', stdout );
}

int main () {
// n1, n2, n3 declarate global, initial zero

printf( "0 + 75464: " );
adunaNn( &n1, 75464 );
printN( &n1 );

printf( "75464 - 75464: " );
scadeNn( &n1, 75464 );
printN( &n1 );

printf( "0 + 834205: " );
adunaNn( &n1, 834205 );
printN( &n1 );

adunaNn( &n2, 1024586 );

printf( "834205 + 1024586: " );
adunaNN( &n1, &n2 );
printN( &n1 );

printf( "834205 + 1024586 - 1024586: " );
scadeNN( &n1, &n2 );
printN( &n1 );

printf( "834205 * 2043984094: " );
inmultesteNn( &n1, 2043984094 );
printN( &n1 );

return 0;
}
</syntaxhighlight>

== Metoda Greedy ==

Uneori trebuie să rezolvăm probleme ce necesită să găsim o soluție minimă sau maximă. Una din cele mai simple și evidente încercări de rezolvare este ca, la fiecare pas, să luăm decizia optimă pe moment - decizie ''lacomă'' - cel mai bun lucru la momentul actual.

Exemplu: dat un șir de numere pozitive și negative să se calculeze suma maximă ce se poate forma cu exact ''K'' numere.

Soluție greedy: la fiecare pas vom selecta maximul dintre numerele rămase. Vom porni cu maximul. Apoi cu al doilea maxim și așa mai departe. La fiecare pas ''ne lăcomim'' la cel mai mare număr posibil.

Este, sper, destul de clar că în acest caz obținem soluția optimă. Însă nu întotdeauna este așa, precum vom vedea.

Să vedem câteva exemple de algoritmi greedy.

=== Plată cu număr minim de bancnote puteri ale lui 2 ===

Dispunem de bancnote puteri ale lui 2. Pentru fiecare putere a lui 2 vom avea un număr de bancnote disponibile, posibil niciuna. Dat '''X''', dorim să achităm suma '''X''' cu un număr minim de bancnote posibile. Cum procedăm?

Vom proceda greedy: selectăm bancnotele de valoare maximă ce încap în '''X'''. Fie epuizăm numărul de bancnote de acea putere și trecem mai departe, fie ne rămân bancnote dar suma de plată devine mai mică decât 2 la acea putere. Procedăm în continuare la fel.

Exemplu: dispunem de următoarele bancnote: 3 × 25, 1 × 23, 2 × 22, 5 × 21, 6 × 20 și ne dorim să achităm suma 53. Procedăm astfel:

<pre>
Pas 1: selectăm 1 × 25. Suma rămasă: 21 = 53 - 32
Pas 2: selectăm 1 × 23. Suma rămasă: 13 = 21 - 8
Pas 3: selectăm 2 × 22. Suma rămasă: 5 = 13 - 8
Pas 4: selectăm 2 × 21. Suma rămasă: 1 = 5 - 4
Pas 5: selectăm 1 × 20. Suma rămasă: 0 = 1 - 1
</pre>

Astfel numărul de bancnote este 7, iar numărul este plătit astfel:

<pre>
53 = 32 + 8 + 4 + 4 + 2 + 2 + 1
</pre>

=== Sortarea prin selecție ===

Ne putem gândi la sortarea prin selecție ca având un pas de bază greedy: la fiecare trecere prin vector selectăm în mod greedy maximul și apoi îl trecem la coadă.

=== Numărul minim de intervale care acoperă un interval ===

Problemă: dată o mulţime de ''N'' intervale <code>[ai, bi]</code> ce acoperă un alt interval mai mare să se găsească o submulţime minimă a acestei mulţimi care conţine intervale ce acoperă același interval original.

[[File:Intervale-pe-dreapta-1.svg.png|thumb]]

Exemplu: fie intervalele

<pre>
1: [3 8]
2: [9 18]
3: [1 5]
4: [0 8]
5: [2 10]
</pre>

Intervalul acoperit este <code>[0, 18]</code>. Ne dorim să păstrăm cât mai puține intervale care să acopere același interval.

''' Idee de soluție '''

O idee naturală este să sortăm intervalele după punctul de început, iar apoi să le luăm în ordine, unul câte unul. Având un interval curent selectat, am putea să selectăm intervalul care începe cât mai târziu dar al cărui interval este în interiorul intervalului curent.

Pe exemplul de mai sus observăm că nu funcționează, deoarece am selecta intervalele 4, 1 și apoi nu am mai avea ce să selectăm în continuare.

''' Soluție '''

Vom parcurge intervalele în ordinea capătului de început, ca mai devreme. Dar vom selecta următorul interval pe acela care se '''închide ultimul''' dintre cele care au capătul stânga în interiorul intervalului curent.

În cazul nostru vom selecta intervalele 4, 5 și 2.

=== Numărul maxim de intervale disjuncte ===

Problemă: dată o submulţime de ''N'' intervale <code>[ai, bi]</code> să se găsească o submulţime maximală a acestei mulţimi care conţine doar intervale disjuncte (neintersectante).

Această problemă este totuna cu numărul minim de puncte ce ''înțeapă'' toate intervalele (de ce?).

''' Idei de soluţie '''

Această problemă apare destul de des la olimpiade, deghizată într-o formă sau alta. Deşi pare o problemă grea, în realitate ea se rezolvă uşor. O primă idee ar fi să încercăm să ordonăm intervalele după punctul de început, apoi să le luăm în ordine, unul câte unul. Pentru fiecare interval ne întrebăm dacă îl intersectează pe cel anterior. Dacă da, îl aruncăm şi mergem mai departe. Dacă nu, îl adăugăm la submulţime şi îl reţinem ca interval ultim. Această soluţie nu funcţionează şi e destul de evident de ce: am putea avea un prim interval foarte lung, care acoperă toate celelalte intervale.

Cu toate acestea rezolvarea nu e total greşită. În fapt, ea aproape funcţionează! Are nevoie doar de o modificare ce se impune, analizînd contraexemplul anterior: de ce nu este bun acel prim interval foarte lung? Deoarece el se termină după celelalte. Şi atunci ne putem întreba, în mod natural, ce s-ar întâmpla dacă am alege intervalul care se închide primul, nu care începe primul? Desigur că acest algoritm funcţionează. Vă las vouă să vă luptaţi cu demonstraţia, care decurge cam aşa: să presupunem că soluţia generată de acest algoritm nu e optimă. Înseamnă că există o altă soluţie cu mai multe intervale. Acea soluţie trebuie să difere undeva faţă de cea găsită de noi. Mergeţi pe această cale şi trebuie să ajungeţi la o contradicţie cum că soluţia optimă nu poate avea mai multe segmente.

[[File:Intervale-pe-dreapta-1.svg.png|thumb]]

Exemplu: fie intervalele

<pre>
1: [3 8]
2: [9 18]
3: [1 5]
4: [0 8]
5: [2 10]
</pre>

Atunci vom selecta, în ordine, intervalele 3 și 2.

==== Soluţie ====

Care este algoritmul, în mare?

''
# Iniţial mulţimea M este vidă.
# Ordonează crescător intervalele după punctul de închidere.
# Consideră ultima închidere (care nu există încă) cu valoarea minus infinit.
# Pentru fiecare interval, în ordine:
## Dacă el conţine ultima închidere
### Ignoră-l.
## Altfel
### Selectează intervalul curent şi adaugă-l la mulţimea M.
### Setează ultima închidere pe închiderea intervalului selectat
# Afişează mulţimea M.
''

Ce se întâmplă dacă avem mai multe intervale care se termină în acelaşi punct? Atunci putem reţine intervalul cel mai mic. De ce? Deoarece este cel mai convenabil. Să presupunem că soluţia maximală conţinea un alt interval care se termina în acel punct. Atunci putem înlocui acel interval cu intervalul cel mai mic, obţinînd o altă soluţie maximală.

==== Considerente de implementare ====

Implementarea directă: memorăm intervalele ca perechi, prin capetele lor. Sortăm perechile după capătul din dreapta. Apoi facem o parcurgere a perechilor. Această implementare necesită ''O(N log N)'' timp și ''O(N)'' memorie.

Implementare relaxată: atunci când coordonatele sunt suficient de mici astfel încât să putem folosi un vector care să memoreze un întreg pentru fiecare coordonată, putem încerca o abordare mai simplă: nu memorăm intervalele. Ci, pentru fiecare interval <code>[ai, bi]</code>, vom seta <code>început[bi] = ai</code>. Cu alte cuvinte vom memora capetele stânga la poziția capetelor dreapta. Apoi parcurgem vectorul în ordine, acoperind segmentul de coordonate care acoperă toate intervalele, testând dacă elementul de la poziția curentă în vector este mai mic decât ultima închidere memorată. Dacă nu, atunci selectăm intervalul și mutăm ultima închidere la poziția curentă în vector. Trebuie să avem grijă la următoarele:

* Să iniţializăm vectorul de coordonate cu o valoare distinctă de capete de interval. Matematic am putea să le iniţializăm cu minus infinit, astfel încât să nu fie selectate niciodată.
* Atunci când ''aşezăm'' intervalele pe vector să avem grijă ca dacă găsim deja o valoare în vector să o înlocuim numai dacă cea curentă este mai mare (intervalul este mai mic).

Această soluţie necesită ''O(N + CMAX)'' timp şi memorie, '''CMAX''' fiind coordonata maximă. De aici rezultă când o putem folosi: atunci când '''CMAX''' este suficient de mic.

==== Generalizare ====

Putem generaliza această problemă: să se calculeze mulţimea maximală de dreptunghiuri neintersectante. Sau de paralelipipede. Sau de paralelipipede n-dimensionale. Cum se rezolvă aceste probleme? Din nefericire aceste probleme fac parte dintr-o clasă de probleme numite ''NP-hard'', pentru care nu se cunoaşte o soluţie bună.

=== Exemplu când greedy nu funcționează: prolema rucsacului ===

Problema rucsacului cere să ''umplem'' cât mai bine un rucsac care poate duce o greutate maximă, dispunând de obiecte de diverse greutăți.

Exemplu: Vreau să umplu cât mai bine un rucsac de 100 și am greutăți 50, 30, 25 și 25.

Prin metoda greedy vom alege greutățile cele mai mari, în ordine: 50 și 30, după care nu mai putem adăuga nimic. Astfel vom obține greutatea totală 80. Dacă am alege însă greutățile 50, 25 și 25 am putea umple complet rucsacul.

De remarcat totuși că chiar și atunci când metoda greedy nu calculează optimul, un algoritm greedy bine gândit va da o soluție bună, aproape de optim.

== Tema 16 ==

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

* [https://www.nerdarena.ro/problema/politic Politic] dată la ONI 2007 clasa a 7-a
* [https://www.nerdarena.ro/problema/sumax SumaX] dată la Shumen Juniori 2015
* [https://www.nerdarena.ro/problema/acoperire Acoperire]
* [https://www.nerdarena.ro/problema/char Char] dată la ONI 2010 clasa a 7-a

Pentru doritorii să încerce și soluția problemei numărul minim de numărul minim de puncte ce ''înțeapă'' toate intervalele puteți rezolva problema [https://www.nerdarena.ro/problema/baloane Baloane].

== Tema opțională ==

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

* [https://www.nerdarena.ro/problema/startrek Star Trek] dată la OJI 2016 clasa a 7-a

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_16:_Tehnica_Two_Pointers_(doi_pointeri),_tipul_de_date_struct_%C8%99i_metoda_Greedy Accesează rezolvarea temei 16]

Clasa a 7-a Lecția 15: Citire / scriere rapidă

2026-02-06T16:31:53Z

Cristian:

== Înregistrare video curs ==

<youtube height="720" width="1280">https://youtu.be/edb5JQiZxoY</youtube>

== Citire/scriere rapidă cu fgetc() / fputc() ==

Știm că atunci când avem de citit numere la intrare <code>fscanf()</code> este foarte lentă. Știm că putem citi mai rapid folosind <code>fgetc()</code> și calculând numerele. Am prezentat, în trecut, o funcție de citire a întregilor bazată pe <code>fgetc()</code>. Am spus că, printre elevi, circulă denumirea de parsing. Vom folosi și noi această denumire, deși ea nu este tocmai corectă, parsingul fiind un capitol al informaticii care se ocupă cu mult mai mult decât citirea întregilor.

Nu am prezentat niciodată o funcție de scriere eficientă a întregilor, care să nu folosească <code>fprintf()</code>.

== Citire/scriere rapidă cu fgetc() / fputc() ==

Iată, mai jos, atât funcția de citire cu care suntem obișnuiți, cât și o funcție de scriere, ambele bazate pe <code>fgetc()</code> și <code>fputc()</code>:

<syntaxhighlight lang="c" line>
// citire intreg cu semn
int readInt() {
int ch, res = 0, semn = 1;

while ( isspace( ch = fgetc( fin ) ) );
if ( ch == '-' ) {
semn = -1;
ch = fgetc( fin );
}
do
res = 10 * res + ch - '0';
while ( isdigit( ch = fgetc( fin ) ) );

return semn * res;
}

// scriere intreg cu semn
void writeInt( int x ) {
int i;
char cifre[10];

if ( x < 0 ) {
fputc( '-', fout );
x = -x;
}

i = 0;
do {
cifre[i++] = '0' + x % 10;
x /= 10;
} while ( x > 0 );

while ( i > 0 )
fputc( cifre[--i], fout );

fputc( '\n', fout ); // separatorul, poate sa difere (' '?)
}
</syntaxhighlight>

Cum procedează funcția de scriere rapidă? Ea folosește împărțiri la constanta 10, împărțiri mult studiate în literatura de specialitate. Ele nu sunt traduse în cod mașină ca împărțiri. Compilatorul folosește matematică în clasă de resturi ''modulo'', folosind înmulțiri cu inversul modular și operații shift. Împărțirea la 10 va fi mai rapidă decât o împărțire oarecare, dar mai lentă decât o adunare.

Se poate mai bine?

== Citire/scriere rapidă cu fread() / fwrite() ==

Funcțiile <code>fread()</code> și <code>fwrite()</code> se află la baza funcțiilor <code>fscanf()</code> / <code>fprintf()</code> și <code>fgetc()</code> / <code>fputc()</code>. Ele sunt cele mai de jos funcții de citire / scriere care folosesc bufferele sistemului de operare.

Cum le vom folosi? Citirea de pe disc, sau alt mediu extern, este foarte lentă. Ceea ce ia cel mai mult este citirea primului octet. Octeții care urmează se citesc mult mai rapid. De aceea este foarte ineficient să citim câte un octet o dată folosind <code>fread()</code>.

Vom citi, în schimb, câte un bloc de date mai mare în memorie, din care vom returna câte un octet (caractere) la cerere. Acest bloc se numește ''buffer'' și este folosit și în funcțiile sistem, <code>fgetc()</code> și <code>fscanf()</code>.

Iată cum arată un parsing scris cu <code>fread()</code> și <code>fwrite()</code>:

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

#define BUFSIZE (128 * 1024)

FILE *fin, *fout;
int rpos = BUFSIZE - 1; char rbuf[BUFSIZE];
int wpos = 0; char wbuf[BUFSIZE];

int v[2000000];

// citire caracter
static inline char readChar() {
if ( !(rpos = (rpos + 1) & (BUFSIZE - 1)) )
fread( rbuf, 1, BUFSIZE, fin );
return rbuf[rpos];
}

// citire intreg cu semn
int readInt() { // citeste un intreg
int ch, res = 0, semn = 1;

while ( isspace( ch = readChar() ) );
if ( ch == '-' ) {
semn = -1;
ch = readChar();
}
do
res = 10 * res + ch - '0';
while ( isdigit( ch = readChar() ) );

return semn * res;
}

// scriere caracter
static inline void writeChar( char ch ) {
wbuf[wpos] = ch;
if ( !(wpos = (wpos + 1) & (BUFSIZE - 1)) )
fwrite( wbuf, 1, BUFSIZE, fout );
}

// scriere intreg cu semn
void writeInt( int x ) {
int i;
char cifre[10];

if ( x < 0 ) {
writeChar( '-' );
x = -x;
}

i = 0;
do {
cifre[i++] = '0' + x % 10;
x /= 10;
} while ( x > 0 );

while ( i > 0 )
writeChar( cifre[--i] );

writeChar( '\n' ); // separatorul, poate sa difere (' '?)
}

// scrie caracterele ramase in buffer
static inline void flushBuf() {
fwrite( wbuf, 1, wpos, fout );
}
</syntaxhighlight>

Cum folosim aceste funcții? Astfel:

<syntaxhighlight lang="c" line>
fin = fopen( "input.in", "r" );
n = readInt();
// ... alte citiri
fclose( fin );

fout = fopen( "input.out", "w" );
writeInt( n );
// ... alte scrieri
flushBuf(); // ne asiguram ca bufferul este complet scris
fclose( fout );
</syntaxhighlight>

== Comparații moduri de citire / scriere ==

Ce funcții ar trebui să folosim atunci când facem parsing? Care este diferența de viteză între ele?

Comparația între diverse funcții nu este ușoară, deoarece sistemul de operare va încărca în memorie fișierele des folosite, așa numitul ''caching''. Aceasta face ca citirile să se efectueze din memorie, și nu de pe disc, ceea ce le va face să apară în mod artificial mai rapide decât sunt în realitate. Pentru o testare reală ar trebui să ne asigurăm că fișierele nu se află în cache.

Iată o comparație între diversele tipuri de citire/scriere. Ea măsoară două milioane de citiri și două milioane de scrieri de întregi folosind cele trei metode: <code>fscanf()</code> / <code>fprintf()</code>, <code>fgetc()</code> / <code>fputc()</code> și <code>fread()</code> / <code>fwrite()</code>. Ca metodologie folosită, am executat fiecare metodă de zece ori și am luat cel mai mic timp obținut. Aceasta înseamnă, probabil, că fișierul de intrare se află în cache. Pe de altă parte același lucru este foarte probabil să se întâmple și pe evaluatorul de la olimpiadă.

{| class="wikitable"
|-
! Timpi Pentium 4 2.40GHz / HDD (NerdArena) !! 2 milioane citiri !! 2 milioane scrieri
|-
| fscanf() / fprintf() || 994ms || 895ms
|-
| fgetc() / fputc() || 348ms (2.9x) || 598ms (1.5x)
|-
| fread() / fwrite() || 166ms (6x) || 419ms (2.1x)
|}

{| class="wikitable"
|-
! Timpi core i7-7700HQ 2.8GHz / SSD PCIe (laptop tipic) !! 2 milioane citiri !! 2 milioane scrieri
|-
| fscanf() / fprintf() || 234ms || 135ms
|-
| fgetc() / fputc() || 72ms (3.25x) || 95ms (1.4x)
|-
| fread() / fwrite() || 45ms (5.2x) || 62ms (2.2x)
|}

Desigur că lucrurile pot sta diferit între Windows și Linux.

== Temă 15 ==

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

* [https://www.nerdarena.ro/problema/rw Read / Write] ca aplicație la parsing
* [https://www.nerdarena.ro/problema/campionat Campionat] dată la OJSEPI 2021, clasa 7-a
* [https://www.nerdarena.ro/problema/puzzle3 Puzzle3] dată la OJI 2018, clasa a 7-a

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_15:_Citire_/_scriere_rapid%C4%83&action=edit&redlink=1 Accesează rezolvarea temei 15]

Clasa a 7-a Lecția 13: Analiză amortizată (2)

2026-02-06T16:13:04Z

Cristian:

== Înregistrare video curs ==

<youtube height="720" width="1280">https://youtu.be/_oXoXO7EEWY</youtube>

== Problema Unific ==

Problema [https://www.nerdarena.ro/problema/unific Unific] a fost dată la OJI 2013 clasa a 7-a. Problema definește o procedură prin care două numere pot fi unificate, dacă au măcar o cifră în comun. Apoi cere să se aplice pe un vector unificări de elemente adiacente până ce nu se mai poate unifica nimic. Întotdeauna se va face prima unificare posibilă de la începutul vectorului.

Soluția forță brută este să căutăm prima pereche unificabilă de la începutul vectorului și să o unificăm. Apoi reluăm, de la începutul vectorului. Ea este pătratică, deci '''va depăși timpul pe teste mari'''.

O soluție mai bună este ca la momentul citirii unui număr nou să îl unificăm cu el dinainte, apoi rezultatul cu cel dinainte și tot așa până ce nu mai putem unifica. Apoi citim următorul număr și reluăm.

Ce complexitate are această soluție?

La prima vedere un număr nou poate fi unificat de cel mult n ori, ceea ce duce la o complexitate pătratică. Desigur că nu e așa. Deoarece fiecare număr poate fi adăugat o singură dată și eliminat o singură dată (prin unificare) rezultă că '''numărul de unificări este maxim 2n. Analiza amortizată ne spune că soluția este liniară în numărul de unificări'''.

O parte grea este unificarea propriu zisă. Deși algoritmul este clar, există destule cazuri particulare, iar implementarea dă suficiente bătăi de cap, așa încât mulți elevi au greșit-o la olimpiadă, denumind-o ''problemă tractor''.

În realitate nu este chiar așa, ea putându-se implementa în circa 90 de linii de cod.

=== Implementare soluție ===

==== Subprograme cu parametri de ieșire ====

În problema de față ne poate fi folositoare o funcție care returnează valori folosind parametri de ieșire. Un parametru de ieșire reprezintă o variabilă care păstrează valoarea calculată în funcție și în afara ei. Am mai vorbit despre ei, dar poate este un moment bun să reluăm.

Știm să scriem '''subprograme cu parametri de intrare''':

<syntaxhighlight lang="C" line>
int subprogram (int variabila1, int variabila2) {}
</syntaxhighlight>

Pentru a putea avea un parametru de ieșire, suntem vom declara acest parametru ca pointer:

<syntaxhighlight lang="C" line>
int subprogram (int variabila1, int *variabila2) {}
</syntaxhighlight>

Vom avea grijă ca oriunde folosim <code>*variabila2</code> să păstram simbolul <code>*</code>.

Când chemăm subprogramul undeva, vom avea grijă să îi spunem compilatorului care este parametrul de ieșire:

<syntaxhighlight lang="C" line>
a = subprogram (var1, &var2);
</syntaxhighlight>

Simbolul <code>&</code> raportează adresa de memorie unde este stocată acea variabilă, astfel că, executarea programului va folosi adresele de memorie, nu valorile în sine din variabile. Așa se explică de ce trimitem parametrii comenzii <code>fscanf()</code> cu <code>&</code>, pentru ca funcția să poată returna variabilele modificate.

Iată un exemplu de program care folosește parametri de ieșire. Programul următor calculează suma și produsul a două numere într-un subprogram de tip <code>int</code>. Suma este returnată de către subprogram iar produsul de către parametrul de ieșire al subprogramului:

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

int suma_produs(int a, int b, int *produs) {
*produs = a * b;
return a + b;
}

int main()
{
FILE *fin, *fout;
int nr1, nr2, suma, prod;

fin = fopen("sp.in", "r");
fscanf(fin, "%d%d", &nr1, &nr2);
fclose(fin);

suma = suma_produs(nr1, nr2, &prod);

fout = fopen("sp.out", "w");
fprintf(fout, "%d %d\n", suma, prod);
fclose(fout);

return 0;
}
</syntaxhighlight>

Urmează sugestii de implementare. Le puteți ignora dacă doriți :-)

==== Programul principal ====

În programul principal:

* vom folosi '''o stivă''' în care vom păstra atâtea doar numere care nu mai pot produce o unificare. Să numim stiva <code>num[]</code>;
* vom determina '''cea mai folosită cifră''', prin încărcarea tuturor cifrelor într-un vector de frecvență. Să îl numim <code>c[]</code>. Pe măsură ce vom citi numerele la intrare, vom prelucra cifrele acestuia în vectorul <code>c</code>. Astfel rezolvăm punctul a al problemei;
* vom verifica '''dacă putem face o unificare'''. Vom verifica dacă stiva are cel puțin două elemente, și dacă da, vom apela o funcție care verifică dacă ultimele două elemente din stivă se pot unifica. Să numim această funcție <code>unific()</code>. Ea va avea antetul astfel: <code>long long unific (long long a, long long b)</code>. Funcția ne va returna una din situațiile:
** fie cele două numere se pot unifica și rezultă un nou număr, caz în care scoatem ultimele două numere din stivă și adăugăm noul număr; numărul de elemente din stivă scade cu unu.
** fie cele două numere se pot unifica și dispar, caz în care pur și simplu scoatem ultimele două elemente din stivă; numărul de elemente din stivă scade cu 2.
** fie cele două numere nu se pot unifica.
* doar în cazul în care ultimele două numere se pot unifica și rezultă un singur număr (primul din cele trei cazuri anterioare) vom continua procedura de unificare, verificând ultimele două numere pe stivă.

==== Subprogramul unific() ====

Antetul programului este:

<syntaxhighlight lang="C" line>
long long unific (long long a, long long b)
</syntaxhighlight>

Acesta va returna rezultatul unificării a două numere, a și b. Rezultatul poate avea unul dintre următoarele valori:

* numărul rezultat prin unificare;
* -1, dacă dispar ambele numere;
* -2, dacă nu se unifică.

Vom implementa procedura descrisă în cerință. Pentru a simplifica calculele, vom defini 2 vectori de frecvență, unul pentru fiecare număr. În <code>va[10]</code> vom salva cifrele numărului <code>a</code> și în <code>vb[10]</code> vom salva cifrele numărului <code>b</code>. Putem crea o altă funcție, care să calculeze acești vectori sau o putem face aici.

De asemenea, vom avea nevoie să calculăm cea mai mare putere a lui 10, mai mică sau egală cu <code>a</code>, respectiv cu <code>b</code>. Să le notăm <code>pa</code> și <code>pb</code>.

Vom parcurge cei doi vectori de frecvență, va și vb și vom vedea dacă găsim cel puțin o cifră comună. Dacă da, atunci trebuie să creăm noul număr. Pentru că există posibilitatea ca după unificare, ambele numere să nu mai aibă nici o cifră, vom crea noul <code>a</code> și noul <code>b</code>. Apoi vom verifica dacă oricare dintre cele două numere noi sunt diferite de 0. Dacă sunt diferite de 0, va trebui să construim numărul din nou.

Pentru a calcula noul <code>a</code> sau noul <code>b</code>, vom crea altă funcție, să o numim <code>nrnou()</code>.

==== Subprogramul nrnou() ====

Antetul programului este:

<syntaxhighlight lang="C" line>
long long nrnou (long long a, long long p10, int v[], int *nrcf)
</syntaxhighlight>

Acesta va returna noul număr și numărul lui de cifre în parametrul de ieșire <code>*nrcf</code>. Explicația parametrilor este următoarea:

* <code>a</code>: numărul din care se elimină cifrele;
* <code>pa</code>: puterea cea mai mare a lui 10 care încape în <code>a</code>, inițial;
* <code>v[]</code>: vectorul de frecvență al cifrelor rămase în noul număr. La apelare va fi de fapt vectorul <code>va[]</code> sau <code>vb[]</code>, pe care îl vom folosi pentru calcule;
* <code>nrcf</code>: numărul de cifre al noului număr (se calculeaza și returnează).

Modul de calcul ar trebui să fie deja evident. Câtă vreme sunt cifre în numărul <code>a</code>, vom calcula prima cifră cu ajutorul puterii pa și vom elimina prima cifră din <code>a</code>. Dacă cifra există în vectorul de frecvență o adăugăm la numărul nou construit. Vom actualiza numărul de cifre pentru noul număr.

Atenție, tot aici trebuie să ajustăm noul număr când singurele cifre rămase sunt 0.

== Problema MaxArea ==

Problema [https://www.nerdarena.ro/problema/maxarea MaxArea] a fost dată la concursul Shumen pentru juniori în 2015.

Rezolvarea folosește o stivă, similar cu problemele [https://www.nerdarena.ro/problema/tower Tower] sau [https://www.nerdarena.ro/problema/maxp MaxP]. Vom memora o stivă de dreptunghiuri de înălțimi din ce în ce mai mari. Când adăugăm o înălțime <code>h</code> vom închide toate dreptunghiurile de înălțimi mai mari de pe stivă. Apoi depunem pe stivă dreptunghiul curent.

Avem două cazuri, dacă dreptunghiul curent este de înălțime strict mai mare vom crea un nou dreptunghi pe stivă de ''lățime 1 + lățimea însumată a dreptunghiurilor eliminate''. Altfel, în caz de egalitate, vom mări lățimea dreptunghiului din vârful stivei cu același număr, ''1 + lătimea însumată a dreptunghiurilor eliminate''.

De remarcat că problema cere citirea a un milion de întregi de 5 cifre. Incluzând separatorul, spațiu, aceasta înseamnă circa 6MB. Soluția fiind ''O(n)'', la fel ca și citirea, este clar că ea va fi dominată ca timp de citire. De aceea este important să nu citim cu <code>fscanf()</code>, ci cu <code>fgetc()</code> (parsing în limbajul olimpicilor).

'''Observație:''' spre finalul numerelor pe stivă se vor afla foarte multe înălțimi egale. O optimizare ar fi, deci, să ''grupăm'' acele înălțimi. În loc de o înălțime putem stoca o pereche <code>(h, ap)</code> unde <code>ap</code> ne spune numărul de apariții ale acelei înălțimi. Când adăugăm o înălțime egală la stivă vom aduna de fapt 1 la <code>ap</code>. Astfel mărimea stivei rămâne mică.

== Problema Skyline ==

Problema [https://www.nerdarena.ro/problema/skyline Skyline] este o problemă clasică. Cere să se găsească dreptunghiul de arie maximă într-un skyline, unde un skyline este linia lăsată de zgârie-nori. Cu alte cuvinte o secvență de dreptunghiuri aliniate cu axa ''Ox''.

Rezolvarea folosește o stivă, similar cu problemele [https://www.nerdarena.ro/problema/tower Tower] sau [https://www.nerdarena.ro/problema/maxp MaxP]. Vom memora o stivă de dreptunghiuri de înălțimi din ce în ce mai mari. Când adăugăm un dreptunghi de înălțime <code>h</code> vom închide toate dreptunghiurile de înălțime mai mare de pe stivă, având grijă să le înlocuim cu un dreptunghi egal cu suma lungimilor lor și de înălțime egală cu <code>h</code>.

Complexitatea este ''O(n)'' prin analiză amortizată și ''O(n)'' memorie.

== Temă 13 ==

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

* [https://www.nerdarena.ro/problema/unific Unific] dată la OJI 2013 clasa a 7-a
* [https://www.nerdarena.ro/problema/maxarea MaxArea] dată la Shumen Juniori 2015
* [https://www.nerdarena.ro/problema/skyline Skyline] problemă clasică de analiză amortizată

== Tema opțională ==

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

* [https://www.nerdarena.ro/problema/dreptunghi1 Dreptunghi1] problemă clasică de analiză amortizată

[http://solpedia.francu.com/wiki/index.php/Clasa_a_7-a_Lec%C8%9Bia_13:_Analiz%C4%83_amortizat%C4%83_(2) Accesează rezolvarea temei 13]

Clasa a 7-a Lecția 12: Analiză amortizată (1)

2026-02-06T16:11:34Z

Cristian:

== Înregistrare video curs ==

<youtube height="720" width="1280">https://youtu.be/PW0OHW6kBeM</youtube>

== Despre analiza amortizată ==

Citat din [http://en.wikipedia.org/wiki/Introduction_to_Algorithms CLRS]: În analiza amortizată facem media timpului necesar pentru a executa o secvență operații, împărțindu-l la toate operațiile executate.

Prin analiza amortizată putem să arătăm că costul mediu al unei operații este mic, atunci când împărțim la numărul de operații, cu toate că o singură operație din secvență ar putea fi "scumpă". Acest cost mediu per operație se mai numește și costul amortizat.

Pentru a înțelege conceptul cât mai bine, iată un clip preluat de pe canalul [https://www.youtube.com/channel/UCTCvWvqjktIq0uvM3trAHCg NerdFirst]:

<youtube height="720" width="1280">https://youtu.be/T7W5E-5mljc</youtube>

În continuare vom lua câteva exemple clasice de analiză amortizată.

=== Incrementarea unui contor binar ===

Să presupunem că vrem să incrementăm un număr binar ale cărui cifre se află într-un vector. Numărul are <code>n</code> cifre, cea mai puțin semnificativă cifră (ultima din număr) fiind stocată prima în vector.

Cum arată această incrementare?

<syntaxhighlight lang="c" line>
i = 0;
while ( v[i] == 1 ) {
v[i] = 0;
i++;
}
v[i] = 1;
</syntaxhighlight>

Vom face această operațiune de <code>2n</code> ori, pentru a trece prin toate valorile binare posibile. Întrebarea este care este numărul de operații per incrementare?

Un răspuns intuitiv ar fi că numărul maxim de operații la o incrementare oarecare este <code>n</code>, deci probabil că numărul mediu de operații este <code>n/2</code>, ceea ce ne duce la un timp ''O(n)'' per incrementare. Desigur că răspunsul este incorect. Să încercăm să-l calculăm mai exact. Vom calcula numărul total de operații pe parcursul tuturor incrementărilor și îl vom împărți la numărul de incrementări, <code>2n</code>.

Să observăm că ultima cifră își va schimba valoarea la fiecare incrementare. Penultima numai din doi în doi. Antepenultima numai din patru în patru și așa mai departe. De unde rezultă că numărul total de cifre schimbate (egal cu numărul de operații total) este:

: <math>T(n) = 2^n + 2^{n-1} + 2^{n-2} + \cdots + 2^1</math>

Această sumă se calculează folosind formula sumei unei progresii geometrice, pe care o veți învăța abia în clasa a zecea. Până atunci să folosim un artificiu: să observăm că numărul <code>T(n)</code> este <code>111...110</code> în baza doi. El conține <code>n</code> cifre 1, iar ultima cifră este zero deoarece 20 lipsește din sumă.

Ce se întâmplă dacă adunăm 2 la acest număr? Vom obține:

: <math>111\ldots110_{(2)} + 2_{(10)} = 100\ldots0_{(2)} \quad \text{(1 urmat de } n+1 \text{ zerouri)} </math>

Acest număr este <code>2n+1</code>. Rezultă că:

: <math>T(n) + 2 = 2n + 1</math> și deci <math> T(n) = 2n + 1 - 2 </math>

Acesta este numărul total de operații, pentru toate incrementările. Împărțind la numărul de incrementări, care este <code>2n</code>, obținem aproximativ două operațiuni per incrementare!

Iată cum, folosind analiza amortizată, am obținut un rezultat mult mai bun.

În loc de ''O(n)'' am aflat că incrementarea unui contor binar este ''O(1)''!

=== Permutări ===

Am studiat în lecțiile trecute algoritmi de generare a permutărilor. Întrebarea, ca și la exercițiul anterior, este câte operații ne costă generarea unei permutări?

Un prim răspuns, intuitiv, este că trebuie să așezăm n elemente în vector pentru fiecare permutare, deci probabil costul este ''O(n)''. Desigur că este greșit. Să încercăm să îl calculăm:

==== Permutări cu liste ====

Să considerăm al doilea algoritm studiat, cel cu liste, deoarece calculul este mai ușor. În acest caz avem <math>n</math> niveluri de recursivitate, la fiecare nivel așezând cifre, astfel:

* pe nivelul <math>n</math> vom așeza <math>n</math> cifre;
* pentru fiecare cifră de pe nivelul <math>n</math>, pe nivelul <math>n-1</math> vom așeza <math>n-1</math> cifre;
* pentru fiecare cifră de pe nivelul <math>n-1</math>, pe nivelul <math>n-2</math> vom așeza <math>n-2</math> cifre;
* ...
* pentru fiecare cifră de pe nivelul <math>2</math>, pe nivelul <math>1</math> vom așeza o cifră.

'''Observație:''' ceea ce am denumit nivelul <math>n</math> este de fapt prima poziție în vectorul în care generăm permutările, nivelul <math>n-1</math> este de fapt a doua poziție, și așa mai departe, nivelul <math>1</math> fiind ultima poziție din vector.

''' Ce operațiuni efectuăm pe nivelul <math>k</math>? '''

În primul rând o parcurgere a tuturor elementelor, pentru a vedea dacă le putem folosi, deci <math>k</math> operații. Apoi, pentru fiecare element așezat vom chema recursiv funcția, deci vom avea <math>k</math> apeluri la nivelul <math>k-1</math>:

: <math> \begin{aligned}
T(k) &= k + k \cdot T(k - 1) \\[1em]
T(k) &= k + k \cdot \left( (k - 1) + (k - 1) \cdot \left( (k - 2) + (k - 2) \cdot \left( \cdots + 3 \cdot (2 + 2 \cdot T(1)) \cdots \right) \right) \right) \\[1em]
T(k) &= k + k(k - 1) + k(k - 1)(k - 2) + \cdots + k(k - 1)(k - 2) \cdots 3 + k(k - 1)(k - 2) \cdots 3 \cdot 2 + k(k - 1)(k - 2) \cdots 3 \cdot 2 \cdot T(1)\\[1em]
\end{aligned}
</math>

Dar <math>T(1)</math> este <math>1</math>, deoarece vom așeza un singur element. Așa încât:

: <math> \begin{aligned}
T(k) &= k + k(k - 1) + k(k - 1)(k - 2) + \cdots + k(k - 1)(k - 2) \cdots 3 + k(k - 1)(k - 2) \cdots 3 \cdot 2 + k(k - 1)(k - 2) \cdots 3 \cdot 2 \cdot 1 \\[1em]
T(k) &= \frac{k!}{(k - 1)!} + \frac{k!}{(k - 2)!} + \frac{k!}{(k - 3)!} + \cdots + \frac{k!}{2!} + \frac{k!}{1!} + \frac{k!}{0!} \\[1em]
T(k) &= k! \left( \frac{1}{(k - 1)!} + \frac{1}{(k - 2)!} + \frac{1}{(k - 3)!} + \cdots + \frac{1}{2!} + \frac{1}{1!} + \frac{1}{0!} \right)\\[1em]
\end{aligned}
</math>

Suma:

: <math>\frac{1}{0!} + \frac{1}{1!} + \frac{1}{2!} + \cdots + \frac{1}{(k - 1)!}</math>

va fi studiată în clasa a zecea. Se demonstrează că ea este mai mică decât o constantă <math>e = 2.71828...</math>. Drept pentru care:

: <math>T(k) \approx e \cdot k!</math>

Numărul total de operații se obține pentru <math>k = n</math>:

: <math>T(n) = e \cdot n!</math>

Deoarece avem <math>n!</math> permutări rezultă că generarea unei permutări ne costă ''O(e) = O(1)''!

Din nou un rezultat surprinzător. Desigur că acest rezultat nu ia în calcul afișarea permutărilor, ci doar generarea lor în vector.

==== Permutări cu vector de frecvență ====

Să considerăm acum primul algoritm, cel care folosește un vector de incluziune pentru a ști dacă o cifră a mai fost folosită, înainte de a o plasa pe poziția curentă. Calculul este similar, până ajungem la întrebarea cât ne costă să așezăm o cifră. Aici ne împotmolim, deoarece nu este clar.

La primul nivel ne costă o operație per cifră, dar undeva la mijloc vom face tot <math>n</math> operații pentru a așeza doar <math>n/2</math> cifre, deoarece parcurgem toate cifrele pentru a determina care sunt cele așezabile. Ce facem în acest caz? Să folosim din nou matematica. Să notăm cu <math>T(k)</math> costul pentru a așeza permutările de <math>k</math> (ultimele <math>k</math> poziții ale vectorului de permutări). În final ne va interesa <math>T(n)</math>.

Ce operațiuni efectuăm pe nivelul <math>k</math>? În primul rând o parcurgere a tuturor elementelor, pentru a vedea dacă le putem folosi, deci <math>n</math> operații. Apoi, pentru fiecare element așezat vom chema recursiv funcția, deci vom avea <math>k</math> apeluri la nivelul <math>k-1</math>:

: <math>\begin{aligned}
T(k) &= n + k \cdot T(k - 1) \\[1em]
T(k) &= n + k \left( n + (k - 1) \left[ n + (k - 2) \left( \cdots + 3(n + 2 \cdot T(1)) \cdots \right) \right] \right) \\[1em]
T(k) &= n + kn + k(k - 1)n + k(k - 1)(k - 2)n + \cdots + k(k - 1)(k - 2) \cdots 3 \cdot n + k(k - 1)(k - 2) \cdots 3 \cdot 2 \cdot T(1)
\end{aligned}
</math>

Dar <math>T(1)</math> este <math>n</math>, deoarece vom parcurge toate elementele și vom așeza unul singur. Așa încât:

: <math> \begin{aligned}
T(k) &= n + n \left( k + k(k - 1) + k(k - 1)(k - 2) + \cdots + k(k - 1)(k - 2) \cdots 3 + k(k - 1)(k - 2) \cdots 3 \cdot 2 \right) \\[1em]
T(k) &= n + n \left( \frac{k!}{(k - 1)!} + \frac{k!}{(k - 2)!} + \frac{k!}{(k - 3)!} + \cdots + \frac{k!}{2!} + \frac{k!}{1!} \right) \\[1em]
T(k) &= n + nk! \left( \frac{1}{(k - 1)!} + \frac{1}{(k - 2)!} + \frac{1}{(k - 3)!} + \cdots + \frac{1}{2!} + \frac{1}{1!} \right)
\end{aligned}
</math>

Suma dintre paranteze este, din nou, mai mică decât <math>e-1</math>, unde <math>e</math> este constanta <math>e = 2.71828....</math>. Drept pentru care:

: <math>T(k) \approx n + (e - 1) \cdot n \cdot k!</math>

Numărul total de operații se obține pentru <math>k = n</math>:

: <math>T(n) = n + (e - 1) \cdot n \cdot n!</math>

Atunci când împărțim acest număr la numărul de permutări generate, <math>n!</math>, obținem costul per permutare ca fiind aproximativ <math>(e - 1) \cdot n</math>, adică ''O(n)''. De unde rezultă că acest algoritm este inferior celui cu liste.

Ar trebui să vedem că algoritmul cu liste este de <math>x</math> ori mai rapid, unde <math display="inline">x = \frac{(e - 1) \cdot n}{e} = \left( 1 - \frac{1}{e} \right) \cdot n</math>. Pentru n=10 numărul <math>x</math> este circa <math>6.32</math>. În realitate vom obține mai puțin deoarece algoritmul cu liste are o constantă multiplicativă ceva mai mare. Pe algoritmii prezentați am măsurat circa <math>3.8</math>.

=== Clădiri vizibile ===

Să presupunem că avem <code>n</code> clădiri înșirate pe o stradă, lipite una de alta. Se cunosc înălțimile fiecărei clădiri. Mergând pe acoperișurile clădirilor ne întrebăm, pentru fiecare acoperiș, ce clădire vedem la acea înălțime uitându-ne spre stânga.

Să traducem această problemă în limbaj informatic: dat un vector v de n numere naturale să se calculeze un vector <code>w</code>, unde <code>w[i]</code> este <code>v[j]</code>, <code>j</code> cel mai mare indice <code>j</code> astfel încât <code>v[j] > v[i]</code>. Cu alte cuvinte pentru fiecare element din vectorul <code>v</code> vom căuta primul element înapoi mai mare decât el.

'''Soluția forță brută''' este ca pentru fiecare indice <code>i</code> să căutăm spre stânga primul indice <code>j</code> unde găsim un element mai mare. Această soluție este ''O(n2)''.

'''Soluție elegantă:''' parcurgem <code>v</code> și menținem o stivă <code>s</code> de elemente interesante, în care așezăm la rând elemente din <code>v</code>, astfel: la pasul <code>i</code> vom șterge din <code>s</code> ultimele elemente, cele mai mici decât <code>v[i]</code>. Ultimul element rămas în <code>s</code> este chiar <code>w[i]</code>. Apoi îl adăugăm pe <code>v[i]</code>.

'''Exemplu:'''

<syntaxhighlight lang="c" line>
Fie vectorul de înălțimi ''v = [7 3 2 5 4 3 9 7]''
Stiva s = []
Vectorul w = []

Pasul 0:
Scoatem din s toate elementele mai mici sau egale cu v[0] == 7
s este goală, nu există nici un element mai mare ca v[0] == 7
Calculăm w[0] = vîrful stivei = nu există, deci îl vom marca cu X
(X este o valoare ce indică lipsa unui element mai mare ca v[0] la stînga)
Adăugăm v[0] == 7 la s
Obținem:
v = [7 3 2 5 4 3 9 7]
w = [X]
s = [7]

Pasul 1:
Scoatem din s toate elementele mai mici sau egale cu v[1] == 3
Nu există astfel de elemente, deci stiva rămîne nemodificată
Calculăm w[1] = vîrful stivei = 7
Adăugăm v[1] == 3 la s
Obținem:
v = [7 3 2 5 4 3 9 7]
w = [X 7]
s = [7 3]

Pasul 2:
Scoatem din s toate elementele mai mici sau egale cu v[2] == 2
Nu există astfel de elemente, deci stiva rămîne nemodificată
Calculăm w[2] = vîrful stivei = 3
Adăugăm v[2] == 2 la s
Obținem:
v = [7 3 2 5 4 3 9 7]
w = [X 7 3]
s = [7 3 2]

Pasul 3:
Scoatem din s toate elementele mai mici sau egale cu v[3] == 5
Vom elimina ultimele două elemente, 3 și 2, deci stiva devine s = [7]
Calculăm w[3] = vîrful stivei = 7
Adăugăm v[3] == 5 la s
Obținem:
v = [7 3 2 5 4 3 9 7]
w = [X 7 3 7]
s = [7 5]

Pasul 4:
Scoatem din s toate elementele mai mici sau egale cu v[4] == 4
Nu există astfel de elemente, deci stiva rămîne nemodificată
Calculăm w[4] = vîrful stivei = 5
Adăugăm v[4] == 4 la s
Obținem:
v = [7 3 2 5 4 3 9 7]
w = [X 7 3 7 5]
s = [7 5 4]

Pasul 5:
Scoatem din s toate elementele mai mici sau egale cu v[5] == 3
Nu există astfel de elemente, deci stiva rămîne nemodificată
Calculăm w[5] = vîrful stivei = 4
Adăugăm v[5] == 3 la s
Obținem:
v = [7 3 2 5 4 3 9 7]
w = [X 7 3 7 5 4]
s = [7 5 4 3]

Pasul 6:
Scoatem din s toate elementele mai mici sau egale cu v[6] == 9
Vom elimina toate elementele din s, deci stiva devine vidă
Calculăm w[6] = vîrful stivei = nu există, deci îl vom marca cu X
Adăugăm v[6] == 9 la s
Obținem:
v = [7 3 2 5 4 3 9 7]
w = [X 7 3 7 5 4 X]
s = [9]

Pasul 7:
Scoatem din s toate elementele mai mici sau egale cu v[7] == 7
Nu există astfel de elemente, deci stiva rămîne nemodificată
Calculăm w[7] = vîrful stivei = 9
Adăugăm v[7] == 7 la s
Obținem:
v = [7 3 2 5 4 3 9 7]
w = [X 7 3 7 5 4 X 9]
s = [9 7]
</syntaxhighlight>

Ce complexitate are acest algoritm? Ar părea că la fiecare pas putem scoate din vectorul s n elemente, caz în care algoritmul ar avea complexitate ''O(n2)''. Să încercăm să calculăm numărul total de operații.

Deși nu știm câte operații vom face la fiecare pas, observăm următorul lucru: fiecare element din vectorul <code>v</code> este adăugat fix o dată și scos fix o dată. Atunci când eliminăm elemente din <code>s</code> scoatem acele elemente adăugate anterior. Drept pentru care numărul total de operații va fi <code>2n</code>.

Complexitatea amortizată a adăugării unui element în s este, de fapt ''O(1)'', iar întregul algoritm are complexitate ''O(n)''.

=== Problema bibliotecarului ===

Un bibliotecar primește cărți una câte una și le returnează în aceeași ordine, la cerere. În spatele ghișeului el are doi subalterni. Bibliotecarul trebuie să dea cărțile primite unuia din subalterni. Poate de asemenea să ceară înapoi cărți de la subalterni. Fiecare subaltern ține o stivă de cărți. Atunci când bibliotecarul îi dă o carte subalternul o pune peste toate celelalte, în stiva sa. Atunci când bibliotecarul îi cere o carte o ia pe prima din stivă și i-o returnează. Voi trebuie să găsiți algoritmul de funcționare a bibliotecarului astfel încât după un număr mare de depuneri și cereri de cărți numărul total de operații (înmânări de cărți) să fie cât mai mic din punct de vedere al complexității. Puteți presupune că vor fi 500000 de depuneri de cărți și 500000 de cereri, în orice ordine coerentă.

Rezolvarea directă, evidentă, este, surprinzător, și cea corectă: bibliotecarul va da toate cărțile primite subalternului 1. Când i se cere o carte, i-o va cere subalternului 2. Dacă subalternul 2 nu are cărți atunci el îi va cere, pe rând cărți subalternului 1 și i le va da subalternului 2, până ce subalternul 1 nu mai are cărți. Apoi returnează cartea pe care i-o va da subalternul 2.

'''Funcționează corect acest algoritm?'''

Desigur, urmăriți un exemplu și vă veți convinge. Dar pare foarte ineficient! Pentru o carte cerută este posibil ca bibliotecarul să facă n operații! Să facem același calcul ca și mai devreme: orice carte va fi depusă la primul subaltern, apoi scoasă și depusă la cel de-al doilea subaltern și apoi returnată. Drept pentru care numărul total de operații va fi 3n, iar costul amortizat al unei operații de depunere sau de scoatere va fi ''O(1)''.

=== Problema StrGen ===

Problema [https://www.nerdarena.ro/problema/strgen strgen] a fost dată la testul de evaluare Nerdvana din 1 noiembrie 2023.

Am dat această problemă în ideea rezolvării cu liste, dar am menționat atunci că există o rezolvare cu două stive și analiză amortizată. Să o reluăm.

==== Soluție cu două stive ====

Există o soluție eficientă ce folosește două stive. Prima stivă este cea în care adăugăm atunci când inserăm un caracter. La momentul avansului poziției scoatem un caracter din prima stivă și îl depunem într-o a doua stivă.

Dacă nu vom ajunge să reluăm poziția de la 1, înseamnă că șirul nostru final este format din caracterele din stiva 2 afișate în sens invers scoaterii din stivă, urmate de caracterele din stiva 1 afișate în sensul scoaterii din stivă.

Ce facem dacă poziția se reia de la 1? Înseamnă că stiva 1 devine goală. Caz în care vom scoate elementele din stiva 2, unul câte unul, și le vom depune în stiva 1. Astfel stiva 2 devine goală, iar stiva 1 conține caracterele șirului curent.

La final afișăm stiva 2 în sens invers și stiva 1 în sens direct.

Iată un program posibil (26 de linii de cod efectiv):

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

#define MAXL 2000000

char stiva1[MAXL + 1] = { '$' }, stiva2[MAXL + 1];

int main() {
FILE *fin, *fout;
char ch;
int i, n1 = 1, n2 = 0;

fin = fopen( "strgen.in", "r" );
while ( (ch = fgetc( fin )) != '\n' )
if ( ch == '>' ) {
stiva2[n2++] = stiva1[--n1];
if ( n1 == 0 )
while ( n2 > 0 )
stiva1[n1++] = stiva2[--n2];
} else
stiva1[n1++] = ch;
fclose( fin );

fout = fopen( "strgen.out", "w" );
for ( i = 0; i < n2; i++ )
fputc( stiva2[i], fout );
for ( i = n1 - 1; i >= 0; i-- )
fputc( stiva1[i], fout );
fputc( '\n', fout );
fclose( fout );

return 0;
}
</syntaxhighlight>

Ce complexitate are această soluție?

La prima vedere pare că fiecare operație poate fi ''O(N)'' ceea ce ar rezulta într-o complexitate de ''O(N2)''. În realitate nu este așa, deoarece pentru fiecare caracter scos din stiva 2 și inserat în stiva 1 vom avea o operație de scoatere din stivă ce se va efectua în ''O(1)''. Suma tuturor operațiilor nu poate depăși ''O(N)''.

Câtă memorie folosim? Desigur tot ''O(N)'', circa 2 bytes per element, deci 2MB (mai puțină decât în soluția cu listă).

== Concluzii ==

Cu aceasta am încheiat exemplele de analiză amortizată. Remarcați ce au ele în comun: de cele mai multe ori în analiza amortizată avem o stivă. Un vector în care depunem la coadă elemente și din care ștergem tot de la coadă toate elementele mai mari ca elementul pe care îl adăugăm. Evident poate fi pe dos în cazul când ne interesează minime.

Oare ne folosește la ceva analiza amortizată, sau este doar ceva pur academic?

Ei bine, ea se dă destul de frecvent la olimpiadă (este posibil să nu o fi remarcat până acum pentru că nu știați semnalmentele după care să vă uitați). În lecția următoare vom vedea probleme cu analiză amortizată date la olimpiada de informatică și alte concursuri.

== Temă 12 ==

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

* [https://www.nerdarena.ro/problema/tower Tower], dată la Shumen 2016 juniori
* [https://www.nerdarena.ro/problema/nrtri NrTri], dată pregătire Vianu clasa a 9-a

== Tema opțională ==

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

* [https://www.nerdarena.ro/problema/nrtri1 NrTri1], problemă identică cu [https://www.nerdarena.ro/problema/nrtri NrTri] cu limitele modificate.

[http://solpedia.francu.com/wiki/index.php/Clasa_a_7-a_Lec%C8%9Bia_12:_Analiz%C4%83_amortizat%C4%83_(1) Accesează rezolvarea temei 12]

Clasa a 7-a Lecția 11: Numere mari, exponențiere rapidă, element majoritar

2026-02-06T16:09:29Z

Cristian:

== Înregistrare video lecție ==

<youtube height="720" width="1280">https://youtu.be/YwpoxbhQoBM</youtube>

== Operații cu numere mari ==

=== Reprezentarea numerelor mari ===

Unele probleme necesită lucrul cu numere mai mari decât ne permite tipul <code>long long</code> (cu aproximație 18 cifre zecimale, mai exact 264).

Ce facem în acest caz? Stocăm aceste numere în vectori, câte o cifră în fiecare element al vectorului.

Numerele mari se reprezintă într-un vector, ultima lor cifra pe prima poziție a vectorului, penultima pe a doua poziție, și așa mai departe. De exemplu, numărul '''24537''' se reprezintă ca în figura alăturată.

[[Image:nr-mare-1.gif|frame|none|Reprezentarea în vector a unui număr mare]]

Observați că am reprezentat vectorul invers, de la dreapta la stânga, pentru ușurința citirii numărului.

De ce reprezentăm cifrele numărului de la coadă la cap? Deoarece atunci când numerele cresc sau se micșorează cifrele lor nu trebuie deplasate în vector pentru a rămâne aliniate la începutul vectorului.

Observăm că vectorul <code>v</code> are ca elemente cifre, adică întregi cuprinși între 0 și 9. Pentru a folosi cât mai puțină memorie vom folosi cel mai mic întreg existent în limbajul C și anume tipul caracter. Să nu uităm că tipul caracter poate fi văzut atât ca și caracter cât și ca un întreg pe opt biți, cuprins între -128 și 127. Această reprezentare a numerelor mari se numește reprezentarea în zecimal despachetat: <code>char v[100]</code> .

Pentru cei curioși există și reprezentarea zecimal împachetat, în care reprezentăm două cifre zecimale pe caracter, respectiv o cifră pe primii 4 biți și o cifră pe ultimii patru biți. În această lecție nu vom vorbi despre această reprezentare.

De asemenea, pentru un număr mare trebuie să ținem minte și numărul său de cifre. În exemplul nostru acesta este 5. Printre olimpici circulă o versiune de numere mari în care numărul de cifre este memorat chiar în primul element al vectorului, <code>v[0]</code>. Aceasta nu este o idee bună din mai multe motive:

* Dacă numărul mare are mai mult de 255 de cifre vom depăși tipul unsigned char.
* Amestecă un număr de cifre cu cifrele însele, punând la grămadă mere cu dovlecei.
* Codul devine mai greu citibil.

Ca ultimă mențiune, trebuie să avem grijă ca cifrele nefolosite din vector să fie setate la zero. Acest lucru este foarte important atunci când numărul poate să crească, cum ar fi la adunare, sau înmulțire.

=== Afișarea numerelor mari ===

Cum afișăm un număr mare?

Afișând toate cifrele sale de la final de vector spre început. Avem însă un caz particular: numărul zero. Convenția de reprezentare a unui număr mare este ca prima lui cifră (cea mai semnificativă) să fie nenulă.

În cazul lui zero acest lucru nu se poate. De aceea numărul mare zero va fi reprezentat ca având zero cifre. De aceea, la afișare nu vom afișa nimic, deoarece vom încerca să afișăm zero cifre. Acesta este cazul particular la afișare, dacă numărul mare are zero cifre vom afișa zero.

Iată codul de afișare a unui număr mare:

<syntaxhighlight lang="c" line>
if ( n == 0 )
fprintf( fout, "0\n" );
else {
for ( i = n; i > 0; i-- )
fputc( '0' + v[i-1], fout );
fputc( '\n', fout );
}
</syntaxhighlight>

=== Adunarea unui număr mic la unul mare ===

Fie <code>v</code> un număr mare cu <code>n</code> cifre. Dorim să adunăm la el un număr ''mic'', <code>a</code>.

Pentru aceasta vom proceda similar cu procedura de adunare ''de mână'': vom aduna a la prima cifră a numărului, vom stoca pe prima poziție ultima cifră a acestui număr, apoi vom calcula transportul prin împărțire la zece. Acest transport se adună la a doua cifră, stocând ultima cifră a rezultatului pe a doua poziție și calculând noul transport prin împărțire la zece.

Diferența față de adunarea ''de mână'' este că transportul poate fi mai mare decât 9. Iată secvența de cod care adună numărul mare <code>(n, v)</code> cu numărul <code>a</code>:

<syntaxhighlight lang="c" line>
i = 0;
while ( a > 0 ) {
a += v[i];
v[i] = a % 10;
a /= 10;
i++;
}
if ( i > n )
n = i;
</syntaxhighlight>

=== Scăderea unui număr mic din unul mare ===

Scăderea unui număr mic din unul mare este similară cu adunarea.

Transportul va fi negativ. Trebuie însă să fim atenți la un lucru: operația <code>%</code> (modulo) în C nu se comportă ca la matematică. La matematică restul împărțirii a două numere este pozitiv sau zero. În C restul împărțirii unui număr negativ la unul pozitiv este negativ sau zero. De aceea codul trebuie modificat față de adunare pentru a calcula restul pozitiv al împărțirii la zece.

De asemenea trebuie să avem grijă să scădem numărul de cifre, dacă este cazul. Vom păstra în <code>n</code> poziția ultimei cifre diferite de zero. Iată secvența de cod care scade numărul mic a din numărul mare <code>(n, v)</code>:

<syntaxhighlight lang="c" line>
a = -a;
i = 0;
while ( a < 0 ) {
a += v[i];
v[i] = a % 10;
a /= 10;
if ( v[i] < 0 ) {
v[i] += 10;
a--;
}
i++;
}
// ajustam numarul de cifre, deoarece primele cifre pot fi zero
while ( n > 0 && v[n-1] == 0 )
n--;
</syntaxhighlight>

'''Atenție''': programul de mai sus presupune că '''numărul mic este mai mic sau egal cu numărul mare'''.

=== Adunarea a două numere mari ===

Adunarea a două numere mari este similară cu adunarea unui număr mare cu unul mic.

Vom folosi un transport și vom aduna cifră cu cifră cele două numere mari. În final vom testa dacă mai avem transport. Dacă avem el este maxim o cifră (demonstrați). Iată secvența de cod care adună numărul mare <code>(n2, v2)</code> la <code>(n1, v1)</code> depunând rezultatul tot în <code>(n1, v1)</code>:

<syntaxhighlight lang="c" line>
n1 = n1 < n2 ? n2 : n1;
t = 0;
for ( i = 0; i < n1; i++ ) {
t = t + v1[i] + v2[i];
v1[i] = t % 10;
t /= 10;
}
if ( t > 0 ) {
v1[i] = t;
n1++;
}
</syntaxhighlight>

=== Scăderea a două numere mari ===

Scăderea a două numere mari este similară cu scăderea unui număr mare din unul mic.

Vom folosi un transport negativ și vom scădea cifră cu cifră cele două numere mari. După ce se termină cifrele numărului de scăzut vom continua scăderea până ce transportul devine zero.

Ca și la scăderea unui număr mic va trebui să avem grijă să scădem numărul de cifre dacă este cazul. Iată secvența de cod care scade numărul mare <code>(n2, v2)</code> din numărul mare <code>(n1, v1)</code>:

<syntaxhighlight lang="c" line>
t = i = 0;
while ( i < n2 || t < 0 ) {
t = t + v1[i] - v2[i];
v1[i] = t % 10;
t /= 10;
if ( v1[i] < 0 ) {
v1[i] += 10;
t--;
}
i++;
}
// ajustam numarul de cifre, deoarece primele cifre pot fi zero
while ( n1 > 0 && v1[n1-1] == 0 )
n1--;
</syntaxhighlight>

=== Înmulțirea unui număr mare cu unul mic ===

Înmulțirea unui număr mare cu unul mic este similară cu adunarea unui număr mare cu unul mic.

Vom folosi un transport la care adunăm cifra curentă înmulțită cu numărul mic. Ultima cifră a transportului se stochează în cifra curentă, iar transportul se împarte la zece, apoi trecem la cifra următoare. După ce se termină cifrele numărului mare vom continua procedura până ce transportul devine zero. Trebuie să avem grijă să actualizăm numărul de cifre dacă este cazul.

Iată secvența de cod care înmulțește numărul mic <code>a</code> cu numărul mare <code>(n, v)</code>:

<syntaxhighlight lang="c" line>
t = i = 0;
while ( i < n || t > 0 ) {
t = t + a * v[i];
v[i] = t % 10;
t /= 10;
i++;
}

if ( i > n )
n = i;

if ( i > n )
n = i;
</syntaxhighlight>

=== Împărțirea unui număr mare la unul mic ===

Împărțirea unui număr mare la unul mic se face invers față de celelalte operații de până acum.

Vom parcurge numărul mare de la cea mai semnificativă cifră (cifra cu indice <code>n - 1</code>) către cifra de indice zero (prima din vector). Vom avea un rest curent; vom adăuga fiecare cifră a numărului mare la coada restului, înmulțind restul cu zece și adunând cifra. Împărțind restul curent la numărul mic obținem încă o cifră din cât, pe care o putem suprascrie peste cifra din numărul mare. La final vom avea câtul în numărul mare, iar ultimul rest este chiar restul împărțirii.

Este posibil câtul să aibă mai puține cifre decât numărul original, drept pentru care va trebui să reducem numărul de cifre căutând prima sa cifră nenulă.

Iată secvența de cod care împarte numărul mare <code>(n, v)</code> la numărul mic <code>a</code>:

<syntaxhighlight lang="c" line>
t = 0;
for ( i = n - 1; i >= 0; i-- ) {
t = t * 10 + v[i];
v[i] = t / a;
t %= a;
}
// ajustam numarul de cifre, deoarece primele cifre pot fi zero
while ( n > 0 && v[n-1] == 0 )
n--;
</syntaxhighlight>

== Exponențiere rapidă ==

Calculați <code>an</code> în mod cât mai eficient (<code>a</code> și <code>n</code> numere naturale). Problema este cunoscută şi sub numele de ridicare la putere în timp logaritmic. Ideea din spatele acestei rezolvări este următoarea:

* Dacă <code>n</code> este par, atunci <code>an = a2*n/2 = (a2)n/2</code>
* Dacă <code>n</code> este impar, atunci <code>n-1</code> este par și avem <code>an = a * an-1 = a * a2*(n-1)/2 = a * (a2)(n-1)/2 = a * (a2)n/2</code>

În formulele de mai sus am considerat că <code>/</code> este împărțirea întreagă din limbajul C. De aceea atunci când <code>n</code> este impar <code>(n-1)/2</code> este totuna cu <code>n/2</code>.

Se observă că indiferent de paritatea lui <code>n</code>, la fiecare pas al iterației putem transforma <code>a</code> în <code>a * a</code> și apoi putem împărți <code>n</code> la 2. Doar în cazurile când <code>n</code> este impar vom acumula valoarea curentă a lui <code>a</code> la produsul calculat.

Iată soluția bazată pe această idee:

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

int main() {
int a, n;
scanf("%d%d", &a, &n);

int p = 1;
while (n > 0) {
if (n % 2 == 1)
p = p * a;
a = a * a;
n = n / 2;
}
printf("%d", p);
}
</syntaxhighlight>

Ce complexitate are acest algoritm? De câte ori se va executa bucla <code>while</code>? La fiecare pas al buclei <code>n</code> se împarte la doi.

De câte ori putem împărți un număr <code>n</code> la doi, înainte ca el să devină zero? Să considerăm cel mai mic <code>k</code> astfel încât <code>n≤2k</code>. Este destul de clar că bucla noastră while se va executa de <code>k</code> ori, deci complexitatea algoritmului este ''O(k)''.

Dar, precum am menționat la exercițiul anterior, dacă avem <code>k</code> astfel încât <code>2k=n</code>, atunci ''k=O(log n)'', deci complexitatea acestei soluții va fi logaritmică, ''O(log n)''.

Ce înseamnă acest lucru? Că timpul necesar calculului este proporțional cu un număr <code>k</code>, unde <code>k</code> este exponentul lui 2 astfel încât <code>n≤2k</code>.

== Element majoritar ==

[https://www.nerdarena.ro/problema/majoritar Majoritar]: dat un vector cu n elemente să se spună dacă conține un element majoritar. Un element majoritar este un element care apare de cel puțin <code>n/2 + 1</code> ori. Încercați să dați o soluție mai bună decât sortarea.

'''Răspuns'''

Dacă există un element majoritar, <code>maj</code>, rezultă că fiecare din elementele vectorului diferite de <code>maj</code> poate fi cuplat cu un element egal cu <code>maj</code> astfel încât după ce toate cuplările au fost făcute să rămână cel puțin un element <code>maj</code> necuplat. Ideea de rezolvare este să simulăm această cuplare. Vom porni cu primul element al vectorului ca un candidat de element majoritar. Parcurgem elementele vectorului ținând minte câți candidați necuplați avem. De fiecare dată când dăm peste un element egal cu candidatul incrementăm numărul de elemente necuplate. Când dăm peste un element diferit scădem numărul de elemente necuplate. Dacă la un moment dat vom avea zero candidați necuplați și mai vine un element diferit de candidat rezultă că am eliminat din vector un număr egal de candidați și non-candidați, drept pentru care putem reporni problema pentru vectorul rămas: vom considera elementul curent drept candidat, cu o apariție.

La final vom rămâne cu un candidat ce trebuie acum verificat: numărăm de câte ori apare el in vector printr-o parcurgere. Dacă apare de măcar <code>n/2+1</code> ori am găsit elementul majoritar, altfel el nu există.

Iată o implementare posibilă:

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

int v[3000000];

int main() {
FILE *fin, *fout;
int n, i, nr, maj;

// citire vector
fin = fopen( "majoritar.in", "r" );
fscanf( fin, "%d", &n );
for ( i = 0; i < n; i++ )
fscanf( fin, "%d", &v[i] );
fclose( fin );

// cautam candidatul la element majoritar
maj = v[0];
nr = 1;
for ( i = 1; i < n; i++ )
if ( v[i] == maj ) // cita vreme avem maj incrementam numarul de maj gasite
nr++;
else {
nr--; // altfel decrementam numarul de maj
if ( nr < 0 ) { // daca am scazut sub zero
maj = v[i]; // alegem drept candidat elementul curent
nr = 1; // care apare o data
}
}

// verificare candidat la element majoritar
nr = 0;
for ( i = 0; i < n; i++ ) // numaram de cit ori apare maj in vector
if ( v[i] == maj )
nr++;

fout = fopen ( "majoritar.out", "w" );
if ( nr > n / 2 ) // daca maj apare de mai mult de n/2 ori este majoritar
fprintf( fout, "%d %d\n", maj, nr );
else
fprintf( fout, "-1\n" );
fclose( fout );
}
</syntaxhighlight>

Ce complexitate are acest algoritm?

Timpul este evident liniar, ''O(n)''. Dar memoria?

Memoria este și ea ''O(n)''. Există o mică confuzie aici, putem avea senzația că nu este nevoie să memorăm elementele parcurse. De fapt trebuie să le memorăm deoarece avem nevoie de ele la pasul doi, cel în care verificăm candidatul.

== Temă 11 ==

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

* [https://www.nerdarena.ro/problema/fib Fib] problemă de adunare a două numere mari
* [https://www.nerdarena.ro/problema/anaf ANAF] problemă de operații între numere mari și numere mici

== Temă opțională ==

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

* [https://www.nerdarena.ro/problema/cod Cod] dată la ONI 2016 clasa a 6-a

[http://solpedia.francu.com/wiki/index.php/Clasa_a_7-a_Lec%C8%9Bia_11:_Numere_mari,_exponen%C8%9Biere_rapid%C4%83,_element_majoritar Accesează rezolvarea temei 11]

Clasa a 7-a Lecția 10: Fill recursiv (flood fill)

2026-02-06T16:06:58Z

Cristian:

== Înregistrare video lecție ==

<youtube height="720" width="1280">https://youtu.be/EB97GkmjVgQ</youtube>

== Despre flood fill ==

Algoritmul fill ''umple'' toate golurile accesibile de la un punct dat.

Golurile pot fi elemente zero într-o matrice, de exemplu, iar vecinii pot fi definiți ca elementele adiacente pe linie și coloană (acesta este cazul cel mai întâlnit). Alteori vecinii pot fi definiți ca având un punct comun cu elementul curent, ceea ce include și elementele alăturate pe diagonală.

Să luăm un exemplu clasic:

Se dă o matrice <code>a[m][n]</code> cu elemente 0 și 1, 0 semnificând liber și 1 semnificând zid, precum și o poziție în matrice, ''(l, c)''. Să se spună câte elemente 0 sunt accesibile de la ''(l, c)'' avansând doar pe linie sau pe coloană.

<syntaxhighlight lang="c" line>
int fill( int l, int c ) { // umple de la coloana l, c
int suma = 1; // contorizam punctul curent

a[l][c] = 1; // marcam pozitia ca parcursa
if ( l > 0 && a[l-1][c] == 0 ) // ne deplasam in sus
suma += fill( l - 1, c );
if ( l < m-1 && a[l+1][c] == 0 ) // ne deplasam in jos
suma += fill( l + 1, c );
if ( c > 0 && a[l][c-1] == 0 ) // ne deplasam spre stinga
suma += fill( l, c - 1 );
if ( c < n-1 && a[l][c+1] == 0 ) // ne deplasam spre dreapta
suma += fill( l, c + 1 );

return suma;
}
...
int main() {
int suma;
...
suma = 0;
if ( a[l][c] == 0 )
suma = fill( l, c );
printf( "%d", suma );
...
}
</syntaxhighlight>

'''Observații:'''

* Ordinea direcțiilor nu contează. Cele patru apeluri recursive pot fi în orice ordine.
* Vecinii pot fi în număr de 4 - cei adiacenți pe linie și pe coloană, ca în exemplul de mai sus, sau pot fi în număr de 8 - și cei adiacenți pe diagonale.

Ce complexitate are acest algoritm?

Acest algoritm are complexitate ''O(m·n)'' ca timp, deoarece poate parcurge toate elementele matricei, iar prelucrarea per element este ''O(1)''. Memoria ocupată este de asemenea ''O(m·n)'' deoarece fiecare apel recursiv necesită ''O(1)'' memorie și putem avea ''O(m·n)'' apeluri recursive unul în altul.

'''Atenție!''' Acesta este principalul impediment al metodei! Ea folosește foarte multă memorie suplimentară.

== Exemplificare grafică ==

Să vedem niște vizualizări ale algoritmului flood fill preluate de la wikipedia: [https://en.wikipedia.org/wiki/Flood_fill algoritm flood fill].

{| class="wikitable" style="text-align: center;"
| [[File:Recursive_Flood_Fill_4_wikipedia.gif|thumb|center|200px|Flood fill cu 4 direcții]]
| [[File:Recursive_Flood_Fill_8_wikipedia.gif|thumb|center|200px|Flood fill cu 8 direcții]]
| [[File:Wfm_floodfill_animation_stack_wikipedia.gif|thumb|center|200px|Exemplu mare de flood fill cu 4 direcții]]
|}

== Optimizări ale algoritmului ==

=== Bordare matrice ===

O primă optimizare de timp este clasică. Pentru a face programul atât mai rapid cât și mai scurt putem borda matricea de jur împrejur cu elementul zid, în cazul nostru 1. Astfel vom scuti testul de ieșire a coordonatelor din matrice.

Funcția se simplifică:

<syntaxhighlight lang="c" line>
int fill( int l, int c ) { // umple de la coloana l, c
int suma = 1; // contorizam punctul curent

a[l][c] = 1; // marcam pozitia ca parcursa
if ( a[l-1][c] == 0 ) // ne deplasam in sus
suma += fill( l - 1, c );
if ( a[l+1][c] == 0 ) // ne deplasam in jos
suma += fill( l + 1, c );
if ( a[l][c-1] == 0 ) // ne deplasam spre stinga
suma += fill( l, c - 1 );
if ( a[l][c+1] == 0 ) // ne deplasam spre dreapta
suma += fill( l, c + 1 );

return suma;
}
</syntaxhighlight>

=== Reducere memorie folosită ===

''' Cum calculăm memoria ocupată? '''

Țineți minte: fiecare apel recursiv ocupă memorie echivalentul unui int. Pe un calculator de 32 de biți, cum sunt cele pe care lucrăm noi (ele sunt de fapt de 64 de biți, dar programele sunt compilate în modul 32 de biți), aceasta înseamnă patru octeți.

Aceasta este adresa de întoarcere din funcție. Alte elemente care ocupă memorie pe stivă sunt parametrii transmiși și variabilele declarate în funcție. În cazul nostru vom avea 16 octeți cei doi parametri, variabila declarată în funcție și adresa de întoarcere din funcție.

Dacă micșorarea memoriei folosite este esențială putem elimina 12 octeți din 16, declarând variabilele <code>l</code>, <code>c</code> și <code>suma</code> globale, astfel:

<syntaxhighlight lang="c" line>
int l, c, suma; // variabile globale
...
void fill() {
suma++;
a[l][c] = 1;
l--;
if ( a[l][c] == 0 ) // apelam pentru (l - 1, c)
fill();
l++;
l++;
if ( a[l][c] == 0 ) // apelam pentru (l + 1, c)
fill();
l--;
c--;
if ( a[l][c] == 0 ) // apelam pentru (l, c - 1)
fill();
c++;
c++;
if ( a[l][c] == 0 ) // apelam pentru (l, c + 1)
fill();
c--; // acum (l, c) sunt cele de la inceput
}
</syntaxhighlight>

Este o modificare urâtă, care face codul nelizibil, dar uneori necesară la olimpiadă. Nu uitați că chiar și în această formă algoritmul va folosi 4 octeți pe apel recursiv imbricat pentru adresa de revenire din funcție.

Observație: variabilele <code>l</code> și <code>c</code> fiind globale ele trebuie să aibă aceeași valoare la ieșirea din funcție ca și la intrarea în funcție. De aceea ultima instrucțiune <code>c--;</code> este importantă!

== Aplicații ce folosesc flood fill și concluzii ==

=== Găsire ieșire din labirint ===

Folosind flood fill putem găsi un punct de ieșire dintr-un labirint memorat într-o matrice. Să presupunem că elementele ''0'' înseamnă loc gol și cele ''1'' înseamnă zid. Ieșirile sunt puncte ''0'' pe marginile matricei. Dat un punct din interiorul matricei, există un drum spre ieșire? Dacă da, putem găsi atât coordonatele ieșirii cât și drumul parcurs.

Iată un exemplu de program care afișează coordonatele ieșirii:

<syntaxhighlight lang="c" line>
int fill( int l, int c ) {
int retval;

if ( lab[l][c] == BORDER ) // am ajuns la margine?
return l * MAXN + c; // returnam (l, c)

lab[l][c] = 1; // marcam punctul curent ca vizitat
retval = 0; // 0 inseamna ca nu am gasit iesire
if ( lab[l + 1][c] != 1 ) // daca nu este zid
retval = fill(l + 1, c); // cautam in jos
if ( retval == 0 ) { // daca nu am gasit iesire
if ( lab[l - 1][c] != 1 ) // si nu este zid
retval = fill(l - 1, c); // cautam in sus
if ( retval == 0 ) { // daca nu am gasit iesire
if ( lab[l][c + 1] != 1 ) // si nu este zid
retval = fill(l, c + 1); // cautam in dreapta
if ( retval == 0 ) // daca nu am gasit iesire
if ( lab[l][c - 1] != 1 ) // si nu este zid
retval = fill(l, c - 1); // cautam in stinga
}
}

return retval;
}

int main() {
FILE *fin, *fout;
int n, l, c, ls, cs, p;

fin = fopen( "iesire.in", "r" );
fscanf( fin, "%d%d%d ", &n, &ls, &cs );
for ( l = 0; l < n; l++ ) {
for ( c = 0; c < n; c++ ) // citim linia l a matricei
lab[l][c] = fgetc( fin ) - '0';
fgetc( fin ); // citim '\n'
}
fclose( fin );
for ( c = 0; c < n; c++ ) { // bordare conditionala margini
if ( lab[0][c] == 0 )
lab[0][c] = BORDER;
if ( lab[n - 1][c] == 0 )
lab[n - 1][c] = BORDER;
if ( lab[c][0] == 0 )
lab[c][0] = BORDER;
if ( lab[c][n - 1] == 0 )
lab[c][n - 1] = BORDER;
}

p = fill( ls - 1, cs - 1 );

fout = fopen( "iesire.out", "w" );
if ( p > 0 )
fprintf( fout, "%d %d\n", 1 + p / MAXN, 1 + p % MAXN );
else
fprintf( fout, "-1\n" );
fclose( fout );

return 0;
}
</syntaxhighlight>

=== Arie goluri ===

Calcul arie goluri: dorim să aflăm numărul de elemente zero accesibile din punctul inițial.

Iată un exemplu de program care afișează aria golului accesibil din punctul inițial:

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

#define MAXN 1000
#define BORDER 2

char lab[MAXN + 2][MAXN + 2]; // matricea labirint

// Executa flood fill de la coordonate (l, c)
// returneaza aria zonei din care se porneste fill (cite puncte 0)
int fill( int l, int c ) {
int aria;

lab[l][c] = 1; // marcam punctul curent ca vizitat
aria = 1; // contorizam punctul curent
if ( lab[l + 1][c] == 0 ) // daca nu este zid
aria += fill(l + 1, c); // cautam in jos
if ( lab[l - 1][c] == 0 ) // daca nu este zid
aria += fill(l - 1, c); // cautam in sus
if ( lab[l][c + 1] == 0 ) // daca nu este zid
aria += fill(l, c + 1); // cautam in dreapta
if ( lab[l][c - 1] == 0 ) // daca nu este zid
aria += fill(l, c - 1); // cautam in stinga

return aria;
}

int main() {
FILE *fin, *fout;
int n, l, c, ls, cs, a;

fin = fopen( "arie.in", "r" );
fscanf( fin, "%d%d%d ", &n, &ls, &cs );
for ( l = 1; l <= n; l++ ) {
for ( c = 1; c <= n; c++ ) // citim linia l a matricei
lab[l][c] = fgetc( fin ) - '0';
fgetc( fin ); // citim '\n'
}
fclose( fin );
for ( c = 1; c <= n; c++ ) // bordare margini
lab[0][c] = lab[n + 1][c] = lab[c][0] = lab[c][n + 1] = BORDER;

a = fill( ls, cs ); // calcul arie accesibila din (ls, cs)

fout = fopen( "arie.out", "w" );
fprintf( fout, "%d\n", a );
fclose( fout );

return 0;
}
</syntaxhighlight>

=== Număr goluri ===

Calcul număr de goluri: denumite și componente conexe, putem folosi fill pentru a număra câte goluri disjuncte există (astfel încât să nu se poată ajunge de la un gol la altul). Pentru aceasta vom parcurge matricea în orice ordine și vom porni câte un fill din fiecare loc unde găsim un element 0.

Iată un exemplu de program:

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

#define MAXN 1000
#define BORDER 2

char lab[MAXN + 2][MAXN + 2]; // matricea labirint

// Executa flood fill de la coordonate (l, c)
void fill( int l, int c ) {
lab[l][c] = 1; // marcam punctul curent ca vizitat
if ( lab[l + 1][c] == 0 ) // daca nu este zid
fill(l + 1, c); // cautam in jos
if ( lab[l - 1][c] == 0 ) // daca nu este zid
fill(l - 1, c); // cautam in sus
if ( lab[l][c + 1] == 0 ) // daca nu este zid
fill(l, c + 1); // cautam in dreapta
if ( lab[l][c - 1] == 0 ) // daca nu este zid
fill(l, c - 1); // cautam in stinga
}

int main() {
FILE *fin, *fout;
int n, l, c, ls, cs, nr;

fin = fopen( "nrgol.in", "r" );
fscanf( fin, "%d%d%d ", &n, &ls, &cs );
for ( l = 1; l <= n; l++ ) {
for ( c = 1; c <= n; c++ ) // citim linia l a matricei
lab[l][c] = fgetc( fin ) - '0';
fgetc( fin ); // citim '\n'
}
fclose( fin );
for ( c = 1; c <= n; c++ ) // bordare margini
lab[0][c] = lab[n + 1][c] = lab[c][0] = lab[c][n + 1] = BORDER;

nr = 0;
for ( l = 1; l <= n; l++ )
for ( c = 1; c <= n; c++ ) // pentru fiecare punct din labirint
if ( lab[l][c] == 0 ) { // daca nu este zid si nu a fost umplut deja
nr++; // contorizam un nou gol
fill( l, c ); // umplem zona
}

fout = fopen( "nrgol.out", "w" );
fprintf( fout, "%d\n", nr );
fclose( fout );

return 0;
}
</syntaxhighlight>

=== Perimetru goluri ===

Calcul perimetru goluri: în locul ariei golurilor putem calcula perimetrul lor, anume numărul de puncte din goluri care se învecinează cu un punct care nu face parte din gol. Trebuie să avem grijă când testăm dacă un punct este pe perimetru.

Un punct se află pe perimetru dacă:

* Unul din vecinii săi este zid,
* Sau unul din vecinii săi este margine bordată.

Un punct '''nu neapărat se află pe perimetru''' dacă:

* Unul din vecinii săi este un alt punct parcurs anterior.

Cum ne dăm seama dacă vecinul este margine, zid, sau punct anterior?

Vom umple golurile cu un număr distinct. În exemplul de mai jos marginile și zidurile sunt codificate cu 1, iar umplerea se face cu 2.

Iată un exemplu de program care afișează perimetrul golului accesibil din punctul inițial:

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

#define MAXN 1000
#define BORDER 1
#define FILL 2

char lab[MAXN + 2][MAXN + 2]; // matricea labirint

// Executa flood fill de la coordonate (l, c)
// returneaza perimetrul zonei din care se porneste fill (cite puncte 0)
int fill( int l, int c ) {
int perimetrul;

lab[l][c] = FILL; // marcam punctul curent ca vizitat
perimetrul = lab[l - 1][c] == 1 // verificam daca punctul curent este pe
|| lab[l + 1][c] == 1 // perimetru
|| lab[l][c - 1] == 1
|| lab[l][c + 1] == 1; // daca da, contorizam punctul curent
if ( lab[l + 1][c] == 0 ) // daca nu este zid
perimetrul += fill(l + 1, c); // cautam in jos
if ( lab[l - 1][c] == 0 ) // daca nu este zid
perimetrul += fill(l - 1, c); // cautam in sus
if ( lab[l][c + 1] == 0 ) // daca nu este zid
perimetrul += fill(l, c + 1); // cautam in dreapta
if ( lab[l][c - 1] == 0 ) // daca nu este zid
perimetrul += fill(l, c - 1); // cautam in stinga

return perimetrul;
}

int main() {
FILE *fin, *fout;
int n, l, c, ls, cs, p;

fin = fopen( "perimetru.in", "r" );
fscanf( fin, "%d%d%d ", &n, &ls, &cs );
for ( l = 1; l <= n; l++ ) {
for ( c = 1; c <= n; c++ ) // citim linia l a matricei
lab[l][c] = fgetc( fin ) - '0';
fgetc( fin ); // citim '\n'
}
fclose( fin );
for ( c = 0; c < n; c++ ) // bordare margini
lab[0][c] = lab[n + 1][c] = lab[c][0] = lab[c][n + 1] = BORDER;

p = fill( ls, cs ); // calcul perimetru accesibil din (ls, cs)

fout = fopen( "perimetru.out", "w" );
fprintf( fout, "%d\n", p );
fclose( fout );

return 0;
}
</syntaxhighlight>

=== Eliminare zid ===

Ne propunem să eliminăm acea pătrațică zid care reduce la minim numărul de goluri.

Cum procedăm?

'''Soluție forță brută''': o soluție forță brută ar fi să eliminăm pe rând fiecare bucată de zid și să numărăm golurile formate.

Ce complexitate are această soluție?

Deoarece numărul de ziduri poate fi ''O(n2)'' iar numărarea golurilor este și ea tot ''O(n2)'' rezultă o complexitate de ''O(n4)''.

Se poate mai bine? Desigur.

'''Soluție optim''': soluția optimă este similară cu cea care numără golurile:

* Umplem toate golurile.
* La fiecare gol umplem cu o valoare diferită de fill.
* La final parcurgem matricea căutând pătrățica zid care are ca vecini cele mai multe goluri diferite (eticheta diferită).

Ce complexitate are această soluție?

* Umplerea golurilor este ''O(n2)''.
* Verificarea zidurilor este ''O(n2)''.

Timpul total va fi, deci, ''O(n2)''.

== Concluzii ==

Fill este o unealtă simplă și utilă, ușor de folosit la concursuri. Principalul ei neajuns este memoria ocupată.

Ce facem în situația când matricea este prea mare și memoria disponibilă insuficientă pentru a folosi flood fill?

În această situație putem folosi BFS fill (breadth first search), care, atunci când este aplicat pe o matrice se mai numește și algoritmul Lee. El folosește o coadă pentru a menține frontiera deja acoperită, reducând memoria la ''O(m+n)'' însă fiind ceva mai lent.

Vom discuta acest algoritm într-o altă lecție.

== Temă 10 ==

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

* [https://www.nerdarena.ro/problema/oras Oraș] dată la .campion 2011
* [https://www.nerdarena.ro/problema/enclave Enclave] de exercițiu în flood fill

== Temă opțională ==

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

* [https://www.nerdarena.ro/problema/ozn OZN] dată la barajul pentru Shumen din Tudor Vianu anul 2014, juniori

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_10:_Fill_recursiv_(flood_fill) Accesează rezolvarea temei 10]

Clasa a 7-a Lecția 8: Recursivitate (2)

2026-02-06T16:03:03Z

Cristian:

== Înregistrare video lecție ==

<youtube height="720" width="1280">https://youtu.be/yPXRdAuZv6w</youtube>

== Exemple de funcții recursive ==

Iată câteva probleme care se rezolvă ușor cu funcții recursive:

=== Palindrom ===

Verificare palindrom:

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

int putere( int n ) { // calculam recursiv cea mai mare
int p = 1; // putere a lui 10 mai mica decit n

if ( n < 10 ) // cand n are o singura cifra
return 1; // cea mai mare putere este 1
return 10 * putere( n / 10 ); // adaugam un zero si taiem o cifra
}

int palindrom( int n, int p10 ) { // pe baza lui n si a puterii lui 10
if ( n < 10 ) // un numar de o cifra este palindrom
return 1;
if ( n / p10 != n % 10 ) // testam prima si ultima cifra
return 0;
return palindrom( n % p10 / 10, p10 / 100 ); // taie prima si ultima cifra
}

int main() {
int n, pow10;

scanf( "%d", &n );
pow10 = putere( n );
if ( palindrom( n, pow10 ) )
printf( "%d este palindrom\n", n );
else
printf( "%d nu este palindrom\n", n );
return 0;
}
</syntaxhighlight>

=== Permutări ===

Dându-se <code>n</code> să se afișeze toate permutările mulțimii numerelor de la 1 la <code>n</code> în ordine lexicografică.

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

int v[10];
char folosit[10];

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
printf( "%d ", v[i] );
printf( "\n" );
} else
for ( v[poz] = 1; v[poz] <= n; v[poz]++ )
if ( !folosit[v[poz]] ) { // daca elementul curent nu e deja folosit
folosit[v[poz]] = 1; // marcheaza-l ca folosit
perm( n, poz + 1 ); // genereaza restul permutarii
folosit[v[poz]] = 0; // demarcheaza elementul
}
}

int main() {
int n;

scanf( "%d", &n );
perm( n, 0 );
return 0;
}
</syntaxhighlight>

Ce complexitate are acest algoritm?

Calculul depășește nivelul acestei lecții. Dar putem vedea că este ineficient: pe măsură ce plasăm numere în vector și vectorul <code>folosit[]</code> se ''umple'', vom plasa pe poziția curentă tot mai puține numere, dar le vom parcurge pe toate <code>n</code>. Cum am putea îmbunătăți algoritmul? Cumva ar fi bine să parcurgem doar elementele pe care le vom plasa. Avem, deci, nevoie ca la fiecare poziție să avem o mulțime a numerelor rămase de plasat, mulțime pe care să o putem parcurge în ''O(n - poz)'' și nu în ''O(n)''.

Avem două idei:

==== Permutări cu interschimbare (swap) ====

Am putea să menținem acea mulțime chiar în vectorul <code>v[]</code>. Convenția este că dacă am ajuns la poziția <code>poz</code> am plasat deja <code>poz</code> elemente, iar cifrele rămase for fi în vector la pozițiile <code>poz..n-1</code>.

Vom scrie, la început, numerele de la 1 la <code>n</code> în vectorul <code>v[]</code>. Vrem să plasăm un element pe poziția <code>poz</code>. El va fi ales de pe o poziția <code>i</code> care se află după <code>poz</code>, <code>i ≤ poz</code>. Vom interschimba, deci, elementele aflate pe pozițiile <code>poz</code> și <code>i</code>. Aceasta îmi garantează că elementele rămase pe pozițiile <code>poz+1..n-1</code> sunt elemente încă nefolosite în permutare. Putem apela recursiv funcția. La revenire vom repune elementele în poziția originală, prin încă o interschimbare a elementelor la poziția <code>poz</code> și <code>i</code>.

Avantajul acestei metode este clar, va parcurge doar elementele plasate. Are și vreun dezavantaj?

Dezavantajul este că permutările nu vor fi generate în ordine lexicografică. În funcție de aplicație acest lucru s-ar putea să nu conteze.

==== Permutări cu liste ====

Am putea să menținem elementele în ordinea lor crescătoare într-o listă. Atunci când folosim un element, plasându-l pe poziția poz, îl eliminăm din listă. Apoi reapelăm. La revenirea din apel plasăm elementul înapoi în listă și trecem la următorul element.

Această metodă, implementată corect, este mai rapidă și generează și permutările în ordine lexicografică, deoarece elementele din listă sunt permanent în ordinea inițială.

=== Plată suma ===

Moduri plată suma cu monede 1, 2, 5:

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

int mon[3] = { 1, 2, 5 };

int suma( int s, int nrmon ) { // in cite feluri platim s folosind nrmon monede
if ( nrmon == 0 ) // daca nu mai avem monede
return 0; // nu putem plati (zero moduri de plata)
if ( s < 0 ) // o suma negativa nu se poate plati
return 0;
if ( s == 0 ) // o suma de zero se plateste intr-un singur fel
return 1;
// putem plati in doua feluri de combinatii
// - fie in combinatii care se termina cu ultima moneda din vector
// - fie in combinatii care nu folosesc deloc ultima moneda din vector
return suma( s - mon[nrmon - 1], nrmon ) + suma( s, nrmon - 1 );
}

int main() {
int s;

scanf( "%d", &s );
printf( "%d este platibila in %d moduri\n", s, suma( s, 3 ) );
return 0;
}
</syntaxhighlight>

== Memoizare (continuare) ==

Anul trecut am vorbit despre [# memoizare]. Am spus atunci că este o metodă de a face un program mai rapid fără a-i schimba modul în care el funcționează. Ideea ei este ca atunci când efectuăm un calcul scump să păstrăm valoarea calculată într-un tablou pentru a economisi timp în cazul când în viitor vom avea din nou nevoie de acea valoare.

Tot atunci am prezentat un exemplu avansat de memoizare folosit într-o funcție recursivă, mai exact în calculul recursiv al unui element din șirul lui Fibonacci.

Merită menționat că tehnica memoizării se aplică mai ales în funcții recursive. Ea ne permite foarte simplu să scădem timpul de execuție al programului folosind mai multă memorie. Această tehnică este cu atât mai eficientă cu cât ne așteptăm să apelăm de multe ori aceeași funcție cu aceiași parametri. De aceea funcția trivială de calcul al unui termen din șirul lui Fibonacci este un exemplu perfect de memoizare, ea avînd un număr exponențial de apeluri, în varianta nememoizată.

'''Important:''' memoizarea nu schimbă logica sau structura algoritmului folosit. Acesta este un mare avantaj. Avem o opțiune între câtă memorie folosim și cât timp câștigăm. Aceste tehnici, în care putem alege între timp și memorie, sunt destul de rare în algoritmică.

Să vedem două exemple clasice de memoizare.

=== Factorial ===

Algoritmul simplu pentru calculul lui n!, fără memoizare, este:

<syntaxhighlight lang="c" line>
long long fact( int n ) {
if ( n == 1 )
return 1;
return n * fact( n - 1 );
}
</syntaxhighlight>

Cel cu memoizare va folosi un vector ce va stoca elementele deja calculate:

<syntaxhighlight lang="c" line>
long long val[20] = { 1 };

// exemplu de funcție factorial implementată folosind memoizare
long long fact( int n ) {
if ( val[n] == 0 ) // valoare inca necalculata
val[n] = n * fact( n - 1 ); // o calculam in tabel

return val[n];
}
</syntaxhighlight>

=== Fibonacci ===

Algoritmul direct de calcul al celui de-al n-lea termen al șirului lui Fibonacci:

<syntaxhighlight lang="c" line>
int fib( int n ) {
if ( n == 1 || n == 2 )
return 1;
return fib( n-1 ) + fib( n-2 );
}
</syntaxhighlight>

Cel cu memoizare va folosi un vector ce va stoca elementele deja calculate:

<syntaxhighlight lang="c" line>
int val[1000] = { 1, 1 };

// exemplu de funcție fibonacci implementată folosind memoizare
int fib( int n ) {
if ( val[n] == 0 ) // inca necalculat
val[n] = fib( n-1 ) + fib( n-2 ); // il calculam in tabel
return val[n]; // returnam valoarea din tabel
}
</syntaxhighlight>

== Recursie Top-Down și Bottom-Up ==

=== Recursie Top-Down ===

Există două moduri de implementare a unei soluții recursive:

Recursie '''Top-Down''': când pornim cu o problemă mai mare și apelăm funcția pentru probleme mai mici pe care le folosim ulterior în apelul curent. În subproblema de bază returnăm un rezultat de bază, cum ar fi zero sau unu. În această categorie sunt aproape toate exemplele de până acum cu excepția cmmdc, interclasare vectori, combinări, permutări și sumă de monede.

=== Recursie Bottom-Up ===

Recursie '''Bottom-Up''': când pornim cu o problemă mai mare și cu un acumulator de soluție, care inițial este vid (zero sau unu), iar în apelurile ulterioare reducem mărimea problemei adăugând (construind) soluția finală în acumulator. Exemplele de combinări și permutări sunt Bottom-Up în care acumulatorul este vectorul și nu este transmis în mod explicit, deși am putea face acest lucru.

=== Exemple de recursie Bottom-Up cu acumulator ===

Implementați bottom-up cu acumulator exemplele făcute până acum.

==== Factorial ====

Iată o comparație a celor două implementări ale funcției factorial, implementată recursiv top-down și bottom-up cu acumulator:

{| class="wikitable"
!Top-down
!Bottom-up
|-
| <syntaxhighlight lang="c" line>
#include <stdio.h>

int fact( int n ) {
if ( n == 1 )
return 1;
return n * fact( n - 1 );
}

int main() {
int n;

scanf( "%d", &n );
printf( "%d! = %d\n", n, fact( n ) );

return 0;
}</syntaxhighlight>
| <syntaxhighlight lang="c" line>
#include <stdio.h>

int fact( int n, int ac ) {
if ( n == 1 ) // cind n = 1 am terminat calculul in ac
return ac;
return fact( n - 1, n * ac ); // adaugam n la acumulator
}

int main() {
int n;

scanf( "%d", &n );
printf( "%d! = %d\n", n, fact( n, 1 ) );

return 0;
}</syntaxhighlight>
|}

==== Putere ====

Iată o comparație a celor două implementări ale funcției putere, implementată recursiv top-down și bottom-up cu acumulator:

{| class="wikitable"
!Top-down
!Bottom-up
|-
| <syntaxhighlight lang="c" line>
#include <stdio.h>

int putere( int a, int n ) {
if ( n == 0 )
return 1;
return a * putere( a, n - 1 );
}

int main() {
int n, a;

scanf( "%d%d", &a, &n );
printf( "%d^%d = %d\n", a, n, putere( a, n ) );
return 0;
}</syntaxhighlight>
| <syntaxhighlight lang="c" line>
#include <stdio.h>

int putere( int a, int n, int ac ) {
if ( n == 0 ) // cind puterea e zero acumulatorul are rezultatul
return ac;
return putere( a, n - 1, a * ac ); // acumuleaza a la rezultat
}

int main() {
int n, a;

scanf( "%d%d", &a, &n );
printf( "%d^%d = %d\n", a, n, putere( a, n, 1 ) );
return 0;
}</syntaxhighlight>
|}

==== CMMDC ====

De remarcat că funcția recursivă care calculează cmmdc a două numere, prezentată în lecția trecută, este deja bottom-up cu acumulator:

<syntaxhighlight lang="c" line>
int cmmdc( int a, int b ) {
if ( b == 0 )
return a;
return cmmdc( b, a % b );
}
</syntaxhighlight>

==== Fibonacci ====

Iată o comparație a celor două implementări ale șirului lui Fibonacci, implementat recursiv top-down și bottom-up cu acumulator:

{| class="wikitable"
!Top-down
!Bottom-up
|-
| <syntaxhighlight lang="c" line>
int fib( int n ) {
if ( n == 1 )
return 0;
if ( n == 2 )
return 1;
return fib( n - 1 ) + fib ( n - 2 );
}</syntaxhighlight>

Ea va fi apelată astfel:

<syntaxhighlight lang="c" line>f = fib( 15 );</syntaxhighlight>

Unde 15 este numărul termenului dorit.
| <syntaxhighlight lang="c" line>
int fib( int n, int f1, int f2 ) {
if ( n == 1 )
return f1;
return fib( n - 1, f2, f1 + f2 );
}</syntaxhighlight>

Ea va fi apelată astfel:

<syntaxhighlight lang="c" line>f = fib( 15, 0, 1 );</syntaxhighlight>

Unde 0 și 1 sunt primii doi termeni ai șirului, iar 15 este numărul termenului dorit.
|}

==== Suma cifrelor unui număr ====

Iată o comparație a celor două implementări ale sumei cifrelor unui număr, implementată recursiv top-down și bottom-up cu acumulator:

{| class="wikitable"
!Top-down
!Bottom-up
|-
| <syntaxhighlight lang="c" line>
int sumac( int n ) {
if ( n == 0 )
return 0;
return n % 10 + sumac( n / 10 );
}</syntaxhighlight>

Ea va fi apelată astfel:

<syntaxhighlight lang="c" line>s = sumac( 2324103 );</syntaxhighlight>

Unde 2324103 este numărul căruia îi calculăm suma cifrelor.
| <syntaxhighlight lang="c" line>
int sumac( int n, int suma ) {
if ( n == 0 )
return suma;
return sumac( n / 10, suma + n % 10 );
}</syntaxhighlight>

Ea va fi apelată astfel:

<syntaxhighlight lang="c" line>s = sumac( 2324103, 0 );</syntaxhighlight>

Unde 2324103 este numărul căruia îi calculăm suma cifrelor, iar 0 este inițializarea acumulatorului sumă.
|}

==== Putere în O(log n) ====

Iată o comparație a celor două implementări ale funcției putere, implementată ''O(log n)'' recursiv top-down și bottom-up cu acumulator:

{| class="wikitable"
!Top-down
!Bottom-up
|-
| <syntaxhighlight lang="c" line>
#include <stdio.h>

// a este numărul de ridicat la putere
// n este puterea
int putere( int a, int n ) {
int p;

if ( n == 0 )
return 1;
p = putere( a * a, n / 2 );
if ( n % 2 ) // n impar?
p *= a;

return p;
}

int main() {
int n, a;

scanf( "%d%d", &a, &n );
printf( "%d^%d = %d\n", a, n, putere( a, n ) );
return 0;
}</syntaxhighlight>
| <syntaxhighlight lang="c" line>
#include <stdio.h>

// in permanenta a^n * ac detine rezultatul
// cind n devine zero a^n * ac = ac, deci rezultatul este chiar ac
int putere( int a, int n, int ac ) {
if ( n == 0 ) // cind puterea e zero acumulatorul are rezultatul
return ac;

if ( n % 2 ) // cind n impar
ac *= a; // acumuleaza a la rezultat

return putere( a * a, n / 2, ac ); // totuna cu (a*a)^(n/2)
}

int main() {
int n, a;

scanf( "%d%d", &a, &n );
printf( "%d^%d = %d\n", a, n, putere( a, n, 1 ) );
return 0;
}

</syntaxhighlight>
|}

==== Interclasare vectori ordonați ====

De remarcat că interclasarea a doi vectori ordonați, prezentată data trecută, este bottom-up cu acumulator (vectorul <code>v3[]</code> este acumulatorul).

Funcția va primi ca parametri cei trei vectori și pozițiile curente în ei (inițial pozițiile de start, 0). La fiecare apel va alege un element pe care îl va copia. Apoi se va reapela cu indici actualizați (<code>i1</code> și <code>i3</code> sau <code>i2</code> și <code>i3</code>).

<syntaxhighlight lang="c" line>
void interclaseaza( int n1, int v1[], int n2, int v2[], int v3[],
int i1, int i2, int i3 ) {
if ( i1 < n1 ) { // mai avem elemente in primul vector?
if ( i2 < n2 && v2[i2] < v1[i1] ) { // v2[i2] exista si e mai mic?
v3[i3] = v2[i2]; // copiem v2[i1]
interclaseaza( n1, v1, n2, v2, v3, i1, i2 + 1, i3 + 1 );
} else {
v3[i3] = v1[i1]; // copiem v1[i1]
interclaseaza( n1, v1, n2, v2, v3, i1 + 1, i2, i3 + 1 );
}
} else if ( i2 < n2 ) { // mai avem elemente in v2? (v1 s-a terminat)
v3[i3] = v2[i2];
interclaseaza( n1, v1, n2, v2, v3, i1, i2 + 1, i3 + 1 );
}
}
</syntaxhighlight>

==== Palindrom ====

Verificarea că un număr este palindrom este, în fapt, mai ușor de scris bottom-up. În acumulator vom construi inversul numărului <code>n</code>. La final vom compara inversul cu originalul. Iată o comparație a celor două implementări ale testului de palindrom, implementat recursiv top-down și bottom-up cu acumulator:

{| class="wikitable"
!Top-down
!Bottom-up
|-
| <syntaxhighlight lang="c" line>
#include <stdio.h>

int putere( int n ) { // calculam recursiv cea mai mare
int p = 1; // putere a lui 10 mai mica decit n

if ( n < 10 ) // cind n are o singura cifra
return 1; // cea mai mare putere este 1
return 10 * putere( n / 10 ); // adaugam un zero si taiem o cifra
}

int palindrom( int n, int p10 ) { // pe baza lui n si a puterii lui 10
if ( n < 10 ) // un numar de o cifra este palindrom
return 1;
if ( n / p10 != n % 10 ) // testam prima si ultima cifra
return 0;
return palindrom( n % p10 / 10, p10 / 100 ); // taie prima si ultima cifra
}

int main() {
int n, pow10;

scanf( "%d", &n );
pow10 = putere( n );
if ( palindrom( n, pow10 ) )
printf( "%d este palindrom\n", n );
else
printf( "%d nu este palindrom\n", n );
return 0;
}</syntaxhighlight>
| <syntaxhighlight lang="c" line>

#include <stdio.h>

int palindrom( int n, int nc, int ac ) {
if ( n == 0 ) // cind n=0 ac este inversul lui nc
return nc == ac; // daca sint egale, returnam 1, altfel 0
return palindrom( n / 10, nc, ac * 10 + n % 10 ); // taiem o cifra tin n
} // si o adaugam la ac

int main() {
int n;

scanf( "%d", &n );
if ( palindrom( n, n, 0 ) )
printf( "%d este palindrom\n", n );
else
printf( "%d nu este palindrom\n", n );
return 0;
}</syntaxhighlight>
|}

=== Transformarea recursiei din Top-Down în Bottom-Up ===

Orice funcție recursivă de tip Top-Down care pe orice cale de execuție are un singur apel recursiv se poate transforma într-o funcție de tip Bottom-Up prin adăugarea unui parametru acumulator. De ce ne interesează acest lucru? Datorită recursiei la coadă. Recursia la coadă este definită ca un apel recursiv exact la ieșirea din funcție. Toate exemplele pe care le-am dat la recursia bottom-up sînt recursive la coadă. Exemplele date la top-down nu sînt recursive la coadă, cu excepția lui cmmdc.

Recursia la coadă este foarte utilă, deoarece nu consumă stivă. În mod normal fiecare apel de funcție consumă cel puțin patru octeți pe stivă (adresa de întoarcere). Ei bine, în cazul apelurilor recursive la coadă stiva consumată este zero (ca să fim exacţi nu este zero, ci ''O(1)''). Explicația acestui fapt este prea tehnică pentru a o detalia aici. Ea ține de modul în care este organizat calculatorul modern Von Neumann și de modul în care se execută apelurile de funcții.

Ce înseamnă pentru noi acest lucru? Înseamnă că putem chema o funcție, recursiv, de un milion de ori, fără să depășim memoria stivă. Ce înseamnă pentru omenire acest lucru? Înseamnă că putem avea întregi limbaje care nu conțin instrucțiuni de ciclare (while sau for), cum ar fi limbajele funcționale (Scheme, Lisp) sau limbajele logice (Prolog). Acest lucru este posibil deoarece recursivitatea la coadă poate înlocui cu succes buclele. Aceste limbaje se bazează pe definiția recursivă a algoritmului. În unele cazuri programele sînt mai clare într-o gândire recursivă.

== Tema 8 ==

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

* [https://www.nerdarena.ro/problema/fibonacci Fibonacci]
* [https://www.nerdarena.ro/problema/primrec Primrec]
* [https://www.nerdarena.ro/problema/maxrec Maxrec]
* [https://www.nerdarena.ro/problema/factorizare Factorizare]
* [https://www.nerdarena.ro/problema/sumprim Sumprim]
* [https://www.nerdarena.ro/problema/fibrec Fibrec]
* [https://www.nerdarena.ro/problema/aparitii2 Aparitii2]

== Tema opțională ==

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

* [https://www.nerdarena.ro/problema/permutari1 Permutări1] Problema cere ca, dându-se indicii anumitor permutări să se calculeze suma acelor permutări.
* [https://www.nerdarena.ro/problema/aranjamente Aranjamente] Problema cere generarea eficientă a tuturor aranjamentelor și a calculului unor proprietăți ale lor.
* [https://www.nerdarena.ro/problema/optim Optim] dată la ONI 2012 clasa a 8-a, problemă ce se poate rezolva recursiv.
* [https://www.nerdarena.ro/problema/balance Balance] dată la Shumen 2012 juniori, problemă pentru avansați, deoarece ea necesită backtracking, ceea ce nu am predat.

'''Temă de gândire, opțională:''' Care ar fi un algoritm iterativ de rezolvare a turnurilor din Hanoi? Încercați să găsiți reguli simple, nu doar să mimați algoritmul recursiv folosind o stivă.

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

Clasa a 7-a Lecția 7: Recursivitate (1)

2026-02-06T16:00:39Z

Cristian:

== Înregistrare video lecție ==

<youtube height="720" width="1280">https://youtu.be/n_LKos0gG0Q</youtube>

== Despre recursivitate ==

O funcție este recursivă dacă se autoapelează. A scrie o funcție recursivă necesită, inițial, o încredere în faptul că funcția funcționează. În fapt, când pornim să scriem o funcție recursivă este bine să considerăm că ea deja funcționează!

Reguli de scriere a unei funcții recursive:

* Înainte de a scrie cod este bine să ne clarificăm formula recurentă.
* Tratăm mai întâi cazurile simple, atunci când funcția poate returna o valoare fără a se autoapela.
* În final, tratăm cazul de recursie, considerând că funcția este deja scrisă pentru cazurile ''mai mici'', folosindu-ne de formula recurentă găsită la început.

Iată un videoclip de prezentare cu exemple de funcții recursive, cu imagini *:

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

'' * Exemplele de cod din film sunt scrise într-un pseudocod, suficient de bine explicate astfel încât să fie ușor redactate în orice limbaj de programare, inclusiv C.''

== Exemple introductive ==

=== Factorial ===

Calcul n! Ne vom folosi de definiția recursivă: <math>n! = \begin{cases} 1, & \mbox{dacă } n = 1 \\ n \cdot (n - 1)!, & \mbox{dacă } n > 1. \end{cases}</math>

<syntaxhighlight lang="C" line>
int fact( int n ) {
if ( n == 1 )
return 1;
return n * fact( n - 1 );
}</syntaxhighlight>

=== Putere ===
Calcul an. Ne vom folosi de definiția recurentă: <math>a^{n} = \begin{cases} 1, & \mbox{dacă } n = 0 \\ a \cdot a^{n-1}, & \mbox{dacă } n > 0. \end{cases}</math>

<syntaxhighlight lang="C" line>
int putere( int a, int n ) {
if ( n == 0 )
return 1;
return a * putere( a, n - 1 );
}</syntaxhighlight>

=== Cmmdc ===
Calcul cmmdc a două numere. Ne vom folosi de definiția recursivă a lui Euclid: <math>cmmdc(a, b) = \begin{cases} a, & \mbox{dacă } b = 0 \\ cmmdc(b, a \bmod b), & \mbox{dacă } b > 0. \end{cases}</math>

<syntaxhighlight lang="C" line>
int cmmdc( int a, int b ) {
if ( b == 0 )
return a;
return cmmdc( b, a % b );
}</syntaxhighlight>

== Exerciții ==

Încercați să scrieți următoarele funcții recursive.

=== Fibonacci ===
Să se scrie o funcție recursivă care, dat <code>n</code>, calculează al <code>n</code>-lea termen din șirul lui Fibonacci: <code>0 1 1 2 3 5 8 13...</code>. Ne vom folosi de definiția recurentă: <math>fib(n) = \begin{cases} 0, & \mbox{dacă } n = 1 \\ 1, & \mbox{dacă } n = 2 \\ fib(n-1) + fib(n-2), & \mbox{dacă } n > 2. \end{cases}</math>

<syntaxhighlight lang="C" line>
int fib( int n ) {
if ( n == 1 )
return 0;
if ( n == 2 )
return 1;
return fib( n - 1 ) + fib ( n - 2 );
}</syntaxhighlight>

=== Suma cifrelor unui număr ===
Să se scrie o funcție recursivă care calculează suma cifrelor unui număr <code>n</code>.

Ne vom folosi de următoarea formulă recurentă: <math>suma(n) = \begin{cases} 0, & \mbox{dacă } n = 0 \\ n % 10 + suma(n / 10), & \mbox{dacă } n > 0. \end{cases}</math>

<syntaxhighlight lang="C" line>
int sumac( int n ) {
if ( n == 0 )
return 0;
return n % 10 + sumac( n / 10 );
}</syntaxhighlight>

=== Putere în O(log n) ===
Calculați <tt>an</tt> în mod cât mai eficient (a și n numere naturale). Problema este cunoscută şi sub numele de ridicare la putere în timp logaritmic. Ideea din spatele acestei rezolvări este următoarea:

*Dacă <code>n</code> este par, atunci <tt>an = a2*n/2 = (a2)n/2</tt>
*Dacă <code>n</code> este impar, atunci <code>n-1</code> este par și avem <tt>an = a * an-1 = a * a2*(n-1)/2 = a * (a2)(n-1)/2 = a * (a2)n/2</tt>

Rezultă formula de recurență:

<math>a^{n} = \begin{cases} 1, & \mbox{dacă } n = 0 \\ {(a^{2})}^{n/2}, & \mbox{dacă } n >0, n % 2 = 0 \\ a \times {(a^{2})}^{n/2}, & \mbox{dacă } n > 0, n % 2 = 1 \end{cases}</math>

În formulele de mai sus am considerat că <code>/</code> este împărțirea întreagă din limbajul C. Se observă că indiferent de paritatea lui <code>n</code>, la fiecare pas al iterației putem transforma <code>a</code> în <code>a * a</code> și apoi putem împărți <code>n</code> la <code>2</code>. Doar în cazurile când <code>n</code> este impar vom acumula valoarea curentă a lui <code>a</code> la produsul calculat. Iată soluția bazată pe această idee:

<syntaxhighlight lang="C" line>
int putere( int a, int n ) {
int p;

if ( n == 0 )
return 1;
p = putere( a * a, n / 2 );
if ( n % 2 ) // n impar?
p *= a;

return p;
}</syntaxhighlight>

=== Afișare ===
Să se afișeze un șir de caractere în ordine inversă. Șirul se termină cu <code>'\n'</code>.

Ne vom folosi de următoarea idee: citim un caracter, apoi chemăm funcția recursivă pentru a afișa restul caracterelor, apoi afișăm caracterul.

<syntaxhighlight lang="C" line>
void afisare( FILE *fin, FILE *fout ) {
char ch;

ch = fgetc( fin );
if ( ch != '\n' ) {
afisare( fin, fout );
fputc( ch, fout );
}
}</syntaxhighlight>

=== Descompunere în baza 2 ===
Să se scrie o funcție recursivă care, dat <code>n</code>, îl afișează în baza 2.

Similar cu exercițiul precedent, vom calcula ultima cifră a descompunerii (restul împărțirii la doi), apoi vom chema funcția cu <code>n / 2</code>, iar la revenire vom afișa cifra.

<syntaxhighlight lang="C" line>
void baza2( int n, FILE *fout ) {
int cf2;

if ( n > 0 ) {
cf2 = n % 2;
baza2( n / 2, fout );
fprintf( fout, "%d", cf2 );
}
}</syntaxhighlight>

=== Interclasare vectori ordonați ===
Dîndu-se doi vectori ordonați să se calculeze un al treilea vector ordonat ce conține elementele lor.

Funcția va primi ca parametri cei trei vectori și pozițiile curente în ei (inițial pozițiile de start, 0). La fiecare apel va alege un element pe care îl va copia. Apoi se va reapela cu indici actualizați (i1 și i3 sau i2 și i3).

<syntaxhighlight lang="C" line>
void interclaseaza( int n1, int v1[], int n2, int v2[], int v3[],
int i1, int i2, int i3 ) {
if ( i1 < n1 ) { // mai avem elemente in primul vector?
if ( i2 < n2 && v2[i2] < v1[i1] ) { // v2[i2] exista si e mai mic?
v3[i3] = v2[i2]; // copiem v2[i1]
interclaseaza( n1, v1, n2, v2, v3, i1, i2 + 1, i3 + 1 );
} else {
v3[i3] = v1[i1]; // copiem v1[i1]
interclaseaza( n1, v1, n2, v2, v3, i1 + 1, i2, i3 + 1 );
}
} else if ( i2 < n2 ) { // mai avem elemente in v2? (v1 s-a terminat)
v3[i3] = v2[i2];
interclaseaza( n1, v1, n2, v2, v3, i1, i2 + 1, i3 + 1 );
}
}</syntaxhighlight>

== Tema 6 ==

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

* [https://www.nerdarena.ro/problema/sumacfnr Sumacfnr]
* [https://www.nerdarena.ro/problema/sumadiv Sumadiv]
* [https://www.nerdarena.ro/problema/nset Nset]
* [https://www.nerdarena.ro/problema/invector Invector]
* [https://www.nerdarena.ro/problema/hanoi Turnurile din Hanoi]: [http://www.puzzle.ro/ro/play_toh.htm exemplu de animație joc aici] să se scrie un program care să rezolve jocul turnurile din Hanoi (să efectueze mutările care duc la soluție).

=== Indicații pentru tema obligatorie ===

'''2. Sumadiv - suma divizorilor unui număr'''

Rezolvați problema [https://www.nerdarena.ro/problema/sumadiv Sumadiv]: să se scrie o funcție recursivă care să calculeze suma divizorilor unui număr.

Ea va arăta astfel:

<syntaxhighlight lang="C" line>
int sumd( int n, int d ) {
...
}
</syntaxhighlight>

și va fi apelată inițial astfel:

<syntaxhighlight lang="C" line>
sum = sumd( n, 1 );
</syntaxhighlight>

Semnificaţia este suma divizorilor lui <code>n</code> care sunt mai mari sau egali cu <code>d</code> şi mai mici sau egali cu <code>n / d</code>. Mai exact trebuie să completați funcția <code>sumd</code> din programul următor:

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

int sumd( int n, int d ) {
...
}

int main() {
FILE *fin, *fout;
int n;

fin = fopen( "sumadiv.in", "r" );
fscanf( fin, "%d", &n );
fclose( fin );

fout = fopen( "sumadiv.out", "w" );
fprintf( fout, "%d\n", sumd( n, 1 ) );
fclose( fout );

return 0;
}
</syntaxhighlight>

Atenţie mare la complexitatea algoritmului obţinut!

'''4. invector - răsturnare vector'''

Rezolvați problema [https://www.nerdarena.ro/problema/invector Invector] să se răstoarne un vector folosind o funcție recursivă. Vectorul trebuie modificat, nu doar afișat invers. Funcția va arăta astfel:

<syntaxhighlight lang="C" line>
void inv( int primul, int ultimul, int v[] ) {
...
}
</syntaxhighlight>

unde primul și ultimul sunt indicii de început, respectiv sfârșit care definesc subvectorul de răsturnat. Funcția va fi apelată inițial astfel:

<syntaxhighlight lang="C" line>
inv( 0, n-1, v );
</syntaxhighlight>

Mai exact trebuie să completați funcția inv din programul următor:

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

int v[100000];

void inv( int primul, int ultimul, int v[] ) {
...
}

int main() {
FILE *fin, *fout;
int n, i;

fin = fopen( "invector.in", "r" );
fscanf( fin, "%d", &n );
for ( i = 0; i < n; i++ )
fscanf( fin, "%d", &v[i] );
fclose( fin );

inv( 0, n-1, v );

fout = fopen( "invector.out", "w" );
for ( i = 0; i < n; i++ )
fprintf( fout, "%d ", v[i] );
fprintf( fout, "\n" );
fclose( fout );

return 0;
}
</syntaxhighlight>

== Tema opțională ==

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

* [https://www.nerdarena.ro/problema/combinari combinări] <math>{C}_{n}^{k}</math><nowiki>- combinări de n luate câte k. Date numerele naturale n și k, k ≤ n, să se afișeze toate submulțimile mulțimii {1, 2, 3, ..., n} de k elemente.</nowiki>
* [https://www.nerdarena.ro/problema/v v] (ONI 2004 clasa a 7-a) Problema este modificată. Puteți lua doar 50% din punctaj. Pentru 100% '''nu este nevoie de parsing'''. Dacă introduceam cerință de parsing aș fi scăzut timpul permis.

[http://solpedia.francu.com/wiki/index.php/Clasa_a_7-a_Lec%C8%9Bia_7:_Recursivitate_(1) Accesează rezolvarea temei 7]

Clasa a 7-a Lecția 5: Precalculare

2026-02-06T15:58:57Z

Cristian:

== Î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 <code>v[]</code> de <code>n</code> 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 <code>while</code> 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 <code>i</code>. 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 <code>isalpha()</code> (testare literă) și <code>isalnum()</code> (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ţă <code>ciur[]</code>, care, pentru fiecare număr <code>p</code>, calculează <code>ciur[p]</code> care ne spune dacă <code>p</code> este prim?

Cum am calcula primalitatea tuturor numerelor până la <code>n</code> î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 <code>k</code> prim. O estimare a numerelor prime până la <code>n</code> 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 <code>k</code> 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 <code>n</code>
* Suma divizorilor primi (unici sau neunici) ai tuturor numerelor până la <code>n</code>
* Numărul de divizori ai tuturor numerelor până la <code>n</code>
* Suma divizorilor tuturor numerelor până la <code>n</code>
* Descompunerea în factori primi a tuturor numerelor până la <code>n</code>
* Numărul de numere prime cu fiecare din numerele până la <code>n</code>

'''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 <code>v[]</code> de <code>n</code> elemente întregi, să se răspundă la multe întrebări de forma '''care este suma elementelor vectorului între poziţiile <code>i</code> şi <code>j</code>?'''.

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

Odată calculat acest vector putem răspunde în timp constant la întrebări. Suma elementelor între <code>i</code> şi <code>j</code> este <code>s[j] - s[i-1]</code>.

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]]

: <code>s[l][c] = s[l][c-1] + s[l-1][c] - s[l-1][c-1] + m[l][c]</code>

* <code>s</code> este matricea pe care o precalculăm;
* <code>m</code> 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]]

: <code>S = s[l2][c2] - s[l2][c1-1] - s[l1-1][c2] + s[l1-1][c1-1]</code>

* <code>S</code> este suma căutată;
* <code>s</code> 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 <code>x & (x - 1)</code>. Complexitate ''O(nr. biţi)''
* Cu precalculare: ţinem un vector în care elementul <code>v[x]</code> este numărul de biţi 1 din reprezentarea în baza 2 a lui <code>x</code>.

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 <code>int</code>?

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

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

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

Soluţia forţă brută implică execuţia celor <code>m</code> operaţiuni. O operaţiune constă în incrementarea a maxim n elemente din vector, deci avem <code>n x m</code> 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 <code>s[]</code> de sume parţiale ale acestui vector constituie chiar rezolvarea problemei.

Avem, deci: <code>s[i] = v[0] + v[1] + ... + v[i]</code>

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

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 <code>s[]</code>. 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 <code>s[]</code>, 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 <code>v[]</code> și -1 pe poziția 10.

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

În fapt, nu avem nevoie de doi vectori. Putem suprascrie vectorul <code>v[]</code>, 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 <code>s[i] = 1</code> ci <code>s[i]++</code> (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 <code>m</code> 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 <code>int</code>?

[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)

2026-02-06T15:56:38Z

Cristian:

== Î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 <<code>h[x]</code>. 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 <code>next[]</code>.

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

* Ușor: ''O(n2)'' - unde <code>n</code> 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)

2026-02-06T15:55:30Z

Cristian:

== Î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 <<code>h[x]</code>. 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 <code>next[]</code>.

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

* Ușor: ''O(n2)'' - unde <code>n</code> 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)

2026-02-06T15:53:01Z

Cristian:

== Î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 <code>v[]</code> care memorează elementele listei (numere întregi de exemplu) și un vector <code>next[]</code>, care memorează indicele următorului element din listă.

Perechea <code>(v[i], next[i])</code> 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 <code>next[]</code>.

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 <code>next[]</code> 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 <code>i</code> 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 <code>i</code>. 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 <code>i</code> avem celula cu elementul 45, ca mai jos. Dorim să eliminăm celula care apare în listă după celula <code>i</code>, cea cu elementul 10, aflat la poziția <code>j</code>. 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 <code>k</code>-lea element în listă va trebui să parcurgem primele <code>k</code> elemente, de la începutul listei. Să presupunem că prima celulă din listă este <code>i</code>. 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 <code>k</code>?

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 <code>n</code> într-un vector și apoi să avansăm <code>k</code> elemente și să afișăm elementul curent, iar apoi să îl setăm pe zero. Reluăm căutarea de <code>n</code> 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 <code>i</code> copii în cerc îi vom număra de <code>k/i</code> ori. Restul elementelor fiind zero, vom face <code>k/i</code> parcurgeri ale întregului vector, deci <code>n·k/i</code> 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 <code>log n</code>. 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 <code>k</code>. Putem optimiza algoritmul numărând până la <code>k % i</code>, unde <code>i</code> 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 <code>n</code> 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 <code>i</code> 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 <code>n</code> 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 <code>b[n]</code> care memorează linia cu bile,n fiind numărul de coloane;
* un vector <code>liste[m]</code> care pentru fiecare linie pointează la o listă de coloane pe care se află obstacole, <code>m</code> fiind numărul de linii;
* doi vectori <code>col[p]</code> și <code>next[p]</code> care memorează coloanele obstacolelor și următorul obstacol pe linie, <code>p</code> 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 <code>(l, c)</code> unde s-ar afla textul (înainte de a citi acel text!) și adăugând coloana <code>c</code> la lista liniei <code>l</code>. 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 <code>prim[]</code> și <code>ultim[]</code>.

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

2026-02-06T15:49:44Z

Cristian:

== Înregistrare video lecție ==

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

== Problema selecției ==

'''Problema'''

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

'''Exemplu'''

Fie șirul <code>3 9 23 13 18 8 3 10 2 10 15 21</code> și poziția <code>k = 6</code>.

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 <code>k</code>. 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, <code>v[n/2]</code>. Sau putem să îl alegem la întâmplare, folosind o funcție ce generează numere aleatoare, cum ar fi funcția <code>rand()</code> în C (parte din biblioteca <code>stdlib.h</code>).

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

Odată efecutată pivotarea vom ști în care din cele două părți se va afla elementul pe poziția <code>k</code> î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:

* <code>push(value)</code> - inserează o valoare dată la sfârșitul listei;
* <code>top</code> - returnează valoarea de la sfârșitul listei;
* <code>pop</code> - șterge valoarea de la sfârșitul listei;
* <code>empty</code> - 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 <code>top</code>, <code>empty</code> și <code>pop</code> presupun verificarea și manipularea numărului de elemente din vector. În exemplul de implementare numărul de elemente este denumit <code>stack_pointer</code>. Dar dacă vectorul vostru denumește numărul de elemente <code>n</code>, atunci veți opera cu <code>n</code>;
* 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

2026-02-06T15:45:58Z

Cristian:

== Î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 <code>a = a + y;</code>. 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 <code>int a = 1</code>;
* 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ă <code>int v[10010]</code>. 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ă <code>else</code> urmează un <code>if</code> atunci instrucțiunea <code>if</code> se pune imediat după <code>else</code> pe aceeași linie, iar corpul de instrucțiuni aparținând lui <code>else</code> se indentează cu două spații, nu cu patru. Astfel, în cazul unor instrucțiuni de genul <code>if ... else if ... else if ...</code> se evită migrarea codului către dreapta prin indentări inutile.
* Fără <code>break / continue / return / goto</code> în interiorul buclelor. Ele distrug programarea structurată și, implicit, zeci de ani de experiență a omenirii.
* Folosim <code>for</code> pentru bucle cu număr cunoscut de pași, <code>while</code> în celelalte cazuri. Aceasta este o regulă de programare ordonată, care face codul mai citibil.
* Nu avem voie să modificăm variabila de buclă <code>for</code> ș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 (<code>n--</code>). Î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 <code>int main()</code> și folosiți <code>return 0</code> 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 <code>fscanf</code>, 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 <code>fopen</code>, iar la final obligatoriu le închideți cu <code>fclose</code>. În nici un caz nu folosiți <code>freopen</code>.
* Folosiți doar funcțiile de intrare/ieșire C, <code>fscanf / fprintf / fgetc / fputc / fgets</code>. Aveți aici un sumar al acestor funcții: [[instrucțiuni de intrare/ieșire în limbajul C]]
* Nu folosiți funcții gen <code>sort</code> și <code>qsort</code>. 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 <code>n</code> î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 <code>n</code> 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 <code>n</code> 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 <code>n</code> 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 <code>n</code> paranteze de <code>k</code> 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 <code>n</code> 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 <code>n</code> 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 <code>n1</code>, respectiv <code>n2</code> elemente
| <math>O(n1 + n2)</math>
| <math>O(n1 + n2)</math>
|
|-
| Sortare prin selecție a <code>n</code> numere - select sort
| <math>O(n^2)</math>
| <math>O(n)</math>
|
|-
| Sortare prin numărare (cu vectori de frecvență) a <code>n</code> 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 <code>n</code> 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 <code>n</code> 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 <code>n</code>
| <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 <code>n</code> elemente
| <math>O(\log{n})</math>
| <math>O(n)</math>
|
|-
| Calculul multiplicității numărului <code>a</code> în <code>n!</code>
| <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 <code>main()</code> și am folosit funcții de intrare ieșire precum <code>fscanf()</code> și <code>fprintf()</code>, precum și funcții matematice din bibliotecile standard precum <code>sqrt()</code> sau <code>abs()</code>. 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 <code>min()</code>:

<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 <code>void</code>, 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 <code>a</code> este o variabilă nou creată la intrarea în funcție în care se copiază valoarea variabilei <code>x</code>. Funcția modifică (incrementează) valoarea lui <code>a</code>, dar aceasta nu influențează valoarea lui <code>x</code>, 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 <code>main()</code> 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 <code>main()</code>) ș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 <code>main()</code>. 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 <code>citire()</code> sau <code>solve()</code> 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 <code>contor</code> sau <code>stegulet</code>. Așa cum stegulețul ar fi bine să se numească <code>terminat</code> sau <code>fara_zero</code>, la fel și funcțiile trebuie denumite sugestiv. Pentru cele două funcții de mai sus nume bune ar fi <code>citesteVectorInaltimi()</code> sau <code>calculSumePartiale()</code>. 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 <code>fgetc()</code> 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 2: Problema selecției și stive

2026-02-06T07:26:32Z

Cristian:

== Înregistrare video lecție ==

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

== Problema selecției ==

'''Problema'''

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

'''Exemplu'''

Fie șirul <code>3 9 23 13 18 8 3 10 2 10 15 21</code> și poziția <code>k = 6</code>.

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 2: Problema selecției și stive

2026-02-06T07:25:20Z

Cristian:

== Înregistrare video lecție ==

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

== Problema selecției ==

'''Problema'''

Dat un șir de <code>n</code> 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 2: Problema selecției și stive

2026-02-06T07:24:35Z

Cristian:

== Înregistrare video lecție ==

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

== Problema selecției ==

'''Problema'''

Dat un șir de <tt>n</tt> 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 2: Problema selecției și stive

2026-02-06T07:23:30Z

Cristian:

== Î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 13: Analiză amortizată (2)

2026-02-06T07:22:23Z

Cristian:

== Înregistrare video curs ==

<youtube height="720" width="1280">https://youtu.be/_oXoXO7EEWY</youtube>

== Problema Unific ==

Problema [https://www.nerdarena.ro/problema/unific Unific] a fost dată la OJI 2013 clasa a 7-a. Problema definește o procedură prin care două numere pot fi unificate, dacă au măcar o cifră în comun. Apoi cere să se aplice pe un vector unificări de elemente adiacente până ce nu se mai poate unifica nimic. Întotdeauna se va face prima unificare posibilă de la începutul vectorului.

Soluția forță brută este să căutăm prima pereche unificabilă de la începutul vectorului și să o unificăm. Apoi reluăm, de la începutul vectorului. Ea este pătratică, deci '''va depăși timpul pe teste mari'''.

O soluție mai bună este ca la momentul citirii unui număr nou să îl unificăm cu el dinainte, apoi rezultatul cu cel dinainte și tot așa până ce nu mai putem unifica. Apoi citim următorul număr și reluăm.

Ce complexitate are această soluție?

La prima vedere un număr nou poate fi unificat de cel mult n ori, ceea ce duce la o complexitate pătratică. Desigur că nu e așa. Deoarece fiecare număr poate fi adăugat o singură dată și eliminat o singură dată (prin unificare) rezultă că '''numărul de unificări este maxim 2n. Analiza amortizată ne spune că soluția este liniară în numărul de unificări'''.

O parte grea este unificarea propriu zisă. Deși algoritmul este clar, există destule cazuri particulare, iar implementarea dă suficiente bătăi de cap, așa încât mulți elevi au greșit-o la olimpiadă, denumind-o ''problemă tractor''.

În realitate nu este chiar așa, ea putându-se implementa în circa 90 de linii de cod.

=== Implementare soluție ===

==== Subprograme cu parametri de ieșire ====

În problema de față ne poate fi folositoare o funcție care returnează valori folosind parametri de ieșire. Un parametru de ieșire reprezintă o variabilă care păstrează valoarea calculată în funcție și în afara ei. Am mai vorbit despre ei, dar poate este un moment bun să reluăm.

Știm să scriem '''subprograme cu parametri de intrare''':

<syntaxhighlight lang="C" line>
int subprogram (int variabila1, int variabila2) {}
</syntaxhighlight>

Pentru a putea avea un parametru de ieșire, suntem vom declara acest parametru ca pointer:

<syntaxhighlight lang="C" line>
int subprogram (int variabila1, int *variabila2) {}
</syntaxhighlight>

Vom avea grijă ca oriunde folosim <source lang="C" enclose="none">*variabila2</source> să păstram simbolul <source lang="C" enclose="none">*</source>.

Când chemăm subprogramul undeva, vom avea grijă să îi spunem compilatorului care este parametrul de ieșire:

<syntaxhighlight lang="C" line>
a = subprogram (var1, &var2);
</syntaxhighlight>

Simbolul <source lang="C" enclose="none">&</source> raportează adresa de memorie unde este stocată acea variabilă, astfel că, executarea programului va folosi adresele de memorie, nu valorile în sine din variabile. Așa se explică de ce trimitem parametrii comenzii <source lang="C" enclose="none">fscanf()</source> cu <source lang="C" enclose="none">&</source>, pentru ca funcția să poată returna variabilele modificate.

Iată un exemplu de program care folosește parametri de ieșire. Programul următor calculează suma și produsul a două numere într-un subprogram de tip <source lang="C" enclose="none">int</source>. Suma este returnată de către subprogram iar produsul de către parametrul de ieșire al subprogramului:

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

int suma_produs(int a, int b, int *produs) {
*produs = a * b;
return a + b;
}

int main()
{
FILE *fin, *fout;
int nr1, nr2, suma, prod;

fin = fopen("sp.in", "r");
fscanf(fin, "%d%d", &nr1, &nr2);
fclose(fin);

suma = suma_produs(nr1, nr2, &prod);

fout = fopen("sp.out", "w");
fprintf(fout, "%d %d\n", suma, prod);
fclose(fout);

return 0;
}
</syntaxhighlight>

Urmează sugestii de implementare. Le puteți ignora dacă doriți :-)

==== Programul principal ====

În programul principal:

* vom folosi '''o stivă''' în care vom păstra atâtea doar numere care nu mai pot produce o unificare. Să numim stiva <source lang="C" enclose="none">num[]</source>;
* vom determina '''cea mai folosită cifră''', prin încărcarea tuturor cifrelor într-un vector de frecvență. Să îl numim <source lang="C" enclose="none">c[]</source>. Pe măsură ce vom citi numerele la intrare, vom prelucra cifrele acestuia în vectorul <source lang="C" enclose="none">c</source>. Astfel rezolvăm punctul a al problemei;
* vom verifica '''dacă putem face o unificare'''. Vom verifica dacă stiva are cel puțin două elemente, și dacă da, vom apela o funcție care verifică dacă ultimele două elemente din stivă se pot unifica. Să numim această funcție <source lang="C" enclose="none">unific()</source>. Ea va avea antetul astfel: <source lang="C" enclose="none">long long unific (long long a, long long b)</source>. Funcția ne va returna una din situațiile:
** fie cele două numere se pot unifica și rezultă un nou număr, caz în care scoatem ultimele două numere din stivă și adăugăm noul număr; numărul de elemente din stivă scade cu unu.
** fie cele două numere se pot unifica și dispar, caz în care pur și simplu scoatem ultimele două elemente din stivă; numărul de elemente din stivă scade cu 2.
** fie cele două numere nu se pot unifica.
* doar în cazul în care ultimele două numere se pot unifica și rezultă un singur număr (primul din cele trei cazuri anterioare) vom continua procedura de unificare, verificând ultimele două numere pe stivă.

==== Subprogramul unific() ====

Antetul programului este:

<syntaxhighlight lang="C" line>
long long unific (long long a, long long b)
</syntaxhighlight>

Acesta va returna rezultatul unificării a două numere, a și b. Rezultatul poate avea unul dintre următoarele valori:

* numărul rezultat prin unificare;
* -1, dacă dispar ambele numere;
* -2, dacă nu se unifică.

Vom implementa procedura descrisă în cerință. Pentru a simplifica calculele, vom defini 2 vectori de frecvență, unul pentru fiecare număr. În <source lang="C" enclose="none">va[10]</source> vom salva cifrele numărului <source lang="C" enclose="none">a</source> și în <source lang="C" enclose="none">vb[10]</source> vom salva cifrele numărului <source lang="C" enclose="none">b</source>. Putem crea o altă funcție, care să calculeze acești vectori sau o putem face aici.

De asemenea, vom avea nevoie să calculăm cea mai mare putere a lui 10, mai mică sau egală cu <source lang="C" enclose="none">a</source>, respectiv cu <source lang="C" enclose="none">b</source>. Să le notăm <source lang="C" enclose="none">pa</source> și <source lang="C" enclose="none">pb</source>.

Vom parcurge cei doi vectori de frecvență, va și vb și vom vedea dacă găsim cel puțin o cifră comună. Dacă da, atunci trebuie să creăm noul număr. Pentru că există posibilitatea ca după unificare, ambele numere să nu mai aibă nici o cifră, vom crea noul <source lang="C" enclose="none">a</source> și noul <source lang="C" enclose="none">b</source>. Apoi vom verifica dacă oricare dintre cele două numere noi sunt diferite de 0. Dacă sunt diferite de 0, va trebui să construim numărul din nou.

Pentru a calcula noul <source lang="C" enclose="none">a</source> sau noul <source lang="C" enclose="none">b</source>, vom crea altă funcție, să o numim <source lang="C" enclose="none">nrnou()</source>.

==== Subprogramul nrnou() ====

Antetul programului este:

<syntaxhighlight lang="C" line>
long long nrnou (long long a, long long p10, int v[], int *nrcf)
</syntaxhighlight>

Acesta va returna noul număr și numărul lui de cifre în parametrul de ieșire <source lang="C" enclose="none">*nrcf</source>. Explicația parametrilor este următoarea:

* <source lang="C" enclose="none">a</source>: numărul din care se elimină cifrele;
* <source lang="C" enclose="none">pa</source>: puterea cea mai mare a lui 10 care încape în <source lang="C" enclose="none">a</source>, inițial;
* <source lang="C" enclose="none">v[]</source>: vectorul de frecvență al cifrelor rămase în noul număr. La apelare va fi de fapt vectorul <source lang="C" enclose="none">va[]</source> sau <source lang="C" enclose="none">vb[]</source>, pe care îl vom folosi pentru calcule;
* <source lang="C" enclose="none">nrcf</source>: numărul de cifre al noului număr (se calculeaza și returnează).

Modul de calcul ar trebui să fie deja evident. Câtă vreme sunt cifre în numărul <source lang="C" enclose="none">a</source>, vom calcula prima cifră cu ajutorul puterii pa și vom elimina prima cifră din <source lang="C" enclose="none">a</source>. Dacă cifra există în vectorul de frecvență o adăugăm la numărul nou construit. Vom actualiza numărul de cifre pentru noul număr.

Atenție, tot aici trebuie să ajustăm noul număr când singurele cifre rămase sunt 0.

== Problema MaxArea ==

Problema [https://www.nerdarena.ro/problema/maxarea MaxArea] a fost dată la concursul Shumen pentru juniori în 2015.

Rezolvarea folosește o stivă, similar cu problemele [https://www.nerdarena.ro/problema/tower Tower] sau [https://www.nerdarena.ro/problema/maxp MaxP]. Vom memora o stivă de dreptunghiuri de înălțimi din ce în ce mai mari. Când adăugăm o înălțime <source lang="C" enclose="none">h</source> vom închide toate dreptunghiurile de înălțimi mai mari de pe stivă. Apoi depunem pe stivă dreptunghiul curent.

Avem două cazuri, dacă dreptunghiul curent este de înălțime strict mai mare vom crea un nou dreptunghi pe stivă de ''lățime 1 + lățimea însumată a dreptunghiurilor eliminate''. Altfel, în caz de egalitate, vom mări lățimea dreptunghiului din vârful stivei cu același număr, ''1 + lătimea însumată a dreptunghiurilor eliminate''.

De remarcat că problema cere citirea a un milion de întregi de 5 cifre. Incluzând separatorul, spațiu, aceasta înseamnă circa 6MB. Soluția fiind ''O(n)'', la fel ca și citirea, este clar că ea va fi dominată ca timp de citire. De aceea este important să nu citim cu <source lang="C" enclose="none">fscanf()</source>, ci cu <source lang="C" enclose="none">fgetc()</source> (parsing în limbajul olimpicilor).

'''Observație:''' spre finalul numerelor pe stivă se vor afla foarte multe înălțimi egale. O optimizare ar fi, deci, să ''grupăm'' acele înălțimi. În loc de o înălțime putem stoca o pereche <source lang="C" enclose="none">(h, ap)</source> unde <source lang="C" enclose="none">ap</source> ne spune numărul de apariții ale acelei înălțimi. Când adăugăm o înălțime egală la stivă vom aduna de fapt 1 la <source lang="C" enclose="none">ap</source>. Astfel mărimea stivei rămâne mică.

== Problema Skyline ==

Problema [https://www.nerdarena.ro/problema/skyline Skyline] este o problemă clasică. Cere să se găsească dreptunghiul de arie maximă într-un skyline, unde un skyline este linia lăsată de zgârie-nori. Cu alte cuvinte o secvență de dreptunghiuri aliniate cu axa ''Ox''.

Rezolvarea folosește o stivă, similar cu problemele [https://www.nerdarena.ro/problema/tower Tower] sau [https://www.nerdarena.ro/problema/maxp MaxP]. Vom memora o stivă de dreptunghiuri de înălțimi din ce în ce mai mari. Când adăugăm un dreptunghi de înălțime <source lang="C" enclose="none">h</source> vom închide toate dreptunghiurile de înălțime mai mare de pe stivă, având grijă să le înlocuim cu un dreptunghi egal cu suma lungimilor lor și de înălțime egală cu <source lang="C" enclose="none">h</source>.

Complexitatea este ''O(n)'' prin analiză amortizată și ''O(n)'' memorie.

== Temă 13 ==

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

* [https://www.nerdarena.ro/problema/unific Unific] dată la OJI 2013 clasa a 7-a
* [https://www.nerdarena.ro/problema/maxarea MaxArea] dată la Shumen Juniori 2015
* [https://www.nerdarena.ro/problema/skyline Skyline] problemă clasică de analiză amortizată

== Tema opțională ==

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

* [https://www.nerdarena.ro/problema/dreptunghi1 Dreptunghi1] problemă clasică de analiză amortizată

[http://solpedia.francu.com/wiki/index.php/Clasa_a_7-a_Lec%C8%9Bia_13:_Analiz%C4%83_amortizat%C4%83_(2) Accesează rezolvarea temei 13]

Clasa a 7-a Lecția 7: Recursivitate (1)

2026-02-06T07:19:45Z

Cristian:

== Înregistrare video lecție ==

<youtube height="720" width="1280">https://youtu.be/n_LKos0gG0Q</youtube>

== Despre recursivitate ==

O funcție este recursivă dacă se autoapelează. A scrie o funcție recursivă necesită, inițial, o încredere în faptul că funcția funcționează. În fapt, când pornim să scriem o funcție recursivă este bine să considerăm că ea deja funcționează!

Reguli de scriere a unei funcții recursive:

* Înainte de a scrie cod este bine să ne clarificăm formula recurentă.
* Tratăm mai întâi cazurile simple, atunci când funcția poate returna o valoare fără a se autoapela.
* În final, tratăm cazul de recursie, considerând că funcția este deja scrisă pentru cazurile ''mai mici'', folosindu-ne de formula recurentă găsită la început.

Iată un videoclip de prezentare cu exemple de funcții recursive, cu imagini *:

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

'' * Exemplele de cod din film sunt scrise într-un pseudocod, suficient de bine explicate astfel încât să fie ușor redactate în orice limbaj de programare, inclusiv C.''

== Exemple introductive ==

=== Factorial ===

Calcul n! Ne vom folosi de definiția recursivă: <math>n! = \begin{cases} 1, & \mbox{dacă } n = 1 \\ n \cdot (n - 1)!, & \mbox{dacă } n > 1. \end{cases}</math>

<syntaxhighlight lang="C" line>
int fact( int n ) {
if ( n == 1 )
return 1;
return n * fact( n - 1 );
}</syntaxhighlight>

=== Putere ===
Calcul an. Ne vom folosi de definiția recurentă: <math>a^{n} = \begin{cases} 1, & \mbox{dacă } n = 0 \\ a \cdot a^{n-1}, & \mbox{dacă } n > 0. \end{cases}</math>

<syntaxhighlight lang="C" line>
int putere( int a, int n ) {
if ( n == 0 )
return 1;
return a * putere( a, n - 1 );
}</syntaxhighlight>

=== Cmmdc ===
Calcul cmmdc a două numere. Ne vom folosi de definiția recursivă a lui Euclid: <math>cmmdc(a, b) = \begin{cases} a, & \mbox{dacă } b = 0 \\ cmmdc(b, a \bmod b), & \mbox{dacă } b > 0. \end{cases}</math>

<syntaxhighlight lang="C" line>
int cmmdc( int a, int b ) {
if ( b == 0 )
return a;
return cmmdc( b, a % b );
}</syntaxhighlight>

== Exerciții ==

Încercați să scrieți următoarele funcții recursive.

=== Fibonacci ===
Să se scrie o funcție recursivă care, dat <source lang="C" enclose="none">n</source>, calculează al <source lang="C" enclose="none">n</source>-lea termen din șirul lui Fibonacci: <source lang="C" enclose="none">0 1 1 2 3 5 8 13...</source>. Ne vom folosi de definiția recurentă: <math>fib(n) = \begin{cases} 0, & \mbox{dacă } n = 1 \\ 1, & \mbox{dacă } n = 2 \\ fib(n-1) + fib(n-2), & \mbox{dacă } n > 2. \end{cases}</math>

<syntaxhighlight lang="C" line>
int fib( int n ) {
if ( n == 1 )
return 0;
if ( n == 2 )
return 1;
return fib( n - 1 ) + fib ( n - 2 );
}</syntaxhighlight>

=== Suma cifrelor unui număr ===
Să se scrie o funcție recursivă care calculează suma cifrelor unui număr <source lang="C" enclose="none">n</source>.

Ne vom folosi de următoarea formulă recurentă: <math>suma(n) = \begin{cases} 0, & \mbox{dacă } n = 0 \\ n % 10 + suma(n / 10), & \mbox{dacă } n > 0. \end{cases}</math>

<syntaxhighlight lang="C" line>
int sumac( int n ) {
if ( n == 0 )
return 0;
return n % 10 + sumac( n / 10 );
}</syntaxhighlight>

=== Putere în O(log n) ===
Calculați <tt>an</tt> în mod cât mai eficient (a și n numere naturale). Problema este cunoscută şi sub numele de ridicare la putere în timp logaritmic. Ideea din spatele acestei rezolvări este următoarea:

*Dacă <source lang="C" enclose="none">n</source> este par, atunci <tt>an = a2*n/2 = (a2)n/2</tt>
*Dacă <source lang="C" enclose="none">n</source> este impar, atunci <source lang="C" enclose="none">n-1</source> este par și avem <tt>an = a * an-1 = a * a2*(n-1)/2 = a * (a2)(n-1)/2 = a * (a2)n/2</tt>

Rezultă formula de recurență:

<math>a^{n} = \begin{cases} 1, & \mbox{dacă } n = 0 \\ {(a^{2})}^{n/2}, & \mbox{dacă } n >0, n % 2 = 0 \\ a \times {(a^{2})}^{n/2}, & \mbox{dacă } n > 0, n % 2 = 1 \end{cases}</math>

În formulele de mai sus am considerat că <source lang="C" enclose="none">/</source> este împărțirea întreagă din limbajul C. Se observă că indiferent de paritatea lui <source lang="C" enclose="none">n</source>, la fiecare pas al iterației putem transforma <source lang="C" enclose="none">a</source> în <source lang="C" enclose="none">a * a</source> și apoi putem împărți <source lang="C" enclose="none">n</source> la <source lang="C" enclose="none">2</source>. Doar în cazurile când <source lang="C" enclose="none">n</source> este impar vom acumula valoarea curentă a lui <source lang="C" enclose="none">a</source> la produsul calculat. Iată soluția bazată pe această idee:

<syntaxhighlight lang="C" line>
int putere( int a, int n ) {
int p;

if ( n == 0 )
return 1;
p = putere( a * a, n / 2 );
if ( n % 2 ) // n impar?
p *= a;

return p;
}</syntaxhighlight>

=== Afișare ===
Să se afișeze un șir de caractere în ordine inversă. Șirul se termină cu <source lang="C" enclose="none">'\n'</source>.

Ne vom folosi de următoarea idee: citim un caracter, apoi chemăm funcția recursivă pentru a afișa restul caracterelor, apoi afișăm caracterul.

<syntaxhighlight lang="C" line>
void afisare( FILE *fin, FILE *fout ) {
char ch;

ch = fgetc( fin );
if ( ch != '\n' ) {
afisare( fin, fout );
fputc( ch, fout );
}
}</syntaxhighlight>

=== Descompunere în baza 2 ===
Să se scrie o funcție recursivă care, dat <source lang="C" enclose="none">n</source>, îl afișează în baza 2.

Similar cu exercițiul precedent, vom calcula ultima cifră a descompunerii (restul împărțirii la doi), apoi vom chema funcția cu <source lang="C" enclose="none">n / 2</source>, iar la revenire vom afișa cifra.

<syntaxhighlight lang="C" line>
void baza2( int n, FILE *fout ) {
int cf2;

if ( n > 0 ) {
cf2 = n % 2;
baza2( n / 2, fout );
fprintf( fout, "%d", cf2 );
}
}</syntaxhighlight>

=== Interclasare vectori ordonați ===
Dîndu-se doi vectori ordonați să se calculeze un al treilea vector ordonat ce conține elementele lor.

Funcția va primi ca parametri cei trei vectori și pozițiile curente în ei (inițial pozițiile de start, 0). La fiecare apel va alege un element pe care îl va copia. Apoi se va reapela cu indici actualizați (i1 și i3 sau i2 și i3).

<syntaxhighlight lang="C" line>
void interclaseaza( int n1, int v1[], int n2, int v2[], int v3[],
int i1, int i2, int i3 ) {
if ( i1 < n1 ) { // mai avem elemente in primul vector?
if ( i2 < n2 && v2[i2] < v1[i1] ) { // v2[i2] exista si e mai mic?
v3[i3] = v2[i2]; // copiem v2[i1]
interclaseaza( n1, v1, n2, v2, v3, i1, i2 + 1, i3 + 1 );
} else {
v3[i3] = v1[i1]; // copiem v1[i1]
interclaseaza( n1, v1, n2, v2, v3, i1 + 1, i2, i3 + 1 );
}
} else if ( i2 < n2 ) { // mai avem elemente in v2? (v1 s-a terminat)
v3[i3] = v2[i2];
interclaseaza( n1, v1, n2, v2, v3, i1, i2 + 1, i3 + 1 );
}
}</syntaxhighlight>

== Tema 6 ==

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

* [https://www.nerdarena.ro/problema/sumacfnr Sumacfnr]
* [https://www.nerdarena.ro/problema/sumadiv Sumadiv]
* [https://www.nerdarena.ro/problema/nset Nset]
* [https://www.nerdarena.ro/problema/invector Invector]
* [https://www.nerdarena.ro/problema/hanoi Turnurile din Hanoi]: [http://www.puzzle.ro/ro/play_toh.htm exemplu de animație joc aici] să se scrie un program care să rezolve jocul turnurile din Hanoi (să efectueze mutările care duc la soluție).

=== Indicații pentru tema obligatorie ===

'''2. Sumadiv - suma divizorilor unui număr'''

Rezolvați problema [https://www.nerdarena.ro/problema/sumadiv Sumadiv]: să se scrie o funcție recursivă care să calculeze suma divizorilor unui număr.

Ea va arăta astfel:

<syntaxhighlight lang="C" line>
int sumd( int n, int d ) {
...
}
</syntaxhighlight>

și va fi apelată inițial astfel:

<syntaxhighlight lang="C" line>
sum = sumd( n, 1 );
</syntaxhighlight>

Semnificaţia este suma divizorilor lui <source lang="C" enclose="none">n</source> care sunt mai mari sau egali cu <source lang="C" enclose="none">d</source> şi mai mici sau egali cu <source lang="C" enclose="none">n / d</source>. Mai exact trebuie să completați funcția <source lang="C" enclose="none">sumd</source> din programul următor:

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

int sumd( int n, int d ) {
...
}

int main() {
FILE *fin, *fout;
int n;

fin = fopen( "sumadiv.in", "r" );
fscanf( fin, "%d", &n );
fclose( fin );

fout = fopen( "sumadiv.out", "w" );
fprintf( fout, "%d\n", sumd( n, 1 ) );
fclose( fout );

return 0;
}
</syntaxhighlight>

Atenţie mare la complexitatea algoritmului obţinut!

'''4. invector - răsturnare vector'''

Rezolvați problema [https://www.nerdarena.ro/problema/invector Invector] să se răstoarne un vector folosind o funcție recursivă. Vectorul trebuie modificat, nu doar afișat invers. Funcția va arăta astfel:

<syntaxhighlight lang="C" line>
void inv( int primul, int ultimul, int v[] ) {
...
}
</syntaxhighlight>

unde primul și ultimul sunt indicii de început, respectiv sfârșit care definesc subvectorul de răsturnat. Funcția va fi apelată inițial astfel:

<syntaxhighlight lang="C" line>
inv( 0, n-1, v );
</syntaxhighlight>

Mai exact trebuie să completați funcția inv din programul următor:

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

int v[100000];

void inv( int primul, int ultimul, int v[] ) {
...
}

int main() {
FILE *fin, *fout;
int n, i;

fin = fopen( "invector.in", "r" );
fscanf( fin, "%d", &n );
for ( i = 0; i < n; i++ )
fscanf( fin, "%d", &v[i] );
fclose( fin );

inv( 0, n-1, v );

fout = fopen( "invector.out", "w" );
for ( i = 0; i < n; i++ )
fprintf( fout, "%d ", v[i] );
fprintf( fout, "\n" );
fclose( fout );

return 0;
}
</syntaxhighlight>

== Tema opțională ==

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

* [https://www.nerdarena.ro/problema/combinari combinări] <math>{C}_{n}^{k}</math><nowiki>- combinări de n luate câte k. Date numerele naturale n și k, k ≤ n, să se afișeze toate submulțimile mulțimii {1, 2, 3, ..., n} de k elemente.</nowiki>
* [https://www.nerdarena.ro/problema/v v] (ONI 2004 clasa a 7-a) Problema este modificată. Puteți lua doar 50% din punctaj. Pentru 100% '''nu este nevoie de parsing'''. Dacă introduceam cerință de parsing aș fi scăzut timpul permis.

[http://solpedia.francu.com/wiki/index.php/Clasa_a_7-a_Lec%C8%9Bia_7:_Recursivitate_(1) Accesează rezolvarea temei 7]

Cercul de informatică gimnaziu

2026-02-03T15:41:46Z

Cristian:

Aceste lecții sînt create în fața unei audiențe "live" :-). Aceasta înseamnă că au fost efectiv folosite în anul școlar 2014-2015. De aceea veți remarca uneori comentarii la teme, laude, mustrări. Nu le-am eliminat deoarece pot fi și ele folositoare pentru instructor în desfășurarea lecției.

== Spiritul cercului de informatică ==
* [[Reguli ale cercului de informatică]]: spiritul acestor lecții
 

== Lecții gimnaziu ==
* [[Lecții de informatică, clasa a V-a]]
* [[Lecții de informatică, clasa a VI-a]]
* [[Clasa a 7-a|Lecții de informatică, clasa VII/VIII]]
 

== Link-uri utile ==
* [[Setări necesare în Code::Blocks]]
* [[Instrucțiuni de intrare/ieșire în limbajul C]]
* [[Testarea timpului de execuție al unui program]]
* [[Unelte software necesare|Download: unelte software necesare]]
* [[Cercul de informatică - sfaturi pentru olimpiadă | Sfaturi pentru olimpiadă]]
* [[Cercul de informatică: pregătirea în vacanța de vară pentru elevii de gimnaziu | Pregătirea în vacanța de vară pentru elevii de gimnaziu]]

Cercul de informatică IQ Academy

2026-02-03T15:40:51Z

Cristian:

''No ''<code>break</code>'', no ''<code>continue</code>'', no ''<code>int v[1005]</code>'', no nonsense''

Aceste lecții sînt create în fața unei audiențe "live" :-). Aceasta înseamnă că au fost efectiv folosite în diverși ani școlari. De aceea veți remarca uneori comentarii la teme, laude, mustrări. Nu le-am eliminat deoarece pot fi și ele folositoare pentru instructor în desfășurarea lecției.

== Cursuri IQ Academy ==
* [[Cercul de informatică, IQ Academy, clasa a VII-a, anul 2019-2020]] - Cristian Frâncu
* [[Cercul de informatică, IQ Academy, clasa a V-a, anul 2019-2020]] - Mihai Tuțu
* [[Cercul de informatică, IQ Academy, clasa a VI-a, anul 2018-2019]] - Cristian Frâncu
* [[Cercul de informatică, IQ Academy, clasa a V-a, anul 2017-2018]] - Cristian Frâncu
* [[Lecții de informatică, clasa VII/VIII|Cercul de informatică, CNITV, clasa VII/VIII, anul 2014-2015]] - Cristian Frâncu
 

[http://iqacademy.ro/ IQ Academy] este o inițiativă a [http://francu.org/ Fundației Frâncu pentru progres și educație] ce își propune formarea unor minți algoritmice, cu putere de abstractizare, cu “gândire computațională”, termen apărut relativ recent și susținut de oameni precum Mark Zuckerberg, creatorul Facebook. IQ Academy oferă momentan cursuri de informatică.

Cercul de informatică IQ Academy

2026-02-03T15:40:23Z

Cristian:

''No ''<code>break</code>'', no ''<code>continue</code>'', no ''<code>int v[1005]</code>'', no nonsense''

Aceste lecții sînt create în fața unei audiențe "live" :-). Aceasta înseamnă că au fost efectiv folosite în diverși ani școlari. De aceea veți remarca uneori comentarii la teme, laude, mustrări. Nu le-am eliminat deoarece pot fi și ele folositoare pentru instructor în desfășurarea lecției.

== Cursuri IQ Academy ==
* [[Cercul de informatică, IQ Academy, clasa a VII-a, anul 2019-2020]] - Cristian Frâncu
* [[Cercul de informatică, IQ Academy, clasa a V-a, anul 2019-2020]] - Mihai Tuțu
* [[Cercul de informatică, IQ Academy, clasa a VI-a, anul 2018-2019]] - Cristian Frâncu
* [[Cercul de informatică, IQ Academy, clasa a V-a, anul 2017-2018]] - Cristian Frâncu
* [[Lecții de informatică, clasa VII/VIII|Cercul de informatică, CNITV, anul 2014-2015]] - Cristian Frâncu
 

[http://iqacademy.ro/ IQ Academy] este o inițiativă a [http://francu.org/ Fundației Frâncu pentru progres și educație] ce își propune formarea unor minți algoritmice, cu putere de abstractizare, cu “gândire computațională”, termen apărut relativ recent și susținut de oameni precum Mark Zuckerberg, creatorul Facebook. IQ Academy oferă momentan cursuri de informatică.

Cercul de informatică IQ Academy

2026-02-03T15:38:58Z

Cristian:

''No ''<code>break</code>'', no ''<code>continue</code>'', no ''<code>int v[1005]</code>'', no nonsense''

Aceste lecții sînt create în fața unei audiențe "live" :-). Aceasta înseamnă că au fost efectiv folosite în diverși ani școlari. De aceea veți remarca uneori comentarii la teme, laude, mustrări. Nu le-am eliminat deoarece pot fi și ele folositoare pentru instructor în desfășurarea lecției.

== Cursuri IQ Academy ==
* [[Cercul de informatică, IQ Academy, clasa a VII-a, anul 2019-2020]] - Cristian Frâncu
* [[Cercul de informatică, IQ Academy, clasa a V-a, anul 2019-2020]] - Mihai Tuțu
* [[Cercul de informatică, IQ Academy, clasa a VI-a, anul 2018-2019]] - Cristian Frâncu
* [[Cercul de informatică, IQ Academy, clasa a V-a, anul 2017-2018]] - Cristian Frâncu
* [[Lecții de informatică, clasa VII/VIII]], anul 2014-2015 - Cristian Frâncu
 

[http://iqacademy.ro/ IQ Academy] este o inițiativă a [http://francu.org/ Fundației Frâncu pentru progres și educație] ce își propune formarea unor minți algoritmice, cu putere de abstractizare, cu “gândire computațională”, termen apărut relativ recent și susținut de oameni precum Mark Zuckerberg, creatorul Facebook. IQ Academy oferă momentan cursuri de informatică.

Cercul de informatică IQ Academy

2026-02-03T15:38:00Z

Cristian:

''No ''<code>break</code>'', no ''<code>continue</code>'', no ''<code>int v[1005]</code>'', no nonsense''

Aceste lecții sînt create în fața unei audiențe "live" :-). Aceasta înseamnă că au fost efectiv folosite în diverși ani școlari. De aceea veți remarca uneori comentarii la teme, laude, mustrări. Nu le-am eliminat deoarece pot fi și ele folositoare pentru instructor în desfășurarea lecției.

== Cursuri IQ Academy ==
* [[Cercul de informatică, IQ Academy, clasa a VII-a, anul 2019-2020]] - Cristian Frâncu
* [[Cercul de informatică, IQ Academy, clasa a V-a, anul 2019-2020]] - Mihai Tuțu
* [[Cercul de informatică, IQ Academy, clasa a VI-a, anul 2018-2019]] - Cristian Frâncu
* [[Cercul de informatică, IQ Academy, clasa a V-a, anul 2017-2018]] - Cristian Frâncu
* [[Lecții de informatică, clasa VII/VIII]] - Cristian Frâncu
 

[http://iqacademy.ro/ IQ Academy] este o inițiativă a [http://francu.org/ Fundației Frâncu pentru progres și educație] ce își propune formarea unor minți algoritmice, cu putere de abstractizare, cu “gândire computațională”, termen apărut relativ recent și susținut de oameni precum Mark Zuckerberg, creatorul Facebook. IQ Academy oferă momentan cursuri de informatică.

Cercul de informatică IQ Academy

2026-02-03T15:37:45Z

Cristian:

''No ''<code>break</code>'', no ''<code>continue</code>'', no ''<code>int v[1005]</code>'', no nonsense''

Aceste lecții sînt create în fața unei audiențe "live" :-). Aceasta înseamnă că au fost efectiv folosite în diverși ani școlari. De aceea veți remarca uneori comentarii la teme, laude, mustrări. Nu le-am eliminat deoarece pot fi și ele folositoare pentru instructor în desfășurarea lecției.

== Cursuri IQ Academy ==
* [[Cercul de informatică, IQ Academy, clasa a VII-a, anul 2019-2020]] - Cristian Frâncu
* [[Cercul de informatică, IQ Academy, clasa a V-a, anul 2019-2020]] - Mihai Tuțu
* [[Cercul de informatică, IQ Academy, clasa a VI-a, anul 2018-2019]] - Cristian Frâncu
* [[Cercul de informatică, IQ Academy, clasa a V-a, anul 2017-2018]] - Cristian Frâncu
* [[Lecții de informatică, clasa VII/VIII]]
 

[http://iqacademy.ro/ IQ Academy] este o inițiativă a [http://francu.org/ Fundației Frâncu pentru progres și educație] ce își propune formarea unor minți algoritmice, cu putere de abstractizare, cu “gândire computațională”, termen apărut relativ recent și susținut de oameni precum Mark Zuckerberg, creatorul Facebook. IQ Academy oferă momentan cursuri de informatică.

Main Page

2026-02-03T15:34:20Z

Cristian:

__NOTOC__
= Algopedia =

== [[Cercul de informatică gimnaziu]] ==
[[Cercul de informatică gimnaziu]] este o colecție de lecții de algoritmi și programare pentru clasele V-VIII. Lecțiile acoperă programa de olimpiadă, dar nu se opresc aici, scopul final fiind de a forma minți algoritmice și a crea informaticieni cu cunoștințe de bază complete. În acest sens evităm "dopajul" (predarea în avans a unor cunoștințe, fără a preda prerechizitele necesare, în scopul obținerii unor rezultate mai bune la olimpiadă). Lecțiile sînt împărțite astfel încît să acopere anul școlar în ritmul de o lecție pe săptămînă, circa 40-44 de lecții la fiecare clasă. Fiecare lecție durează două ore. Unele lecții sînt concursuri cu participare de acasă, ele dublînd lecția din acea săptămînă.

== [[Cercul de informatică IQ Academy]] ==
[[Cercul de informatică IQ Academy]] este un curs oferit de [http://iqacademy.ro/ IQ Academy], o inițiativă a [http://francu.org/ Fundației Frâncu pentru progres și educație] ce își propune formarea unor minți algoritmice, cu putere de abstractizare, cu “gândire computațională”, termen apărut relativ recent și susținut de oameni precum Mark Zuckerberg, creatorul Facebook.
 
 

== Cercul de informatică, colegiul Tudor Vianu, 2012-2020 ==
Găsiți aici detalii despre [[Cercul de informatică - Colegiul Național de Informatică Tudor Vianu]] desfășurat în perioada 2012-2020.
 
 

== Data Structures and Algorithms ==
A future translation to English. Work in progress.
* [[Introduction to Algorithms]]
* [[Introductory Exercises]]
* [[Problems Involving Sequences]]
* [[Problems Involving Arrays]]
 

== Contact ==
Puteți contacta creatorul acestui site, Cristian Frâncu, la [mailto:cristian@francu.com cristian@francu.com]

Cercul de informatică IQ Academy

2026-02-03T15:32:30Z

Cristian:

''No ''<code>break</code>'', no ''<code>continue</code>'', no ''<code>int v[1005]</code>'', no nonsense''

Aceste lecții sînt create în fața unei audiențe "live" :-). Aceasta înseamnă că au fost efectiv folosite în diverși ani școlari. De aceea veți remarca uneori comentarii la teme, laude, mustrări. Nu le-am eliminat deoarece pot fi și ele folositoare pentru instructor în desfășurarea lecției.

== Cursuri IQ Academy ==
* [[Cercul de informatică, IQ Academy, clasa a VII-a, anul 2019-2020]] - Cristian Frâncu
* [[Cercul de informatică, IQ Academy, clasa a V-a, anul 2019-2020]] - Mihai Tuțu
* [[Cercul de informatică, IQ Academy, clasa a VI-a, anul 2018-2019]] - Cristian Frâncu
* [[Cercul de informatică, IQ Academy, clasa a V-a, anul 2017-2018]] - Cristian Frâncu
 

[http://iqacademy.ro/ IQ Academy] este o inițiativă a [http://francu.org/ Fundației Frâncu pentru progres și educație] ce își propune formarea unor minți algoritmice, cu putere de abstractizare, cu “gândire computațională”, termen apărut relativ recent și susținut de oameni precum Mark Zuckerberg, creatorul Facebook. IQ Academy oferă momentan cursuri de informatică.

Clasa a V-a lecția 30 - 8 mar 2018

2026-02-03T15:18:57Z

Cristian:

= Comentarii rezultate faza pe sector =
# Felicitări tuturor! Ați ajuns pînă aici cu foarte multă muncă.
# Felicitări celor ce au luat 100p la prima problemă, șir, o problemă ce necesita atenție și concentrare: '''Armin Asgari''' și '''Alex Nicu'''!
# Felicitări negative celor ce nu au luat 100p la a doua problemă, cifre. Era o problemă ușoară, de lecția 10. Poate nu v-ați dat suficiente teste?
# Cei ce nu ați dat surse la prima problemă, șir: ar fi fost bine să dați o sursă care afișa un număr, la inspirație. De exemplu 2 (primul număr prim), sau 1 (primul număr prim minu unu), sau poate suma primelor două numere prime minus 1 (adică 4). 10p puncte cîștigate la concurs vă puteau avansa 10-15 locuri în clasament!
# Pentru cei ce ați luat 100p la a doua problemă, cifre, și care ați lucrat la prima problemă, șir, dar ați luat 0p sau 10p: nu vă demoralizați! Este o problemă grea, la care este mai greu să iei punctaje parțiale. Uitați-vă la rezultate și veți vedea că avem doar patru scoruri nenule: 10p, 80p și 90p. O mică corectură în programul vostru putea să vă transforme sursa în una de 90p. La municipiu puteți foarte bine să luați 190p.
# Nu uitați, important: la IQ Academy '''nu facem pregătire pentru olimpiadă''', ci '''ne formăm ca informaticieni'''. Aceasta înseamnă că nu facem dopaj și învățăm să codăm corect. Obiceiurile proaste cu care veniți de la pregătitorii de olimpici nu se acceptă. Printre acestea se numără folosirea lui break, a stegulețelor inutile, a freopen, vectori declarați cu cîteva elemente în plus în caz că vine drăcușorul indicilor și ne încurcă, for pe post de while și invers, if-uri exclusive între ele care nu se înlănțuie unul pe else-ul celuilalt.

= Comentarii tema 29 =
# Felicitări pentru comentarii (cei care mă ajută comentînd programele): '''Nicola''', '''Petcu'''
# Topul pescarilor la speciale: '''Aizic''' 14 surse, '''Togan''' 8 surse, '''Dumitrescu''' 7 surse, '''Ipate''' 7 surse, '''Iordache''' 6 surse, '''Tatomir''' 6 surse, '''Badea''' 5 surse, '''Nicu''' 5 surse
# Speciale: v-a cam dat gata! mulți nu ați luat 100p.
# Speciale: mulți dintre voi nu au folosit vectori preinițializați, sau i-au folosit parțial, acolo unde era cel mai puțin nevoie de ei. Nu e de mirare că v-a dat gata problema. Acesta era scopul problemei, să exersăm vectori preinițializați, nu doar să luăm 100p.

= Tema - rezolvări =

Rezolvări aici [http://solpedia.francu.com/wiki/index.php/Clasa_a_V-a_lec%C8%9Bia_29_-_1_mar_2018]

= Lecţie =
<html5media height="720" width="1280">https://www.algopedia.ro/video/2017-2018/2018-03-08-lectie-info-30-720p.mp4</html5media>

== Problemele de la olimpiada pe sector ==
Dragilor, cred că sînteți de acord cu mine că problemele de anul acesta au fost drăguțe și abordabile, nici prea grele, nici prea ușoare. Nu cred că puteați primi probleme mai bune de olimpiada pe sector.

Să le discutăm.

=== Problema șir6 ===
Problema [http://varena.ro/problema/sir6 șir6] a fost dată la faza pe sector 2018, clasa a 5a. O voi introduce pe varena.ro imediat ce obțin testele. Ea este o problemă standard ce se poate rezolva conform manualului de informatică (unul care predă informatică, nu Scratch :-). Ea conține doar elemente învățate, pe care voi trebuie să le combinați pentru a calcula rezultatul. Algoritmul este clar, fiind aproape explicat de enunț.

Pentru rezolvare vom citi cifrele de la intrare, păstrînd mereu penultima cifră, pentru testul de paritate. La fiecare citire de cifră va trebui să calculăm și următorul număr prim. Pentru aceasta vom porni de la numărul prim anterior, să-i spunem <code>prim</code>, și vom parcurge toate numerele <code>prim</code>+1, <code>prim</code>+2, <code>prim+3</code>, ..., testînd primalitatea lor. Ne vom opri atunci cînd găsim primul număr prim, pe care îl vom aduna la suma cerută. Dacă ultimele două cifre din secvență au parități diferite va trebui să scădem unu din sumă.

Unde trebuie să avem grijă?

==== Testul de găsire număr prim ====
Algoritmul va avea două bucle. Cea interioară testează dacă un număr este prim. Cea exterioară va executa bucla interioară în mod repetat, pînă ce va găsi un număr prim. Pentru testul buclei exterioare veți fi tentați să folosiți stegulețe și veți scrie cod încîlcit. Pentru a nu ajunge acolo, gîndim astfel:

* Scriem mai întîi bucla interioară, care testează dacă un număr este prim. Ea este, sper banală și bine cunoscută:
<syntaxhighlight lang="C"> d = 2;
while ( d * d <= prim && prim % d > 0 )
d++;</syntaxhighlight>
* Apoi scriem bucla interioară, fără să ne preocupăm de condiția ei de oprire:
<syntaxhighlight lang="C"> while ( <condiție necunoscută de oprire> ) {
prim++; // numarul anterior nu este prim, deci avansam
d = 2;
while ( d * d <= prim && prim % d > 0 )
d++;
}</syntaxhighlight>
* Acum:
** Care este condiția să ieșim din <code>while</code>? '''Răspuns''': să găsim un număr prim.
** Care este condiția ce ne spune că am găsit un număr prim? '''Răspuns''': clasică, <code>if ( d * d > prim )</code>
** În concluzie, deoarece condiția din while este cea de a nu fi găsit un număr prim, va trebui să o punem pe dos: <code>while ( d * d <= prim )</code>
Rezultă codul:
<syntaxhighlight lang="C"> while ( d * d <= prim ) {
prim++; // numarul anterior nu este prim, deci avansam
d = 2;
while ( d * d <= prim && prim % d > 0 )
d++;
}</syntaxhighlight>
* Ce mai rămîne de rezolvat? Pornirea: cu ce trebuie să inițializăm <code>prim</code> și <code>d</code> pentru a ne asigura că intrăm cu bine în buclă. Să vedem:
** Ce semnificație exactă are <code>prim</code>? El este ultimul număr prim "folosit". La intrarea în buclă vom avea grijă să îl incrementăm. Deoarece primul număr prim este 2, el fiind și primul ce se va aduna la sumă, trebuie să pornim cu <code>prim</code> cu unu mai puțin, adică 1. Acest lucru se va întîmpla chiar la începutul algoritmului.
** Dar <code>d</code>? Unde și cu cît îl inițializăm? Observăm că imediat ce intrăm în prima buclă <code>d</code> va fi setat la 2. Deci nu contează ce valoare va avea înainte de intrarea în buclă, cîtă vreme condiția din <code>while</code> este adevărată. Deoarece cea mai mică valoare a lui <code>prim</code> este 1, hai să-i dăm lui <code>d</code> valoarea 1.
Rezultă codul:
<syntaxhighlight lang="C"> // cautam urmatorul numar prim, pentru a il insuma
d = 1; // valore introdusa astfel incit sa intram in bucla
while ( d * d <= prim ) {
prim++; // numarul anterior nu este prim, deci avansam
d = 2;
while ( d * d <= prim && prim % d > 0 )
d++;
}</syntaxhighlight>

==== Citirea cifrelor ====
Enunțul problemei nu vă spune cîte cifre aveți la intrare, doar că avem minim două cifre, maxim 3000. Deci, pentru a citi aceste cifre, va trebui să le citim caracter cu caracter, pînă la '\n'. Unii din voi încă au probleme cu astfel de citiri. Să lămurim puțin lucrurile:
* Șirul de la intrare e de forma: cf1 cf2 cf3 ...cfn\n
* Remarcați că putem descompune elegant șirul în perechi de forma (cf, ch), unde cf este o cifră, iar ch este fie caracterul spațiu, fie caracterul \n. El va fi \n o singură dată, la final.
* De aceea vom avea grijă ca la fiecare iterație a buclei să citim perechi de caractere, cifră și imediat după aceea caracterul următor. Ne oprim cînd acel caracter următor este '\n'.
* O ultimă precauție: trebuie să memorăm valoarea penultimei cifre, pentru calculul parității perechilor de cifre.

==== Testul de paritate al perechilor de cifre ====
Sînt convins că vă veți descurca să scădeți unu din sumă în cazul cînd paritățile cifrelor sînt diferite, folosind trei instrucțiuni <code>if</code>. Hai să vedem cum facem fără nici un <code>if</code>. Pentru aceasta să facem tabelul celor patru cazuri posibile, pentru a vedea cînd scădem unu. În acest tabel vom calcula și paritatea sumei cifrelor.

{| class="wikitable"
!Penultima cifră
!Ultima cifră
!Suma
!Scădem unu?
|-
| pară
| pară
| pară
| NU
|-
| pară
| impară
| impară
| DA
|-
| impară
| pară
| impară
| DA
|-
| impară
| impară
| pară
| NU
|}

Ce observăm, imediat? Că vom scădea unu numai atunci cînd suma ultimelor două cifre este impară. Drept care putem rezolva adunarea numărului prim la sumă elegant, într-o singură linie, astfel:

<syntaxhighlight lang="C">suma = suma + prim - (ucf + cf) % 2;</syntaxhighlight>

Iată un program foarte scurt care ține cont de cele discutate mai sus:

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

int main() {
FILE *fin, *fout;
int suma, prim, ucf, cf, d;
char ch;

fin = fopen( "sir6.in", "r" );
suma = 0; // suma de afisat la final, initial zero
prim = 1; // pornim cu numarul din-naintea primului numar prim
ucf = fgetc( fin ) - '0'; // citim prima cifra la intrare
ch = fgetc( fin ); // citim spatiul de dupa
while ( ch != '\n' ) { // mai avem cifre?
cf = fgetc( fin ) - '0'; // citim inca o cifra
ch = fgetc( fin ); // si caracterul de dupa ea

// cautam urmatorul numar prim, pentru a il insuma
d = 1; // valore introdusa astfel incit sa intram in bucla
while ( d * d <= prim ) {
prim++; // numarul anterior nu este prim, deci avansam
d = 2;
while ( d * d <= prim && prim % d > 0 )
d++;
}

// la iesirea din while stim ca prim este urmatorul numar prim
suma = suma + prim - (ucf + cf) % 2; // il adunam la suma conform paritatii
ucf = cf; // pastram ultima cifra
}
fclose( fin );

fout = fopen( "sir6.out", "w" );
fprintf( fout, "%d\n", suma );
fclose( fout );

return 0;
}</syntaxhighlight>

=== Problema cifre9 ===
Problema [http://varena.ro/problema/cifre9 cifre9] a fost dată la faza pe sector 2018, clasa a 5a. O voi introduce pe varena.ro imediat ce obțin testele. Ca și problema șir6, ea este o problemă standard, de manual, ea conținînd doar elemente învățate, simple, de lucrul cu cifre.

Există mai multe moduri de a aborda această problemă. Un mod este să extragem pe rînd cifrele lui <code>N</code>, de la coadă, numărînd aparițiile lui <code>k</code> și formînd în același timp numărul de afișat. Dacă cifra extrasă este diferită de <code>k</code> o vom adăuga la numărul nou format, dacă este <code>k</code> o vom număra și o vom adăuga la un număr ce va conține toate cifrele <code>k</code>.

Iată o variantă de program:

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

int main() {
FILE *fin, *fout;
int n, k, nrk, kkk, nmod, p10, cf;

fin = fopen( "cifre9.in", "r" );
fscanf( fin, "%d%d", &n, &k );
fclose( fin );

nrk = 0; // de cite ori apare cifra k in n
kkk = 0; // numarul format din nrk cifre k
nmod = 0; // n modificat astfel incit toate cifrele k sa fie la inceput
p10 = 1; // puterea lui 10 cu care vom adauga cifrele in nmod
while ( n > 0 ) {
cf = n % 10; // ultima cifra a lui n
n /= 10; // eliminam ultima cifra din n
if ( cf == k ) { // n avea pe ultima pozitie cifra k?
nrk++; // adunam unu la numarul de cifre k din n
kkk = kkk * 10 + k; // adaugam cifra la kkk
} else { // daca cifra este diferita de k
nmod = nmod + p10 * cf; // o adaugam la n modificat
p10 *= 10; // pregatim urmatoarea putere a lui 10
}
}
nmod += p10 * kkk; // adaugam kkk in fata numarului modificat

fout = fopen( "cifre9.out", "w" );
fprintf( fout, "%d\n%d\n", nrk, nmod ); // afisam numerele cerute
fclose( fout );

return 0;
}</syntaxhighlight>

== Manipularea orelor și minutelor pe ceas ==
Deși orele și minutele sînt doar numere, anumite exerciții pot pune probleme.

'''Problemă''': se dau doi timpi, <tt>t1</tt> și <tt>t2</tt>, specificați ca ore și minute. Astfel, vom avea la intrare <tt>o1</tt>, <tt>m1</tt> și <tt>o2</tt>, <tt>m2</tt>. Cîte ore și minute se află între acești doi timpi? Atenție! Dacă <tt>t2</tt> este înaintea lui <tt>t1</tt> se consideră că am trecut într-o nouă zi. Exemplu: dacă <tt>t1</tt> este <tt>10:35</tt> și <tt>t2</tt> este <tt>18:20</tt> atunci vom afișa <tt>07:45</tt>. Dacă <tt>t1</tt> este <tt>22:25</tt> și <tt>t2</tt> este <tt>20:05</tt> vom afișa <tt>21:40</tt>.

La prima vedere acest exercițiu pare încîlcit. Va trebui să comparăm cei doi timpi. Dacă <tt>t1</tt> este înaintea lui <tt>t2</tt> atunci va trebui să comparăm cîte ore avem între <tt>o1</tt> și <tt>o2</tt>. Dar și aceasta va depinde de relația dintre <tt>m1</tt> și <tt>m2</tt>. Dacă <tt>t1</tt> este după <tt>t2</tt> lucrurile se complică și mai mult: trebuie să aflăm cîte ore și minute avem pîna la finalul zilei, apoi să aflăm cîte ore și minute avem de la începutul zilei pînă la <tt>t2</tt>, iar în final trebuie să le adunăm. Multe cazuri particulare. Cum facem să simplificăm lucrurile?

'''''Regulă''''': pentru a nu ne încurca, întotdeauna vom face conversia orelor la cea mai mică unitate de măsură, fie ea minut sau secundă. În final vom face conversia inversă, de la minute, la ore și minute.

În cazul problemei noastre, vom converti t1 și t2 la minute. Algoritmul este următorul:

<pre>1. calculează t1 = o1 * 60 + m1
2. calculează t2 = o2 * 60 + m2
3. calculează d = t2 - t1
4. dacă d < 0 atunci
4.1 calculează d = 24 * 60 - d
5. calculează o3 și t3 pe baza lui d, astfel:
5.1 o3 = d / 60
5.2 m3 = d % 60
6. afișează o3 și m3</pre>

Concluzie: în problemele în care avem nevoie să lucrăm cu ore, minute și secunde, este foarte important să transformăm timpul într-un singur număr exprimat în cea mai mică unitate de timp implicată. În exemplul de mai sus această unitate este minutul. Uneori s-ar putea să fie secunda. După transformare vom face calculele cerute de problemă. În final vom transforma înapoi în ore, minute, posibil secunde, dacă problema necesită acest lucru.

= Temă =
[http://varena.ro/runda/2018-03-08-clasa-5-tema-30 Tema 30]: să se rezolve următoarele probleme (program C trimis la vianuarena):
* [http://varena.ro/problema/chibrituri chibrituri] dată la OJI 2013 clasa a 5a
* [http://varena.ro/problema/ore ore] dată la concursul .campion 2011
* [http://varena.ro/problema/consiliu consiliu] dată la OMI Iași 2012

Rezolvări aici [http://solpedia.francu.com/wiki/index.php/Clasa_a_V-a_lec%C8%9Bia_30_-_8_mar_2018]

Clasa a 7-a Lecția 16: Tehnica Two Pointers (doi pointeri), tipul de date struct și metoda Greedy

2026-02-03T15:11:29Z

Cristian: /* Studiu de caz: problema bile1 */

== Înregistrare video lecție ==

<youtube height="720" width="1280">https://youtu.be/W59ZLyfMZlc</youtube>

== Tehnica Two Pointers (doi pointeri) ==

În informatica de concurs avem tehnici semi-banale cărora le dăm o denumire pentru a putea să le referim ușor într-o discuție. Este și cazul acestei metode. Deși relativ evidentă, ea are un nume 🙂 Pe scurt, '''Two Pointers''' folosește doi indici într-un vector ce avansează pe rând, similar cu interclasarea, în căutarea rezultatului. Este o tehnică ce produce în general algoritmi liniari. Ea decurge în mod natural din căutarea binară, atunci când avem un algoritm relativ simplu ce folosește multiple căutări binare, ale căror rezultate sunt fie crescătoare fie descrescătoare.

Să luăm câteva exemple.

=== Pereche de sumă X ===

Dat un vector <source lang="C" enclose="none">v[]</source> de elemente sortate crescător, să se spună câte o perechi există de indici <source lang="C" enclose="none">(i, j)</source> astfel încât <source lang="C" enclose="none">v[i] + v[j] == X</source>.

Cum am putea rezolva problema? Pentru fiecare număr <source lang="C" enclose="none">v[i]</source> să căutăm un număr <source lang="C" enclose="none">v[j]</source> cu <source lang="C" enclose="none">j > i</source> astfel încât <source lang="C" enclose="none">v[i] + v[j] == X</source>. Dacă fixăm <source lang="C" enclose="none">v[i]</source> atunci <source lang="C" enclose="none">v[j]</source> poate fi determinat prin căutare binară, deoarece vectorul este ordonat crescător. Vom obține, deci, un algoritm ''O(N log N)'', unde '''N''' este numărul de elemente din vector.

'''Exemplu'''

Fie vectorul:

<source lang="C" line>
v[] = { 20, 25, 30, 35, 40, 50, 55, 65, 75 }
indici: 0 1 2 3 4 5 6 7 8
</source>

și <source lang="C" enclose="none">X = 75</source>. Pentru fiecare <source lang="C" enclose="none">v[i]</source> vom căuta binar ultimul număr mai mic sau egal cu <source lang="C" enclose="none">X - v[i]</source>. Astfel:

* Pentru <source lang="C" enclose="none">i = 0</source>, <source lang="C" enclose="none">v[i] = 20</source> căutăm valoarea <source lang="C" enclose="none">X - v[i] = 55</source> și găsim <source lang="C" enclose="none">j = 6</source>, <source lang="C" enclose="none">v[j] = 55</source> soluție.
* Pentru <source lang="C" enclose="none">i = 1</source>, <source lang="C" enclose="none">v[i] = 25</source> căutăm valoarea <source lang="C" enclose="none">50</source> și găsim <source lang="C" enclose="none">j = 5</source>, <source lang="C" enclose="none">v[j] = 50</source> soluție.
* Pentru <source lang="C" enclose="none">i = 2</source>, <source lang="C" enclose="none">v[i] = 30</source> căutăm valoarea <source lang="C" enclose="none">45</source> și găsim <source lang="C" enclose="none">j = 4</source>, <source lang="C" enclose="none">v[j] = 40</source> (ultima mai mică sau egală cu 45) nu este soluție.
* Pentru <source lang="C" enclose="none">i = 3</source>, <source lang="C" enclose="none">v[i] = 35</source> căutăm valoarea <source lang="C" enclose="none">40</source> și găsim <source lang="C" enclose="none">j = 4</source>, <source lang="C" enclose="none">v[j] = 40</source> soluție.
* Pentru <source lang="C" enclose="none">i = 4</source>, <source lang="C" enclose="none">v[i] = 40</source> ar trebui să căutăm valoarea <source lang="C" enclose="none">35</source> care este mai mică decât <source lang="C" enclose="none">v[i]</source> așa încât ne oprim.

Ce observăm? Că valorile lui <source lang="C" enclose="none">j</source> sunt descrescătoare. Este destul de clar că așa și trebuie să fie, nu?

'''Observație importantă'''

'''Tehnica Two Pointers''': atunci când o succesiune de '''căutări binare''' într-un vector au ca rezultat o '''secvență monotonă''' de numere (crescătoare sau descrescătoare), căutările binare pot fi înlocuite cu '''căutări liniare'''. Această înlocuire și noua metodă rezultată poartă denumirea de '''Two Pointers'''.

Ce complexitate are noul algoritm?

La prima vedere , pentru fiecare element <source lang="C" enclose="none">v[i]</source> vom căuta liniar perechea lui, ceea ce ar rezulta într-un algoritm ''O(N)''. În realitate, indicele <source lang="C" enclose="none">j</source> se va muta mereu către stânga, drept care el nu va putea parcurge mai mult de ''O(N)'' elemente în toate căutările liniare. Deci, folosind analiza amortizată, deși oricare din căutările liniare poate fi ''O(N)'', suma tuturor acestor căutări nu poate depăși ''O(N)''. Drept care metoda Two Pointers duce la un algoritm ''O(N)'', superior celui cu căutare binară, care era ''O(N log N)''.

=== Subsecvență de sumă X ===

Dat un vector <source lang="C" enclose="none">v[]</source> de elemente nenule, să se spună câte o perechi există de indici <source lang="C" enclose="none">(i, j)</source> astfel încât <source lang="C" enclose="none">v[i] + v[i+1] + v[i+2] + ... + v[j] == X</source>.

Și aici avem un algoritm relativ simplu: calculăm vectorul <source lang="C" enclose="none">s[]</source> de sume parțiale și pentru fiecare element pe poziția <source lang="C" enclose="none">i</source> în vector vom căuta binar în vectorul <source lang="C" enclose="none">s[]</source> valoarea <source lang="C" enclose="none">s[i-1] + X</source>. Dacă găsim această valoare la poziția <source lang="C" enclose="none">j</source> avem că <source lang="C" enclose="none">s[j] - s[i-1] == X</source> și deci suma elementelor de la <source lang="C" enclose="none">i</source> la <source lang="C" enclose="none">j</source> în vectorul <source lang="C" enclose="none">v[]</source> este <source lang="C" enclose="none">X</source>, deci avem o soluție.

Complexitatea acestui algoritm va fi, din nou, ''O(N log N)''.

Ce observăm, însă? Că rezultatele căutărilor binare (indicii <source lang="C" enclose="none">j</source>) vor fi în ordine crescătoare, deoarece sumele parțiale sunt strict crescătoare. Putem, deci, folosi '''Two Pointers''' pentru a căuta indicii <source lang="C" enclose="none">j</source> prin căutare liniară: pentru fiecare avans al lui <source lang="C" enclose="none">i</source> vom avansa indicele <source lang="C" enclose="none">j</source> până ce suma devine mai mare sau egală cu cea dorită, moment la care testăm egalitatea.

Acest algoritm are complexitate ''O(N)''. Mai mult, deoarece ne interesează doar suma subsecvenței de la <source lang="C" enclose="none">i</source> la <source lang="C" enclose="none">j</source> putem renunța la vectorul de sume parțiale și lucra direct pe vectorul original <source lang="C" enclose="none">v[]</source>, menținând incremental suma subsecvenței studiate.

=== Problema NrTri ===

Am discutat într-o lecție trecută problema [https://www.nerdarena.ro/problema/nrtri NrTri]. Ea cere să găsiți într-un vector numărul de tripleți ce pot forma laturile unui triunghi. Aici avem o soluție cu căutare binară: după ce sortăm elementele, pentru fiecare pereche de indici <source lang="C" enclose="none">(i, j)</source> vom căuta binar cel mai mare element <source lang="C" enclose="none">k > j</source> cu proprietatea că <source lang="C" enclose="none">v[k]</source>. Toate elementele între <source lang="C" enclose="none">j</source> și <source lang="C" enclose="none">k</source> (inclusiv <source lang="C" enclose="none">k</source>) formează un triplet valabil cu perechea <source lang="C" enclose="none">(i, j)</source>.

Această soluție are complexitatea ''O(N2 log N)''. Ca și în exemplele anterioare, observăm că atunci când <source lang="C" enclose="none">j</source> avansează căutarea binară va returna valori <source lang="C" enclose="none">k</source> crescătoare. Și aici putem aplica tehnica ''Two Pointers'', avansând liniar indicele <source lang="C" enclose="none">k</source>.

Rezultă un algoritm O(N2). Observați că tehnica aceasta reduce complexitatea cu acel factor log N. În practică nu este clar că vom putea întotdeauna diferenția între căutarea binară și Two Pointers. Cu toate acestea metoda merită, deoarece codul rezultat este mai simplu și constanta de implementare scade considerabil.

== Tipul de date struct ==

Până acum am învățat tipuri de date simple (<source lang="C" enclose="none">int</source>, <source lang="C" enclose="none">char</source>, <source lang="C" enclose="none">long long</source>, etc) și tipuri de date compuse (ce grupează mai multe tipuri de date simple) anume tablouri, fie ele unidimensionale (vectori), bidimensionale (matrice), sau chiar de dimensiuni mai mari.

'''Exemplu:'''

<syntaxhighlight lang="C" line>
struct nrmare { int ncf; char cf[MAXNCF]; };
...
struct nrmare n1, n2, n3;
</syntaxhighlight>

sau, mai scurt (putem declara variabile la definirea tipului <source lang="C" enclose="none">struct</source>):

<syntaxhighlight lang="C" line>
struct nrmare { int ncf; char cf[MAXNCF]; } n1, n2, n3;
</syntaxhighlight>

Elementele declarate în interiorul unui <source lang="C" enclose="none">struct</source> se numesc membri. Putem accesa membrii unei variabile tip <source lang="C" enclose="none">struct</source> cu operatorul punct.

'''Exemplu:'''

<syntaxhighlight lang="C" line>
t += n1.cf[i] + n2.cf[i];
n3.cf[i] = t % 10;
t /= 10;
</syntaxhighlight>

Tipul <source lang="C" enclose="none">struct</source> reprezintă un alt mod de a grupa date simple într-o ''structură''. Aceste date vor fi reprezentate în memorie la rând, una după alta.

'''Diferențe''' între tipul <source lang="C" enclose="none">struct</source> și tipul tablou:

* Tipul struct poate grupa date de tipuri diferite, tipul <source lang="C" enclose="none">tablou</source> nu.
* Tipul struct accesează elementele sale pe bază de denumire, tipul tablou accesează elementele numeric, pe bază de indice (poziție).
* În consecință tipul <source lang="C" enclose="none">struct</source> grupează un număr relativ mic de date.

'''Avantaje''' ale tipului <source lang="C" enclose="none">struct</source>:

* Gruparea datelor duce la o ordine a codului.
* Codul devine mai clar și mai ușor de citit, deci o depanare mai ușoară.
* Folosit corect tipul struct poate duce la un acces mai localizat al memorie (''cache friendly'') și, deci, la o scăderea a timpului de execuție.

'''Atenție:''' probleme cu tipul <source lang="C" enclose="none">struct</source>:

* Orice variabilă de tip <source lang="C" enclose="none">struct</source> va fi completată până la <source lang="C" enclose="none">int</source>. Actual, acest tip este pe patru octeți, ceea ce înseamnă că un struct va ocupa un număr de octeți divizibil cu patru. Dacă vom declara un struct cu un <source lang="C" enclose="none">int</source> și un <source lang="C" enclose="none">char</source> el va ocupa 8 octeți și nu 5!

* Un vector de structuri poate fi înlocuit întotdeauna cu mai mulți vectori, câte unul pentru fiecare membru. Decizia de a folosi struct trebuie luată în funcție de modul de accesare a membrilor în algoritmul nostru. O decizie proastă poate duce la deteriorarea timpului de execuție din motive de cache.

* Combinația între cele două de mai sus poate fi destul de rea: un struct care ocupă mai mult, chiar dacă nu duce la o depășire de memorie, va crește necesarul de memorie ceea ce duce la creșterea timpului de execuție din motive de ''cache''. Aceasta, combinat cu un acces prost la memorie, poate duce la o creștere semnificativă a timpului de execuție - poate chiar dublarea lui!

'''Concluzie''': folosiți tipul <source lang="C" enclose="none">struct</source> numai dacă știți exact ce faceți. Recomandarea mea este ca deocamdată să nu îl folosiți.

=== Studiu de caz: problema bile1 ===

Implementarea listelor se face în general bine folosind tipul <source lang="C" enclose="none">struct</source>. În mod natural o celulă a listei va conține o informație și o legătură la următoarea celulă (next). În particular am învățat acea structură de date, vectorul de liste, pe care îl foloseam pentru a evita sortarea, memorând pentru fiecare linie a unei matrice acele coloane care ne interesează, unde apar elemente interesante pe acea linie. Să luăm un caz concret.

În problema [https://www.nerdarena.ro/problema/bile1 Bile1] se cere să simulăm căderea unor bile printr-o matrice cu obstacole. Am rezolvat-o memorând obstacolele ca liste de coloane ''agățate'' pe liniile unde apar obstacole. Pentru aceasta am folosit doi vectori. Iată soluția de atunci:

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

#define MAXN 2000
#define NOBST 10000

short lin[MAXN + 1]; // capetele de lista
short col[NOBST + 1], next[NOBST + 1]; // celulele listelor
int bile[MAXN]; // bilele ce vor fi redistribuite

int main () {
FILE *fin, *fout;
int m, n, p, i, pc, l, c;

fin = fopen( "bile1.in", "r" );
fscanf( fin, "%d%d%d", &m, &n, &p );
for ( i = 1; i <= p; i++ ) { // citire obstacole
fscanf( fin, "%d%d", &l, &c );
col[i] = c; // asezam coloana c in lista liniei l
next[i] = lin[l]; // coloana noua vine la inceputul listei liniei l
lin[l] = i;
}
for ( i = 0; i < n; i++ ) // citire bile pe prima linie
fscanf( fin, "%d", &bile[i] );
fclose( fin );

// parcurgem liniile in ordine si cautam coloane cu obstacole
for ( l = 1; l <= m; l++ ) {
pc = lin[l];
while ( pc > 0 ) { // cita vreme mai avem elemente in lista
c = col[pc] - 1; // avem obstacol la coloana c
bile[c-1] += bile[c] / 2 + bile[c] % 2; // n/2 + 1 in stinga
bile[c+1] += bile[c] / 2; // n/2 in dreapta
bile[c] = 0;
pc = next[pc]; // trecem la urmatorul element din lista
}
}

fout = fopen( "bile1.out", "w" );
for ( i = 0; i < n; i++ )
fprintf( fout, "%d\n", bile[i] );
fclose( fout );

return 0;
}</syntaxhighlight>

Este clar că atunci când accesăm o celulă a listei vom avea nevoie atât de numărul de coloană cât și de next, pentru a avansa la elementul următor. Deci poate ar fi o idee bună să le grupăm, pentru ''cache''. Partea bună este că atât coloana cât și următorul element sunt mici, deci putem folosi tipul <source lang="C" enclose="none">short</source>, ceea ce înseamnă că o celulă va ocupa două elemente <source lang="C" enclose="none">short</source>, adică patru octeți, fiind aliniată la întreg.

Iată programul modificat să folosească tipul <source lang="C" enclose="none">struct</source>:

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

#define MAXN 2000
#define NOBST 10000

short lin[MAXN + 1]; // capetele de lista
struct cell { short col; short next; } obst[NOBST + 1]; // celulele listelor
int bile[MAXN]; // bilele ce vor fi redistribuite

int main () {
FILE *fin, *fout;
int m, n, p, i, pc, l, c;

fin = fopen( "bile1.in", "r" );
fscanf( fin, "%d%d%d", &m, &n, &p );
for ( i = 1; i <= p; i++ ) { // citire obstacole
fscanf( fin, "%d%d", &l, &c );
// asezam coloana c in lista liniei l
// coloana noua vine la inceputul listei liniei l
obst[i] = (struct cell){ .col = c, .next = lin[l] }; // cream noua celula
lin[l] = i;
}
for ( i = 0; i < n; i++ ) // citire bile pe prima linie
fscanf( fin, "%d", &bile[i] );
fclose( fin );

// parcurgem liniile in ordine si cautam coloane cu obstacole
for ( l = 1; l <= m; l++ ) {
pc = lin[l];
while ( pc > 0 ) { // cita vreme mai avem elemente in lista
c = obst[pc].col - 1; // avem obstacol la coloana c
bile[c-1] += bile[c] / 2 + bile[c] % 2; // n/2 + 1 in stinga
bile[c+1] += bile[c] / 2; // n/2 in dreapta
bile[c] = 0;
pc = obst[pc].next; // trecem la urmatorul element din lista
}
}

fout = fopen( "bile1.out", "w" );
for ( i = 0; i < n; i++ )
fprintf( fout, "%d\n", bile[i] );
fclose( fout );

return 0;
}
</syntaxhighlight>

Remarcați cum putem atribui o variabilă de tip <source lang="C" enclose="none">struct</source>, folosind denumirile membrilor săi:

<syntaxhighlight lang="C" line>
obst[i] = (struct cell){ .col = c, .next = lin[l] };
</syntaxhighlight>

=== Studiu de caz: numere mari ===

Numerele mari se pot reprezenta în mod natural ca un struct ce conține numărul de cifre și vectorul de cifre, precum am văzut mai sus. Avantajul constă în gruparea datelor și în claritatea codului ce menține numarul de cifre corect - nu mai avem nevoie să returnăm în funcția de înmulțire numărul de cifre al rezultatului, ci îl setăm chiar în numărul mare trimis ca parametru.

Atunci când trimitem un <source lang="C" enclose="none">struct</source> mare ca parametru (care ocupă mai mult de un întreg) este bine să-l trimitem ca pointer, deoarece evităm copierea. În acest caz accesul la <source lang="C" enclose="none">struct</source> se face un pic anevoios.

Iată un exemplu de funcție de adunare număr mic la număr mare:

<syntaxhighlight lang="c" line>
// aduna numarul mic a la numarul mare n
// n transmis prin referinta pentru a nu fi copiat + il modificam
void adunaNn( struct nrmare *n, int a ) {
int i;

i = 0;
while ( a > 0 ) {
a += (*n).cf[i];
(*n).cf[i] = a % 10;
a /= 10;
i++;
}

if ( i > (*n).ncf )
(*n).ncf = i;
}
</syntaxhighlight>

Remarcați că avem nevoie de două paranteze, un asterisc și un punct pentru a apela un membru al structurii trimise ca pointer. De aceea limbajul C ne oferă o alternativă mai simplă:

<syntaxhighlight lang="c" line>
// forme echivalente:
(*n).cf[i];

// este totuna cu
n->cf[i];
</syntaxhighlight>

Precum vedeți săgețica este echivalentul punctului atunci când variabila este de tip pointer la <source lang="C" enclose="none">struct</source>.

Iată un exemplu de implementare de numere mari:

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

#define MAXNCF 1000

struct nrmare { int ncf; char cf[MAXNCF]; } n1, n2, n3;

// aduna numarul mic a la numarul mare n
// n transmis prin referinta pentru a nu fi copiat + il modificam
void adunaNn( struct nrmare *n, int a ) {
int i;

i = 0;
while ( a > 0 ) {
a += n->cf[i];
n->cf[i] = a % 10;
a /= 10;
i++;
}

if ( i > n->ncf )
n->ncf = i;
}

// scade numarul mic a din numarul mare n
// considera ca nu se ajunge la un numar mare negativ (a <= n)
// n transmis prin referinta pentru a nu fi copiat + il modificam
void scadeNn( struct nrmare *n, int a ) {
int i;

a = -a;
i = 0;
while ( a < 0 ) {
a += n->cf[i];
n->cf[i] = a % 10;
a /= 10;
if ( n->cf[i] < 0 ) {
n->cf[i] += 10;
a--;
}
i++;
}

while ( n->ncf > 0 && n->cf[n->ncf-1] == 0 )
n->ncf--;
}

// aduna numarul mare n2 la numarul mare n1
// n1, n2 transmise prin referinta pentru a nu fi copiate + le modificam
void adunaNN( struct nrmare *n1, struct nrmare *n2 ) {
int i, max, t;

max = n1->ncf < n2->ncf ? n2->ncf : n1->ncf;
t = 0;
for ( i = 0; i < max; i++ ) {
t = t + n1->cf[i] + n2->cf[i];
n1->cf[i] = t % 10;
t /= 10;
}
if ( t > 0 ) {
n1->cf[i] = t;
max++;
}

n1->ncf = max;
}

// scade numarul mare n2 din numarul mare n1
// considera ca nu se ajunge la un numar mare negativ (n2 <= n1)
// n1, n2 transmise prin referinta pentru a nu fi copiate + le modificam
void scadeNN( struct nrmare *n1, struct nrmare *n2 ) {
int i, t;

t = i = 0;
while ( i < n2->ncf || t < 0 ) {
t = t + n1->cf[i] - n2->cf[i];
n1->cf[i] = t % 10;
t /= 10;
if ( n1->cf[i] < 0 ) {
n1->cf[i] += 10;
t--;
}
i++;
}

while ( n1->ncf > 0 && n1->cf[n1->ncf-1] == 0 )
n1->ncf--;
}

// inmulteste numarul mic a cu numarul mare n cu rezultatul in n
// n transmis prin referinta pentru a nu fi copiat + il modificam
void inmultesteNn( struct nrmare *n, int a ) {
int i;
long long t;

t = i = 0;
while ( i < n->ncf || t > 0 ) {
t = t + a * (long long)n->cf[i];
n->cf[i] = t % 10;
t /= 10;
i++;
}

if ( i > n->ncf )
n->ncf = i;
}

// tipareste un numar mare n
void printN( struct nrmare *n ) {
int i;

if ( n->ncf == 0 )
fputc( '0', stdout );
else
for ( i = n->ncf - 1; i >= 0; i-- )
fputc( '0' + n->cf[i], stdout );
fputc( '\n', stdout );
}

int main () {
// n1, n2, n3 declarate global, initial zero

printf( "0 + 75464: " );
adunaNn( &n1, 75464 );
printN( &n1 );

printf( "75464 - 75464: " );
scadeNn( &n1, 75464 );
printN( &n1 );

printf( "0 + 834205: " );
adunaNn( &n1, 834205 );
printN( &n1 );

adunaNn( &n2, 1024586 );

printf( "834205 + 1024586: " );
adunaNN( &n1, &n2 );
printN( &n1 );

printf( "834205 + 1024586 - 1024586: " );
scadeNN( &n1, &n2 );
printN( &n1 );

printf( "834205 * 2043984094: " );
inmultesteNn( &n1, 2043984094 );
printN( &n1 );

return 0;
}
</syntaxhighlight>

== Metoda Greedy ==

Uneori trebuie să rezolvăm probleme ce necesită să găsim o soluție minimă sau maximă. Una din cele mai simple și evidente încercări de rezolvare este ca, la fiecare pas, să luăm decizia optimă pe moment - decizie ''lacomă'' - cel mai bun lucru la momentul actual.

Exemplu: dat un șir de numere pozitive și negative să se calculeze suma maximă ce se poate forma cu exact ''K'' numere.

Soluție greedy: la fiecare pas vom selecta maximul dintre numerele rămase. Vom porni cu maximul. Apoi cu al doilea maxim și așa mai departe. La fiecare pas ''ne lăcomim'' la cel mai mare număr posibil.

Este, sper, destul de clar că în acest caz obținem soluția optimă. Însă nu întotdeauna este așa, precum vom vedea.

Să vedem câteva exemple de algoritmi greedy.

=== Plată cu număr minim de bancnote puteri ale lui 2 ===

Dispunem de bancnote puteri ale lui 2. Pentru fiecare putere a lui 2 vom avea un număr de bancnote disponibile, posibil niciuna. Dat '''X''', dorim să achităm suma '''X''' cu un număr minim de bancnote posibile. Cum procedăm?

Vom proceda greedy: selectăm bancnotele de valoare maximă ce încap în '''X'''. Fie epuizăm numărul de bancnote de acea putere și trecem mai departe, fie ne rămân bancnote dar suma de plată devine mai mică decât 2 la acea putere. Procedăm în continuare la fel.

Exemplu: dispunem de următoarele bancnote: 3 × 25, 1 × 23, 2 × 22, 5 × 21, 6 × 20 și ne dorim să achităm suma 53. Procedăm astfel:

<pre>
Pas 1: selectăm 1 × 25. Suma rămasă: 21 = 53 - 32
Pas 2: selectăm 1 × 23. Suma rămasă: 13 = 21 - 8
Pas 3: selectăm 2 × 22. Suma rămasă: 5 = 13 - 8
Pas 4: selectăm 2 × 21. Suma rămasă: 1 = 5 - 4
Pas 5: selectăm 1 × 20. Suma rămasă: 0 = 1 - 1
</pre>

Astfel numărul de bancnote este 7, iar numărul este plătit astfel:

<pre>
53 = 32 + 8 + 4 + 4 + 2 + 2 + 1
</pre>

=== Sortarea prin selecție ===

Ne putem gândi la sortarea prin selecție ca având un pas de bază greedy: la fiecare trecere prin vector selectăm în mod greedy maximul și apoi îl trecem la coadă.

=== Numărul minim de intervale care acoperă un interval ===

Problemă: dată o mulţime de ''N'' intervale <code>[ai, bi]</code> ce acoperă un alt interval mai mare să se găsească o submulţime minimă a acestei mulţimi care conţine intervale ce acoperă același interval original.

[[File:Intervale-pe-dreapta-1.svg.png|thumb]]

Exemplu: fie intervalele

<pre>
1: [3 8]
2: [9 18]
3: [1 5]
4: [0 8]
5: [2 10]
</pre>

Intervalul acoperit este <source lang="C" enclose="none">[0, 18]</source>. Ne dorim să păstrăm cât mai puține intervale care să acopere același interval.

''' Idee de soluție '''

O idee naturală este să sortăm intervalele după punctul de început, iar apoi să le luăm în ordine, unul câte unul. Având un interval curent selectat, am putea să selectăm intervalul care începe cât mai târziu dar al cărui interval este în interiorul intervalului curent.

Pe exemplul de mai sus observăm că nu funcționează, deoarece am selecta intervalele 4, 1 și apoi nu am mai avea ce să selectăm în continuare.

''' Soluție '''

Vom parcurge intervalele în ordinea capătului de început, ca mai devreme. Dar vom selecta următorul interval pe acela care se '''închide ultimul''' dintre cele care au capătul stânga în interiorul intervalului curent.

În cazul nostru vom selecta intervalele 4, 5 și 2.

=== Numărul maxim de intervale disjuncte ===

Problemă: dată o submulţime de ''N'' intervale <code>[ai, bi]</code> să se găsească o submulţime maximală a acestei mulţimi care conţine doar intervale disjuncte (neintersectante).

Această problemă este totuna cu numărul minim de puncte ce ''înțeapă'' toate intervalele (de ce?).

''' Idei de soluţie '''

Această problemă apare destul de des la olimpiade, deghizată într-o formă sau alta. Deşi pare o problemă grea, în realitate ea se rezolvă uşor. O primă idee ar fi să încercăm să ordonăm intervalele după punctul de început, apoi să le luăm în ordine, unul câte unul. Pentru fiecare interval ne întrebăm dacă îl intersectează pe cel anterior. Dacă da, îl aruncăm şi mergem mai departe. Dacă nu, îl adăugăm la submulţime şi îl reţinem ca interval ultim. Această soluţie nu funcţionează şi e destul de evident de ce: am putea avea un prim interval foarte lung, care acoperă toate celelalte intervale.

Cu toate acestea rezolvarea nu e total greşită. În fapt, ea aproape funcţionează! Are nevoie doar de o modificare ce se impune, analizînd contraexemplul anterior: de ce nu este bun acel prim interval foarte lung? Deoarece el se termină după celelalte. Şi atunci ne putem întreba, în mod natural, ce s-ar întâmpla dacă am alege intervalul care se închide primul, nu care începe primul? Desigur că acest algoritm funcţionează. Vă las vouă să vă luptaţi cu demonstraţia, care decurge cam aşa: să presupunem că soluţia generată de acest algoritm nu e optimă. Înseamnă că există o altă soluţie cu mai multe intervale. Acea soluţie trebuie să difere undeva faţă de cea găsită de noi. Mergeţi pe această cale şi trebuie să ajungeţi la o contradicţie cum că soluţia optimă nu poate avea mai multe segmente.

[[File:Intervale-pe-dreapta-1.svg.png|thumb]]

Exemplu: fie intervalele

<pre>
1: [3 8]
2: [9 18]
3: [1 5]
4: [0 8]
5: [2 10]
</pre>

Atunci vom selecta, în ordine, intervalele 3 și 2.

==== Soluţie ====

Care este algoritmul, în mare?

''
# Iniţial mulţimea M este vidă.
# Ordonează crescător intervalele după punctul de închidere.
# Consideră ultima închidere (care nu există încă) cu valoarea minus infinit.
# Pentru fiecare interval, în ordine:
## Dacă el conţine ultima închidere
### Ignoră-l.
## Altfel
### Selectează intervalul curent şi adaugă-l la mulţimea M.
### Setează ultima închidere pe închiderea intervalului selectat
# Afişează mulţimea M.
''

Ce se întâmplă dacă avem mai multe intervale care se termină în acelaşi punct? Atunci putem reţine intervalul cel mai mic. De ce? Deoarece este cel mai convenabil. Să presupunem că soluţia maximală conţinea un alt interval care se termina în acel punct. Atunci putem înlocui acel interval cu intervalul cel mai mic, obţinînd o altă soluţie maximală.

==== Considerente de implementare ====

Implementarea directă: memorăm intervalele ca perechi, prin capetele lor. Sortăm perechile după capătul din dreapta. Apoi facem o parcurgere a perechilor. Această implementare necesită ''O(N log N)'' timp și ''O(N)'' memorie.

Implementare relaxată: atunci când coordonatele sunt suficient de mici astfel încât să putem folosi un vector care să memoreze un întreg pentru fiecare coordonată, putem încerca o abordare mai simplă: nu memorăm intervalele. Ci, pentru fiecare interval <source lang="C" enclose="none">[ai, bi]</source>, vom seta <source lang="C" enclose="none">început[bi] = ai</source>. Cu alte cuvinte vom memora capetele stânga la poziția capetelor dreapta. Apoi parcurgem vectorul în ordine, acoperind segmentul de coordonate care acoperă toate intervalele, testând dacă elementul de la poziția curentă în vector este mai mic decât ultima închidere memorată. Dacă nu, atunci selectăm intervalul și mutăm ultima închidere la poziția curentă în vector. Trebuie să avem grijă la următoarele:

* Să iniţializăm vectorul de coordonate cu o valoare distinctă de capete de interval. Matematic am putea să le iniţializăm cu minus infinit, astfel încât să nu fie selectate niciodată.
* Atunci când ''aşezăm'' intervalele pe vector să avem grijă ca dacă găsim deja o valoare în vector să o înlocuim numai dacă cea curentă este mai mare (intervalul este mai mic).

Această soluţie necesită ''O(N + CMAX)'' timp şi memorie, '''CMAX''' fiind coordonata maximă. De aici rezultă când o putem folosi: atunci când '''CMAX''' este suficient de mic.

==== Generalizare ====

Putem generaliza această problemă: să se calculeze mulţimea maximală de dreptunghiuri neintersectante. Sau de paralelipipede. Sau de paralelipipede n-dimensionale. Cum se rezolvă aceste probleme? Din nefericire aceste probleme fac parte dintr-o clasă de probleme numite ''NP-hard'', pentru care nu se cunoaşte o soluţie bună.

=== Exemplu când greedy nu funcționează: prolema rucsacului ===

Problema rucsacului cere să ''umplem'' cât mai bine un rucsac care poate duce o greutate maximă, dispunând de obiecte de diverse greutăți.

Exemplu: Vreau să umplu cât mai bine un rucsac de 100 și am greutăți 50, 30, 25 și 25.

Prin metoda greedy vom alege greutățile cele mai mari, în ordine: 50 și 30, după care nu mai putem adăuga nimic. Astfel vom obține greutatea totală 80. Dacă am alege însă greutățile 50, 25 și 25 am putea umple complet rucsacul.

De remarcat totuși că chiar și atunci când metoda greedy nu calculează optimul, un algoritm greedy bine gândit va da o soluție bună, aproape de optim.

== Tema 16 ==

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

* [https://www.nerdarena.ro/problema/politic Politic] dată la ONI 2007 clasa a 7-a
* [https://www.nerdarena.ro/problema/sumax SumaX] dată la Shumen Juniori 2015
* [https://www.nerdarena.ro/problema/acoperire Acoperire]
* [https://www.nerdarena.ro/problema/char Char] dată la ONI 2010 clasa a 7-a

Pentru doritorii să încerce și soluția problemei numărul minim de numărul minim de puncte ce ''înțeapă'' toate intervalele puteți rezolva problema [https://www.nerdarena.ro/problema/baloane Baloane].

== Tema opțională ==

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

* [https://www.nerdarena.ro/problema/startrek Star Trek] dată la OJI 2016 clasa a 7-a

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_16:_Tehnica_Two_Pointers_(doi_pointeri),_tipul_de_date_struct_%C8%99i_metoda_Greedy Accesează rezolvarea temei 16]

Clasa a VII-a lecția 19 - 30 ian 2020

2026-02-03T15:05:44Z

Cristian:

= Fulgerică - rezolvare =
Problema cere să se spună dacă dintr-un milion de numere avem maxim 1000 de valori distincte.

== Comentarii ==
* Mulți ați dat soluția forță brută.
* Majoritatea care ați dat o soluție, forță brută sau nu, nu ați analizat, sau ați analizat parțial complexitatea în timp. Nu ați făcut înlocuiri, sau le-ați făcut dar nu ați făcut calculele. Nu ați tras o concluzie, intră în timp sau nu?
* După aproape doi ani de analiză la fiecare algoritm și problemă prezentată, este inacceptabil să nu fiți în stare să analizați un algoritm simplu.
* Mulți dintre voi nu ați făcut analiza memoriei algoritmului vostru. Intră în memorie sau nu?
* Unii dintre voi nu știu că un long long are 8 bytes, nu 4 bytes. Și vreți să fiți la IQ Academy? Vă admir voința, în acest caz :-)
* Mulți dintre voi mi-ați scris că 8'''·'''1000=8KB. Ar trebui să știți că nu este așa. 8KB=8192B. Dacă scriați "aproximativ" era OK.
* Concluzia dureroasă este că unii din voi nu sînt capabili să facă calcule de memorie.
* Din cei care ați găsit un algoritm bun, cu căutări binare și deplasări, doar '''Ghica''' s-a prins că deplasările nu sînt ''K2'' operații, ci ''K2''/2 ceea ce înjumătățește numărul de operații.

== Clasament ==
{| class="wikitable"
!Nr.
!Nume
!F1
!F2
!Total
|-
| 1
| '''Ghica'''
|85
|95
|180
|-
| 1
| '''Petrescu'''
|100
|80
|180
|-
| 3
| '''Ipate'''
|100
|50
|150
|-
| 4
| '''Tatomir'''
|90
|45
|135
|-
| 5
| '''Voicu M'''
|100
|15
|115
|-
| 6
| '''Dobre'''
|95
|15
|110
|-
| 6
| '''Iordache'''
| 100
| 10
| 110
|-
| 6
| '''Rebengiuc'''
|10
|100
|110
|-
| 9
| '''Mușat'''
|0
|95
|95
|-
| 10
| '''Nicu'''
|0
|90
|90
|-
| 11
| '''Voicu T'''
|0
|80
|80
|-
| 12
| '''Nicola'''
|0
|50
|50
|-
| 13
| '''Fares'''
|0
|45
|45
|-
| 14
| '''Ruginiș'''
|15
|20
|35
|-
| 15
| '''Badea'''
|10
|15
|25
|-
| 16
| '''Stancu'''
|0
|20
|20
|-
| 17
| '''Petcu'''
|5
|14
|19
|-
| 18
| '''Grecu'''
|0
|18
|18
|-
| 19
| '''Ilie'''
|0
|15
|15
|-
| 19
| '''Marcu'''
|5
|10
|15
|-
| 19
| '''Mocanu'''
|0
|15
|15
|-
| 19
| '''Ștefănescu'''
|0
|15
|15
|-
| 23
| '''Aizic'''
|0
|10
|10
|-
| 23
| '''Asgari'''
|0
|10
|10
|-
| 23
| '''Cadîr'''
|0
|10
|10
|-
| 23
| '''Calotă'''
|0
|10
|10
|-
| 23
| '''Dimulescu'''
|0
|10
|10
|-
| 23
| '''Teodorescu'''
|0
|10
|10
|-
| 29
| '''Benescu'''
|0
|5
|5
|-
| 29
| '''Chivu'''
|0
|5
|5
|-
| 31
| '''Burac'''
|0
|0
|0
|-
| 31
| '''Cojocariu'''
|0
|absent
|0
|-
| 31
| '''Hossu'''
|0
|motivat
|0
|-
| 31
| '''Popescu'''
|0
|0
|0
|-
| 31
| '''Togan'''
|0
|0
|0
|}

= Tema - rezolvări =
== Disjoint ==
Problema [http://varena.ro/problema/disjoint disjoint] este educativă. Rostul ei este să vă puteţi testa implementarea algoritmului ''union-find''.

== Channels ==
Problema [http://varena.ro/problema/channels channels] a fost dată la concursul de la Shumen 2012, juniori.

=== Comentarii generale ===
* V-ați descurcat bine, bravo! Pare că ați înțeles algoritmul union-find.
* Foarte mulți dintre voi ați numărat la final cîțe mulțimi disjuncte rămîn. Acest număr se putea calcula pe parcurs.

=== Soluţia union-find ===
Vom parcurge muchiile în orice ordine, folosindu-le doar dacă au lăţimea cel puţin ''k'' şi dacă nu creează cicluri. De fiecare dată cînd folosim o muchie numărul de componente disjuncte scade cu unu. În final, numărul rămas minus unu este chiar răspunsul căutat. Folosind union-find complexitatea este aproximativ ''O(m)''. Este cea mai simplă soluţie.

Iată o soluţie bazată pe union-find (35 linii de cod efectiv):

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

#define WSHIFT (1024*1024)
#define NSHIFT 1024

int sef[1001]; // vectorul de sefi ai nodurilor
int canal[100000]; // vector de stocare a muchiilor: 8 biti latimea, iar
// nodurile cite 10 biti fiecare, 28 de biti total

// algoritmul clasic de find (folosim zero ca marker pentru sef suprem)
int find( int nod ) {
if ( sef[nod] == 0 )
return nod;
return sef[nod] = find( sef[nod] );
}

int main() {
FILE *fin, *fout;
int n, m, i, j, w, k, c, conexe;

fin = fopen( "channels.in", "r" );
fscanf( fin, "%d%d", &n, &m );
for ( c = 0; c < m; c++ ) {
fscanf( fin, "%d%d%d", &i, &j, &w ); // citim o muchie
canal[c] = w * WSHIFT + i * NSHIFT + j; // o stocam in vector, codata
}
fscanf( fin, "%d", &k );
fclose( fin );

conexe = n; // numarul curent de componente conexe (disjuncte)
for ( c = 0; c < m; c++ ) // parcurgem muchiile
if ( (canal[c] / WSHIFT) >= k ) { // daca latimea >= k, muchie folosibila
i = find( (canal[c] / NSHIFT) % NSHIFT ); // reprezentantul primului nod
j = find( canal[c] % NSHIFT ); // reprezentantul nodului 2
if ( i != j ) { // daca nu fac parte din aceeasi componenta conexa
sef[j] = i; // le unim
conexe--; // numarul de componente conexe se micsoreaza
}
}

fout = fopen( "channels.out", "w" );
fprintf( fout, "%d\n", conexe - 1 ); // atitea muchii mai avem de largit
fclose( fout );

return 0;
}</syntaxhighlight>

Ce complexități avem?

Citirea canalelor este ''O(m)''. Apoi, pentru fiecare canal vom efectua două operații ''find()'', care au complexitate practică ''O(1)''. Rezultă că timpul de execuție este ''O(m)''. În realitate inițializarea vectorului de șefi durează și ea, deci mai corect ar fi ''O(m + n)''.

Dar memoria?

În mod normal am avea nevoie doar de vectorul de șefi, adica circa 4KB. Din nefericire, deoarece ''k'' se dă la final, sîntem nevoiți să memorăm canalele. Stocarea din programul de mai jos încearcă să economisească spațiu, folosind un întreg per canal. Astfel, avem ''O(m + n)'' memorie, sau, mai precis, circa 400KB.

Pentru cei avansați și curioși, voi discuta mai jos două soluții care ies din cadrul lecțiilor noastre.

=== Soluţia forţă brută ===
Această problemă poate fi rezolvată cu forță brută! Deoarece avem suficientă memorie la dispoziție putem să memorăm graful, în ce formă dorim. Vom ignora muchiile care au lățime mai mică decît ''k''. Pe acest graf trebuie să aflăm numărul de componente conexe. Este clar că numărul de muchii ce trebuie lărgite este numărul de componente conexe minus unu. Cum aflăm componentele conexe? Printr-o parcurgere DFS (parcurgere în adîncime, ca la flood-fill).

Complexitatea acestei soluţii este ''O(m + n)'' dacă reprezentăm graful cu liste de adiacenţă, sau ''O(n2)'' cînd reprezentăm graful matricial. Ambele se vor încadra în timp.

=== Soluţia comisiei ===
Se construieşte un arbore parţial de cost '''maxim''' (nu minim). Pentru aceasta folosim unul din algoritmii clasici, de exemplul algoritmul lui Kruskal. Vom sorta muchiile şi le vom parcurge după lăţime, în ordine descrescătoare. Vom alege o muchie doar atunci cînd nu creează un ciclu. Ne oprim atunci cînd arborele este complet (are ''n-1'' noduri). De asemenea contorizăm cîte muchii am ales care au lăţimea mai mică strict decît ''k''. Acela este numărul muchiilor care trebuie lărgite.

Acest algoritm are complexitatea ''O(m log m)'' pentru sortare şi apoi aproximativ ''O(m)'' pentru parcurgerea muchiilor, folosind algoritmul union-find. Deoarece lăţimile sînt mici (maxim 200) putem face o sortare mai eficientă, gen bucket sort, ceea ce reduce complexitatea sortării la ''O(m + k)''.

Soluția comisiei este cea mai complicată, ceea ce ne arată că și la case mari se mai întîmplă.

== Bile3 ==
Problema [http://varena.ro/problema/bile3 bile3] a fost preluată de pe site-ul infoarena. Este o problemă de Union-Find în sens invers.

=== Comentarii generale ===
* A fost o problemă ceva mai grea.
* Unii din voi nu au folosit vectori de direcție și au duplicat mult cod.

= Tema opțională - rezolvări =
== Flota ==
Problema [http://varena.ro/problema/flota flota] a fost dată la cercul de informatică, clasa a 10a. Ea este o aplicație poate nu chiar evidentă de union-find.

== Ruine ==
Problema [http://varena.ro/problema/ruine ruine] a fost dată la cercul de informatică, clasa a 10a. Este o problemă clasică de Union-Find invers.

Rezolvări aici [http://solpedia.francu.com/wiki/index.php/Clasa_a_VII-a_lec%C8%9Bia_18_-_23_ian_2020]

= Lecţie - Tehnici de programare: divide et impera =
<html5media height="720" width="1280">https://www.algopedia.ro/video/2019-2020/2020-01-30-clasa-7-lectie-info-19-720p.mp4</html5media>
Denumită și divide and conquer sau dezbină și stăpînește, este o tehnică cunoscută de mii de ani conducătorilor. Este o tehnică de cucerire sau menținere a puterii asupra unui grup care ar avea putere mai mare dacă s-ar uni. Ținînd acel grup dezbinat, fiecare facțiune în parte are putere mică și poate fi cucerită, sau condusă. Tehnica a fost aplicată de Cezar, Napoleon, iar, mai recent, de către Britanici în Africa și de către Stalin în Rusia. Dintre tehnicile folosite în lumea reală putem menționa:

* Ajutorarea și promovarea celor care cooperează cu puterea, pedepsirea celor ce nu cooperează.
* Încurajarea cheltuielilor prostești, pentru a reduce capitalul disponibil organizării sau luptei.
* Încurajarea divizării oamenilor pentru a preveni formarea alianțelor.
* Încurajarea turnătorilor, cei care trîmbițează orice alianță posibil periculoasă.
* Sădirea de neîncredere între oameni.

O parte din aceste tehnici se regăsesc și în țara noastră, precum și în majoritatea țărilor lumii, inclusiv cele dezvoltate. De exemplu, toate țările lumii folosesc un număr uriaș de taxe și impozite, fiecare din ele relativ mici. Cînd le însumăm constatăm că în jur de 90% din banii noștri se duc pe aceste taxe și impozite. Dacă ar exista o taxă unică de 90%, oamenii s-ar revolta. Astfel, tehnica de împărțire a unor taxe mari în mai multe taxe mici îi face pe oameni să nu le observe și să nu se revolte.

Pentru exemple clasice de folosire a acestei tehnici în lumea reală vizitați pagina de [http://en.wikipedia.org/wiki/Divide_and_rule divide et impera] a wikipediei.

== Tehnica divide et impera (divide and conquer) în informatică ==
În informatică divide et impera constă în împărțirea problemei în subprobleme mai mici, nesuprapuse (o tehnică în care subproblemele sînt suprapuse este programarea dinamică). Fiecare din aceste subprobleme se rezolvă separat, mai ușor, deoarece sînt mai mici. Rezultatul final se obține din combinația rezultatelor subproblemelor.

== Tehnica divide et impera simplă (decrease and conquer) ==
În următoarele exemple de divide et impera problema se reduce la o singură problemă, mai mică. Este un caz degenerat, în care implementarea poate fi iterativă (nu necesită recursivitate).

=== Algoritmul lui Euclid ===
Și acest binecunoscut algoritm poate fi văzut ca un exemplu de divide et impera. El reduce problema de la cmmdc(a, b) la o problemă mai mică, cmmdc(b, a mod b). Complexitate: O(log min(a, b)).

=== Căutare binară ===
Precum știm, căutarea binară împarte vectorul original în două, apoi decide care din cele două jumătați ar putea să conțină elementul căutat. Apoi rezolvă problema mai mică. Complexitate: O(log n).

=== Căutare punct fix ===
Se dă un vector sortat de <tt>n</tt> elemente întregi distincte. Să se găsească dacă există indicele <tt>i</tt> astfel încît <tt><nowiki>v[i] == i</nowiki></tt>. Găsiți un algoritm divide et impera care are complexitate ''O(log n)''.

=== Puzzle balanţă ===
Avem 25 de bile care arată identic, una este ceva mai ușoară. Avem la dispoziție o balanță. Găsiți bila mai ușoară din trei cîntăriri.

=== Selecția ===
Complexitate: pe medie ''O(n)'', în cel mai rău caz ''O(n2)''. Este necesară la problema antitir.

=== Probleme vianuarena ===
Următoarele probleme de la vianuarena sînt de divide et impera degenerat:

* [http://varena.ro/problema/z zparcurgere]
* [http://varena.ro/problema/tabela tabela]
* [http://varena.ro/problema/antitir antitir]

== Tehnica divide et impera propriu zisă ==
În următoarele exemple de divide et impera problema se reduce la două sau mai multe probleme mai mici. Implementarea este mult mai simplă dacă folosim recursivitate.

=== Puzzle pavare ===
Se dă o grilă de 2n x 2n pătrate din care lipsește un pătrat. Să se acopere cu piese formate din 3 pătrate aranjate în formă de litera L.

[[File:pav2.jpg|frame|none|Exemplu de pavare cu L-uri]]

Problema pare destul de grea, nu? În realitate, odată ce încercăm să folosim divide et impera ea devine destul de ușoară. Cum putem împărți problema în probleme mai mici?

Să definim o problemă astfel:

''P(n, gol)'' = pavează un pătrat de latură 2n care are un pătrățel lipsă (un gol).

O primă idee ar fi să încercăm să împărțim pătratul în patru pătrate de latură 2n-1 și să rezolvăm acele probleme. Avem, însă, o dificultate: doar unul din pătrate va avea un pătrățel lipsă. Celelalte trei vor fi pline. Ce ne facem?

Am putea încerca să eliminăm artificial cîte un pătrățel din celelalte trei pătrate. Cum putem face acest lucru? Cu condiția ca cele trei pătrățele să fie în formă de L și să le acoperim cu o piesă elementară. Ei bine avem cum să alegem pătratele în acest fel: le vom selecta pe cele de la centru! Astfel vom obține subproblemele:

''P(n, l, c)'' se descompune în:
''P(n-1, gol)'' (golul original)
''P(n-1, gol1)''
''P(n-1, gol2)''
''P(n-1, gol3)''

=== Mergesort ===
Algoritmul mergesort, sau sortare prin interclasare, funcționează astfel:
* Divide vectorul de sortat în două părți egale (sau aproape egale)
* Reapelează mergesort pe acele părți
* La revenire avem două jumătăți sortate, deci putem sorta vectorul interclasînd cei doi vectori în timp liniar

Iată un algoritm:

<pre>
mergesort( V[], i, j )
mij = (i + j) / 2;
daca i < mij
mergesort( V[], i, mij )
daca mij + 1 < j
mergesort( V[], mij + 1, j )
merge( V[], i, mij, j )
</pre>

<tt>merge( V[], i, mij, j )</tt> interclasează vectorii sortați <tt>V[i..mij]</tt> și <tt>V[mij+1..j]</tt>.

Ce complexitate are mergesort?

Să calculăm numărul de operații, ''T(N)'', pentru a sorta un vector de ''N'' elemente:

''T(N) = 2 '''·''' T(N/2) + N''
''T(N) = 2 '''·''' (2 '''·''' T(N/4) + N/2) + N''
''T(N) = 4 '''·''' T(N/4) + 2 '''·''' N''
''T(N) = 4 '''·''' (2 '''·''' T(N/8) + N/4'') + 2 '''·''' N''
''T(N) = 8 '''·''' T(N/8) + 3 '''·''' N''
...
''T(N) = N '''·''' T(N/N) + log N '''·''' N''
''T(N) = N '''·''' T(1) + log N '''·''' N''

Deoarece ''T(1)'' este ''O(1)'' rezultă o complexitate ''O(N + N log N) = O(N log N)''.

Cîtă memorie suplimentară folosește algoritmul?

Pentru interclasarea clasică avem nevoie de un alt vector, deci ''O(N)''.

În concluzie avem complexitățile:

* timp: ''O(n log n)''
* memorie suplimentară: ''O(n)'' (aceasta e problema principală a algoritmului).

Există variante ale algoritmului care folosesc mai puțină memorie (o idee evidentă este să folosim doar jumate din memorie deoarece în timpul interclasării putem suprascrie una din jumătăți).

==== Aplicație mergesort - inversiunile unei permutări ====
O problemă care apare uneori la concursuri este următoarea: se dă o permutare a numerelor de la 1 la ''N''. Să se numere cîte inversiuni are ea. O inversiune este o pereche de indici ''(i, j)'' astfel încît ''i < j'' și ''P[i] > P[j]''.

În linii mari, algoritmul este următorul:

* Sortăm prima jumate a vectorului folosind un mergesort special, care ne returnează numărul de inversiuni din vectorul de sortat.
* Sortăm a doua jumate a vectorului.
* În acest moment știm inversiunile din cele două jumătăți - le adunăm.
* Interclasăm cele două jumătăți. În timpul interclasării cînd selectăm un număr din prima jumătate știm că numerele deja selectate din jumătatea a doua sînt mai mici, deci putem aduna numărul lor la numărul total de inversiuni.

=== Quicksort ===
Algoritmul quicksort, sau sortare rapidă, inventat în 1959 de informaticianul britanic Tony Hoare, funcționează astfel:
* Alege o poziție la întîmplare din vectorul de sortat. Vom denumi valoarea de la acea poziție ''pivot''.
* Rearanjează vectorul astfel încît în prima parte să avem elemente mai mici sau egale cu pivotul iar în a doua parte elemente mai mari sau egale cu pivotul. Vom denumi acest pas ''pivotare''.
* Reapelează quicksort pe acele două părți

Din acest algoritm avem de lămurit pasul de pivotare. El este același ca la quickselect, prezentat într-o lecție anterioară. El procedează astfel:
* Pornește cu doi indici, unul la începutul vectorului și unul la final de vector, să le spunem ''b'' si ''e''.
* Avansează indicele ''b'' pînă la primul element mai mare sau egal cu pivotul
* Devansează (merge înapoi) indicele ''e'' pînă la primul element mai mic sau egal cu pivotul
* Interschimbă elementele din vector de la pozițiile ''b'' și ''e''
* Repetă pînă ce indicii se ating, ''b >= e''

Iată o implementare posibilă. Ea este implementarea originală a lui Hoare, transformată pentru a fi structurată:

<syntaxhighlight lang="C">void myqsort( int begin, int end ) {
int aux, b = begin, e = end,
pivot = v[(begin + end) / 2]; // poate fi orice pozitie intre begin si end - 1

while (v[b] < pivot) // cauta primul element mai mare sau egal cu pivotul
b++;

while (v[e] > pivot) // cauta primul element mai mic sau egal cu pivotul
e--;

while( b < e ) { // daca indicii nu s-au atins
aux = v[b]; // interschimba elementele la pozitiile b si e
v[b] = v[e];
v[e] = aux;

do // cauta primul element mai mare sau egal cu pivotul
b++;
while (v[b] < pivot);

do // cauta primul element mai mic sau egal cu pivotul
e--;
while (v[e] > pivot);
}

// acum [begin..e] sint mai mici sau egale cu pivotul
if ( begin < e )
myqsort(begin, e);
// si [e+1..end] sint mai mari sau egale cu pivotul
if ( e + 1 < end )
myqsort(e + 1, end);
}</syntaxhighlight>

Ce complexitate are quicksort?

Deoarece pivotarea este liniară, calculele sînt similare cu cele de la mergesort. Avem două diferențe:
* Procesarea liniară se face la început, înainte de recursie.
* Împărțirea vectorului nu este neapărat în două părți egale, ceea ce duce la o complexitate ''O(N2)'' pe cazul cel mai rău.

Pentru cazul mediu, cînd împărțirea este în două părți aproximativ egale, rezultă aceeași complexitate ''O(N log N)''.

Cîtă memorie suplimentară folosește algoritmul?

Memoria este cea necesară stivei. E va fi, deci, proporțională cu cel mai lung lanț de apeluri recursive imbricate. Pe cazul cel mai rău el este ''O(N)'', iar pe cazul mediu este ''O(log N)''

'''Optimizare''': putem reduce cazul cel mai rău astfel:
* Observăm că al doilea apel recursiv este recursiv la coadă.
* Precum știm, el nu va consuma memorie.
* Putem reduce memoria stivei apelînd mai întîi pentru partea mai mică ce rezultă după pivotare.
* În acest fel chiar și în cazul cel mai rău memoria suplimentară necesară va fi ''O(log N)''.

În concluzie avem complexitățile:

* timp: ''O(N log N)''
* memorie suplimentară: ''O(log N)''

'''Atenție''': deși putem selecta ca pivot orice element din vector, nu putem selecta ca pivot ultimul element. Aceasta ar duce la o buclă infinită.

==== Pivotarea Lomuto ====
În școli, de multe ori se predă un alt algoritm de pivotare, probabil deoarece este considerat mai simplu. Nu o vom discuta aici, deoarece este foarte ineficientă. Iată diferențele față de pivotarea Hoare:
* Lomuto este ceva mai simplu de reținut și ceva mai scurtă.
* Ambii algoritmi sînt ''cache friendly'' deoarece parcurg liniar vectorul.
* Lomuto face de trei ori mai multe interschimburi.
* Lomuto face ''O(N2)'' operații pe un vector sortat, Hoare doar ''O(N log N)''
* Lomuto face ''O(N2)'' operații pe un vector cu elemente egale, Hoare doar ''O(N log N)''

'''Concluzie''': Pivotarea Lomuto este un algoritm didactic, bun pentru înțelegerea pivotării, dar este contraindicat într-o implementare practică.

==== Randomizarea pivotului ====
Dacă alegem ca pivot prima poziție din vector, sau cea din mijloc, "adversarul" poate, studiind algoritmul, să găsească un vector special pe care implementarea noastră să intre pe cazul cel mai rău, ''O(N2)''. Putem lupta cu aceasta, alegînd pivotul pe o poziție aleatoare din intervalul [begin..end-1].

==== Probleme quicksort ====
'''Atenție'''! Algoritmul este celebru pentru bug-urile pe care le putem introduce la implementare. Un semn mai mic transformat în mai mic sau egal poate duce la bucle infinite sau la un vector nesortat.

'''Soluție''': pentru olimpiadă este bine să memorați algoritmul pe din-afară.

Ați putea spune "hei, dar la olimpiadă pot folosi ''algorithms''!" Este opțiunea voastră, dar eu nu aș risca. Motivele împotriva folosirii funcției de sortare de bibliotecă:

* Ea primește ca parametru o funcție de comparație. Apelul acelei funcții este lent, fiind vorba de accesul unui pointer pentru a obține adresa funcției, apoi de punerea pe stivă a parametrilor. Toate acestea se reduc la o comparație sau două în codul nostru.
* Funcția de bibliotecă este o cutie neagră. Ea depinde de compilator și de biblioteca de funcții a acestuia. Ea este scrisă de alți oameni. Aveți mai multă încredere în cod scris de alții, care variază în funcție de calculatorul pe care se face evaluarea?
* În mod uzual funcțiile de bibliotecă consumă mai multă memorie, iar uneori mult mai multă. De ce? Bună întrebare. Nu știu.
* Algoritmul de mai sus are 23 de linii de cod efectiv. El este simplu și eficient și poate fi adaptat să sorteze orice tip de date, cu mici modificări. De ce am risca să apelăm o funcție de bibliotecă despre care nu știm nimic, cînd în 3 minute am scris acest cod?

=== Ziua regelui ===
Un rege organizează o petrecere mare de ziua lui. Petrecerea începe peste 24 de ore. Regele află că una din cele 1000 de sticle de vin pe care le va servi este otrăvită. Otrava acționează ciudat: omul care bea chiar și cea mai mică cantitate din această otravă nu are nici un simptom vreme de 24 de ore, apoi moare subit. Regele are sclavi la dispoziție pe care îi poate folosi. Lui nu îi pasă cîți sclavi mor, dar îi pasă cîți sclavi beau vin, deoarece un sclav care a băut vin nu poate fi folosit la treabă, ci trebuie izolat spre observare. Care este numărul minim de sclavi cu care regele poate afla sticla otrăvită?

=== Probleme temă ===
Problemele de la temă sînt probleme de divide et impera propriu zise:

* [http://varena.ro/problema/latin latin] dată la cercul de informatică Vianu, gimnaziu 2013
* [http://varena.ro/problema/pav pav] dată la Lot IS 2008
* [http://varena.ro/problema/forma forma] dată la olimpiada pe sector 2012, clasa a 8a
* [http://varena.ro/problema/hanoi1 hanoi1]

= Fulgerică (test fulger) =
''Găsiți un algoritm la următoarea problemă și explicați-l pe o foaie de hîrtie. Dacă nu vă descurcați să îl explicați puteți scrie cod. Sau formule matematice. Sau puteți scrie din toate trei. Important este ca algoritmul să se înțeleagă și să fie corect. Atenție! Spre deosebire de varena, vi se cere un algoritm corect, echivalentul unei rezolvări care să treacă toate testele. Nu gîndiți la modul "cum fac să iau cît mai multe puncte". Nu se acceptă "mînăreli". Voi corecta lucrările personal. Nu vă concentrați pe citire, sau scriere.''

== Problema Gigel ==
Fie următorul număr în baza 16:

'''X''' = 123456789ABCDEF

Gigel vă ia din acest număr un subnumăr de '''K''' cifre contigue (una după alta). Gigel fiind lacom, el va lua cel mai mare număr posibil de '''K''' cifre. De exemplu, pentru '''K'''=6 el va lua numărul ABCDEF.

Voi vreți ca Gigel să ia un număr cît mai mic. Pentru aceasta puteți reordona cifrele numărului '''X'''. Cum îl veți reordona pentru aceasta?

La intrare veți citi numărul '''K''' (1 ≤ '''K''' ≤ 14).

Se cere să afișați două numere:
* Numărul minim de '''K''' cifre pe care îl poate lua Gigel.
* O rearanjare a lui '''X''' care duce la acel număr minim.

=== Exemplu ===
Pentru '''K'''=2 putem rearanja '''X''' astfel:

'''X''' = 68D57E19A23BC4F

Ceea ce duce la faptul că Gigel va lua numărul de două cifre

E1

el fiind și cel mai mic număr de două cifre pe care îl poate lua din toate posibilitățile de a rearanja '''X'''.

Deci, dacă ați determinat cele două valori, veți afișa:

E1
68D57E19A23BC4F

=== Restricţii ===
* timp de execuție: 0.1s.
* memorie disponibilă: 64MB.

= Temă =
* [http://varena.ro/runda/2020-01-30-clasa-7-tema-18 Tema 19 clasa a 7a]
** [http://varena.ro/problema/latin latin] dată la cercul de informatică Vianu, gimnaziu 2013
** [http://varena.ro/problema/pav pav] dată la Lot IS 2008
** [http://varena.ro/problema/forma forma] dată la olimpiada pe sector 2012, clasa a 8a
* '''Opţional''': [http://varena.ro/runda/2020-01-30-clasa-7-tema-19-optionala Tema 19 clasa a 7a opţională]
** [http://varena.ro/problema/hanoi1 hanoi1] dată la concursul .campion 2003
* '''Opţional''': încercaţi să găsiţi rezolvări la problemele enunţate în lecţia aceasta, inclusiv la puzzle-uri:
** [http://varena.ro/problema/z zparcurgere]
** [http://varena.ro/problema/tabela tabela]
** [http://varena.ro/problema/antitir antitir]

Rezolvări aici [http://solpedia.francu.com/wiki/index.php/Clasa_a_VII-a_lec%C8%9Bia_19_-_30_ian_2020]

Clasa a 7-a Lecția 16: Tehnica Two Pointers (doi pointeri), tipul de date struct și metoda Greedy

2026-02-03T14:55:19Z

Cristian: /* Studiu de caz: problema bile1 */

== Înregistrare video lecție ==

<youtube height="720" width="1280">https://youtu.be/W59ZLyfMZlc</youtube>

== Tehnica Two Pointers (doi pointeri) ==

În informatica de concurs avem tehnici semi-banale cărora le dăm o denumire pentru a putea să le referim ușor într-o discuție. Este și cazul acestei metode. Deși relativ evidentă, ea are un nume 🙂 Pe scurt, '''Two Pointers''' folosește doi indici într-un vector ce avansează pe rând, similar cu interclasarea, în căutarea rezultatului. Este o tehnică ce produce în general algoritmi liniari. Ea decurge în mod natural din căutarea binară, atunci când avem un algoritm relativ simplu ce folosește multiple căutări binare, ale căror rezultate sunt fie crescătoare fie descrescătoare.

Să luăm câteva exemple.

=== Pereche de sumă X ===

Dat un vector <source lang="C" enclose="none">v[]</source> de elemente sortate crescător, să se spună câte o perechi există de indici <source lang="C" enclose="none">(i, j)</source> astfel încât <source lang="C" enclose="none">v[i] + v[j] == X</source>.

Cum am putea rezolva problema? Pentru fiecare număr <source lang="C" enclose="none">v[i]</source> să căutăm un număr <source lang="C" enclose="none">v[j]</source> cu <source lang="C" enclose="none">j > i</source> astfel încât <source lang="C" enclose="none">v[i] + v[j] == X</source>. Dacă fixăm <source lang="C" enclose="none">v[i]</source> atunci <source lang="C" enclose="none">v[j]</source> poate fi determinat prin căutare binară, deoarece vectorul este ordonat crescător. Vom obține, deci, un algoritm ''O(N log N)'', unde '''N''' este numărul de elemente din vector.

'''Exemplu'''

Fie vectorul:

<source lang="C" line>
v[] = { 20, 25, 30, 35, 40, 50, 55, 65, 75 }
indici: 0 1 2 3 4 5 6 7 8
</source>

și <source lang="C" enclose="none">X = 75</source>. Pentru fiecare <source lang="C" enclose="none">v[i]</source> vom căuta binar ultimul număr mai mic sau egal cu <source lang="C" enclose="none">X - v[i]</source>. Astfel:

* Pentru <source lang="C" enclose="none">i = 0</source>, <source lang="C" enclose="none">v[i] = 20</source> căutăm valoarea <source lang="C" enclose="none">X - v[i] = 55</source> și găsim <source lang="C" enclose="none">j = 6</source>, <source lang="C" enclose="none">v[j] = 55</source> soluție.
* Pentru <source lang="C" enclose="none">i = 1</source>, <source lang="C" enclose="none">v[i] = 25</source> căutăm valoarea <source lang="C" enclose="none">50</source> și găsim <source lang="C" enclose="none">j = 5</source>, <source lang="C" enclose="none">v[j] = 50</source> soluție.
* Pentru <source lang="C" enclose="none">i = 2</source>, <source lang="C" enclose="none">v[i] = 30</source> căutăm valoarea <source lang="C" enclose="none">45</source> și găsim <source lang="C" enclose="none">j = 4</source>, <source lang="C" enclose="none">v[j] = 40</source> (ultima mai mică sau egală cu 45) nu este soluție.
* Pentru <source lang="C" enclose="none">i = 3</source>, <source lang="C" enclose="none">v[i] = 35</source> căutăm valoarea <source lang="C" enclose="none">40</source> și găsim <source lang="C" enclose="none">j = 4</source>, <source lang="C" enclose="none">v[j] = 40</source> soluție.
* Pentru <source lang="C" enclose="none">i = 4</source>, <source lang="C" enclose="none">v[i] = 40</source> ar trebui să căutăm valoarea <source lang="C" enclose="none">35</source> care este mai mică decât <source lang="C" enclose="none">v[i]</source> așa încât ne oprim.

Ce observăm? Că valorile lui <source lang="C" enclose="none">j</source> sunt descrescătoare. Este destul de clar că așa și trebuie să fie, nu?

'''Observație importantă'''

'''Tehnica Two Pointers''': atunci când o succesiune de '''căutări binare''' într-un vector au ca rezultat o '''secvență monotonă''' de numere (crescătoare sau descrescătoare), căutările binare pot fi înlocuite cu '''căutări liniare'''. Această înlocuire și noua metodă rezultată poartă denumirea de '''Two Pointers'''.

Ce complexitate are noul algoritm?

La prima vedere , pentru fiecare element <source lang="C" enclose="none">v[i]</source> vom căuta liniar perechea lui, ceea ce ar rezulta într-un algoritm ''O(N)''. În realitate, indicele <source lang="C" enclose="none">j</source> se va muta mereu către stânga, drept care el nu va putea parcurge mai mult de ''O(N)'' elemente în toate căutările liniare. Deci, folosind analiza amortizată, deși oricare din căutările liniare poate fi ''O(N)'', suma tuturor acestor căutări nu poate depăși ''O(N)''. Drept care metoda Two Pointers duce la un algoritm ''O(N)'', superior celui cu căutare binară, care era ''O(N log N)''.

=== Subsecvență de sumă X ===

Dat un vector <source lang="C" enclose="none">v[]</source> de elemente nenule, să se spună câte o perechi există de indici <source lang="C" enclose="none">(i, j)</source> astfel încât <source lang="C" enclose="none">v[i] + v[i+1] + v[i+2] + ... + v[j] == X</source>.

Și aici avem un algoritm relativ simplu: calculăm vectorul <source lang="C" enclose="none">s[]</source> de sume parțiale și pentru fiecare element pe poziția <source lang="C" enclose="none">i</source> în vector vom căuta binar în vectorul <source lang="C" enclose="none">s[]</source> valoarea <source lang="C" enclose="none">s[i-1] + X</source>. Dacă găsim această valoare la poziția <source lang="C" enclose="none">j</source> avem că <source lang="C" enclose="none">s[j] - s[i-1] == X</source> și deci suma elementelor de la <source lang="C" enclose="none">i</source> la <source lang="C" enclose="none">j</source> în vectorul <source lang="C" enclose="none">v[]</source> este <source lang="C" enclose="none">X</source>, deci avem o soluție.

Complexitatea acestui algoritm va fi, din nou, ''O(N log N)''.

Ce observăm, însă? Că rezultatele căutărilor binare (indicii <source lang="C" enclose="none">j</source>) vor fi în ordine crescătoare, deoarece sumele parțiale sunt strict crescătoare. Putem, deci, folosi '''Two Pointers''' pentru a căuta indicii <source lang="C" enclose="none">j</source> prin căutare liniară: pentru fiecare avans al lui <source lang="C" enclose="none">i</source> vom avansa indicele <source lang="C" enclose="none">j</source> până ce suma devine mai mare sau egală cu cea dorită, moment la care testăm egalitatea.

Acest algoritm are complexitate ''O(N)''. Mai mult, deoarece ne interesează doar suma subsecvenței de la <source lang="C" enclose="none">i</source> la <source lang="C" enclose="none">j</source> putem renunța la vectorul de sume parțiale și lucra direct pe vectorul original <source lang="C" enclose="none">v[]</source>, menținând incremental suma subsecvenței studiate.

=== Problema NrTri ===

Am discutat într-o lecție trecută problema [https://www.nerdarena.ro/problema/nrtri NrTri]. Ea cere să găsiți într-un vector numărul de tripleți ce pot forma laturile unui triunghi. Aici avem o soluție cu căutare binară: după ce sortăm elementele, pentru fiecare pereche de indici <source lang="C" enclose="none">(i, j)</source> vom căuta binar cel mai mare element <source lang="C" enclose="none">k > j</source> cu proprietatea că <source lang="C" enclose="none">v[k]</source>. Toate elementele între <source lang="C" enclose="none">j</source> și <source lang="C" enclose="none">k</source> (inclusiv <source lang="C" enclose="none">k</source>) formează un triplet valabil cu perechea <source lang="C" enclose="none">(i, j)</source>.

Această soluție are complexitatea ''O(N2 log N)''. Ca și în exemplele anterioare, observăm că atunci când <source lang="C" enclose="none">j</source> avansează căutarea binară va returna valori <source lang="C" enclose="none">k</source> crescătoare. Și aici putem aplica tehnica ''Two Pointers'', avansând liniar indicele <source lang="C" enclose="none">k</source>.

Rezultă un algoritm O(N2). Observați că tehnica aceasta reduce complexitatea cu acel factor log N. În practică nu este clar că vom putea întotdeauna diferenția între căutarea binară și Two Pointers. Cu toate acestea metoda merită, deoarece codul rezultat este mai simplu și constanta de implementare scade considerabil.

== Tipul de date struct ==

Până acum am învățat tipuri de date simple (<source lang="C" enclose="none">int</source>, <source lang="C" enclose="none">char</source>, <source lang="C" enclose="none">long long</source>, etc) și tipuri de date compuse (ce grupează mai multe tipuri de date simple) anume tablouri, fie ele unidimensionale (vectori), bidimensionale (matrice), sau chiar de dimensiuni mai mari.

'''Exemplu:'''

<syntaxhighlight lang="C" line>
struct nrmare { int ncf; char cf[MAXNCF]; };
...
struct nrmare n1, n2, n3;
</syntaxhighlight>

sau, mai scurt (putem declara variabile la definirea tipului <source lang="C" enclose="none">struct</source>):

<syntaxhighlight lang="C" line>
struct nrmare { int ncf; char cf[MAXNCF]; } n1, n2, n3;
</syntaxhighlight>

Elementele declarate în interiorul unui <source lang="C" enclose="none">struct</source> se numesc membri. Putem accesa membrii unei variabile tip <source lang="C" enclose="none">struct</source> cu operatorul punct.

'''Exemplu:'''

<syntaxhighlight lang="C" line>
t += n1.cf[i] + n2.cf[i];
n3.cf[i] = t % 10;
t /= 10;
</syntaxhighlight>

Tipul <source lang="C" enclose="none">struct</source> reprezintă un alt mod de a grupa date simple într-o ''structură''. Aceste date vor fi reprezentate în memorie la rând, una după alta.

'''Diferențe''' între tipul <source lang="C" enclose="none">struct</source> și tipul tablou:

* Tipul struct poate grupa date de tipuri diferite, tipul <source lang="C" enclose="none">tablou</source> nu.
* Tipul struct accesează elementele sale pe bază de denumire, tipul tablou accesează elementele numeric, pe bază de indice (poziție).
* În consecință tipul <source lang="C" enclose="none">struct</source> grupează un număr relativ mic de date.

'''Avantaje''' ale tipului <source lang="C" enclose="none">struct</source>:

* Gruparea datelor duce la o ordine a codului.
* Codul devine mai clar și mai ușor de citit, deci o depanare mai ușoară.
* Folosit corect tipul struct poate duce la un acces mai localizat al memorie (''cache friendly'') și, deci, la o scăderea a timpului de execuție.

'''Atenție:''' probleme cu tipul <source lang="C" enclose="none">struct</source>:

* Orice variabilă de tip <source lang="C" enclose="none">struct</source> va fi completată până la <source lang="C" enclose="none">int</source>. Actual, acest tip este pe patru octeți, ceea ce înseamnă că un struct va ocupa un număr de octeți divizibil cu patru. Dacă vom declara un struct cu un <source lang="C" enclose="none">int</source> și un <source lang="C" enclose="none">char</source> el va ocupa 8 octeți și nu 5!

* Un vector de structuri poate fi înlocuit întotdeauna cu mai mulți vectori, câte unul pentru fiecare membru. Decizia de a folosi struct trebuie luată în funcție de modul de accesare a membrilor în algoritmul nostru. O decizie proastă poate duce la deteriorarea timpului de execuție din motive de cache.

* Combinația între cele două de mai sus poate fi destul de rea: un struct care ocupă mai mult, chiar dacă nu duce la o depășire de memorie, va crește necesarul de memorie ceea ce duce la creșterea timpului de execuție din motive de ''cache''. Aceasta, combinat cu un acces prost la memorie, poate duce la o creștere semnificativă a timpului de execuție - poate chiar dublarea lui!

'''Concluzie''': folosiți tipul <source lang="C" enclose="none">struct</source> numai dacă știți exact ce faceți. Recomandarea mea este ca deocamdată să nu îl folosiți.

=== Studiu de caz: problema bile1 ===

Implementarea listelor se face în general bine folosind tipul <source lang="C" enclose="none">struct</source>. În mod natural o celulă a listei va conține o informație și o legătură la următoarea celulă (next). În particular am învățat acea structură de date, vectorul de liste, pe care îl foloseam pentru a evita sortarea, memorând pentru fiecare linie a unei matrice acele coloane care ne interesează, unde apar elemente interesante pe acea linie. Să luăm un caz concret.

În problema [https://www.nerdarena.ro/problema/bile1 Bile1] se cere să simulăm căderea unor bile printr-o matrice cu obstacole. Am rezolvat-o memorând obstacolele ca liste de coloane ''agățate'' pe liniile unde apar obstacole. Pentru aceasta am folosit doi vectori. Iată soluția de atunci:

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

#define MAXN 2000
#define NOBST 10000

short lin[MAXN + 1]; // capetele de lista
short col[NOBST + 1], next[NOBST + 1]; // celulele listelor
int bile[MAXN]; // bilele ce vor fi redistribuite

int main () {
FILE *fin, *fout;
int m, n, p, i, pc, l, c;

fin = fopen( "bile1.in", "r" );
fscanf( fin, "%d%d%d", &m, &n, &p );
for ( i = 1; i <= p; i++ ) { // citire obstacole
fscanf( fin, "%d%d", &l, &c );
col[i] = c; // asezam coloana c in lista liniei l
next[i] = lin[l]; // coloana noua vine la inceputul listei liniei l
lin[l] = i;
}
for ( i = 0; i < n; i++ ) // citire bile pe prima linie
fscanf( fin, "%d", &bile[i] );
fclose( fin );

// parcurgem liniile in ordine si cautam coloane cu obstacole
for ( l = 1; l <= m; l++ ) {
pc = lin[l];
while ( pc > 0 ) { // cita vreme mai avem elemente in lista
c = col[pc] - 1; // avem obstacol la coloana c
bile[c-1] += bile[c] / 2 + bile[c] % 2; // n/2 + 1 in stinga
bile[c+1] += bile[c] / 2; // n/2 in dreapta
bile[c] = 0;
pc = next[pc]; // trecem la urmatorul element din lista
}
}

fout = fopen( "bile1.out", "w" );
for ( i = 0; i < n; i++ )
fprintf( fout, "%d\n", bile[i] );
fclose( fout );

return 0;
}</syntaxhighlight>

Este clar că atunci când accesăm o celulă a listei vom avea nevoie atât de numărul de coloană cât și de next, pentru a avansa la elementul următor. Deci poate ar fi o idee bună să le grupăm, pentru ''cache''. Partea bună este că atât coloana cât și următorul element sunt mici, deci putem folosi tipul <source lang="C" enclose="none">short</source>, ceea ce înseamnă că o celulă va ocupa două elemente <source lang="C" enclose="none">short</source>, adică patru octeți, fiind aliniată la întreg.

Iată programul modificat să folosească tipul <source lang="C" enclose="none">struct</source>:

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

#define MAXN 2000
#define NOBST 10000

short lin[MAXN + 1]; // capetele de lista
struct cell { short col; short next; } obst[NOBST + 1]; // celulele listelor
int bile[MAXN]; // bilele ce vor fi redistribuite

int main () {
FILE *fin, *fout;
int m, n, p, i, pc, l, c;

fin = fopen( "bile1.in", "r" );
fscanf( fin, "%d%d%d", &m, &n, &p );
for ( i = 1; i <= p; i++ ) { // citire obstacole
fscanf( fin, "%d%d", &l, &c );
// asezam coloana c in lista liniei l
// coloana noua vine la inceputul listei liniei l
obst[i] = (struct cell){ .col = c, .next = lin[l] }; // cream noua celula
lin[l] = i;
}
for ( i = 0; i < n; i++ ) // citire bile pe prima linie
fscanf( fin, "%d", &bile[i] );
fclose( fin );

// parcurgem liniile in ordine si cautam coloane cu obstacole
for ( l = 1; l <= m; l++ ) {
pc = lin[l];
while ( pc > 0 ) { // cita vreme mai avem elemente in lista
c = obst[pc].col - 1; // avem obstacol la coloana c
bile[c-1] += bile[c] / 2 + bile[c] % 2; // n/2 + 1 in stinga
bile[c+1] += bile[c] / 2; // n/2 in dreapta
bile[c] = 0;
pc = obst[pc].next; // trecem la urmatorul element din lista
}
}

fout = fopen( "bile1.out", "w" );
for ( i = 0; i < n; i++ )
fprintf( fout, "%d\n", bile[i] );
fclose( fout );

return 0;
}
</syntaxhighlight>

Remarcați cum putem atribui o variabilă de tip <source lang="C" enclose="none">struct</source>, folosind denumirile membrilor săi:

<syntaxhighlight lang="C" line>
obst[i] = (struct cell){ .col = c, .next = lin[l] };
</syntaxhighlight>

=== Studiu de caz: numere mari ===

Numerele mari se pot reprezenta în mod natural ca un struct ce conține numărul de cifre și vectorul de cifre, precum am văzut mai sus. Avantajul constă în gruparea datelor și în claritatea codului ce menține numarul de cifre corect - nu mai avem nevoie să returnăm în funcția de înmulțire numărul de cifre al rezultatului, ci îl setăm chiar în numărul mare trimis ca parametru.

Atunci când trimitem un <source lang="C" enclose="none">struct</source> mare ca parametru (care ocupă mai mult de un întreg) este bine să-l trimitem ca pointer, deoarece evităm copierea. În acest caz accesul la <source lang="C" enclose="none">struct</source> se face un pic anevoios.

Iată un exemplu de funcție de adunare număr mic la număr mare:

<syntaxhighlight lang="c" line>
// aduna numarul mic a la numarul mare n
// n transmis prin referinta pentru a nu fi copiat + il modificam
void adunaNn( struct nrmare *n, int a ) {
int i;

i = 0;
while ( a > 0 ) {
a += (*n).cf[i];
(*n).cf[i] = a % 10;
a /= 10;
i++;
}

if ( i > (*n).ncf )
(*n).ncf = i;
}
</syntaxhighlight>

Remarcați că avem nevoie de două paranteze, un asterisc și un punct pentru a apela un membru al structurii trimise ca pointer. De aceea limbajul C ne oferă o alternativă mai simplă:

<syntaxhighlight lang="c" line>
// forme echivalente:
(*n).cf[i];

// este totuna cu
n->cf[i];
</syntaxhighlight>

Precum vedeți săgețica este echivalentul punctului atunci când variabila este de tip pointer la <source lang="C" enclose="none">struct</source>.

Iată un exemplu de implementare de numere mari:

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

#define MAXNCF 1000

struct nrmare { int ncf; char cf[MAXNCF]; } n1, n2, n3;

// aduna numarul mic a la numarul mare n
// n transmis prin referinta pentru a nu fi copiat + il modificam
void adunaNn( struct nrmare *n, int a ) {
int i;

i = 0;
while ( a > 0 ) {
a += n->cf[i];
n->cf[i] = a % 10;
a /= 10;
i++;
}

if ( i > n->ncf )
n->ncf = i;
}

// scade numarul mic a din numarul mare n
// considera ca nu se ajunge la un numar mare negativ (a <= n)
// n transmis prin referinta pentru a nu fi copiat + il modificam
void scadeNn( struct nrmare *n, int a ) {
int i;

a = -a;
i = 0;
while ( a < 0 ) {
a += n->cf[i];
n->cf[i] = a % 10;
a /= 10;
if ( n->cf[i] < 0 ) {
n->cf[i] += 10;
a--;
}
i++;
}

while ( n->ncf > 0 && n->cf[n->ncf-1] == 0 )
n->ncf--;
}

// aduna numarul mare n2 la numarul mare n1
// n1, n2 transmise prin referinta pentru a nu fi copiate + le modificam
void adunaNN( struct nrmare *n1, struct nrmare *n2 ) {
int i, max, t;

max = n1->ncf < n2->ncf ? n2->ncf : n1->ncf;
t = 0;
for ( i = 0; i < max; i++ ) {
t = t + n1->cf[i] + n2->cf[i];
n1->cf[i] = t % 10;
t /= 10;
}
if ( t > 0 ) {
n1->cf[i] = t;
max++;
}

n1->ncf = max;
}

// scade numarul mare n2 din numarul mare n1
// considera ca nu se ajunge la un numar mare negativ (n2 <= n1)
// n1, n2 transmise prin referinta pentru a nu fi copiate + le modificam
void scadeNN( struct nrmare *n1, struct nrmare *n2 ) {
int i, t;

t = i = 0;
while ( i < n2->ncf || t < 0 ) {
t = t + n1->cf[i] - n2->cf[i];
n1->cf[i] = t % 10;
t /= 10;
if ( n1->cf[i] < 0 ) {
n1->cf[i] += 10;
t--;
}
i++;
}

while ( n1->ncf > 0 && n1->cf[n1->ncf-1] == 0 )
n1->ncf--;
}

// inmulteste numarul mic a cu numarul mare n cu rezultatul in n
// n transmis prin referinta pentru a nu fi copiat + il modificam
void inmultesteNn( struct nrmare *n, int a ) {
int i;
long long t;

t = i = 0;
while ( i < n->ncf || t > 0 ) {
t = t + a * (long long)n->cf[i];
n->cf[i] = t % 10;
t /= 10;
i++;
}

if ( i > n->ncf )
n->ncf = i;
}

// tipareste un numar mare n
void printN( struct nrmare *n ) {
int i;

if ( n->ncf == 0 )
fputc( '0', stdout );
else
for ( i = n->ncf - 1; i >= 0; i-- )
fputc( '0' + n->cf[i], stdout );
fputc( '\n', stdout );
}

int main () {
// n1, n2, n3 declarate global, initial zero

printf( "0 + 75464: " );
adunaNn( &n1, 75464 );
printN( &n1 );

printf( "75464 - 75464: " );
scadeNn( &n1, 75464 );
printN( &n1 );

printf( "0 + 834205: " );
adunaNn( &n1, 834205 );
printN( &n1 );

adunaNn( &n2, 1024586 );

printf( "834205 + 1024586: " );
adunaNN( &n1, &n2 );
printN( &n1 );

printf( "834205 + 1024586 - 1024586: " );
scadeNN( &n1, &n2 );
printN( &n1 );

printf( "834205 * 2043984094: " );
inmultesteNn( &n1, 2043984094 );
printN( &n1 );

return 0;
}
</syntaxhighlight>

== Metoda Greedy ==

Uneori trebuie să rezolvăm probleme ce necesită să găsim o soluție minimă sau maximă. Una din cele mai simple și evidente încercări de rezolvare este ca, la fiecare pas, să luăm decizia optimă pe moment - decizie ''lacomă'' - cel mai bun lucru la momentul actual.

Exemplu: dat un șir de numere pozitive și negative să se calculeze suma maximă ce se poate forma cu exact ''K'' numere.

Soluție greedy: la fiecare pas vom selecta maximul dintre numerele rămase. Vom porni cu maximul. Apoi cu al doilea maxim și așa mai departe. La fiecare pas ''ne lăcomim'' la cel mai mare număr posibil.

Este, sper, destul de clar că în acest caz obținem soluția optimă. Însă nu întotdeauna este așa, precum vom vedea.

Să vedem câteva exemple de algoritmi greedy.

=== Plată cu număr minim de bancnote puteri ale lui 2 ===

Dispunem de bancnote puteri ale lui 2. Pentru fiecare putere a lui 2 vom avea un număr de bancnote disponibile, posibil niciuna. Dat '''X''', dorim să achităm suma '''X''' cu un număr minim de bancnote posibile. Cum procedăm?

Vom proceda greedy: selectăm bancnotele de valoare maximă ce încap în '''X'''. Fie epuizăm numărul de bancnote de acea putere și trecem mai departe, fie ne rămân bancnote dar suma de plată devine mai mică decât 2 la acea putere. Procedăm în continuare la fel.

Exemplu: dispunem de următoarele bancnote: 3 × 25, 1 × 23, 2 × 22, 5 × 21, 6 × 20 și ne dorim să achităm suma 53. Procedăm astfel:

<pre>
Pas 1: selectăm 1 × 25. Suma rămasă: 21 = 53 - 32
Pas 2: selectăm 1 × 23. Suma rămasă: 13 = 21 - 8
Pas 3: selectăm 2 × 22. Suma rămasă: 5 = 13 - 8
Pas 4: selectăm 2 × 21. Suma rămasă: 1 = 5 - 4
Pas 5: selectăm 1 × 20. Suma rămasă: 0 = 1 - 1
</pre>

Astfel numărul de bancnote este 7, iar numărul este plătit astfel:

<pre>
53 = 32 + 8 + 4 + 4 + 2 + 2 + 1
</pre>

=== Sortarea prin selecție ===

Ne putem gândi la sortarea prin selecție ca având un pas de bază greedy: la fiecare trecere prin vector selectăm în mod greedy maximul și apoi îl trecem la coadă.

=== Numărul minim de intervale care acoperă un interval ===

Problemă: dată o mulţime de ''N'' intervale <code>[ai, bi]</code> ce acoperă un alt interval mai mare să se găsească o submulţime minimă a acestei mulţimi care conţine intervale ce acoperă același interval original.

[[File:Intervale-pe-dreapta-1.svg.png|thumb]]

Exemplu: fie intervalele

<pre>
1: [3 8]
2: [9 18]
3: [1 5]
4: [0 8]
5: [2 10]
</pre>

Intervalul acoperit este <source lang="C" enclose="none">[0, 18]</source>. Ne dorim să păstrăm cât mai puține intervale care să acopere același interval.

''' Idee de soluție '''

O idee naturală este să sortăm intervalele după punctul de început, iar apoi să le luăm în ordine, unul câte unul. Având un interval curent selectat, am putea să selectăm intervalul care începe cât mai târziu dar al cărui interval este în interiorul intervalului curent.

Pe exemplul de mai sus observăm că nu funcționează, deoarece am selecta intervalele 4, 1 și apoi nu am mai avea ce să selectăm în continuare.

''' Soluție '''

Vom parcurge intervalele în ordinea capătului de început, ca mai devreme. Dar vom selecta următorul interval pe acela care se '''închide ultimul''' dintre cele care au capătul stânga în interiorul intervalului curent.

În cazul nostru vom selecta intervalele 4, 5 și 2.

=== Numărul maxim de intervale disjuncte ===

Problemă: dată o submulţime de ''N'' intervale <code>[ai, bi]</code> să se găsească o submulţime maximală a acestei mulţimi care conţine doar intervale disjuncte (neintersectante).

Această problemă este totuna cu numărul minim de puncte ce ''înțeapă'' toate intervalele (de ce?).

''' Idei de soluţie '''

Această problemă apare destul de des la olimpiade, deghizată într-o formă sau alta. Deşi pare o problemă grea, în realitate ea se rezolvă uşor. O primă idee ar fi să încercăm să ordonăm intervalele după punctul de început, apoi să le luăm în ordine, unul câte unul. Pentru fiecare interval ne întrebăm dacă îl intersectează pe cel anterior. Dacă da, îl aruncăm şi mergem mai departe. Dacă nu, îl adăugăm la submulţime şi îl reţinem ca interval ultim. Această soluţie nu funcţionează şi e destul de evident de ce: am putea avea un prim interval foarte lung, care acoperă toate celelalte intervale.

Cu toate acestea rezolvarea nu e total greşită. În fapt, ea aproape funcţionează! Are nevoie doar de o modificare ce se impune, analizînd contraexemplul anterior: de ce nu este bun acel prim interval foarte lung? Deoarece el se termină după celelalte. Şi atunci ne putem întreba, în mod natural, ce s-ar întâmpla dacă am alege intervalul care se închide primul, nu care începe primul? Desigur că acest algoritm funcţionează. Vă las vouă să vă luptaţi cu demonstraţia, care decurge cam aşa: să presupunem că soluţia generată de acest algoritm nu e optimă. Înseamnă că există o altă soluţie cu mai multe intervale. Acea soluţie trebuie să difere undeva faţă de cea găsită de noi. Mergeţi pe această cale şi trebuie să ajungeţi la o contradicţie cum că soluţia optimă nu poate avea mai multe segmente.

[[File:Intervale-pe-dreapta-1.svg.png|thumb]]

Exemplu: fie intervalele

<pre>
1: [3 8]
2: [9 18]
3: [1 5]
4: [0 8]
5: [2 10]
</pre>

Atunci vom selecta, în ordine, intervalele 3 și 2.

==== Soluţie ====

Care este algoritmul, în mare?

''
# Iniţial mulţimea M este vidă.
# Ordonează crescător intervalele după punctul de închidere.
# Consideră ultima închidere (care nu există încă) cu valoarea minus infinit.
# Pentru fiecare interval, în ordine:
## Dacă el conţine ultima închidere
### Ignoră-l.
## Altfel
### Selectează intervalul curent şi adaugă-l la mulţimea M.
### Setează ultima închidere pe închiderea intervalului selectat
# Afişează mulţimea M.
''

Ce se întâmplă dacă avem mai multe intervale care se termină în acelaşi punct? Atunci putem reţine intervalul cel mai mic. De ce? Deoarece este cel mai convenabil. Să presupunem că soluţia maximală conţinea un alt interval care se termina în acel punct. Atunci putem înlocui acel interval cu intervalul cel mai mic, obţinînd o altă soluţie maximală.

==== Considerente de implementare ====

Implementarea directă: memorăm intervalele ca perechi, prin capetele lor. Sortăm perechile după capătul din dreapta. Apoi facem o parcurgere a perechilor. Această implementare necesită ''O(N log N)'' timp și ''O(N)'' memorie.

Implementare relaxată: atunci când coordonatele sunt suficient de mici astfel încât să putem folosi un vector care să memoreze un întreg pentru fiecare coordonată, putem încerca o abordare mai simplă: nu memorăm intervalele. Ci, pentru fiecare interval <source lang="C" enclose="none">[ai, bi]</source>, vom seta <source lang="C" enclose="none">început[bi] = ai</source>. Cu alte cuvinte vom memora capetele stânga la poziția capetelor dreapta. Apoi parcurgem vectorul în ordine, acoperind segmentul de coordonate care acoperă toate intervalele, testând dacă elementul de la poziția curentă în vector este mai mic decât ultima închidere memorată. Dacă nu, atunci selectăm intervalul și mutăm ultima închidere la poziția curentă în vector. Trebuie să avem grijă la următoarele:

* Să iniţializăm vectorul de coordonate cu o valoare distinctă de capete de interval. Matematic am putea să le iniţializăm cu minus infinit, astfel încât să nu fie selectate niciodată.
* Atunci când ''aşezăm'' intervalele pe vector să avem grijă ca dacă găsim deja o valoare în vector să o înlocuim numai dacă cea curentă este mai mare (intervalul este mai mic).

Această soluţie necesită ''O(N + CMAX)'' timp şi memorie, '''CMAX''' fiind coordonata maximă. De aici rezultă când o putem folosi: atunci când '''CMAX''' este suficient de mic.

==== Generalizare ====

Putem generaliza această problemă: să se calculeze mulţimea maximală de dreptunghiuri neintersectante. Sau de paralelipipede. Sau de paralelipipede n-dimensionale. Cum se rezolvă aceste probleme? Din nefericire aceste probleme fac parte dintr-o clasă de probleme numite ''NP-hard'', pentru care nu se cunoaşte o soluţie bună.

=== Exemplu când greedy nu funcționează: prolema rucsacului ===

Problema rucsacului cere să ''umplem'' cât mai bine un rucsac care poate duce o greutate maximă, dispunând de obiecte de diverse greutăți.

Exemplu: Vreau să umplu cât mai bine un rucsac de 100 și am greutăți 50, 30, 25 și 25.

Prin metoda greedy vom alege greutățile cele mai mari, în ordine: 50 și 30, după care nu mai putem adăuga nimic. Astfel vom obține greutatea totală 80. Dacă am alege însă greutățile 50, 25 și 25 am putea umple complet rucsacul.

De remarcat totuși că chiar și atunci când metoda greedy nu calculează optimul, un algoritm greedy bine gândit va da o soluție bună, aproape de optim.

== Tema 16 ==

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

* [https://www.nerdarena.ro/problema/politic Politic] dată la ONI 2007 clasa a 7-a
* [https://www.nerdarena.ro/problema/sumax SumaX] dată la Shumen Juniori 2015
* [https://www.nerdarena.ro/problema/acoperire Acoperire]
* [https://www.nerdarena.ro/problema/char Char] dată la ONI 2010 clasa a 7-a

Pentru doritorii să încerce și soluția problemei numărul minim de numărul minim de puncte ce ''înțeapă'' toate intervalele puteți rezolva problema [https://www.nerdarena.ro/problema/baloane Baloane].

== Tema opțională ==

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

* [https://www.nerdarena.ro/problema/startrek Star Trek] dată la OJI 2016 clasa a 7-a

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_16:_Tehnica_Two_Pointers_(doi_pointeri),_tipul_de_date_struct_%C8%99i_metoda_Greedy Accesează rezolvarea temei 16]

Clasa a 7-a Lecția 16: Tehnica Two Pointers (doi pointeri), tipul de date struct și metoda Greedy

2026-02-03T14:47:24Z

Cristian: /* Studiu de caz: problema bile1 */

== Înregistrare video lecție ==

<youtube height="720" width="1280">https://youtu.be/W59ZLyfMZlc</youtube>

== Tehnica Two Pointers (doi pointeri) ==

În informatica de concurs avem tehnici semi-banale cărora le dăm o denumire pentru a putea să le referim ușor într-o discuție. Este și cazul acestei metode. Deși relativ evidentă, ea are un nume 🙂 Pe scurt, '''Two Pointers''' folosește doi indici într-un vector ce avansează pe rând, similar cu interclasarea, în căutarea rezultatului. Este o tehnică ce produce în general algoritmi liniari. Ea decurge în mod natural din căutarea binară, atunci când avem un algoritm relativ simplu ce folosește multiple căutări binare, ale căror rezultate sunt fie crescătoare fie descrescătoare.

Să luăm câteva exemple.

=== Pereche de sumă X ===

Dat un vector <source lang="C" enclose="none">v[]</source> de elemente sortate crescător, să se spună câte o perechi există de indici <source lang="C" enclose="none">(i, j)</source> astfel încât <source lang="C" enclose="none">v[i] + v[j] == X</source>.

Cum am putea rezolva problema? Pentru fiecare număr <source lang="C" enclose="none">v[i]</source> să căutăm un număr <source lang="C" enclose="none">v[j]</source> cu <source lang="C" enclose="none">j > i</source> astfel încât <source lang="C" enclose="none">v[i] + v[j] == X</source>. Dacă fixăm <source lang="C" enclose="none">v[i]</source> atunci <source lang="C" enclose="none">v[j]</source> poate fi determinat prin căutare binară, deoarece vectorul este ordonat crescător. Vom obține, deci, un algoritm ''O(N log N)'', unde '''N''' este numărul de elemente din vector.

'''Exemplu'''

Fie vectorul:

<source lang="C" line>
v[] = { 20, 25, 30, 35, 40, 50, 55, 65, 75 }
indici: 0 1 2 3 4 5 6 7 8
</source>

și <source lang="C" enclose="none">X = 75</source>. Pentru fiecare <source lang="C" enclose="none">v[i]</source> vom căuta binar ultimul număr mai mic sau egal cu <source lang="C" enclose="none">X - v[i]</source>. Astfel:

* Pentru <source lang="C" enclose="none">i = 0</source>, <source lang="C" enclose="none">v[i] = 20</source> căutăm valoarea <source lang="C" enclose="none">X - v[i] = 55</source> și găsim <source lang="C" enclose="none">j = 6</source>, <source lang="C" enclose="none">v[j] = 55</source> soluție.
* Pentru <source lang="C" enclose="none">i = 1</source>, <source lang="C" enclose="none">v[i] = 25</source> căutăm valoarea <source lang="C" enclose="none">50</source> și găsim <source lang="C" enclose="none">j = 5</source>, <source lang="C" enclose="none">v[j] = 50</source> soluție.
* Pentru <source lang="C" enclose="none">i = 2</source>, <source lang="C" enclose="none">v[i] = 30</source> căutăm valoarea <source lang="C" enclose="none">45</source> și găsim <source lang="C" enclose="none">j = 4</source>, <source lang="C" enclose="none">v[j] = 40</source> (ultima mai mică sau egală cu 45) nu este soluție.
* Pentru <source lang="C" enclose="none">i = 3</source>, <source lang="C" enclose="none">v[i] = 35</source> căutăm valoarea <source lang="C" enclose="none">40</source> și găsim <source lang="C" enclose="none">j = 4</source>, <source lang="C" enclose="none">v[j] = 40</source> soluție.
* Pentru <source lang="C" enclose="none">i = 4</source>, <source lang="C" enclose="none">v[i] = 40</source> ar trebui să căutăm valoarea <source lang="C" enclose="none">35</source> care este mai mică decât <source lang="C" enclose="none">v[i]</source> așa încât ne oprim.

Ce observăm? Că valorile lui <source lang="C" enclose="none">j</source> sunt descrescătoare. Este destul de clar că așa și trebuie să fie, nu?

'''Observație importantă'''

'''Tehnica Two Pointers''': atunci când o succesiune de '''căutări binare''' într-un vector au ca rezultat o '''secvență monotonă''' de numere (crescătoare sau descrescătoare), căutările binare pot fi înlocuite cu '''căutări liniare'''. Această înlocuire și noua metodă rezultată poartă denumirea de '''Two Pointers'''.

Ce complexitate are noul algoritm?

La prima vedere , pentru fiecare element <source lang="C" enclose="none">v[i]</source> vom căuta liniar perechea lui, ceea ce ar rezulta într-un algoritm ''O(N)''. În realitate, indicele <source lang="C" enclose="none">j</source> se va muta mereu către stânga, drept care el nu va putea parcurge mai mult de ''O(N)'' elemente în toate căutările liniare. Deci, folosind analiza amortizată, deși oricare din căutările liniare poate fi ''O(N)'', suma tuturor acestor căutări nu poate depăși ''O(N)''. Drept care metoda Two Pointers duce la un algoritm ''O(N)'', superior celui cu căutare binară, care era ''O(N log N)''.

=== Subsecvență de sumă X ===

Dat un vector <source lang="C" enclose="none">v[]</source> de elemente nenule, să se spună câte o perechi există de indici <source lang="C" enclose="none">(i, j)</source> astfel încât <source lang="C" enclose="none">v[i] + v[i+1] + v[i+2] + ... + v[j] == X</source>.

Și aici avem un algoritm relativ simplu: calculăm vectorul <source lang="C" enclose="none">s[]</source> de sume parțiale și pentru fiecare element pe poziția <source lang="C" enclose="none">i</source> în vector vom căuta binar în vectorul <source lang="C" enclose="none">s[]</source> valoarea <source lang="C" enclose="none">s[i-1] + X</source>. Dacă găsim această valoare la poziția <source lang="C" enclose="none">j</source> avem că <source lang="C" enclose="none">s[j] - s[i-1] == X</source> și deci suma elementelor de la <source lang="C" enclose="none">i</source> la <source lang="C" enclose="none">j</source> în vectorul <source lang="C" enclose="none">v[]</source> este <source lang="C" enclose="none">X</source>, deci avem o soluție.

Complexitatea acestui algoritm va fi, din nou, ''O(N log N)''.

Ce observăm, însă? Că rezultatele căutărilor binare (indicii <source lang="C" enclose="none">j</source>) vor fi în ordine crescătoare, deoarece sumele parțiale sunt strict crescătoare. Putem, deci, folosi '''Two Pointers''' pentru a căuta indicii <source lang="C" enclose="none">j</source> prin căutare liniară: pentru fiecare avans al lui <source lang="C" enclose="none">i</source> vom avansa indicele <source lang="C" enclose="none">j</source> până ce suma devine mai mare sau egală cu cea dorită, moment la care testăm egalitatea.

Acest algoritm are complexitate ''O(N)''. Mai mult, deoarece ne interesează doar suma subsecvenței de la <source lang="C" enclose="none">i</source> la <source lang="C" enclose="none">j</source> putem renunța la vectorul de sume parțiale și lucra direct pe vectorul original <source lang="C" enclose="none">v[]</source>, menținând incremental suma subsecvenței studiate.

=== Problema NrTri ===

Am discutat într-o lecție trecută problema [https://www.nerdarena.ro/problema/nrtri NrTri]. Ea cere să găsiți într-un vector numărul de tripleți ce pot forma laturile unui triunghi. Aici avem o soluție cu căutare binară: după ce sortăm elementele, pentru fiecare pereche de indici <source lang="C" enclose="none">(i, j)</source> vom căuta binar cel mai mare element <source lang="C" enclose="none">k > j</source> cu proprietatea că <source lang="C" enclose="none">v[k]</source>. Toate elementele între <source lang="C" enclose="none">j</source> și <source lang="C" enclose="none">k</source> (inclusiv <source lang="C" enclose="none">k</source>) formează un triplet valabil cu perechea <source lang="C" enclose="none">(i, j)</source>.

Această soluție are complexitatea ''O(N2 log N)''. Ca și în exemplele anterioare, observăm că atunci când <source lang="C" enclose="none">j</source> avansează căutarea binară va returna valori <source lang="C" enclose="none">k</source> crescătoare. Și aici putem aplica tehnica ''Two Pointers'', avansând liniar indicele <source lang="C" enclose="none">k</source>.

Rezultă un algoritm O(N2). Observați că tehnica aceasta reduce complexitatea cu acel factor log N. În practică nu este clar că vom putea întotdeauna diferenția între căutarea binară și Two Pointers. Cu toate acestea metoda merită, deoarece codul rezultat este mai simplu și constanta de implementare scade considerabil.

== Tipul de date struct ==

Până acum am învățat tipuri de date simple (<source lang="C" enclose="none">int</source>, <source lang="C" enclose="none">char</source>, <source lang="C" enclose="none">long long</source>, etc) și tipuri de date compuse (ce grupează mai multe tipuri de date simple) anume tablouri, fie ele unidimensionale (vectori), bidimensionale (matrice), sau chiar de dimensiuni mai mari.

'''Exemplu:'''

<syntaxhighlight lang="C" line>
struct nrmare { int ncf; char cf[MAXNCF]; };
...
struct nrmare n1, n2, n3;
</syntaxhighlight>

sau, mai scurt (putem declara variabile la definirea tipului <source lang="C" enclose="none">struct</source>):

<syntaxhighlight lang="C" line>
struct nrmare { int ncf; char cf[MAXNCF]; } n1, n2, n3;
</syntaxhighlight>

Elementele declarate în interiorul unui <source lang="C" enclose="none">struct</source> se numesc membri. Putem accesa membrii unei variabile tip <source lang="C" enclose="none">struct</source> cu operatorul punct.

'''Exemplu:'''

<syntaxhighlight lang="C" line>
t += n1.cf[i] + n2.cf[i];
n3.cf[i] = t % 10;
t /= 10;
</syntaxhighlight>

Tipul <source lang="C" enclose="none">struct</source> reprezintă un alt mod de a grupa date simple într-o ''structură''. Aceste date vor fi reprezentate în memorie la rând, una după alta.

'''Diferențe''' între tipul <source lang="C" enclose="none">struct</source> și tipul tablou:

* Tipul struct poate grupa date de tipuri diferite, tipul <source lang="C" enclose="none">tablou</source> nu.
* Tipul struct accesează elementele sale pe bază de denumire, tipul tablou accesează elementele numeric, pe bază de indice (poziție).
* În consecință tipul <source lang="C" enclose="none">struct</source> grupează un număr relativ mic de date.

'''Avantaje''' ale tipului <source lang="C" enclose="none">struct</source>:

* Gruparea datelor duce la o ordine a codului.
* Codul devine mai clar și mai ușor de citit, deci o depanare mai ușoară.
* Folosit corect tipul struct poate duce la un acces mai localizat al memorie (''cache friendly'') și, deci, la o scăderea a timpului de execuție.

'''Atenție:''' probleme cu tipul <source lang="C" enclose="none">struct</source>:

* Orice variabilă de tip <source lang="C" enclose="none">struct</source> va fi completată până la <source lang="C" enclose="none">int</source>. Actual, acest tip este pe patru octeți, ceea ce înseamnă că un struct va ocupa un număr de octeți divizibil cu patru. Dacă vom declara un struct cu un <source lang="C" enclose="none">int</source> și un <source lang="C" enclose="none">char</source> el va ocupa 8 octeți și nu 5!

* Un vector de structuri poate fi înlocuit întotdeauna cu mai mulți vectori, câte unul pentru fiecare membru. Decizia de a folosi struct trebuie luată în funcție de modul de accesare a membrilor în algoritmul nostru. O decizie proastă poate duce la deteriorarea timpului de execuție din motive de cache.

* Combinația între cele două de mai sus poate fi destul de rea: un struct care ocupă mai mult, chiar dacă nu duce la o depășire de memorie, va crește necesarul de memorie ceea ce duce la creșterea timpului de execuție din motive de ''cache''. Aceasta, combinat cu un acces prost la memorie, poate duce la o creștere semnificativă a timpului de execuție - poate chiar dublarea lui!

'''Concluzie''': folosiți tipul <source lang="C" enclose="none">struct</source> numai dacă știți exact ce faceți. Recomandarea mea este ca deocamdată să nu îl folosiți.

=== Studiu de caz: problema bile1 ===

Implementarea listelor se face în general bine folosind tipul <source lang="C" enclose="none">struct</source>. În mod natural o celulă a listei va conține o informație și o legătură la următoarea celulă (next). În particular am învățat acea structură de date, vectorul de liste, pe care îl foloseam pentru a evita sortarea, memorând pentru fiecare linie a unei matrice acele coloane care ne interesează, unde apar elemente interesante pe acea linie. Să luăm un caz concret.

În problema [https://www.nerdarena.ro/problema/bile1 Bile1] se cere să simulăm căderea unor bile printr-o matrice cu obstacole. Am rezolvat-o memorând obstacolele ca liste de coloane ''agățate'' pe liniile unde apar obstacole. Pentru aceasta am folosit doi vectori. Iată soluția de atunci:

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

#define MAXN 2000
#define NOBST 10000

short lin[MAXN + 1]; // capetele de lista
short col[NOBST + 1], next[NOBST + 1]; // celulele listelor
int bile[MAXN]; // bilele ce vor fi redistribuite

int main () {
FILE *fin, *fout;
int m, n, p, i, pc, l, c;

fin = fopen( "bile1.in", "r" );
fscanf( fin, "%d%d%d", &m, &n, &p );
for ( i = 1; i <= p; i++ ) { // citire obstacole
fscanf( fin, "%d%d", &l, &c );
col[i] = c; // asezam coloana c in lista liniei l
next[i] = lin[l]; // coloana noua vine la inceputul listei liniei l
lin[l] = i;
}
for ( i = 0; i < n; i++ ) // citire bile pe prima linie
fscanf( fin, "%d", &bile[i] );
fclose( fin );

// parcurgem liniile in ordine si cautam coloane cu obstacole
for ( l = 1; l <= m; l++ ) {
pc = lin[l];
while ( pc > 0 ) { // cita vreme mai avem elemente in lista
c = col[pc] - 1; // avem obstacol la coloana c
bile[c-1] += bile[c] / 2 + bile[c] % 2; // n/2 + 1 in stinga
bile[c+1] += bile[c] / 2; // n/2 in dreapta
bile[c] = 0;
pc = next[pc]; // trecem la urmatorul element din lista
}
}

fout = fopen( "bile1.out", "w" );
for ( i = 0; i < n; i++ )
fprintf( fout, "%d\n", bile[i] );
fclose( fout );

return 0;
}</source>

Este clar că atunci când accesăm o celulă a listei vom avea nevoie atât de numărul de coloană cât și de next, pentru a avansa la elementul următor. Deci poate ar fi o idee bună să le grupăm, pentru ''cache''. Partea bună este că atât coloana cât și următorul element sunt mici, deci putem folosi tipul <source lang="C" enclose="none">short</source>, ceea ce înseamnă că o celulă va ocupa două elemente <source lang="C" enclose="none">short</source>, adică patru octeți, fiind aliniată la întreg.

Iată programul modificat să folosească tipul <source lang="C" enclose="none">struct</source>:

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

#define MAXN 2000
#define NOBST 10000

short lin[MAXN + 1]; // capetele de lista
struct cell { short col; short next; } obst[NOBST + 1]; // celulele listelor
int bile[MAXN]; // bilele ce vor fi redistribuite

int main () {
FILE *fin, *fout;
int m, n, p, i, pc, l, c;

fin = fopen( "bile1.in", "r" );
fscanf( fin, "%d%d%d", &m, &n, &p );
for ( i = 1; i <= p; i++ ) { // citire obstacole
fscanf( fin, "%d%d", &l, &c );
// asezam coloana c in lista liniei l
// coloana noua vine la inceputul listei liniei l
obst[i] = (struct cell){ .col = c, .next = lin[l] }; // cream noua celula
lin[l] = i;
}
for ( i = 0; i < n; i++ ) // citire bile pe prima linie
fscanf( fin, "%d", &bile[i] );
fclose( fin );

// parcurgem liniile in ordine si cautam coloane cu obstacole
for ( l = 1; l <= m; l++ ) {
pc = lin[l];
while ( pc > 0 ) { // cita vreme mai avem elemente in lista
c = obst[pc].col - 1; // avem obstacol la coloana c
bile[c-1] += bile[c] / 2 + bile[c] % 2; // n/2 + 1 in stinga
bile[c+1] += bile[c] / 2; // n/2 in dreapta
bile[c] = 0;
pc = obst[pc].next; // trecem la urmatorul element din lista
}
}

fout = fopen( "bile1.out", "w" );
for ( i = 0; i < n; i++ )
fprintf( fout, "%d\n", bile[i] );
fclose( fout );

return 0;
}
</syntaxhighlight>

Remarcați cum putem atribui o variabilă de tip <source lang="C" enclose="none">struct</source>, folosind denumirile membrilor săi:

<syntaxhighlight lang="C" line>
obst[i] = (struct cell){ .col = c, .next = lin[l] };
</syntaxhighlight>

=== Studiu de caz: numere mari ===

Numerele mari se pot reprezenta în mod natural ca un struct ce conține numărul de cifre și vectorul de cifre, precum am văzut mai sus. Avantajul constă în gruparea datelor și în claritatea codului ce menține numarul de cifre corect - nu mai avem nevoie să returnăm în funcția de înmulțire numărul de cifre al rezultatului, ci îl setăm chiar în numărul mare trimis ca parametru.

Atunci când trimitem un <source lang="C" enclose="none">struct</source> mare ca parametru (care ocupă mai mult de un întreg) este bine să-l trimitem ca pointer, deoarece evităm copierea. În acest caz accesul la <source lang="C" enclose="none">struct</source> se face un pic anevoios.

Iată un exemplu de funcție de adunare număr mic la număr mare:

<syntaxhighlight lang="c" line>
// aduna numarul mic a la numarul mare n
// n transmis prin referinta pentru a nu fi copiat + il modificam
void adunaNn( struct nrmare *n, int a ) {
int i;

i = 0;
while ( a > 0 ) {
a += (*n).cf[i];
(*n).cf[i] = a % 10;
a /= 10;
i++;
}

if ( i > (*n).ncf )
(*n).ncf = i;
}
</syntaxhighlight>

Remarcați că avem nevoie de două paranteze, un asterisc și un punct pentru a apela un membru al structurii trimise ca pointer. De aceea limbajul C ne oferă o alternativă mai simplă:

<syntaxhighlight lang="c" line>
// forme echivalente:
(*n).cf[i];

// este totuna cu
n->cf[i];
</syntaxhighlight>

Precum vedeți săgețica este echivalentul punctului atunci când variabila este de tip pointer la <source lang="C" enclose="none">struct</source>.

Iată un exemplu de implementare de numere mari:

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

#define MAXNCF 1000

struct nrmare { int ncf; char cf[MAXNCF]; } n1, n2, n3;

// aduna numarul mic a la numarul mare n
// n transmis prin referinta pentru a nu fi copiat + il modificam
void adunaNn( struct nrmare *n, int a ) {
int i;

i = 0;
while ( a > 0 ) {
a += n->cf[i];
n->cf[i] = a % 10;
a /= 10;
i++;
}

if ( i > n->ncf )
n->ncf = i;
}

// scade numarul mic a din numarul mare n
// considera ca nu se ajunge la un numar mare negativ (a <= n)
// n transmis prin referinta pentru a nu fi copiat + il modificam
void scadeNn( struct nrmare *n, int a ) {
int i;

a = -a;
i = 0;
while ( a < 0 ) {
a += n->cf[i];
n->cf[i] = a % 10;
a /= 10;
if ( n->cf[i] < 0 ) {
n->cf[i] += 10;
a--;
}
i++;
}

while ( n->ncf > 0 && n->cf[n->ncf-1] == 0 )
n->ncf--;
}

// aduna numarul mare n2 la numarul mare n1
// n1, n2 transmise prin referinta pentru a nu fi copiate + le modificam
void adunaNN( struct nrmare *n1, struct nrmare *n2 ) {
int i, max, t;

max = n1->ncf < n2->ncf ? n2->ncf : n1->ncf;
t = 0;
for ( i = 0; i < max; i++ ) {
t = t + n1->cf[i] + n2->cf[i];
n1->cf[i] = t % 10;
t /= 10;
}
if ( t > 0 ) {
n1->cf[i] = t;
max++;
}

n1->ncf = max;
}

// scade numarul mare n2 din numarul mare n1
// considera ca nu se ajunge la un numar mare negativ (n2 <= n1)
// n1, n2 transmise prin referinta pentru a nu fi copiate + le modificam
void scadeNN( struct nrmare *n1, struct nrmare *n2 ) {
int i, t;

t = i = 0;
while ( i < n2->ncf || t < 0 ) {
t = t + n1->cf[i] - n2->cf[i];
n1->cf[i] = t % 10;
t /= 10;
if ( n1->cf[i] < 0 ) {
n1->cf[i] += 10;
t--;
}
i++;
}

while ( n1->ncf > 0 && n1->cf[n1->ncf-1] == 0 )
n1->ncf--;
}

// inmulteste numarul mic a cu numarul mare n cu rezultatul in n
// n transmis prin referinta pentru a nu fi copiat + il modificam
void inmultesteNn( struct nrmare *n, int a ) {
int i;
long long t;

t = i = 0;
while ( i < n->ncf || t > 0 ) {
t = t + a * (long long)n->cf[i];
n->cf[i] = t % 10;
t /= 10;
i++;
}

if ( i > n->ncf )
n->ncf = i;
}

// tipareste un numar mare n
void printN( struct nrmare *n ) {
int i;

if ( n->ncf == 0 )
fputc( '0', stdout );
else
for ( i = n->ncf - 1; i >= 0; i-- )
fputc( '0' + n->cf[i], stdout );
fputc( '\n', stdout );
}

int main () {
// n1, n2, n3 declarate global, initial zero

printf( "0 + 75464: " );
adunaNn( &n1, 75464 );
printN( &n1 );

printf( "75464 - 75464: " );
scadeNn( &n1, 75464 );
printN( &n1 );

printf( "0 + 834205: " );
adunaNn( &n1, 834205 );
printN( &n1 );

adunaNn( &n2, 1024586 );

printf( "834205 + 1024586: " );
adunaNN( &n1, &n2 );
printN( &n1 );

printf( "834205 + 1024586 - 1024586: " );
scadeNN( &n1, &n2 );
printN( &n1 );

printf( "834205 * 2043984094: " );
inmultesteNn( &n1, 2043984094 );
printN( &n1 );

return 0;
}
</syntaxhighlight>

== Metoda Greedy ==

Uneori trebuie să rezolvăm probleme ce necesită să găsim o soluție minimă sau maximă. Una din cele mai simple și evidente încercări de rezolvare este ca, la fiecare pas, să luăm decizia optimă pe moment - decizie ''lacomă'' - cel mai bun lucru la momentul actual.

Exemplu: dat un șir de numere pozitive și negative să se calculeze suma maximă ce se poate forma cu exact ''K'' numere.

Soluție greedy: la fiecare pas vom selecta maximul dintre numerele rămase. Vom porni cu maximul. Apoi cu al doilea maxim și așa mai departe. La fiecare pas ''ne lăcomim'' la cel mai mare număr posibil.

Este, sper, destul de clar că în acest caz obținem soluția optimă. Însă nu întotdeauna este așa, precum vom vedea.

Să vedem câteva exemple de algoritmi greedy.

=== Plată cu număr minim de bancnote puteri ale lui 2 ===

Dispunem de bancnote puteri ale lui 2. Pentru fiecare putere a lui 2 vom avea un număr de bancnote disponibile, posibil niciuna. Dat '''X''', dorim să achităm suma '''X''' cu un număr minim de bancnote posibile. Cum procedăm?

Vom proceda greedy: selectăm bancnotele de valoare maximă ce încap în '''X'''. Fie epuizăm numărul de bancnote de acea putere și trecem mai departe, fie ne rămân bancnote dar suma de plată devine mai mică decât 2 la acea putere. Procedăm în continuare la fel.

Exemplu: dispunem de următoarele bancnote: 3 × 25, 1 × 23, 2 × 22, 5 × 21, 6 × 20 și ne dorim să achităm suma 53. Procedăm astfel:

<pre>
Pas 1: selectăm 1 × 25. Suma rămasă: 21 = 53 - 32
Pas 2: selectăm 1 × 23. Suma rămasă: 13 = 21 - 8
Pas 3: selectăm 2 × 22. Suma rămasă: 5 = 13 - 8
Pas 4: selectăm 2 × 21. Suma rămasă: 1 = 5 - 4
Pas 5: selectăm 1 × 20. Suma rămasă: 0 = 1 - 1
</pre>

Astfel numărul de bancnote este 7, iar numărul este plătit astfel:

<pre>
53 = 32 + 8 + 4 + 4 + 2 + 2 + 1
</pre>

=== Sortarea prin selecție ===

Ne putem gândi la sortarea prin selecție ca având un pas de bază greedy: la fiecare trecere prin vector selectăm în mod greedy maximul și apoi îl trecem la coadă.

=== Numărul minim de intervale care acoperă un interval ===

Problemă: dată o mulţime de ''N'' intervale <code>[ai, bi]</code> ce acoperă un alt interval mai mare să se găsească o submulţime minimă a acestei mulţimi care conţine intervale ce acoperă același interval original.

[[File:Intervale-pe-dreapta-1.svg.png|thumb]]

Exemplu: fie intervalele

<pre>
1: [3 8]
2: [9 18]
3: [1 5]
4: [0 8]
5: [2 10]
</pre>

Intervalul acoperit este <source lang="C" enclose="none">[0, 18]</source>. Ne dorim să păstrăm cât mai puține intervale care să acopere același interval.

''' Idee de soluție '''

O idee naturală este să sortăm intervalele după punctul de început, iar apoi să le luăm în ordine, unul câte unul. Având un interval curent selectat, am putea să selectăm intervalul care începe cât mai târziu dar al cărui interval este în interiorul intervalului curent.

Pe exemplul de mai sus observăm că nu funcționează, deoarece am selecta intervalele 4, 1 și apoi nu am mai avea ce să selectăm în continuare.

''' Soluție '''

Vom parcurge intervalele în ordinea capătului de început, ca mai devreme. Dar vom selecta următorul interval pe acela care se '''închide ultimul''' dintre cele care au capătul stânga în interiorul intervalului curent.

În cazul nostru vom selecta intervalele 4, 5 și 2.

=== Numărul maxim de intervale disjuncte ===

Problemă: dată o submulţime de ''N'' intervale <code>[ai, bi]</code> să se găsească o submulţime maximală a acestei mulţimi care conţine doar intervale disjuncte (neintersectante).

Această problemă este totuna cu numărul minim de puncte ce ''înțeapă'' toate intervalele (de ce?).

''' Idei de soluţie '''

Această problemă apare destul de des la olimpiade, deghizată într-o formă sau alta. Deşi pare o problemă grea, în realitate ea se rezolvă uşor. O primă idee ar fi să încercăm să ordonăm intervalele după punctul de început, apoi să le luăm în ordine, unul câte unul. Pentru fiecare interval ne întrebăm dacă îl intersectează pe cel anterior. Dacă da, îl aruncăm şi mergem mai departe. Dacă nu, îl adăugăm la submulţime şi îl reţinem ca interval ultim. Această soluţie nu funcţionează şi e destul de evident de ce: am putea avea un prim interval foarte lung, care acoperă toate celelalte intervale.

Cu toate acestea rezolvarea nu e total greşită. În fapt, ea aproape funcţionează! Are nevoie doar de o modificare ce se impune, analizînd contraexemplul anterior: de ce nu este bun acel prim interval foarte lung? Deoarece el se termină după celelalte. Şi atunci ne putem întreba, în mod natural, ce s-ar întâmpla dacă am alege intervalul care se închide primul, nu care începe primul? Desigur că acest algoritm funcţionează. Vă las vouă să vă luptaţi cu demonstraţia, care decurge cam aşa: să presupunem că soluţia generată de acest algoritm nu e optimă. Înseamnă că există o altă soluţie cu mai multe intervale. Acea soluţie trebuie să difere undeva faţă de cea găsită de noi. Mergeţi pe această cale şi trebuie să ajungeţi la o contradicţie cum că soluţia optimă nu poate avea mai multe segmente.

[[File:Intervale-pe-dreapta-1.svg.png|thumb]]

Exemplu: fie intervalele

<pre>
1: [3 8]
2: [9 18]
3: [1 5]
4: [0 8]
5: [2 10]
</pre>

Atunci vom selecta, în ordine, intervalele 3 și 2.

==== Soluţie ====

Care este algoritmul, în mare?

''
# Iniţial mulţimea M este vidă.
# Ordonează crescător intervalele după punctul de închidere.
# Consideră ultima închidere (care nu există încă) cu valoarea minus infinit.
# Pentru fiecare interval, în ordine:
## Dacă el conţine ultima închidere
### Ignoră-l.
## Altfel
### Selectează intervalul curent şi adaugă-l la mulţimea M.
### Setează ultima închidere pe închiderea intervalului selectat
# Afişează mulţimea M.
''

Ce se întâmplă dacă avem mai multe intervale care se termină în acelaşi punct? Atunci putem reţine intervalul cel mai mic. De ce? Deoarece este cel mai convenabil. Să presupunem că soluţia maximală conţinea un alt interval care se termina în acel punct. Atunci putem înlocui acel interval cu intervalul cel mai mic, obţinînd o altă soluţie maximală.

==== Considerente de implementare ====

Implementarea directă: memorăm intervalele ca perechi, prin capetele lor. Sortăm perechile după capătul din dreapta. Apoi facem o parcurgere a perechilor. Această implementare necesită ''O(N log N)'' timp și ''O(N)'' memorie.

Implementare relaxată: atunci când coordonatele sunt suficient de mici astfel încât să putem folosi un vector care să memoreze un întreg pentru fiecare coordonată, putem încerca o abordare mai simplă: nu memorăm intervalele. Ci, pentru fiecare interval <source lang="C" enclose="none">[ai, bi]</source>, vom seta <source lang="C" enclose="none">început[bi] = ai</source>. Cu alte cuvinte vom memora capetele stânga la poziția capetelor dreapta. Apoi parcurgem vectorul în ordine, acoperind segmentul de coordonate care acoperă toate intervalele, testând dacă elementul de la poziția curentă în vector este mai mic decât ultima închidere memorată. Dacă nu, atunci selectăm intervalul și mutăm ultima închidere la poziția curentă în vector. Trebuie să avem grijă la următoarele:

* Să iniţializăm vectorul de coordonate cu o valoare distinctă de capete de interval. Matematic am putea să le iniţializăm cu minus infinit, astfel încât să nu fie selectate niciodată.
* Atunci când ''aşezăm'' intervalele pe vector să avem grijă ca dacă găsim deja o valoare în vector să o înlocuim numai dacă cea curentă este mai mare (intervalul este mai mic).

Această soluţie necesită ''O(N + CMAX)'' timp şi memorie, '''CMAX''' fiind coordonata maximă. De aici rezultă când o putem folosi: atunci când '''CMAX''' este suficient de mic.

==== Generalizare ====

Putem generaliza această problemă: să se calculeze mulţimea maximală de dreptunghiuri neintersectante. Sau de paralelipipede. Sau de paralelipipede n-dimensionale. Cum se rezolvă aceste probleme? Din nefericire aceste probleme fac parte dintr-o clasă de probleme numite ''NP-hard'', pentru care nu se cunoaşte o soluţie bună.

=== Exemplu când greedy nu funcționează: prolema rucsacului ===

Problema rucsacului cere să ''umplem'' cât mai bine un rucsac care poate duce o greutate maximă, dispunând de obiecte de diverse greutăți.

Exemplu: Vreau să umplu cât mai bine un rucsac de 100 și am greutăți 50, 30, 25 și 25.

Prin metoda greedy vom alege greutățile cele mai mari, în ordine: 50 și 30, după care nu mai putem adăuga nimic. Astfel vom obține greutatea totală 80. Dacă am alege însă greutățile 50, 25 și 25 am putea umple complet rucsacul.

De remarcat totuși că chiar și atunci când metoda greedy nu calculează optimul, un algoritm greedy bine gândit va da o soluție bună, aproape de optim.

== Tema 16 ==

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

* [https://www.nerdarena.ro/problema/politic Politic] dată la ONI 2007 clasa a 7-a
* [https://www.nerdarena.ro/problema/sumax SumaX] dată la Shumen Juniori 2015
* [https://www.nerdarena.ro/problema/acoperire Acoperire]
* [https://www.nerdarena.ro/problema/char Char] dată la ONI 2010 clasa a 7-a

Pentru doritorii să încerce și soluția problemei numărul minim de numărul minim de puncte ce ''înțeapă'' toate intervalele puteți rezolva problema [https://www.nerdarena.ro/problema/baloane Baloane].

== Tema opțională ==

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

* [https://www.nerdarena.ro/problema/startrek Star Trek] dată la OJI 2016 clasa a 7-a

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_16:_Tehnica_Two_Pointers_(doi_pointeri),_tipul_de_date_struct_%C8%99i_metoda_Greedy Accesează rezolvarea temei 16]

Clasa a 7-a Lecția 16: Tehnica Two Pointers (doi pointeri), tipul de date struct și metoda Greedy

2026-02-03T14:47:03Z

Cristian: /* Studiu de caz: problema bile1 */

== Înregistrare video lecție ==

<youtube height="720" width="1280">https://youtu.be/W59ZLyfMZlc</youtube>

== Tehnica Two Pointers (doi pointeri) ==

În informatica de concurs avem tehnici semi-banale cărora le dăm o denumire pentru a putea să le referim ușor într-o discuție. Este și cazul acestei metode. Deși relativ evidentă, ea are un nume 🙂 Pe scurt, '''Two Pointers''' folosește doi indici într-un vector ce avansează pe rând, similar cu interclasarea, în căutarea rezultatului. Este o tehnică ce produce în general algoritmi liniari. Ea decurge în mod natural din căutarea binară, atunci când avem un algoritm relativ simplu ce folosește multiple căutări binare, ale căror rezultate sunt fie crescătoare fie descrescătoare.

Să luăm câteva exemple.

=== Pereche de sumă X ===

Dat un vector <source lang="C" enclose="none">v[]</source> de elemente sortate crescător, să se spună câte o perechi există de indici <source lang="C" enclose="none">(i, j)</source> astfel încât <source lang="C" enclose="none">v[i] + v[j] == X</source>.

Cum am putea rezolva problema? Pentru fiecare număr <source lang="C" enclose="none">v[i]</source> să căutăm un număr <source lang="C" enclose="none">v[j]</source> cu <source lang="C" enclose="none">j > i</source> astfel încât <source lang="C" enclose="none">v[i] + v[j] == X</source>. Dacă fixăm <source lang="C" enclose="none">v[i]</source> atunci <source lang="C" enclose="none">v[j]</source> poate fi determinat prin căutare binară, deoarece vectorul este ordonat crescător. Vom obține, deci, un algoritm ''O(N log N)'', unde '''N''' este numărul de elemente din vector.

'''Exemplu'''

Fie vectorul:

<source lang="C" line>
v[] = { 20, 25, 30, 35, 40, 50, 55, 65, 75 }
indici: 0 1 2 3 4 5 6 7 8
</source>

și <source lang="C" enclose="none">X = 75</source>. Pentru fiecare <source lang="C" enclose="none">v[i]</source> vom căuta binar ultimul număr mai mic sau egal cu <source lang="C" enclose="none">X - v[i]</source>. Astfel:

* Pentru <source lang="C" enclose="none">i = 0</source>, <source lang="C" enclose="none">v[i] = 20</source> căutăm valoarea <source lang="C" enclose="none">X - v[i] = 55</source> și găsim <source lang="C" enclose="none">j = 6</source>, <source lang="C" enclose="none">v[j] = 55</source> soluție.
* Pentru <source lang="C" enclose="none">i = 1</source>, <source lang="C" enclose="none">v[i] = 25</source> căutăm valoarea <source lang="C" enclose="none">50</source> și găsim <source lang="C" enclose="none">j = 5</source>, <source lang="C" enclose="none">v[j] = 50</source> soluție.
* Pentru <source lang="C" enclose="none">i = 2</source>, <source lang="C" enclose="none">v[i] = 30</source> căutăm valoarea <source lang="C" enclose="none">45</source> și găsim <source lang="C" enclose="none">j = 4</source>, <source lang="C" enclose="none">v[j] = 40</source> (ultima mai mică sau egală cu 45) nu este soluție.
* Pentru <source lang="C" enclose="none">i = 3</source>, <source lang="C" enclose="none">v[i] = 35</source> căutăm valoarea <source lang="C" enclose="none">40</source> și găsim <source lang="C" enclose="none">j = 4</source>, <source lang="C" enclose="none">v[j] = 40</source> soluție.
* Pentru <source lang="C" enclose="none">i = 4</source>, <source lang="C" enclose="none">v[i] = 40</source> ar trebui să căutăm valoarea <source lang="C" enclose="none">35</source> care este mai mică decât <source lang="C" enclose="none">v[i]</source> așa încât ne oprim.

Ce observăm? Că valorile lui <source lang="C" enclose="none">j</source> sunt descrescătoare. Este destul de clar că așa și trebuie să fie, nu?

'''Observație importantă'''

'''Tehnica Two Pointers''': atunci când o succesiune de '''căutări binare''' într-un vector au ca rezultat o '''secvență monotonă''' de numere (crescătoare sau descrescătoare), căutările binare pot fi înlocuite cu '''căutări liniare'''. Această înlocuire și noua metodă rezultată poartă denumirea de '''Two Pointers'''.

Ce complexitate are noul algoritm?

La prima vedere , pentru fiecare element <source lang="C" enclose="none">v[i]</source> vom căuta liniar perechea lui, ceea ce ar rezulta într-un algoritm ''O(N)''. În realitate, indicele <source lang="C" enclose="none">j</source> se va muta mereu către stânga, drept care el nu va putea parcurge mai mult de ''O(N)'' elemente în toate căutările liniare. Deci, folosind analiza amortizată, deși oricare din căutările liniare poate fi ''O(N)'', suma tuturor acestor căutări nu poate depăși ''O(N)''. Drept care metoda Two Pointers duce la un algoritm ''O(N)'', superior celui cu căutare binară, care era ''O(N log N)''.

=== Subsecvență de sumă X ===

Dat un vector <source lang="C" enclose="none">v[]</source> de elemente nenule, să se spună câte o perechi există de indici <source lang="C" enclose="none">(i, j)</source> astfel încât <source lang="C" enclose="none">v[i] + v[i+1] + v[i+2] + ... + v[j] == X</source>.

Și aici avem un algoritm relativ simplu: calculăm vectorul <source lang="C" enclose="none">s[]</source> de sume parțiale și pentru fiecare element pe poziția <source lang="C" enclose="none">i</source> în vector vom căuta binar în vectorul <source lang="C" enclose="none">s[]</source> valoarea <source lang="C" enclose="none">s[i-1] + X</source>. Dacă găsim această valoare la poziția <source lang="C" enclose="none">j</source> avem că <source lang="C" enclose="none">s[j] - s[i-1] == X</source> și deci suma elementelor de la <source lang="C" enclose="none">i</source> la <source lang="C" enclose="none">j</source> în vectorul <source lang="C" enclose="none">v[]</source> este <source lang="C" enclose="none">X</source>, deci avem o soluție.

Complexitatea acestui algoritm va fi, din nou, ''O(N log N)''.

Ce observăm, însă? Că rezultatele căutărilor binare (indicii <source lang="C" enclose="none">j</source>) vor fi în ordine crescătoare, deoarece sumele parțiale sunt strict crescătoare. Putem, deci, folosi '''Two Pointers''' pentru a căuta indicii <source lang="C" enclose="none">j</source> prin căutare liniară: pentru fiecare avans al lui <source lang="C" enclose="none">i</source> vom avansa indicele <source lang="C" enclose="none">j</source> până ce suma devine mai mare sau egală cu cea dorită, moment la care testăm egalitatea.

Acest algoritm are complexitate ''O(N)''. Mai mult, deoarece ne interesează doar suma subsecvenței de la <source lang="C" enclose="none">i</source> la <source lang="C" enclose="none">j</source> putem renunța la vectorul de sume parțiale și lucra direct pe vectorul original <source lang="C" enclose="none">v[]</source>, menținând incremental suma subsecvenței studiate.

=== Problema NrTri ===

Am discutat într-o lecție trecută problema [https://www.nerdarena.ro/problema/nrtri NrTri]. Ea cere să găsiți într-un vector numărul de tripleți ce pot forma laturile unui triunghi. Aici avem o soluție cu căutare binară: după ce sortăm elementele, pentru fiecare pereche de indici <source lang="C" enclose="none">(i, j)</source> vom căuta binar cel mai mare element <source lang="C" enclose="none">k > j</source> cu proprietatea că <source lang="C" enclose="none">v[k]</source>. Toate elementele între <source lang="C" enclose="none">j</source> și <source lang="C" enclose="none">k</source> (inclusiv <source lang="C" enclose="none">k</source>) formează un triplet valabil cu perechea <source lang="C" enclose="none">(i, j)</source>.

Această soluție are complexitatea ''O(N2 log N)''. Ca și în exemplele anterioare, observăm că atunci când <source lang="C" enclose="none">j</source> avansează căutarea binară va returna valori <source lang="C" enclose="none">k</source> crescătoare. Și aici putem aplica tehnica ''Two Pointers'', avansând liniar indicele <source lang="C" enclose="none">k</source>.

Rezultă un algoritm O(N2). Observați că tehnica aceasta reduce complexitatea cu acel factor log N. În practică nu este clar că vom putea întotdeauna diferenția între căutarea binară și Two Pointers. Cu toate acestea metoda merită, deoarece codul rezultat este mai simplu și constanta de implementare scade considerabil.

== Tipul de date struct ==

Până acum am învățat tipuri de date simple (<source lang="C" enclose="none">int</source>, <source lang="C" enclose="none">char</source>, <source lang="C" enclose="none">long long</source>, etc) și tipuri de date compuse (ce grupează mai multe tipuri de date simple) anume tablouri, fie ele unidimensionale (vectori), bidimensionale (matrice), sau chiar de dimensiuni mai mari.

'''Exemplu:'''

<syntaxhighlight lang="C" line>
struct nrmare { int ncf; char cf[MAXNCF]; };
...
struct nrmare n1, n2, n3;
</syntaxhighlight>

sau, mai scurt (putem declara variabile la definirea tipului <source lang="C" enclose="none">struct</source>):

<syntaxhighlight lang="C" line>
struct nrmare { int ncf; char cf[MAXNCF]; } n1, n2, n3;
</syntaxhighlight>

Elementele declarate în interiorul unui <source lang="C" enclose="none">struct</source> se numesc membri. Putem accesa membrii unei variabile tip <source lang="C" enclose="none">struct</source> cu operatorul punct.

'''Exemplu:'''

<syntaxhighlight lang="C" line>
t += n1.cf[i] + n2.cf[i];
n3.cf[i] = t % 10;
t /= 10;
</syntaxhighlight>

Tipul <source lang="C" enclose="none">struct</source> reprezintă un alt mod de a grupa date simple într-o ''structură''. Aceste date vor fi reprezentate în memorie la rând, una după alta.

'''Diferențe''' între tipul <source lang="C" enclose="none">struct</source> și tipul tablou:

* Tipul struct poate grupa date de tipuri diferite, tipul <source lang="C" enclose="none">tablou</source> nu.
* Tipul struct accesează elementele sale pe bază de denumire, tipul tablou accesează elementele numeric, pe bază de indice (poziție).
* În consecință tipul <source lang="C" enclose="none">struct</source> grupează un număr relativ mic de date.

'''Avantaje''' ale tipului <source lang="C" enclose="none">struct</source>:

* Gruparea datelor duce la o ordine a codului.
* Codul devine mai clar și mai ușor de citit, deci o depanare mai ușoară.
* Folosit corect tipul struct poate duce la un acces mai localizat al memorie (''cache friendly'') și, deci, la o scăderea a timpului de execuție.

'''Atenție:''' probleme cu tipul <source lang="C" enclose="none">struct</source>:

* Orice variabilă de tip <source lang="C" enclose="none">struct</source> va fi completată până la <source lang="C" enclose="none">int</source>. Actual, acest tip este pe patru octeți, ceea ce înseamnă că un struct va ocupa un număr de octeți divizibil cu patru. Dacă vom declara un struct cu un <source lang="C" enclose="none">int</source> și un <source lang="C" enclose="none">char</source> el va ocupa 8 octeți și nu 5!

* Un vector de structuri poate fi înlocuit întotdeauna cu mai mulți vectori, câte unul pentru fiecare membru. Decizia de a folosi struct trebuie luată în funcție de modul de accesare a membrilor în algoritmul nostru. O decizie proastă poate duce la deteriorarea timpului de execuție din motive de cache.

* Combinația între cele două de mai sus poate fi destul de rea: un struct care ocupă mai mult, chiar dacă nu duce la o depășire de memorie, va crește necesarul de memorie ceea ce duce la creșterea timpului de execuție din motive de ''cache''. Aceasta, combinat cu un acces prost la memorie, poate duce la o creștere semnificativă a timpului de execuție - poate chiar dublarea lui!

'''Concluzie''': folosiți tipul <source lang="C" enclose="none">struct</source> numai dacă știți exact ce faceți. Recomandarea mea este ca deocamdată să nu îl folosiți.

=== Studiu de caz: problema bile1 ===

Implementarea listelor se face în general bine folosind tipul <source lang="C" enclose="none">struct</source>. În mod natural o celulă a listei va conține o informație și o legătură la următoarea celulă (next). În particular am învățat acea structură de date, vectorul de liste, pe care îl foloseam pentru a evita sortarea, memorând pentru fiecare linie a unei matrice acele coloane care ne interesează, unde apar elemente interesante pe acea linie. Să luăm un caz concret.

În problema [https://www.nerdarena.ro/problema/bile1 Bile1] se cere să simulăm căderea unor bile printr-o matrice cu obstacole. Am rezolvat-o memorând obstacolele ca liste de coloane ''agățate'' pe liniile unde apar obstacole. Pentru aceasta am folosit doi vectori. Iată soluția de atunci:

<source lang="C">#include <stdio.h>

#define MAXN 2000
#define NOBST 10000

short lin[MAXN + 1]; // capetele de lista
short col[NOBST + 1], next[NOBST + 1]; // celulele listelor
int bile[MAXN]; // bilele ce vor fi redistribuite

int main () {
FILE *fin, *fout;
int m, n, p, i, pc, l, c;

fin = fopen( "bile1.in", "r" );
fscanf( fin, "%d%d%d", &m, &n, &p );
for ( i = 1; i <= p; i++ ) { // citire obstacole
fscanf( fin, "%d%d", &l, &c );
col[i] = c; // asezam coloana c in lista liniei l
next[i] = lin[l]; // coloana noua vine la inceputul listei liniei l
lin[l] = i;
}
for ( i = 0; i < n; i++ ) // citire bile pe prima linie
fscanf( fin, "%d", &bile[i] );
fclose( fin );

// parcurgem liniile in ordine si cautam coloane cu obstacole
for ( l = 1; l <= m; l++ ) {
pc = lin[l];
while ( pc > 0 ) { // cita vreme mai avem elemente in lista
c = col[pc] - 1; // avem obstacol la coloana c
bile[c-1] += bile[c] / 2 + bile[c] % 2; // n/2 + 1 in stinga
bile[c+1] += bile[c] / 2; // n/2 in dreapta
bile[c] = 0;
pc = next[pc]; // trecem la urmatorul element din lista
}
}

fout = fopen( "bile1.out", "w" );
for ( i = 0; i < n; i++ )
fprintf( fout, "%d\n", bile[i] );
fclose( fout );

return 0;
}</source>

Este clar că atunci când accesăm o celulă a listei vom avea nevoie atât de numărul de coloană cât și de next, pentru a avansa la elementul următor. Deci poate ar fi o idee bună să le grupăm, pentru ''cache''. Partea bună este că atât coloana cât și următorul element sunt mici, deci putem folosi tipul <source lang="C" enclose="none">short</source>, ceea ce înseamnă că o celulă va ocupa două elemente <source lang="C" enclose="none">short</source>, adică patru octeți, fiind aliniată la întreg.

Iată programul modificat să folosească tipul <source lang="C" enclose="none">struct</source>:

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

#define MAXN 2000
#define NOBST 10000

short lin[MAXN + 1]; // capetele de lista
struct cell { short col; short next; } obst[NOBST + 1]; // celulele listelor
int bile[MAXN]; // bilele ce vor fi redistribuite

int main () {
FILE *fin, *fout;
int m, n, p, i, pc, l, c;

fin = fopen( "bile1.in", "r" );
fscanf( fin, "%d%d%d", &m, &n, &p );
for ( i = 1; i <= p; i++ ) { // citire obstacole
fscanf( fin, "%d%d", &l, &c );
// asezam coloana c in lista liniei l
// coloana noua vine la inceputul listei liniei l
obst[i] = (struct cell){ .col = c, .next = lin[l] }; // cream noua celula
lin[l] = i;
}
for ( i = 0; i < n; i++ ) // citire bile pe prima linie
fscanf( fin, "%d", &bile[i] );
fclose( fin );

// parcurgem liniile in ordine si cautam coloane cu obstacole
for ( l = 1; l <= m; l++ ) {
pc = lin[l];
while ( pc > 0 ) { // cita vreme mai avem elemente in lista
c = obst[pc].col - 1; // avem obstacol la coloana c
bile[c-1] += bile[c] / 2 + bile[c] % 2; // n/2 + 1 in stinga
bile[c+1] += bile[c] / 2; // n/2 in dreapta
bile[c] = 0;
pc = obst[pc].next; // trecem la urmatorul element din lista
}
}

fout = fopen( "bile1.out", "w" );
for ( i = 0; i < n; i++ )
fprintf( fout, "%d\n", bile[i] );
fclose( fout );

return 0;
}
</syntaxhighlight>

Remarcați cum putem atribui o variabilă de tip <source lang="C" enclose="none">struct</source>, folosind denumirile membrilor săi:

<syntaxhighlight lang="C" line>
obst[i] = (struct cell){ .col = c, .next = lin[l] };
</syntaxhighlight>

=== Studiu de caz: numere mari ===

Numerele mari se pot reprezenta în mod natural ca un struct ce conține numărul de cifre și vectorul de cifre, precum am văzut mai sus. Avantajul constă în gruparea datelor și în claritatea codului ce menține numarul de cifre corect - nu mai avem nevoie să returnăm în funcția de înmulțire numărul de cifre al rezultatului, ci îl setăm chiar în numărul mare trimis ca parametru.

Atunci când trimitem un <source lang="C" enclose="none">struct</source> mare ca parametru (care ocupă mai mult de un întreg) este bine să-l trimitem ca pointer, deoarece evităm copierea. În acest caz accesul la <source lang="C" enclose="none">struct</source> se face un pic anevoios.

Iată un exemplu de funcție de adunare număr mic la număr mare:

<syntaxhighlight lang="c" line>
// aduna numarul mic a la numarul mare n
// n transmis prin referinta pentru a nu fi copiat + il modificam
void adunaNn( struct nrmare *n, int a ) {
int i;

i = 0;
while ( a > 0 ) {
a += (*n).cf[i];
(*n).cf[i] = a % 10;
a /= 10;
i++;
}

if ( i > (*n).ncf )
(*n).ncf = i;
}
</syntaxhighlight>

Remarcați că avem nevoie de două paranteze, un asterisc și un punct pentru a apela un membru al structurii trimise ca pointer. De aceea limbajul C ne oferă o alternativă mai simplă:

<syntaxhighlight lang="c" line>
// forme echivalente:
(*n).cf[i];

// este totuna cu
n->cf[i];
</syntaxhighlight>

Precum vedeți săgețica este echivalentul punctului atunci când variabila este de tip pointer la <source lang="C" enclose="none">struct</source>.

Iată un exemplu de implementare de numere mari:

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

#define MAXNCF 1000

struct nrmare { int ncf; char cf[MAXNCF]; } n1, n2, n3;

// aduna numarul mic a la numarul mare n
// n transmis prin referinta pentru a nu fi copiat + il modificam
void adunaNn( struct nrmare *n, int a ) {
int i;

i = 0;
while ( a > 0 ) {
a += n->cf[i];
n->cf[i] = a % 10;
a /= 10;
i++;
}

if ( i > n->ncf )
n->ncf = i;
}

// scade numarul mic a din numarul mare n
// considera ca nu se ajunge la un numar mare negativ (a <= n)
// n transmis prin referinta pentru a nu fi copiat + il modificam
void scadeNn( struct nrmare *n, int a ) {
int i;

a = -a;
i = 0;
while ( a < 0 ) {
a += n->cf[i];
n->cf[i] = a % 10;
a /= 10;
if ( n->cf[i] < 0 ) {
n->cf[i] += 10;
a--;
}
i++;
}

while ( n->ncf > 0 && n->cf[n->ncf-1] == 0 )
n->ncf--;
}

// aduna numarul mare n2 la numarul mare n1
// n1, n2 transmise prin referinta pentru a nu fi copiate + le modificam
void adunaNN( struct nrmare *n1, struct nrmare *n2 ) {
int i, max, t;

max = n1->ncf < n2->ncf ? n2->ncf : n1->ncf;
t = 0;
for ( i = 0; i < max; i++ ) {
t = t + n1->cf[i] + n2->cf[i];
n1->cf[i] = t % 10;
t /= 10;
}
if ( t > 0 ) {
n1->cf[i] = t;
max++;
}

n1->ncf = max;
}

// scade numarul mare n2 din numarul mare n1
// considera ca nu se ajunge la un numar mare negativ (n2 <= n1)
// n1, n2 transmise prin referinta pentru a nu fi copiate + le modificam
void scadeNN( struct nrmare *n1, struct nrmare *n2 ) {
int i, t;

t = i = 0;
while ( i < n2->ncf || t < 0 ) {
t = t + n1->cf[i] - n2->cf[i];
n1->cf[i] = t % 10;
t /= 10;
if ( n1->cf[i] < 0 ) {
n1->cf[i] += 10;
t--;
}
i++;
}

while ( n1->ncf > 0 && n1->cf[n1->ncf-1] == 0 )
n1->ncf--;
}

// inmulteste numarul mic a cu numarul mare n cu rezultatul in n
// n transmis prin referinta pentru a nu fi copiat + il modificam
void inmultesteNn( struct nrmare *n, int a ) {
int i;
long long t;

t = i = 0;
while ( i < n->ncf || t > 0 ) {
t = t + a * (long long)n->cf[i];
n->cf[i] = t % 10;
t /= 10;
i++;
}

if ( i > n->ncf )
n->ncf = i;
}

// tipareste un numar mare n
void printN( struct nrmare *n ) {
int i;

if ( n->ncf == 0 )
fputc( '0', stdout );
else
for ( i = n->ncf - 1; i >= 0; i-- )
fputc( '0' + n->cf[i], stdout );
fputc( '\n', stdout );
}

int main () {
// n1, n2, n3 declarate global, initial zero

printf( "0 + 75464: " );
adunaNn( &n1, 75464 );
printN( &n1 );

printf( "75464 - 75464: " );
scadeNn( &n1, 75464 );
printN( &n1 );

printf( "0 + 834205: " );
adunaNn( &n1, 834205 );
printN( &n1 );

adunaNn( &n2, 1024586 );

printf( "834205 + 1024586: " );
adunaNN( &n1, &n2 );
printN( &n1 );

printf( "834205 + 1024586 - 1024586: " );
scadeNN( &n1, &n2 );
printN( &n1 );

printf( "834205 * 2043984094: " );
inmultesteNn( &n1, 2043984094 );
printN( &n1 );

return 0;
}
</syntaxhighlight>

== Metoda Greedy ==

Uneori trebuie să rezolvăm probleme ce necesită să găsim o soluție minimă sau maximă. Una din cele mai simple și evidente încercări de rezolvare este ca, la fiecare pas, să luăm decizia optimă pe moment - decizie ''lacomă'' - cel mai bun lucru la momentul actual.

Exemplu: dat un șir de numere pozitive și negative să se calculeze suma maximă ce se poate forma cu exact ''K'' numere.

Soluție greedy: la fiecare pas vom selecta maximul dintre numerele rămase. Vom porni cu maximul. Apoi cu al doilea maxim și așa mai departe. La fiecare pas ''ne lăcomim'' la cel mai mare număr posibil.

Este, sper, destul de clar că în acest caz obținem soluția optimă. Însă nu întotdeauna este așa, precum vom vedea.

Să vedem câteva exemple de algoritmi greedy.

=== Plată cu număr minim de bancnote puteri ale lui 2 ===

Dispunem de bancnote puteri ale lui 2. Pentru fiecare putere a lui 2 vom avea un număr de bancnote disponibile, posibil niciuna. Dat '''X''', dorim să achităm suma '''X''' cu un număr minim de bancnote posibile. Cum procedăm?

Vom proceda greedy: selectăm bancnotele de valoare maximă ce încap în '''X'''. Fie epuizăm numărul de bancnote de acea putere și trecem mai departe, fie ne rămân bancnote dar suma de plată devine mai mică decât 2 la acea putere. Procedăm în continuare la fel.

Exemplu: dispunem de următoarele bancnote: 3 × 25, 1 × 23, 2 × 22, 5 × 21, 6 × 20 și ne dorim să achităm suma 53. Procedăm astfel:

<pre>
Pas 1: selectăm 1 × 25. Suma rămasă: 21 = 53 - 32
Pas 2: selectăm 1 × 23. Suma rămasă: 13 = 21 - 8
Pas 3: selectăm 2 × 22. Suma rămasă: 5 = 13 - 8
Pas 4: selectăm 2 × 21. Suma rămasă: 1 = 5 - 4
Pas 5: selectăm 1 × 20. Suma rămasă: 0 = 1 - 1
</pre>

Astfel numărul de bancnote este 7, iar numărul este plătit astfel:

<pre>
53 = 32 + 8 + 4 + 4 + 2 + 2 + 1
</pre>

=== Sortarea prin selecție ===

Ne putem gândi la sortarea prin selecție ca având un pas de bază greedy: la fiecare trecere prin vector selectăm în mod greedy maximul și apoi îl trecem la coadă.

=== Numărul minim de intervale care acoperă un interval ===

Problemă: dată o mulţime de ''N'' intervale <code>[ai, bi]</code> ce acoperă un alt interval mai mare să se găsească o submulţime minimă a acestei mulţimi care conţine intervale ce acoperă același interval original.

[[File:Intervale-pe-dreapta-1.svg.png|thumb]]

Exemplu: fie intervalele

<pre>
1: [3 8]
2: [9 18]
3: [1 5]
4: [0 8]
5: [2 10]
</pre>

Intervalul acoperit este <source lang="C" enclose="none">[0, 18]</source>. Ne dorim să păstrăm cât mai puține intervale care să acopere același interval.

''' Idee de soluție '''

O idee naturală este să sortăm intervalele după punctul de început, iar apoi să le luăm în ordine, unul câte unul. Având un interval curent selectat, am putea să selectăm intervalul care începe cât mai târziu dar al cărui interval este în interiorul intervalului curent.

Pe exemplul de mai sus observăm că nu funcționează, deoarece am selecta intervalele 4, 1 și apoi nu am mai avea ce să selectăm în continuare.

''' Soluție '''

Vom parcurge intervalele în ordinea capătului de început, ca mai devreme. Dar vom selecta următorul interval pe acela care se '''închide ultimul''' dintre cele care au capătul stânga în interiorul intervalului curent.

În cazul nostru vom selecta intervalele 4, 5 și 2.

=== Numărul maxim de intervale disjuncte ===

Problemă: dată o submulţime de ''N'' intervale <code>[ai, bi]</code> să se găsească o submulţime maximală a acestei mulţimi care conţine doar intervale disjuncte (neintersectante).

Această problemă este totuna cu numărul minim de puncte ce ''înțeapă'' toate intervalele (de ce?).

''' Idei de soluţie '''

Această problemă apare destul de des la olimpiade, deghizată într-o formă sau alta. Deşi pare o problemă grea, în realitate ea se rezolvă uşor. O primă idee ar fi să încercăm să ordonăm intervalele după punctul de început, apoi să le luăm în ordine, unul câte unul. Pentru fiecare interval ne întrebăm dacă îl intersectează pe cel anterior. Dacă da, îl aruncăm şi mergem mai departe. Dacă nu, îl adăugăm la submulţime şi îl reţinem ca interval ultim. Această soluţie nu funcţionează şi e destul de evident de ce: am putea avea un prim interval foarte lung, care acoperă toate celelalte intervale.

Cu toate acestea rezolvarea nu e total greşită. În fapt, ea aproape funcţionează! Are nevoie doar de o modificare ce se impune, analizînd contraexemplul anterior: de ce nu este bun acel prim interval foarte lung? Deoarece el se termină după celelalte. Şi atunci ne putem întreba, în mod natural, ce s-ar întâmpla dacă am alege intervalul care se închide primul, nu care începe primul? Desigur că acest algoritm funcţionează. Vă las vouă să vă luptaţi cu demonstraţia, care decurge cam aşa: să presupunem că soluţia generată de acest algoritm nu e optimă. Înseamnă că există o altă soluţie cu mai multe intervale. Acea soluţie trebuie să difere undeva faţă de cea găsită de noi. Mergeţi pe această cale şi trebuie să ajungeţi la o contradicţie cum că soluţia optimă nu poate avea mai multe segmente.

[[File:Intervale-pe-dreapta-1.svg.png|thumb]]

Exemplu: fie intervalele

<pre>
1: [3 8]
2: [9 18]
3: [1 5]
4: [0 8]
5: [2 10]
</pre>

Atunci vom selecta, în ordine, intervalele 3 și 2.

==== Soluţie ====

Care este algoritmul, în mare?

''
# Iniţial mulţimea M este vidă.
# Ordonează crescător intervalele după punctul de închidere.
# Consideră ultima închidere (care nu există încă) cu valoarea minus infinit.
# Pentru fiecare interval, în ordine:
## Dacă el conţine ultima închidere
### Ignoră-l.
## Altfel
### Selectează intervalul curent şi adaugă-l la mulţimea M.
### Setează ultima închidere pe închiderea intervalului selectat
# Afişează mulţimea M.
''

Ce se întâmplă dacă avem mai multe intervale care se termină în acelaşi punct? Atunci putem reţine intervalul cel mai mic. De ce? Deoarece este cel mai convenabil. Să presupunem că soluţia maximală conţinea un alt interval care se termina în acel punct. Atunci putem înlocui acel interval cu intervalul cel mai mic, obţinînd o altă soluţie maximală.

==== Considerente de implementare ====

Implementarea directă: memorăm intervalele ca perechi, prin capetele lor. Sortăm perechile după capătul din dreapta. Apoi facem o parcurgere a perechilor. Această implementare necesită ''O(N log N)'' timp și ''O(N)'' memorie.

Implementare relaxată: atunci când coordonatele sunt suficient de mici astfel încât să putem folosi un vector care să memoreze un întreg pentru fiecare coordonată, putem încerca o abordare mai simplă: nu memorăm intervalele. Ci, pentru fiecare interval <source lang="C" enclose="none">[ai, bi]</source>, vom seta <source lang="C" enclose="none">început[bi] = ai</source>. Cu alte cuvinte vom memora capetele stânga la poziția capetelor dreapta. Apoi parcurgem vectorul în ordine, acoperind segmentul de coordonate care acoperă toate intervalele, testând dacă elementul de la poziția curentă în vector este mai mic decât ultima închidere memorată. Dacă nu, atunci selectăm intervalul și mutăm ultima închidere la poziția curentă în vector. Trebuie să avem grijă la următoarele:

* Să iniţializăm vectorul de coordonate cu o valoare distinctă de capete de interval. Matematic am putea să le iniţializăm cu minus infinit, astfel încât să nu fie selectate niciodată.
* Atunci când ''aşezăm'' intervalele pe vector să avem grijă ca dacă găsim deja o valoare în vector să o înlocuim numai dacă cea curentă este mai mare (intervalul este mai mic).

Această soluţie necesită ''O(N + CMAX)'' timp şi memorie, '''CMAX''' fiind coordonata maximă. De aici rezultă când o putem folosi: atunci când '''CMAX''' este suficient de mic.

==== Generalizare ====

Putem generaliza această problemă: să se calculeze mulţimea maximală de dreptunghiuri neintersectante. Sau de paralelipipede. Sau de paralelipipede n-dimensionale. Cum se rezolvă aceste probleme? Din nefericire aceste probleme fac parte dintr-o clasă de probleme numite ''NP-hard'', pentru care nu se cunoaşte o soluţie bună.

=== Exemplu când greedy nu funcționează: prolema rucsacului ===

Problema rucsacului cere să ''umplem'' cât mai bine un rucsac care poate duce o greutate maximă, dispunând de obiecte de diverse greutăți.

Exemplu: Vreau să umplu cât mai bine un rucsac de 100 și am greutăți 50, 30, 25 și 25.

Prin metoda greedy vom alege greutățile cele mai mari, în ordine: 50 și 30, după care nu mai putem adăuga nimic. Astfel vom obține greutatea totală 80. Dacă am alege însă greutățile 50, 25 și 25 am putea umple complet rucsacul.

De remarcat totuși că chiar și atunci când metoda greedy nu calculează optimul, un algoritm greedy bine gândit va da o soluție bună, aproape de optim.

== Tema 16 ==

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

* [https://www.nerdarena.ro/problema/politic Politic] dată la ONI 2007 clasa a 7-a
* [https://www.nerdarena.ro/problema/sumax SumaX] dată la Shumen Juniori 2015
* [https://www.nerdarena.ro/problema/acoperire Acoperire]
* [https://www.nerdarena.ro/problema/char Char] dată la ONI 2010 clasa a 7-a

Pentru doritorii să încerce și soluția problemei numărul minim de numărul minim de puncte ce ''înțeapă'' toate intervalele puteți rezolva problema [https://www.nerdarena.ro/problema/baloane Baloane].

== Tema opțională ==

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

* [https://www.nerdarena.ro/problema/startrek Star Trek] dată la OJI 2016 clasa a 7-a

[http://solpedia.francu.com/wiki/index.php?title=Clasa_a_7-a_Lec%C8%9Bia_16:_Tehnica_Two_Pointers_(doi_pointeri),_tipul_de_date_struct_%C8%99i_metoda_Greedy Accesează rezolvarea temei 16]

Clasa a V-a lecția 29 - 1 mar 2018

2026-02-03T14:46:15Z

Cristian: /* Soluție fără vectori */

= Comentarii tema 28 =
# Topul pescarilor la jimjam: '''Ipate''' 16 surse, '''Nicola''' 13 surse, '''Togan''' 13 surse, '''Mocanu''' 12 surse, '''Aizic''' 10 surse, '''Benescu''' 10 surse, '''Dobre''' 10 surse, '''Chivu''' 9 surse, '''Petcu''' 9 surse, '''Asgari''' 8 surse, '''Iordache''' 7 surse, '''Grecu''' 6 surse, '''Cadîr''' 5 surse, '''Dumitrescu''' 5 surse, '''Rebengiuc''' 5 surse,
# Topul indentatorilor de cartier: '''Cadîr''' în categoria: 'indentăm artistic, după suflet'. '''Cojocaru''', în categoria 'o sursă da, una ba'.
# Topul copiatorilor: '''Asgari''', '''Petcu''' și '''Voicu''' cîștigă competiția de surse copiate la varena, reușind să copieze nici mai mult nici mai puțin decît de la... de la Cristian Frâncu! Motto-ul lor este ''copiem doar de la cei mai buni!'' Pe locul doi se află '''Tatomir''', cu motto-ul ''tata este cel mai tare!''
# Mulți dintre voi au simțit nevoia să folosească tipul <code>long long</code> la problema jimjam. Nu era necesar. De aceea nu este bine să învățați materia în avans, veți folosi greșit acele cunoștințe.
# Unii din voi au folosit vectori la numere10. Nu erau necesari.
# Problema numere10 cere să se calculeze numărul de divizori ai unui număr. Este o problemă care se rezolvă eficient testînd divizorii doar pînă la radical din n. Am mai discutat acest lucru cu alte ocazii. Există și rezolvarea bazată pe descompunerea în factori primi pe care o vom discuta.

= Tema - rezolvări =

Rezolvări aici [http://solpedia.francu.com/wiki/index.php/Clasa_a_V-a_lec%C8%9Bia_28_-_22_feb_2018]

= Sfaturi pentru olimpiadă =
Iată cîteva sugestii pentru olimpiadă.
== 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, al telefonului 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.
* '''Cereți-vă drepturile''': dacă vă opresc mai devreme decît e cazul, sau dacă ați pierdut zece minute din cauza unui calculator care nu a funcționat și nu vi se dau, cereți respectuos să vi se extindă timpul cu acele minute. Supraveghetorii pot uneori să uite, olimpiada este stresantă și pentru ei. Dacă nu înțelegeți textul unei probleme, după ce l-ați citit cu mare atenție, puneți întrebări pentru clarificare (formulate astfel încît răspunsul să fie 'DA' sau 'NU').
* '''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. Sînteț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 sînt 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, 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.

=== 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 tot, 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ă ați terminat problemele și vă plictisiți creați mai multe teste pe care să le testați. 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 î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ă.
* '''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 în numai cîteva luni. Grija voastră trebuie să fie rezolvarea problemelor, nu noi. Noi sîntem de partea voastră. Chiar dacă la cerc sau la clasă, cînd sîntem î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 pentru noi, sîntem 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 5a, 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. Bătaia este interzisă cu excepţia cazului cînd sînteţ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 olimpiadă''': olimpiada este ca legitima apărare. Ca şi cînd sînteţ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ă sînt 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.

= Lecţie =

Deoarece lecția a fost foarte lungă și bateria camerei video s-a descărcat discuția soluțiilor la problema interval2 nu apare pe film.

<html5media height="720" width="1280">https://www.algopedia.ro/video/2017-2018/2018-03-01-lectie-info-29-720p.mp4</html5media>

== Vectori preinițializați ==
Să presupunem că vrem să rezolvăm următoarea problemă:

=== Aprinse ===
Dispunem de un calculator de buzunar care afișează cifrele în mod clasic, folosind 7 fante luminoase aprinse sau stinse. Astfel, cele zece cifre zecimale se reprezintă astfel:

[[file:cifre-lcd.jpg|frame|none|Cifre afișaj electronic]]

Se cere ca, dat un număr de maximum 18 cifre la intrare să se afișeze numărul de fante aprinse necesare pentru a afișa acel număr pe ecranul calculatorului de buzunar.

'''Exemple''': numărul 254 are 14 segmente aprinse (5 + 5 + 4), iar numărul 2083 are 23 de segmente (5 + 6 + 7 + 5).

Pentru a rezolva această problemă vom afla pe rînd cifrele numărului, și pentru fiecare cifră în parte vom afla numărul său de segmente, pe care îl vom aduna la o sumă globală (variabilă acumulator). Întrebarea este 'cum calculăm numărul de segmente al unei cifre date'?

=== Soluție fără vectori ===
Putem rezolva această problemă fără a folosi vectori. Pentru fiecare cifră vom avea nouă teste <code>if</code> pentru a decide ce număr adunăm:

<source lang="C">s = 0;
while ( n > 0 ) {
cf = n % 10;
n /= 10;
if ( cf == 0 )
s += 6;
else if ( cf == 1 )
s += 2;
else if ( cf == 2 )
s += 5;
...
else if ( cf == 8 )
s += 7;
else
s += 6;
}
printf( "%d", s)</source>

Putem scurta puțin această soluție grupînd cifrele după numărul lor de segmente:

<syntaxhighlight>s = 0;
while ( n > 0 ) {
cf = n % 10;
n /= 10;
if ( cf == 0 || cf == 6 || cf == 9 )
s += 6;
else if ( cf == 1 )
s += 2;
else if ( cf == 2 || cf == 3 || cf == 5 )
s += 5;
else if ( cf == 4 )
s += 4;
else if ( cf == 7 )
s += 3;
else
s += 7;
}
printf( "%d", s)</syntaxhighlight>

Există o soluție mai bună?

=== Soluție cu vector ===
Desigur, folosind vectori. Am putea să păstrăm pentru fiecare cifră numărul ei de segmente. Vom păstra aceste numere într-un vector <code>nrseg[10]</code>, pe care îl vom inițializa la începutul programului. În acest fel putem afla ușor cîte segmente are o cifră: dacă cifra este <code>cf</code>, atunci numărul său de segmente este <code>nrseg[cf]</code>.

Iată un program posibil:

<syntaxhighlight>int nrseg[10];
...
nrseg[0] = 6;
nrseg[1] = 2;
nrseg[2] = 5;
nrseg[3] = 5;
nrseg[4] = 4;
nrseg[5] = 5;
nrseg[6] = 6;
nrseg[7] = 3;
nrseg[8] = 7;
nrseg[9] = 6;

s = 0;
while ( n > 0 ) {
cf = n % 10;
n /= 10;
s += nrseg[cf];
}
printf( "%d", s)</syntaxhighlight>

Precum observați, programul nu este cu mult mai scurt. Dar de data aceasta mare parte din program este inițializarea vectorului <code>nrseg[10]</code>, instrucțiunile de atribuire. Calculul în sine ocupă doar șase linii, corpul instrucțiuni <code>while</code> este mult mai mic față de soluțiile anterioare.

=== Soluție cu vector preinițializat ===
Pentru astfel de situații, atunci cînd ne dorim să inițializăm un întreg vector cu multiple valori, limbajul C ne ajută să scriem ceva mai puțin. Putem atribui toate cele zece valori într-o singură linie! Această atribuire se face în aceeași linie în care declarăm vectorul. Astfel, în exemplul nostru, vom atribui cele zece valori astfel:

<syntaxhighlight>int nrseg[10] = { 6, 2, 5, 5, 4, 5, 6, 3, 7, 6 };</syntaxhighlight>

Acest tip de declarație poartă denumirea de '''vector preinițializat'''. Astfel, programul nostru devine:

<syntaxhighlight>int nrseg[10] = { 6, 2, 5, 5, 4, 5, 6, 3, 7, 6 };
...
s = 0;
while ( n > 0 ) {
cf = n % 10;
n /= 10;
s += nrseg[cf];
}
printf( "%d", s)</syntaxhighlight>

Unele probleme se rezolvă ceva mai ușor folosind astfel de vectori. Acesta este și cazul problemei [http://varena.ro/problema/speciale speciale] pe care o aveți la temă.

== Problemele date la Info Oltenia clasele 5-6 ==

=== Problema brățara ===
Problema [http://varena.ro/problema/bratara brățara] a fost dată la [http://www.cnfb.ro/infooltenia2018/ Info Oltenia 2018], clasele 5-6.

<syntaxhighlight>#include <stdio.h>

int poz[100]; // poz[i] = pozitia margelei care incepe cu i

int main() {
FILE *fin, *fout;
int n, c, i, nrb, ucf, cap, lmax, start, p, u;

fin = fopen( "bratara.in", "r" );
fscanf( fin, "%d%d", &c, &n );
nrb = 0; // numarul de bratari ce nu pot fi extinse (punctul 1)
ucf = 100; // ultimele doua cifre ale margelei anterioare
cap = 0; // pozitia capului (inceputlui) bratarii curente
lmax = 1; // lungimea bratarii circulare maxime, initial ceva imposibil
start = 0; // pozitia de start a bratarii circulare maxime
for ( i = 1; i <= n; i++ ) {
fscanf( fin, "%d", &p );
u = p % 100; // ultimele doua cifre
while ( p >= 100 ) // calculam primele doua cifre
p /= 10;

if ( p != ucf ) { // nu se potriveste cu margeaua din-nainte?
if ( i - cap > 1 ) // bratara s-a incheiat, are macar doua margele?
nrb++; // numaram inca o bratara ce nu poate fi extinsa (punctul 1)
cap = i; // retinem noul inceput pentru bratara care tocmai incepe (cap)
}
if ( poz[p] < cap ) // daca e prima margea care incepe cu p in noua bratara
poz[p] = i; // retinem pozitia ei, i

if ( poz[u] >= cap ) { // daca avem o margea din urma care incepe cu u
// am gasit o bratara circulara, testam daca e mai mare decit ce avem deja
if ( i - poz[u] + 1 > lmax ) { // lungimea e mai mare decit maximul?
lmax = i - poz[u] + 1; // retinem lungimea
start = poz[u]; // si pozitia ei de inceput
}
}

ucf = u;
}
// testam ultima bratara - caz special la punctul 1
if ( cap < n - 1 ) // daca avem cel putin doua margele in ultima bratara
nrb++;
fclose( fin );

fout = fopen( "bratara.out", "w" );
if ( c == 1 )
fprintf( fout, "%d\n", nrb );
else if ( lmax == 1 ) // nu am gasit nici o bratara circulara
fprintf( fout, "-1\n" );
else
fprintf( fout, "%d %d %d\n", lmax, start, start + lmax - 1 );
fclose( fout );

return 0;
}</syntaxhighlight>

=== Problema interval2 ===
Problema [http://varena.ro/problema/interval2 interval2] a fost dată la [http://www.cnfb.ro/infooltenia2018/ Info Oltenia 2018], clasele 5-6.

==== Soluția comisiei ====
<syntaxhighlight>#include <stdio.h>

int main() {
FILE *fin, *fout;
int q, T, i, a, b;
long long A, r, p, u;

fin = fopen( "interval2.in", "r" );
fout = fopen( "interval2.out", "w" );
fscanf( fin, "%d%d%d", &a, &b, &q );
for ( i = 0; i < q; i++ ) {
fscanf( fin, "%d%lld", &T, &A );
if ( T == 1 ) // cite numere divizibile cu A in intervalul [a, b]
r = b / A - (a - 1) / A;
else if ( T == 2 ) { // cite perechi de numere div. cu A in interv. [a, b]
r = b / A - (a - 1) / A;
r = r * (r - 1) / 2;
} else { // cite perechi de numere in [a, b] cu produsul > A
r = 0;
p = (A + b) / b; // p e cel mai mic nr. p cu care putem forma o pereche
if ( p < a ) // il ajustam sa faca parte din interval
p = a;
for ( ; p < b; p++ ) {
u = (A + p) / p; // cautam cel mai mic u a.i. p * u > A
if ( u <= p )
u = p + 1;
r += b - u + 1; // formam perechi (p u), (p u+1) ... (p b)
}
}
fprintf( fout, "%lld\n", r );
}

fclose( fin );
fclose( fout );

return 0;
}</syntaxhighlight>

==== Soluție îmbunătățită ====
<syntaxhighlight>#include <stdio.h>

int main() {
FILE *fin, *fout;
int q, T, i, a, b;
long long A, r, p, u;

fin = fopen( "interval2.in", "r" );
fout = fopen( "interval2.out", "w" );
fscanf( fin, "%d%d%d", &a, &b, &q );
for ( i = 0; i < q; i++ ) {
fscanf( fin, "%d%lld", &T, &A );
if ( T == 1 ) // cite numere divizibile cu A in intervalul [a, b]
r = b / A - (a - 1) / A;
else if ( T == 2 ) { // cite perechi de numere div. cu A in interv. [a, b]
r = b / A - (a - 1) / A;
r = r * (r - 1) / 2;
} else { // cite perechi de numere in [a, b] cu produsul > A
r = 0;
p = (A + b) / b; // cautam cel mai mic p a.i. p * b > A
if ( p < a ) // daca este in afara intervalului, il ajustam
p = a;
if ( p < b ) {
u = b;
while ( p < u ) { // cita vreme nu sint consecutive
r += u - p; // formam perechi (p u), (p+1 u) ... (u-1 u)
u--;
if ( p * u <= A ) // trebuie sa marim p?
p++;
}
}
}
fprintf( fout, "%lld\n", r );
}

fclose( fin );
fclose( fout );

return 0;
}</syntaxhighlight>

==== Soluție optimizată ====
<syntaxhighlight>#include <stdio.h>
#include <math.h>

int main() {
FILE *fin, *fout;
int q, T, i, a, b;
long long A, r, p, u;

fin = fopen( "interval2.in", "r" );
fout = fopen( "interval2.out", "w" );
fscanf( fin, "%d%d%d", &a, &b, &q );
for ( i = 0; i < q; i++ ) {
fscanf( fin, "%d%lld", &T, &A );
if ( T == 1 ) // cite numere divizibile cu A in intervalul [a, b]
r = b / A - (a - 1) / A;
else if ( T == 2 ) { // cite perechi de numere div. cu A in interv. [a, b]
r = b / A - (a - 1) / A;
r = r * (r - 1) / 2;
} else { // cite perechi de numere in [a, b] cu produsul > A
p = sqrtl( A ); // cautam cel mai mic p a.i. p * (p + 1) > A
if ( p * (p + 1) <= A ) // p este cumva prea mic?
p++;
if ( p <= a ) { // toate perechile sint OK
r = b - a + 1; // numarul de numere in [a, b]
r = r * (r - 1) / 2; // numarul de perechi din [a, b]
} else if ( p >= b ) // nici o pereche nu este OK
r = 0;
else { // p este in intervalul (a, b) deschis la ambele capete
// putem forma toate perechile din [p+1, p+2, ..., b]
r = (b - p - 1) * (b - p) / 2;
u = p + 1;
while ( p >= a && u <= b ) {
r += b - u + 1; // formam perechi (p u) (p u+1) ... (p b)
p--;
u++;
while ( p * u <= A && u <= b ) // marim u atit cit e nevoie
u++;
}
}
}
fprintf( fout, "%lld\n", r );
}

fclose( fin );
fclose( fout );

return 0;
}</syntaxhighlight>

= Temă =
[http://varena.ro/runda/2018-03-01-clasa-5-tema-29 Tema 29]: să se rezolve următoarele probleme (program C trimis la vianuarena):
* [http://varena.ro/problema/speciale speciale] dată la OJI 2015 clasa a 5a
* [http://varena.ro/problema/cuart cuarț] dată la OJI 2015 clasa a 5a

Rezolvări aici [http://solpedia.francu.com/wiki/index.php/Clasa_a_V-a_lec%C8%9Bia_29_-_1_mar_2018]

= Succes la olimpiadă! =
Mult succes la olimpiadă! Nu uitaţi că sînteţi cei mai buni şi că ne sînteţi dragi indiferent de rezultatul de duminică.