Prelucrări în matrice

Prelucrarea unei matrice înseamnă aplicarea unei operații tuturor elementelor sau unei regiuni definite: o linie, o coloană, o diagonală ori elementele care satisfac o condiție. Alegerea indicilor din bucle trebuie să corespundă exact regiunii. Pentru liniile $[1,2,3]$ și $[4,5,6]$, suma celei de-a doua coloane este $2+5=7$.

Prelucrarea unei matrice înseamnă aplicarea unei operații tuturor elementelor sau unei regiuni definite: o linie, o coloană, o diagonală, o zonă triunghiulară sau elementele care respectă o condiție. Alegerea limitelor și a ciclurilor trebuie să corespundă exact regiunii: pentru o linie $i$ se folosește un singur ciclu după $j$, pentru toate liniile unul exterior după $i$, iar acumulatorul unei linii se reinițializează la începutul fiecărei linii. Pentru vecinătăți, indicii vecinilor sunt $(i-1,j)$, $(i+1,j)$, $(i,j-1)$ și $(i,j+1)$ în vecinătatea cu patru direcții; la marginea matricei, unii dintre ei ies din matrice și trebuie verificați înainte de acces.

Exemplul 1 — suma fiecărei linii.

int a[2][3] = {{1, 2, 3}, {4, 5, 6}};
for (int i = 0; i < 2; ++i) {
    int suma = 0;
    for (int j = 0; j < 3; ++j)
        suma += a[i][j];
    cout << suma << " ";
}

Pentru prima linie suma ia valorile 1, 3, 6; pentru a doua 4, 9, 15. Se afișează 6 15. Variabila suma este resetată la 0 la începutul fiecărei linii. Dacă ar fi inițializată doar înaintea buclei exterioare, valorile afișate ar fi 6 21, pentru că a doua sumă ar include și linia întâi.

Exemplul 2 — vecinii unei celule. În matricea cu liniile $(1,2,3)$, $(4,5,6)$, $(7,8,9)$ celula interioară $(1,1)$, cu valoarea 5, are patru vecini: sus 2, jos 8, stânga 4, dreapta 6. Suma lor este $2+8+4+6=20$. Celula $(0,0)$, din colț, are doar doi vecini în matrice, $(1,0)$ și $(0,1)$, adică 4 și 2, cu suma 6; ceilalți doi, $(-1,0)$ și $(0,-1)$, ar ieși din matrice. Pentru un caz general, fiecare vecin se adună numai dacă $0\le i^{\prime }<n$ și $0\le j^{\prime }<m$.

Exemplul 3 — transpunerea unei matrice pătratice. Transpusa înlocuiește elementul $a_{ij}$ cu $a_{ji}$. Pentru o matrice pătratică, ea se obține schimbând între ele perechile de elemente simetrice față de diagonala principală. Se parcurg numai pozițiile de deasupra diagonalei, cu $j>i$, pentru ca fiecare pereche să fie schimbată o singură dată.

for (int i = 0; i < 3; ++i)
    for (int j = i + 1; j < 3; ++j) {
        int aux = a[i][j];
        a[i][j] = a[j][i];
        a[j][i] = aux;
    }

Matricea cu liniile $(1,2,3)$, $(4,5,6)$, $(7,8,9)$ devine $(1,4,7)$, $(2,5,8)$, $(3,6,9)$. Dacă ciclul interior ar parcurge toate coloanele, fiecare pereche ar fi schimbată de două ori și matricea ar rămâne neschimbată. Pentru o matrice dreptunghiulară cu $n$ linii și $m$ coloane transpusa are $m$ linii și $n$ coloane, deci nu se poate face pe loc; rezultatul se scrie într-o a doua matrice, b[j][i] = a[i][j]. Pentru liniile $(1,2,3)$ și $(4,5,6)$, transpusa are trei linii: $(1,4)$, $(2,5)$ și $(3,6)$.

Exemplul 4 — maximul pe fiecare linie. Pentru matricea cu liniile $(3,9,2)$ și $(7,1,8)$ se caută maximul fiecărei linii.

int a[2][3] = {{3, 9, 2}, {7, 1, 8}};
for (int i = 0; i < 2; ++i) {
    int mx = a[i][0];
    for (int j = 1; j < 3; ++j)
        if (a[i][j] > mx)
            mx = a[i][j];
    cout << mx << " ";
}

Pe prima linie mx pornește de la 3, devine 9 la $j=1$ și rămâne 9 după $j=2$; pe a doua pornește de la 7, rămâne 7 la $j=1$ și devine 8 la $j=2$. Se afișează 9 8. Pentru linia $(-5,-2,-9)$, o inițializare cu 0 ar da greșit 0; inițializarea cu primul element al liniei dă corect $-2$.

La un program care schimbă elemente, urmărește matricea după fiecare atribuire. Transpunerea schimbă liniile cu coloanele; pentru o matrice pătratică se poate face prin schimburi numai deasupra diagonalei principale, astfel încât fiecare pereche să fie tratată o dată. Pentru una dreptunghiulară, dimensiunile rezultatului se inversează. Pentru vecinătăți, înainte de acces testează limitele (în matricea $3\times 3$ a exemplului, celula centrală este singura cu patru vecini): pentru celula $(0,0)$ vecinii cu indici negativi nu există. Verifică și locul în care se resetează acumulatorii: o sumă pe linii cere resetare la fiecare linie, iar o sumă totală nu.

Exemplu în formatul examenului. Ce se afișează în urma executării secvenței de mai jos?

int a[2][3] = {{1, 2, 3}, {4, 5, 6}};
int s = 0;
for (int i = 0; i < 2; ++i) {
    for (int j = 0; j < 3; ++j)
        s += a[i][j];
    cout << s << ' ';
}

• a) 6 15
• b) 6 21
• c) 21 21
• d) 1 4

Răspunsul corect este b). Variabila s este declarată o singură dată, înaintea ciclurilor, și nu este resetată la trecerea la linia următoare. După prima linie $s=1+2+3=6$ și se afișează 6; pe a doua linie se continuă de la 6: $6+4+5+6=21$, deci se afișează 21. Varianta a) ar fi corectă dacă s = 0 ar fi scris în ciclul exterior, înaintea ciclului interior.

Poți verifica numărarea vecinilor pe matricea $3\times 3$: celula centrală are 4 vecini, cele 4 celule de pe laturi au câte 3, iar cele 4 colțuri au câte 2. Suma este $4+4\cdot 3+4\cdot 2=24$, adică de două ori numărul perechilor de celule vecine, 12.

Greșeli frecvente

• Greșit: acumulatorul unei sume pe linii se inițializează o singură dată, înaintea ambelor cicluri.
  Corect: se reinițializează la începutul fiecărei linii.
• Greșit: transpunerea unei matrice pătratice se face parcurgând toate perechile $(i,j)$ cu schimb.
  Corect: se parcurge doar jumătatea de deasupra diagonalei, altfel schimburile se anulează.
• Greșit: celulele de la margine au tot patru vecini în matrice.
  Corect: vecinii care ies din matrice trebuie omiși.

Înainte și după