CS Open CourseWare

Cursuri CC

mihaela.balint — 2026-04-14T12:17:01+03:00

@@ -50,6 +50,9 @@
    * {{ :pp:26:cursuri:mihaela:curs10.rkt |Schelet Racket}}
    * {{ :pp:26:cursuri:mihaela:curs10-solved.rkt |Schelet Racket rezolvat}}
    * {{ :pp:26:cursuri:mihaela:utils.rkt |Fișier cu macro-uri}}
    * [[https://notebooklm.google.com/notebook/68ee0a07-d1d8-4d71-bc25-bb1bf03dbc5c|Notebook Curs 10]]
+ 
+   * {{ :pp:26:cursuri:mihaela:curs11.rkt |Schelet Racket - exerciții curs 11}}
+   * {{ :pp:26:cursuri:mihaela:curs11-solved.rkt |Schelet Racket rezolvat}}

pp:26:cursuri:mihaela:curs11-solved.rkt - created

mihaela.balint — 2026-04-14T12:16:05+03:00

pp:26:cursuri:mihaela:curs11.rkt - created

mihaela.balint — 2026-04-14T12:16:05+03:00

Laborator 06: Parcurgerea grafurilor. Aplicații (1/2)

radu.nichita — 2026-04-14T01:57:39+03:00

@@ -3,9 +3,8 @@
  ===== Obiective laborator =====
  
    * Înțelegerea conceptele de graf, reprezentare și parcugere
    * Studierea unor aplicații pentru parcurgeri
- 
  
  ===== Importanţă – aplicaţii practice =====
  
  Grafurile sunt utile pentru a modela diverse probleme și au numeroase aplicații practice:
@@ -15,14 +14,13 @@
    * Rețele sociale (ex. sugestii de prietenie pe Facebook)
    * Hărți cu drumuri (ex. drum minim între două localități)
    * Modelare grafică (ex. arbori de parționare)
    * Rețele de transport (ex. flux)
- 
  
  ===== Grafuri =====
  Puteți consulta capitolul "Elementary Graph Algorithms" din "Introduction to Algorithms" [0] pentru mai multe definiții formale. Această secțiune sumarizează principalele notații folosite în laboratoarele de PA.
  
-  ==== Definiții ====
+ ==== Definiții ====
  
  >> Un **graf** G se definește ca fiind o pereche (V, E), unde **V = {node / un nod oarecare din graf}**, iar **E = {(x, y) / (x, y) muchie in graf}**.
  
  >> Un graf este **neorientat** dacă relațiile dintre noduri sunt **bidirecționale**: oricare ar fi $(x, y)$ în $E$, există și $(y, x)$ în $E$. Relațiile se numesc **muchii**.
@@ -31,8 +29,9 @@
  
  >> O **componentă conexă (CC)** este o submulțime maximală de noduri, cu proprietatea că oricare ar fi două noduri x și y din aceasta, există drum de la x la y. Pentru grafuri orientate, o componentă conexă se numește ** componentă tare conexă (CTC)**.
  
  >> Un graf **aciclic** este un graf (orientat/neorientat) care nu conține cicluri.
+ 
  ==== Reprezentare ====
  Problemele care se modelează folosind grafuri, de obicei, presupun explorarea spațiului. O parcurgere explorează fiecare nod al grafului, exact o singură dată, pornind de la un nod ales, numit în continuare nod sursă (EN: **source**). Modul de reprezentare al grafului poate influența performanța unei parcurgeri/unui algoritm.
  
  Un graf poate fi modelat în mai multe moduri (folosind mai multe notații):
@@ -50,15 +49,12 @@
      * printr-o pereche de mulțimi $G = (nodes, adj)$
        * $nodes$ = {node / node este un nod în graf} 
        * $adj$   = {$adj[node]$ / unde $adj[node]$ este lista de adiacență a lui node} = reprezentarea grafului ca liste de adiacențe
          * $adj[node] = {..., neigh, ...}$ => există muchie/arc (node, neigh)
- 
- 
  
  Reprezentarea în memorie a grafurilor se face, de obicei, cu **liste de adiacență**. Se pot folosi însă și alte structuri de date, care vor fi introduse pe parcurs.
  
  Cele mai uzuale notații din laboratoarele de grafuri sunt descrise în [[https://ocw.cs.pub.ro/courses/pa/skel_graph | Precizări laboratoare 06-11]] (ex. $n$, $m$, $adj$, $adj\_trans$, $(x, y)$, etc).
- 
  
  ==== Colorare ====
  Algoritmii de parcugere se pot folosi de o colorare a nodurilor:
  
@@ -66,9 +62,8 @@
  
      * **gray** (gri)  = nod care este în curs de vizitare (a fost adăugat în coadă)
  
      * **black** (negru) = nod care a fost complet vizitat (node scos din coadă și pentru care s-a vizitat tot subarborele)
- 
  
  ==== Algoritmi de parcurgere ====
  Problemă: Să se parcurgă un graf dat. Fiecare nod se parcuge (exact) o singură dată.
  Algoritmi:
@@ -79,18 +74,15 @@
  
  ===== BFS - Parcurgerea în lățime =====
  
  Parcurgerea în lățime **(Breadth-first Search - BFS)** este un algoritm de căutare în graf, în care, atunci când se ajunge într-un nod oarecare **node**, nevizitat, se vizitează toate nodurile nevizitate adiacente lui (notate pe rand cu **neigh**), apoi toate vârfurile nevizitate adiacente vârfurilor adiacente lui node, etc.
- 
  
  Atenție! BFS depinde de nodul de start **source**. Plecând din acest nod, se vor vizita toate nodurile accesibile. De exemplu, într-un graf neorientat, aceste noduri accesibile formează o componentă conexă; în urma aplicării algoritmului BFS asupra fiecărei componente conexe a grafului, se obține un arbore de acoperire a întregului graf (prin eliminarea muchiilor pe care nu le folosim la parcurgere). Pentru a putea reconstitui acest arbore, se păstrează pentru fiecare nod dat identitatea părintelui său. În cazul în care nu exista o funcție de cost asociată muchiilor, BFS va determina și drumurile minime de la rădăcină la oricare nod.
- 
  
  Pentru implementarea BFS se folosește o coadă. 
- 
  
  ==== Algoritm ====
- <code cpp| BFS>
+ <code cpp>
  // do a BFS traversal from source
  //
  // source    = the source for the BFS traversal
  // nodes     = list of all nodes from G
@@ -138,18 +130,17 @@
          
         // [optional] color[node] = black;
      }
  }
- 
  </code>
  
  <note>
  Liniile cu **[optional]** se referă la logica de colorare menționată anterior, care se poate omite (dacă nu se dorește acest rezultat).
  </note>
  
  ==== Complexitate ==== 
-   *cu liste de adiacență: $O(n + m)$ sau $O(|V| + |E|)$
-   *cu matrice de adiacență: $O(n^2)$ sau  $ O(|V|^2)$
+   * cu liste de adiacență: $O(n + m)$ sau $O(|V| + |E|)$
+   * cu matrice de adiacență: $O(n^2)$ sau  $O(|V|^2)$
  
  ===== DFS - Parcurgerea în adâncime =====
  
  Parcurgerea în adâncime **(Depth-First Search - DFS)** pornește de la un nod dat (**node**), care este marcat ca fiind în curs de procesare. Se alege primul vecin nevizitat al acestui nod (**neigh**), se marchează și acesta ca fiind în curs de procesare, apoi și pentru acest vecin se caută primul vecin nevizitat, și așa mai departe. În momentul în care nodul curent nu mai are vecini nevizitati, se marchează că fiind deja procesat și se revine la nodul anterior. Pentru acest nod se caută primul vecin nevizitat. Algoritmul se repetă până când toate nodurile grafului au fost procesate.
@@ -159,15 +150,13 @@
  Pentru fiecare nod se vor reține: 
    * $start[node]$ = timestamp-ul / timpul descoperirii
    * $finish[node]$ = timestamp-ul / timpul finalizării
    * $p[node]$ = părintele din parcugerea DFS a lui node
-  
  
  Spre deosebire de BFS, pentru implementarea DFS se folosește o stivă (abordare **LIFO** în loc de **FIFO**). În practică, stiva nu va fi reținută explicit - ci ne vom baza pe recursivitate.
- 
  
  ====  Algoritm ====
- <code cpp | DFS>
+ <code cpp>
  // do a DFS traversal from all nodes
  //
  // nodes     = list of all nodes from G
  // adj[node] = the adjacency list of node
@@ -216,12 +205,10 @@
  Liniile cu **[optional]** se referă la logica de colorare menționată anterior, care se poate omite (dacă nu se dorește acest rezultat).
  </note>
  
  ==== Complexitate ====
-   *cu liste de adiacență: $O(n + m)$ sau $O(|V| + |E|)$
-   *cu matrice de adiacență: $O(n^2)$ sau  $ O(|V|^2)$
- 
- 
+   * cu liste de adiacență: $O(n + m)$ sau $O(|V| + |E|)$
+   * cu matrice de adiacență: $O(n^2)$ sau  $O(|V|^2)$
  
  ==== Tipuri de muchii/arce în parcurgerea DFS ====
  >> **Arborele de parcurgere DFS** cuprinde toate nodurile din graf împreună cu muchiile/arcele pe vizitate de DFS. Dacă graful nu este conex / tare conex, se obțin mai mulți arbori care formează o **pădure de arbori DFS**.
  <note>
@@ -238,9 +225,9 @@
  
  >> **back-edge** (**B**) / muchie înapoi = muchie **(x, y)** care conectează un nod x de un strămoș y (ambele noduri sunt în curs de vizitare). 
  
  Pentru **graf orientat**, mai există încă 2 tipuri de muchii (arce):
- >> **forward-edge** (**F**) / muchie înainte /muchie de înaintare = muchie **(x, y**) care nu este **tree-edge**  și care conecteză un nod **x** de un descendent **y** . 
+ >> **forward-edge** (**F**) / muchie înainte /muchie de înaintare = muchie **(x, y)** care nu este **tree-edge** și care conecteză un nod **x** de un descendent **y** . 
  
  <note>
  În graful neorientat aceasta nu are sens. Într-un graf neorientat, **(x, y)** și **(y, x)** reprezintă același lucru. Dacă x ar fi strămoș a lui y (x nu este părintele lui y, căci altfel **(x, y)** ar fi **tree-edge**), mai întâi se va încerca din y să se ajungă în x (moment în care spunem că muchia **(y, x)** este **back-edge**), ulterior la revenirea din recursivitate se va încerca din x să se ajungă în y (moment în care ar trebui să spunem că muchia **(x, y)** este **forward-edge**). Deoarece există o singură muchie **(x, y)** sau **(y, x)**, nu putem pune 2 categorii, așa că rămâne prima categorie găsită: **back-edge**.
  
@@ -278,9 +265,9 @@
  ==== Problemă ====
  
  >> O **sortare topologică** într-un **graf orientat aciclic** reprezintă o aranjare/permutare a nodurilor din graf care ține cont de arce.
  
- Orientarea muchiilor corespunde unei relatii de ordine de la nodul sursa catre cel destinație: dacă $(x,y$) este un arc, $x$ trebuie să apară înaintea lui $y$ în inșiruire. 
+ Orientarea muchiilor corespunde unei relatii de ordine de la nodul sursa catre cel destinație: dacă $(x,y)$ este un arc, $x$ trebuie să apară înaintea lui $y$ în inșiruire. 
  
  <note>
  Daca graful ar fi ciclic, nu ar putea exista o astfel de insiruire (nu se poate stabili o ordine intre nodurile care alcatuiesc un ciclu). 
  </note>
@@ -290,9 +277,8 @@
  
  În figura anterioară avem un graf cu:
      * $n = 5$   $m = 4$ 
      * $arce: { (1,2); (1,3); (2,3); (2,4);} $
- 
  
  Toate sortările topologice valide sunt:
    * cele date de ordinea relativa a primelor 4 noduri: (1,2,3,4)
      * $topsort = [1, 2, 3, 4, 5] $
@@ -311,8 +297,9 @@
    * deoarece avem arcele $1 \rightarrow 3$ si $1 \rightarrow 2$, 1 trebuie să apara înainte lui 2 și 3
    * deoarece avem arcul $2 \rightarrow 3$ si $2 \rightarrow 4$, 2 trebuie să apara înainte lui 3 și 4
    * 5 nu depinde de nimeni, poate să apară oriunde
  </spoiler>
+ 
  ==== Algoritmi ====
  Sunt doi algoritmi cunoscuti pentru sortarea topologică.
  
  === TopSort - DFS: sortare descrescătoare după timpul de finalizare ===
@@ -325,9 +312,9 @@
  
  **Optimizare**: Pentru a evita sortarea nodurilor in functie de timpul de finalizare, se poate folosi o stiva ce retine aceste noduri in ordinea terminarii parcurgerii (sau un vector care la final este inversat).
  
  == Complexitate ==
-     * $T(n) = O(n+ m)$
+     * $T(n) = O(n + m)$
  
  === TopSort - BFS: algoritmul lui Kahn ===
  <note>
  Algoritm TopSort cu BFS:
@@ -343,15 +330,15 @@
  
  **Optimizare**: Pentru a evita ștergerea propriu-zisă a muchiilor din graf, se poate modifica gradul intern al fiecărui nod (care poate fi reținut într-un vector $in\_degree[node]$).
  
  == Complexitate ==
-     * $T(n) = O(n+ m)$
- 
+     * $T(n) = O(n + m)$
  
  ==== Concluzie ====
  Ambele variante au aceeasi complexitate. 
      * Algoritmul bazat pe DFS nu verifica daca graful este ciclic: presupune corectitudinea inputului. Este relativ mai simplu de implementat.
      * Algoritmul bazat pe BFS se poate folosi pentru a detecta daca graful este aciclic; in caz afirmativ, gaseste o sortare topologica valida. 
+ 
  ===== TLDR =====
  
      * Cele mai uzuale moduri de reprezentare a unui graf sunt: liste de adiacentă și matrice de adiacentă.
  
@@ -359,9 +346,8 @@
  
      * O aplicație importantă a parcurgerilor este **Sortarea topologică** -  o modalitate de aranjare a nodurilor în funcție de muchiile dintre ele. În functie de nodul de start al DFS, se pot obține sortări diferite, păstrând însă proprietatile generale ale sortarii topologice.
  
  ===== Exerciții =====
- 
  
  <note warning>
  Înainte de a rezolva exercițiile, asigurați-vă ca ați citit și înțeles toate precizările din secțiunea
  [[https://ocw.cs.pub.ro/courses/pa/skel_graph | Precizări laboratoare 06-11]].
@@ -369,9 +355,8 @@
  Prin citirea acestor precizari vă asigurați ca:
     * cunoasteți **convențiile** folosite
     * evitați **buguri**
     * evitați **depunctări** la lab/teme/test
- 
  </note>
  
  <note>
  Scheletul de laborator se găsește pe pagina [[https://github.com/acs-pa/pa-lab/tree/main/skel/lab06|pa-lab::skel/lab06]].
@@ -380,18 +365,77 @@
  <note warning>
  Începând cu acest laborator, fiecare problemă are restricții concrete: dimensiuni pentru input și timp maxim de execuție. Pentru a vedea dacă o soluție (idee) intră în timp înainte de a o implementa, va trebui să îi calculați complexitatea și să aproximați timpul de execuție folosind tutorialul [[https://github.com/acs-pa/pa-lab/tree/main/docs/complexity.md|pa-lab::docs/Complexity]].
  </note>
  
+ ====== Pool probleme (pentru prezentări) ======
  
+ ======= 1) Berării 2 =======
  
- === Task-1: BFS ===
+ **Enunț:** Se dă un graf orientat reprezentând o rețea de străzi și intersecții ale unui oraș, precum și locațiile în care se află berării. Se cere găsirea tuturor intersecțiilor din care **nu** se poate ajunge la nicio berărie, indiferent de traseul ales, respectând sensul unic al străzilor.
+ 
+ **Date de intrare:** Numărul de intersecții ''N'', numărul de străzi ''M'', numărul de berării ''P'', urmate de ''M'' perechi de noduri (reprezentând străzile orientate) și de ''P'' numere reprezentând intersecțiile unde se află berării.
+ 
+ **Date de ieșire:** Numărul de intersecții din care nu se poate ajunge la o berărie, urmat de lista acestor intersecții, afișate în ordine crescătoare.
+ 
+ Problema se poate testa la: \\
+ [[https://infoarena.ro/problema/berarii2|Infoarena - Berării 2]]
+ 
+ ======= 2) Alee =======
+ 
+ **Enunț:** O parcare este formată din ''N × N'' pătrate de latură 1. Anumite pătrate sunt ocupate de copaci și nu pot fi traversate. Se cere determinarea numărului minim de pași necesari pentru a ajunge de la un pătrat de start la un pătrat de destinație, ocolind copacii. Se pot face pași doar pe orizontală și verticală (Nord, Sud, Est, Vest).
+ 
+ **Date de intrare:** Dimensiunea parcării ''N'', numărul de copaci ''M'', urmate de coordonatele celor ''M'' copaci și, la final, coordonatele punctului de plecare și cele ale punctului de sosire.
+ 
+ **Date de ieșire:** Un singur număr reprezentând distanța minimă (numărul de pași) între cele două poziții.
+ 
+ Problema se poate testa la: \\
+ [[https://infoarena.ro/problema/alee|Infoarena - Alee]]
+ 
+ ======= 3) Muzeu =======
+ 
+ **Enunț:** Un muzeu este reprezentat printr-o matrice de ''N × N'' zone. În muzeu există spații libere, pereți (obstacole) și mai mulți paznici. Trebuie să determinați, pentru fiecare zonă liberă, distanța minimă până la cel mai apropiat paznic, folosind doar deplasări sus/jos/stânga/dreapta.
+ 
+ **Date de intrare:** Un număr întreg ''N'' reprezentând dimensiunea muzeului, urmat de o matrice de ''N × N'' caractere, unde ''P'' este paznic, ''#'' este perete, iar ''.'' este zonă liberă.
+ 
+ **Date de ieșire:** O matrice ''N × N'' de numere întregi. Celulele conțin 0 dacă acolo este un paznic, -1 dacă este un perete, -2 dacă este o zonă în care nu poate ajunge niciun paznic, respectiv distanța minimă pentru zonele libere accesibile.
+ 
+ Problema se poate testa la: \\
+ [[https://infoarena.ro/problema/muzeu|Infoarena - Muzeu]]
+ 
+ ======= 4) Course Schedule =======
+ 
+ **Enunț:** Se dau ''N'' cursuri (numerotate de la 1 la ''N'') și ''M'' cerințe. Fiecare cerință are forma: "cursul ''A'' trebuie finalizat înainte de a putea începe cursul ''B''". Se cere găsirea unei ordini valide în care un student ar putea să finalizeze toate cele ''N'' cursuri respectând aceste condiții.
+ 
+ **Date de intrare:** Numărul de cursuri ''N'' și numărul de cerințe ''M'', urmate de ''M'' perechi de numere ''(A, B)'' reprezentând dependențele.
+ 
+ **Date de ieșire:** O permutare a celor ''N'' cursuri care respectă cerințele date. Dacă este imposibil să se finalizeze toate cursurile, se va afișa textul "IMPOSSIBLE".
+ 
+ Problema se poate testa la: \\
+ [[https://cses.fi/problemset/task/1679|CSES - Course Schedule]]
+ 
+ ======= 5) Insule =======
+ 
+ **Enunț:** O hartă este descrisă de o matrice cu ''N'' linii și ''M'' coloane. Elementele hărții pot fi 0 (apă) sau 1, 2, 3 (insule aparținând a trei țări diferite). Se cere aflarea numărului de insule din fiecare țară, precum și lungimea minimă a unui pod (format exclusiv din celule cu apă) care să unească o insulă a țării 1 de o insulă a țării 2.
+ 
+ **Date de intrare:** Dimensiunile hărții ''N'' și ''M'', urmate de matricea de caractere formata din ''0'', ''1'', ''2'' și ''3''.
+ 
+ **Date de ieșire:** Patru numere: numărul de insule din grupa 1, grupa 2, grupa 3 și lungimea podului minim construit peste apă.
+ 
+ Problema se poate testa la: \\
+ [[https://infoarena.ro/problema/insule|Infoarena - Insule]]
+ 
+ ===== Extra =====
+ 
+ ==== Exerciții ====
+ 
+ <spoiler BFS>
  Se dă un graf **neorientat** cu **n** noduri și **m** muchii. Se mai dă un nod special **source**, pe care îl vom numi sursa. 
  
  Se cere să se găsească **numărul minim de muchii** ce trebuie parcurse de la **source** la **toate ** celelalte noduri. 
  
  <note warning>
  Restricții și precizări:
-   * $ n, m <= 10^5 $
+   * $n, m <= 10^5$
    * timp de execuție
      * C++: 1s
      * Java: 1s
  </note>
@@ -404,13 +448,13 @@
    * ** d[source] = 0 **
    * ** d[node] = -1**, dacă nu se poate ajunge de la **source** la **node**
  </note>
  
- <spoiler Exemplu 1>
+ **Exemplu 1:**
+ 
  $n = 5$   $m = 4$  $source = 3$ 
  
  $muchii: { (1,2); (1,3); (2,3); (2,4);} $
- 
  
  Răspuns:
  |node|1|2|3|4|5|
  |d|1|1|0|2|-1|
@@ -423,12 +467,11 @@
    * ** d[3] = 0 ** pentru că 1 este sursa
    * ** d[1] = d[2] = 1 ** pentru că există muchie directă de la 2 la fiecare nod
    * ** d[4] = 2 ** pentru că trebuie să parcurgem 2 muchii ($3-2-4$)
    * ** d[5] = -1 ** pentru că nu se poate ajunge de la 3 la 5
- </spoiler>
  
+ **Exemplu 2:**
  
- <spoiler Exemplu 2>
  $n = 7$   $m = 7$  $source = 1$ 
  
  $muchii: { (1,2); (1,4); (2,3); (4,5); (5,6); (3,7); (7,6) } $
  
@@ -444,12 +487,11 @@
    * ** d[1] = 0 ** pentru că 1 este sursa
    * ** d[2] = d[4] = 1 ** pentru că există muchie directă de la 2 la fiecare nod
    * ** d[3] = d[5] = 2 ** pentru că trebuie să parcurgem 2 muchii ($1-2-3$, $1-4-5$)
    * ** d[6] = d[7] = 3 ** pentru ca trebuie să parcurgem 3 muchii ($1-2-3-7$ sau $1-4-5-6$)
- </spoiler>
  
+ **Exemplu 3:**
  
- <spoiler Exemplu 3>
  $n = 7$   $m = 8$  $source = 1$ 
  
  $muchii: { (1,2); (1,4); (2,3); (4,5); (5,6); (3,7); (7,6); (1, 6) } $
  
@@ -466,15 +508,14 @@
    * ** d[2] = d[4] = d[6] = 1 ** pentru că există muchie directă de la 2 la fiecare nod
    * ** d[3] = d[5] = d[7] = 2 ** pentru că trebuie să parcurgem 2 muchii ($1-2-3$, $1-4-5$, $1-6-7$)
  </spoiler>
  
- 
- === Task-2: Topological Sort ===
+ <spoiler Topological Sort>
  Se dă un graf **orientat** aciclic cu **n** noduri și **m** arce. Se cere să se găsească **o sortare topologica** validă.
  
  <note warning>
  Restricții si precizari:
-   * $ n, m <= 10^5 $
+   * $n, m <= 10^5$
    * timp de executie
      * C++: 1s
      * Java: 1s
  </note>
@@ -484,13 +525,13 @@
  
  Vectorul **topsort** va reprezenta o permutare a multimii ${1, 2, 3,..., n}$ reprezentand sortarea topologica gasita.
  </note>
  
- <spoiler Exemplu 1>
+ **Exemplu 1:**
+ 
  $n = 5$   $m = 4$ 
  
  $arce: { (1,2); (1,3); (2,3); (2,4);} $
- 
  
  Răspuns: $topsort = [1, 2, 3, 4, 5] $
  
  Explicație: 
@@ -514,12 +555,10 @@
      * $topsort = [1, 2, 5, 4, 3] $
      * $topsort = [1, 5, 2, 4, 3] $
      * $topsort = [5, 1, 2, 4, 3] $
  
- </spoiler>
- 
+ **Exemplu 2:**
  
- <spoiler Exemplu 2>
  $n = 9$   $m = 8$ 
  
  $arce: { 
  (1,2);
@@ -530,9 +569,8 @@
  (4,6);
  (4,7);
  (4,8);
  } $
- 
  
  Răspuns: $topsort = [1, 2, 3, 4, 6, 7, 8, 5, 9] $
  
  Explicație: 
@@ -542,107 +580,55 @@
  
  Se observă din desen că soluția menționată este validă.
  </spoiler>
  
- 
- === Task-3: Max Packet Size ===
+ <spoiler Max Packet Size>
  Rezolvați problema [[ https://www.hackerrank.com/contests/test-practic-pa-2018-v1-deadbeef/challenges/test-1-2-2-max-packet-size-medie/problem | Max Packet Size ]] pe Hackerrank.
- 
- === Task-4: Berării 2===
- Rezolvați problema [[https://infoarena.ro/problema/berarii2 | Berării 2 ]] pe Infoarena. 
- 
- === BONUS ===
- **B1** Determinați componentele conexe ale unui graf neorientat. Puteți testa implementarea pe infoarena la problema [[https://infoarena.ro/problema/dfs| dfs]].
- 
- **B2** Rezolvați problema [[https://infoarena.ro/problema/muzeu| muzeu]] pe infoarena.
- 
- === Extra ===
- 
- <spoiler arbore3>
- Rezolvați problema [[https://infoarena.ro/problema/arbore3
- | arbore3]] pe infoarena. 
  </spoiler>
  
- <spoiler Pokemon GO AWAY>
- Rezolvați problema [[https://www.hackerrank.com/contests/test-practic-pa-2017-v2-meeseeks/challenges/test-2-pokemon-go-away-grea| Pokemon GO AWAY]] de la test PA 2017.
+ <spoiler Labyrinth (CSES)>
+ **Enunț:** Se dă o hartă a unui labirint sub forma unei matrice. Se cere să se găsească un drum de lungime minimă de la o celulă de start 'A' la o celulă de destinație 'B'. Afișați lungimea drumului minim și o secvență de mutări (L, R, U, D) care descrie pașii.
  
- Cu ce problemă seamana?
+ Problema se poate testa la: \\
+ [[https://cses.fi/problemset/task/1193 | CSES - Labyrinth]]
  </spoiler>
  
- <spoiler insule>
- Rezolvați problema [[https://infoarena.ro/problema/insule
- | insule]] pe infoarena.
- </spoiler>
+ <spoiler Building Roads (CSES)>
+ **Enunț:** Se dă o rețea de ''N'' orașe și ''M'' drumuri bidirecționale existente. Se cere determinarea numărului minim de drumuri noi ce trebuie construite astfel încât să se poată ajunge din orice oraș în oricare altul din rețea. 
  
- <spoiler tsunami>
- Rezolvați problema [[https://infoarena.ro/problema/tsunami
- | tsunami]] pe infoarena.
- </spoiler>
+ **Hint:** Problema se reduce la aflarea numărului de componente conexe.
  
- 
- <spoiler berarii2>
- Rezolvați problema [[https://infoarena.ro/problema/berarii2
- | berarii2]] pe infoarena.
+ Problema se poate testa la: \\
+ [[https://cses.fi/problemset/task/1666 | CSES - Building Roads]]
  </spoiler>
  
- 
- ====== Pool probleme (pentru prezentări) ======
- 
- ======= 1) Berării 2 =======
- 
- **Enunț:** Se dă un graf orientat reprezentând o rețea de străzi și intersecții ale unui oraș, precum și locațiile în care se află berării. Se cere găsirea tuturor intersecțiilor din care **nu** se poate ajunge la nicio berărie, indiferent de traseul ales, respectând sensul unic al străzilor.
- 
- **Date de intrare:** Numărul de intersecții ''N'', numărul de străzi ''M'', numărul de berării ''P'', urmate de ''M'' perechi de noduri (reprezentând străzile orientate) și de ''P'' numere reprezentând intersecțiile unde se află berării.
- 
- **Date de ieșire:** Numărul de intersecții din care nu se poate ajunge la o berărie, urmat de lista acestor intersecții, afișate în ordine crescătoare.
+ <spoiler Componente Conexe>
+ **Enunț:** Se dă un graf neorientat cu ''N'' noduri și ''M'' muchii. Se cere să se determine numărul de componente conexe din graf. O componentă conexă este un subgraf maximal în care există drum între oricare două noduri.
  
  Problema se poate testa la: \\
- [[https://infoarena.ro/problema/berarii2|Infoarena - Berării 2]]
+ [[https://infoarena.ro/problema/dfs | Infoarena - DFS]]
+ </spoiler>
  
- ======= 2) Alee =======
- 
- **Enunț:** O parcare este formată din ''N × N'' pătrate de latură 1. Anumite pătrate sunt ocupate de copaci și nu pot fi traversate. Se cere determinarea numărului minim de pași necesari pentru a ajunge de la un pătrat de start la un pătrat de destinație, ocolind copacii. Se pot face pași doar pe orizontală și verticală (Nord, Sud, Est, Vest).
- 
- **Date de intrare:** Dimensiunea parcării ''N'', numărul de copaci ''M'', urmate de coordonatele celor ''M'' copaci și, la final, coordonatele punctului de plecare și cele ale punctului de sosire.
- 
- **Date de ieșire:** Un singur număr reprezentând distanța minimă (numărul de pași) între cele două poziții.
+ <spoiler Sortare Topologică>
+ **Enunț:** Se dă un graf orientat aciclic (DAG) cu ''N'' noduri și ''M'' arce. Să se determine o sortare topologică a nodurilor sale. Aranjamentul trebuie să garanteze că pentru orice arc de la ''X'' la ''Y'', nodul ''X'' apare înaintea nodului ''Y'' în secvența finală. 
  
  Problema se poate testa la: \\
- [[https://infoarena.ro/problema/alee|Infoarena - Alee]]
+ [[https://infoarena.ro/problema/sortaret | Infoarena - Sortare Topologică]]
+ </spoiler>
  
- ======= 3) Muzeu =======
+ <spoiler Arbore3>
+ Rezolvați problema [[https://infoarena.ro/problema/arbore3 | arbore3]] pe Infoarena.
+ </spoiler>
  
- **Enunț:** Un muzeu este reprezentat printr-o matrice de ''N × N'' zone. În muzeu există spații libere, pereți (obstacole) și mai mulți paznici. Trebuie să determinați, pentru fiecare zonă liberă, distanța minimă până la cel mai apropiat paznic, folosind doar deplasări sus/jos/stânga/dreapta.
+ <spoiler Pokemon GO AWAY>
+ Rezolvați problema [[https://www.hackerrank.com/contests/test-practic-pa-2017-v2-meeseeks/challenges/test-2-pokemon-go-away-grea | Pokemon GO AWAY]] de la Testul Practic PA 2017.
  
- **Date de intrare:** Un număr întreg ''N'' reprezentând dimensiunea muzeului, urmat de o matrice de ''N × N'' caractere, unde ''P'' este paznic, ''#'' este perete, iar ''.'' este zonă liberă.
- 
- **Date de ieșire:** O matrice ''N × N'' de numere întregi. Celulele conțin 0 dacă acolo este un paznic, -1 dacă este un perete, -2 dacă este o zonă în care nu poate ajunge niciun paznic, respectiv distanța minimă pentru zonele libere accesibile.
- 
- Problema se poate testa la: \\
- [[https://infoarena.ro/problema/muzeu|Infoarena - Muzeu]]
- 
- ======= 4) Course Schedule =======
- 
- **Enunț:** Se dau ''N'' cursuri (numerotate de la 1 la ''N'') și ''M'' cerințe. Fiecare cerință are forma: "cursul ''A'' trebuie finalizat înainte de a putea începe cursul ''B''". Se cere găsirea unei ordini valide în care un student ar putea să finalizeze toate cele ''N'' cursuri respectând aceste condiții.
- 
- **Date de intrare:** Numărul de cursuri ''N'' și numărul de cerințe ''M'', urmate de ''M'' perechi de numere ''(A, B)'' reprezentând dependențele.
- 
- **Date de ieșire:** O permutare a celor ''N'' cursuri care respectă cerințele date. Dacă este imposibil să se finalizeze toate cursurile, se va afișa textul "IMPOSSIBLE".
- 
- Problema se poate testa la: \\
- [[https://cses.fi/problemset/task/1679|CSES - Course Schedule]]
- 
- ======= 5) Insule =======
- 
- **Enunț:** O hartă este descrisă de o matrice cu ''N'' linii și ''M'' coloane. Elementele hărții pot fi 0 (apă) sau 1, 2, 3 (insule aparținând a trei țări diferite). Se cere aflarea numărului de insule din fiecare țară, precum și lungimea minimă a unui pod (format exclusiv din celule cu apă) care să unească o insulă a țării 1 de o insulă a țării 2.
- 
- **Date de intrare:** Dimensiunile hărții ''N'' și ''M'', urmate de matricea de caractere formata din ''0'', ''1'', ''2'' și ''3''.
- 
- **Date de ieșire:** Patru numere: numărul de insule din grupa 1, grupa 2, grupa 3 și lungimea podului minim construit peste apă.
- 
- Problema se poate testa la: \\
- [[https://infoarena.ro/problema/insule|Infoarena - Insule]]
+ **Hint:** Cu ce problemă seamănă?
+ </spoiler>
  
+ <spoiler Tsunami>
+ Rezolvați problema [[https://infoarena.ro/problema/tsunami | tsunami]] pe Infoarena.
+ </spoiler>
  
  ===== Referințe =====
  
  [0] Chapter **Elementary Graph Algorithms**, “Introduction to Algorithms”, Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest and Clifford Stein
@@ -651,5 +637,4 @@
  
  [2] [[https://en.wikipedia.org/wiki/Depth-first_search]]
  
  [3] [[https://en.wikipedia.org/wiki/Topological_sorting]]
-

Proiect - InkTime - [Upload:]

dan.tudose — 2026-04-13T11:01:03+03:00

@@ -22,8 +22,9 @@
  <code>
    - Hardware
    |-- fișierul schematic (.sch)
    |-- fișierul cu board-ul (.brd)
+   |-- print-out al fișierului schematic (.pdf)
    - Manufacturing
    |-- gerbers.zip
    |-- fișierul Bill of Materials (.bom)
    |-- fișierul Pick and Place (.cpl)

Laboratorul 1 - Introducere în clusterul HPC al UPB - [Comenzi uzuale SLURM]

tudor.calafeteanu — 2026-04-10T17:27:47+03:00

@@ -396,9 +396,8 @@
  sbatch --partition=ucsx hello_cuda.sh            # override partiție din linia de comandă
  srun --partition=ucsx --gres=gpu:1 ./hello_cuda  # rulare interactivă simplă
  srun --partition=ucsx --gres=gpu:1 --pty bash    # sesiune interactivă pe nodul de calcul
  srun --partition=haswell -w haswell-wnxx --pty bash # rulare interactivă simplă pe un anumit nod (xx se inlocuieste cu un numar anume de sistem) de pe partitia haswell
- 
  
  # === Informații despre cluster ===
  sinfo                                              # afișare simplă a partițiilor
  sinfo -o "%20P %6a %8D %8c %10m %20G %10l %8t %N"  # format detaliat

Tema 1 - [Tema 1]

emil.slusanschi — 2026-04-09T17:44:10+03:00

@@ -1,9 +1,9 @@
  ====== Tema 1 ======
  
  <note important>
    * **Deadline soft:** ** 26 Aprilie 2026, ora 23:55**. 
-   * Primiți un bonus de 10% din punctajul obținut pentru trimiterea temei înainte de ** 21 Aprilie 2026, ora 23:55**. Veți primi o depunctare de 10% din punctajul maxim al temei pentru fiecare zi de întârziere, până la maxim 7 zile, adică până pe ** 3 Mai 2026, ora 23:55**.
+   * Primiți un bonus de 10% din punctajul obținut pentru trimiterea temei înainte de ** 24 Aprilie 2026, ora 23:55**. Veți primi o depunctare de 10% din punctajul maxim al temei pentru fiecare zi de întârziere, până la maxim 7 zile, adică până pe ** 3 Mai 2026, ora 23:55**.
    * **Deadline hard:** **3 Mai 2026, ora 23:55**.
    * **Responsabili:** [[vladspoiala@gmail.com |Vlad Spoiala]], [[emil.slusanschi@cs.pub.ro|Emil Slusanschi]], [[serban.ionescu0609@stud.acs.upb.ro | Serban Ionescu]], [[adumitrescu2708@stud.acs.upb.ro | Alexandra Dumitrescu]].
  </note>

Lecture 06 - Comparing Systems

emilian.radoi — 2026-04-08T20:00:24+03:00

@@ -1,5 +1,4 @@
  ====== Lecture 06 - Comparing Systems ======
  
- <hidden>
  [[https://docs.google.com/presentation/d/e/2PACX-1vTdxm4Be1Bmi9z02e4sRiq2O1zXma5i18LjdpC8Z0QX7KOPVpt9G2r5oITCYUWOLI0YEcAYVURiLSoW/pub?start=false&loop=false&delayms=3000|EP/L6 - Comparing Systems]]
- </hidden>
+

Cursuri CB

andrei.olaru — 2026-04-08T18:28:48+03:00

@@ -15,4 +15,7 @@
      * {{:pp:26:cursuri:andrei:pp-04-racket-legare.rkt|Legare în Racket}}
    * {{:pp:26:cursuri:andrei:pp-05-racket-lazy.pdf|Curs 5: Programare leneșă în Racket}}
      * cod discutat la curs: {{:pp:26:cursuri:andrei:pp-05-racket-prod.rkt|prod}}, {{:pp:26:cursuri:andrei:pp-05-racket-stream.rkt|stream}}, {{:pp:26:cursuri:andrei:pp-05-racket-eval-console.txt|consolă}}
      * {{:pp:26:cursuri:andrei:pp-06-racket-streams-2.rkt|cod discutat în 2.04}} și pe marginea {{:pp:26:cursuri:andrei:pp-06-exemple-intrebari.rkt|întrebărilor despre legare}}
+   * Curs 6: eficiență în Racket
+     * {{:pp:26:cursuri:andrei:pp-07-racket-effciency.rkt|memoizare}}
+     * {{:pp:26:cursuri:andrei:pp-07-racket-folds.rkt|fold}}

pp:26:cursuri:andrei:pp-07-racket-folds.rkt - created

andrei.olaru — 2026-04-08T18:28:31+03:00

pp:26:cursuri:andrei:pp-07-racket-effciency.rkt - created

andrei.olaru — 2026-04-08T18:28:31+03:00

Planificare laboratoare

alexandru.predescu — 2026-04-08T15:02:31+03:00

@@ -10,9 +10,9 @@
  |  7   |   30 Mar-3 Apr  | Laboratorul 5: Serial Peripheral Interface (SPI), Stabilire temă proiect   |
  |  8   |   6-10 Aprilie  | Laboratorul 6: Protocolul I2C                                              |
  |  9   |   20-24 Aprilie  | <color red>Test Laborator (practic)</color>                               |
  |  10  |   27 Apr-01 Mai  | Proiect: Confirmare finală temă proiect + learn to solder      | 
- |  11  |   4-8 Mai  | Milestone proiect - documentație, Colocviu laborator (la ora de curs)          | 
+ |  11  |   4-8 Mai  | Milestone proiect - documentație         | 
  |  12  |   11-15 Mai  | Milestone - hardware                                                           |                    
  |  13  |   18-22 Mai  | Milestone - software                                                           |
  |  14  |   25-29 Mai  | Hol EC - PM Fair (prezentarea finală pentru TOATE proiectele)         |

Laboratorul 06. Generare de NPCs, Items și Simulare de Lume - [Generarea procedurală de NPCs]

maria_anca.balutoiu — 2026-04-08T09:07:06+03:00

@@ -9,9 +9,9 @@
  În general, clasele de NPC nu sunt echiprobabile (de exemplu, războinicii sunt mai comuni decât magicienii legendari). Distribuția ponderată permite controlul frecvenței fiecărei clase.
   
  
  === Atribute derivate din clasă ===
- Fiecare clasă definește **intervale de bază** pentru atributele NPC-urilor. Randomizarea se aplică în interiorul acestor intervale, nu global — un Mage va fi mereu mai slab fizic decât un Warrior, indiferent de roll. Exemplu:
+ Fiecare clasă definește **intervale de bază** pentru atributele NPC-urilor. Randomizarea se aplică în interiorul acestor intervale, nu global; un Mage va fi mereu mai slab fizic decât un Warrior, indiferent de roll. Exemplu:
  
  ^ Class ^ HP ^ Damage ^ Armor ^
  | Warrior | 80–120 | 15–25 | 10–20 |
  | Mage | 40–65 | 30–50 | 2–5 |

Cursuri

maria_anca.balutoiu — 2026-04-08T09:00:49+03:00

@@ -6,10 +6,10 @@
    * [[:gp:laboratoare:02]]
    * [[:gp:laboratoare:03]]
    * [[:gp:laboratoare:04]]
    * [[:gp:laboratoare:05]]
- <hidden>
    * [[:gp:laboratoare:06]]
+ <hidden>
    * [[:gp:laboratoare:07]]
  </hidden>
  <hidden>
  {{indexmenu>:gp:laboratoare}}</hidden>

Laboratorul 06 - Arhitectura GPU NVIDIA CUDA - [Ierarhia de memorie]

alexandru.bala — 2026-04-08T07:25:05+03:00

@@ -73,9 +73,9 @@
  <code sh>
  __const__ float pi = 3.14f
  </code>
    * In functie de implementarea hardware, 100GB/sec -> 100TB/sec
-   * In general performanta foarte buna, (cache L1/L2, zona dedicata),
+   * In general performanta foarte buna, (cache L1/L2, zona dedicata)
    * Are durata de viata a aplicatiei kernel
  
  **Global Memory**
  <code sh>

pp:26:cursuri:mihaela:curs10-solved.rkt - created

mihaela.balint — 2026-04-06T22:58:18+03:00

pp:26:cursuri:mihaela:curs10.pdf - created

mihaela.balint — 2026-04-06T11:10:05+03:00

pp:26:cursuri:mihaela:utils.rkt - created

mihaela.balint — 2026-04-06T11:10:05+03:00

pp:26:cursuri:mihaela:curs10.rkt - created

mihaela.balint — 2026-04-06T11:10:05+03:00

pp:26:cursuri:andrei:pp-06-racket-streams-2.rkt - created

andrei.olaru — 2026-04-03T09:18:49+03:00