Mảng 2 chiều và ma trận: cách duyệt hàng, cột, đường chéo và mảng hướng dx, dy (C++, Python)

#include <iostream>
#include <vector>

using namespace std;

// Tính tổng từng hàng, từng cột, đường chéo chính và đường chéo phụ của ma trận vuông n x n
void thong_ke_ma_tran_vuong(const vector<vector<int>>& a) {
    int n = static_cast<int>(a.size());
    vector<int> tong_hang(n, 0), tong_cot(n, 0);
    int cheo_chinh = 0, cheo_phu = 0;

    // Duyệt hàng i trước, cột j sau (tối ưu bộ nhớ đệm CPU - row-major order)
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            tong_hang[i] += a[i][j];
            tong_cot[j] += a[i][j];
            if (i == j) {
                cheo_chinh += a[i][j];
            }
            if (i + j == n - 1) {
                cheo_phu += a[i][j];
            }
        }
    }

    for (int i = 0; i < n; ++i) {
        cout << tong_hang[i] << (i + 1 == n ? '\n' : ' ');
    }
    for (int j = 0; j < n; ++j) {
        cout << tong_cot[j] << (j + 1 == n ? '\n' : ' ');
    }
    cout << cheo_chinh << " " << cheo_phu << "\n";
}

int main() {
    vector<vector<int>> a = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    thong_ke_ma_tran_vuong(a);
    return 0;
}

def tao_ma_tran_dung(n: int, m: int) -> list[list[int]]:
    """Tạo ma trận n hàng, m cột độc lập (KHÔNG dùng [[0] * m] * n)."""
    return [[0] * m for _ in range(n)]


def thong_ke_ma_tran_vuong(a: list[list[int]]) -> tuple[list[int], list[int], int, int]:
    """Tính tổng từng hàng, từng cột, đường chéo chính và đường chéo phụ."""
    n = len(a)
    tong_hang = [0] * n
    tong_cot = [0] * n
    cheo_chinh = 0
    cheo_phu = 0

    for i in range(n):
        for j in range(n):
            tong_hang[i] += a[i][j]
            tong_cot[j] += a[i][j]
            if i == j:
                cheo_chinh += a[i][j]
            if i + j == n - 1:
                cheo_phu += a[i][j]

    return tong_hang, tong_cot, cheo_chinh, cheo_phu


if __name__ == "__main__":
    # Kiểm chứng khởi tạo đúng: sửa 1 ô không làm đổi các hàng khác
    mat = tao_ma_tran_dung(3, 3)
    mat[0][0] = 99
    assert mat[1][0] == 0 and mat[2][0] == 0

    a = [
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9],
    ]
    tong_hang, tong_cot, cheo_chinh, cheo_phu = thong_ke_ma_tran_vuong(a)
    print(*tong_hang)
    print(*tong_cot)
    print(cheo_chinh, cheo_phu)

#include <iostream>
#include <vector>

using namespace std;

// 4 hướng kề cạnh: Lên, Phải, Xuống, Trái
const int DX4[4] = {-1, 0, 1, 0};
const int DY4[4] = {0, 1, 0, -1};

// 8 hướng kề cạnh và kề góc
const int DX8[8] = {-1, -1, -1, 0, 0, 1, 1, 1};
const int DY8[8] = {-1, 0, 1, -1, 1, -1, 0, 1};

bool trong_luoi(int r, int c, int so_hang, int so_cot) {
    return r >= 0 && r < so_hang && c >= 0 && c < so_cot;
}

// 1. Tính tổng các ô kề cạnh (4 hướng) của ô (r, c)
int tong_4_ke(const vector<vector<int>>& g, int r, int c) {
    int so_hang = static_cast<int>(g.size());
    int so_cot = static_cast<int>(g[0].size());
    int tong = 0;
    for (int dir = 0; dir < 4; ++dir) {
        int nr = r + DX4[dir];
        int nc = c + DY4[dir];
        if (trong_luoi(nr, nc, so_hang, so_cot)) {
            tong += g[nr][nc];
        }
    }
    return tong;
}

// 2. Đếm số ô lớn hơn nghiêm ngặt tất cả các ô lân cận 8 hướng của nó
int dem_cuc_dai_8_huong(const vector<vector<int>>& g) {
    int so_hang = static_cast<int>(g.size());
    int so_cot = static_cast<int>(g[0].size());
    int dem = 0;
    for (int r = 0; r < so_hang; ++r) {
        for (int c = 0; c < so_cot; ++c) {
            bool cuc_dai = true;
            for (int dir = 0; dir < 8; ++dir) {
                int nr = r + DX8[dir];
                int nc = c + DY8[dir];
                if (trong_luoi(nr, nc, so_hang, so_cot) && g[nr][nc] >= g[r][c]) {
                    cuc_dai = false;
                    break;
                }
            }
            if (cuc_dai) ++dem;
        }
    }
    return dem;
}

int main() {
    vector<vector<int>> g = {
        {2, 5, 1, 4},
        {3, 8, 6, 2},
        {7, 4, 9, 5}
    };
    // Ô (1, 1) = 8 có 4 ô kề cạnh là 5, 6, 4, 3 -> tổng = 18
    // Ô góc (0, 0) = 2 có 2 ô kề cạnh là 5, 3 -> tổng = 8
    // Cực đại 8 hướng duy nhất là ô (2, 2) = 9 -> đếm = 1
    cout << tong_4_ke(g, 1, 1) << " " << tong_4_ke(g, 0, 0) << " " << dem_cuc_dai_8_huong(g) << "\n";
    return 0;
}

# 4 hướng kề cạnh: Lên, Phải, Xuống, Trái
DX4 = (-1, 0, 1, 0)
DY4 = (0, 1, 0, -1)

# 8 hướng kề cạnh và kề góc
DX8 = (-1, -1, -1, 0, 0, 1, 1, 1)
DY8 = (-1, 0, 1, -1, 1, -1, 0, 1)


def trong_luoi(r: int, c: int, so_hang: int, so_cot: int) -> bool:
    return 0 <= r < so_hang and 0 <= c < so_cot


def tong_4_ke(g: list[list[int]], r: int, c: int) -> int:
    """Tính tổng các ô kề cạnh (4 hướng) hợp lệ của ô (r, c)."""
    so_hang, so_cot = len(g), len(g[0])
    tong = 0
    for dx, dy in zip(DX4, DY4):
        nr, nc = r + dx, c + dy
        if trong_luoi(nr, nc, so_hang, so_cot):
            tong += g[nr][nc]
    return tong


def dem_cuc_dai_8_huong(g: list[list[int]]) -> int:
    """Đếm số ô lớn hơn nghiêm ngặt tất cả các ô lân cận 8 hướng của nó."""
    so_hang, so_cot = len(g), len(g[0])
    dem = 0
    for r in range(so_hang):
        for c in range(so_cot):
            cuc_dai = True
            for dx, dy in zip(DX8, DY8):
                nr, nc = r + dx, c + dy
                if trong_luoi(nr, nc, so_hang, so_cot) and g[nr][nc] >= g[r][c]:
                    cuc_dai = False
                    break
            if cuc_dai:
                dem += 1
    return dem


if __name__ == "__main__":
    g = [
        [2, 5, 1, 4],
        [3, 8, 6, 2],
        [7, 4, 9, 5],
    ]
    print(tong_4_ke(g, 1, 1), tong_4_ke(g, 0, 0), dem_cuc_dai_8_huong(g))