Lecție-punte: indicii în matrice

De ce contează?

Pe o tablă de șah, fiecare pătrat are o adresă: rândul și coloana. Dacă încurci ordinea — spui „coloana 3, rândul a" în loc de invers — ajungi în alt loc. Toate erorile clasice la matrice vin din indici: ordinea lor, marginile și vecinii. Lecția asta le pune cap la cap.

Regula de aur: `[linie][coloană]`

Primul indice e mereu linia, al doilea coloana. a[i][j] = linia i, coloana j. Pare banal, dar inversarea a[j][i] e cea mai frecventă eroare — mai ales la matrice nepătratice, unde provoacă și acces în afara matricei.

Observația-cheie

La o matrice m×n (m linii, n coloane), o declari a[m][n] și folosești i în [0, m), j în [0, n). Dacă m ≠ n, a inversa indicii nu doar mută elementul — te scoate din matrice.

Marginile: unde lucrurile se sparg

Erorile apar la colțuri și margini, unde unele direcții ies din grilă. Înainte de a accesa o poziție, verific-o:

bool inMatrice(int i, int j, int m, int n) {
    return i >= 0 && i < m && j >= 0 && j < n;
}

Folosit la vecini, te protejează de accesul în afara matricei:

if (inMatrice(ni, nj, m, n)) {
    // sigur sa folosesti a[ni][nj]
}

Vecinii: vectori de direcție

Ca să nu scrii patru (sau opt) cazuri separate, folosești doi vectori de direcție:

int di[] = {-1, 1, 0, 0};       // sus, jos, stanga, dreapta
int dj[] = {0, 0, -1, 1};
for (int k = 0; k < 4; k++) {
    int ni = i + di[k], nj = j + dj[k];
    if (inMatrice(ni, nj, m, n)) {
        // proceseaza vecinul (ni, nj)
    }
}

Observația-cheie

di[k] și dj[k] trebuie să descrie aceeași direcție pe același index k. Pentru 8 vecini (cu diagonale), extinzi ambii vectori la 8 valori aliniate. E tiparul standard pentru parcurgeri, simulări și algoritmi pe grilă (Lee, fill).

„Aplatizarea": de la 2D la 1D

Uneori e util să tratezi o matrice ca un vector lung. Celula (i, j) devine indicele i * n + j, iar invers: i = idx / n, j = idx % n. Folositor la memorarea stărilor sau la structuri care vor un singur index.

Recapitulare: erorile vin din indici

Simptom	Cauza de indici
acces în afara matricei	`i <= m` / `j <= n` sau vecin neverificat
element greșit	`a[j][i]` în loc de `a[i][j]`
diagonală greșită	`a[i][n-i]` în loc de `a[i][n-1-i]`
stare „contaminată" la simulare	modificare pe loc, fără matrice auxiliară

Greșeli frecvente

Capcane reale legate de indicii în matrice:

Inversezi linia cu coloana: a[j][i] — element greșit, plus ieșire din matrice la m ≠ n.
Nu verifici marginile la vecini: accesezi a[-1][j] sau a[m][j] → memorie din afară.
Vectori de direcție dezaliniați: di și dj descriu direcții diferite pe același k → sari aiurea pe grilă.
Off-by-one la dimensiuni: confunzi m cu n sau folosești <= în condiții. Liniile merg [0, m), coloanele [0, n).

De reținut

a[i][j] = linia i, coloana j — niciodată invers; la m≠n, inversarea iese din matrice.
Verifică marginile (0 ≤ i < m, 0 ≤ j < n) înainte de orice acces la vecini.
Vecinii prin vectori de direcție aliniați di/dj; aplatizare (i,j) → i*n+j.

Regula de aur: [linie][coloană]