Pentru TOATE laboratoarele de grafuri, vom face convenția că nodurile sunt indexate de la 1 (1, 2, 3, …, n). Justificare: În unele probleme vom adăuga un nod fictiv 0 (și înca unul n + 1), de aceea este indicat să avem acest index nefolosit.

$n$ = număr de noduri

$m$ = număr de muchii/arce (în funcție de tipul grafului)

$adj[node]$ = lista de adiacență a nodului node

$adj\_trans[node]$ = lista de adiacență a nodului node în graful transpus

În general, când vorbim de muchii/arce, putem folosi următoarele notații:

- în grafuri fără costuri pe muchii:

• $(node, neigh)$: muchie/arc de la nodul node la neigh. Notație uzuală în parcurgeri, când vrem să evidențiem relația între noduri: în parcugere se trece din nodul curent (node) în vecin (neigh).
• $(x, y)$ - muchie/arc de la nodul x la y. Notație uzuală când cele 2 noduri nu au neapărat o semnificație anume (exemplu: o dinamică unde x și y sunt 2 noduri oarecare din graf). Notația se poate extinde intuitiv și pentru 3 noduri (adică la triplet) $(x, y, z)$.
• $(i, j)$ - muchie/arc de la nodul i la j. Notație uzuală când facem foruri pentru initițializări, iar x și y sunt rezervate. Se poate extinde intuitiv și la triplet $(i, j, k)$.

- în grafuri cu costuri pe muchii:

• putem nota costul cu c / w / c[x][y] / w[x][y]
• exemple:
  • (node, neigh, c): muchie/arc de la nodul node la neigh de cost c
  • w[x][y]: muchie/arc de la nodul x la w de cost w[x][y]

Orice tablou (vector/matrice/multidimensional etc) se va aloca folosind una din următoarele variante:

• pe heap : se poate folosi vector / ArrayList sau new . [C++] observație : adj[NMAX] este alocat tot pe heap, întrucât Task-ul este alocat pe heap (vezi în main)

Recomandăm varianta cu vector/ArrayList.

Precizări:

• Orice abatere de la aceste reguli va fi penalizată de checker, lucru asigurat prin testele mari (ultimele), care vor genera SEGFAULT dacă nu se respectă alocarea.
• La problemele bonus care NU au checker, asistentul va depuncta manual astfel de probleme grave. În principiu, este permisă orice formă de alocare care suportă dimensiunile indicate in enunț.

Exemplu de problemă gravă: [C++]: void f() { int v[n]; } (alocare de dimensiune variabila pe stiva), poate crăpa stiva! (n poate fi mare). Interzicem folosirea acestui tip de alocare la PA. Pentru acest exemplu, scheletul va genera și o eroare de compilare, pentru a vă atrage atenția că NU ar trebui să folosiți acest tip de alocare, dacă n poate să fie mare! (grafuri mari)

Observație: Precizările menționate sunt valabile doar pentru contextul PA, unde facem algoritmi eficienți și care dorim să meargă pe dimensiuni cât mai mari! Asta nu înseamnă că în alte contexte (ex. multi-threaded) nu se va putea folosi VLA (variable length array on stack).

Scopul acestui paragraf este să va atragă atenția asupra alocării corespunzătoare a datelor la PA , astfel încât să evitați erori de run time pe care să nu vi le puteți explica.