Matrix Diagonal Sum

Matrix Diagonal Sum - Problem

Array Matrix Easy

Given a square matrix mat, return the sum of the matrix diagonals.

Only include the sum of all the elements on the primary diagonal and all the elements on the secondary diagonal that are not part of the primary diagonal.

The primary diagonal consists of elements where row index = column index. The secondary diagonal consists of elements where row index + column index = n - 1, where n is the matrix size.

Input & Output

Example 1 — 3×3 Matrix

$ Input: mat = [[1,2,3],[4,5,6],[7,8,9]]

› Output: 25

💡 Note: Primary diagonal: mat[0][0] + mat[1][1] + mat[2][2] = 1 + 5 + 9 = 15. Secondary diagonal: mat[0][2] + mat[2][0] = 3 + 7 = 10. The center element 5 is shared, so total = 15 + 10 = 25.

Example 2 — 2×2 Matrix

$ Input: mat = [[1,1],[1,1]]

› Output: 4

💡 Note: Primary diagonal: mat[0][0] + mat[1][1] = 1 + 1 = 2. Secondary diagonal: mat[0][1] + mat[1][0] = 1 + 1 = 2. No overlap in even-sized matrix, so total = 2 + 2 = 4.

Example 3 — 1×1 Matrix

$ Input: mat = [[5]]

› Output: 5

💡 Note: Only one element which is both primary and secondary diagonal. Count it once: 5.

Constraints

n == mat.length == mat[i].length
1 ≤ n ≤ 100
1 ≤ mat[i][j] ≤ 100

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 Apple 6

The key insight is that we only need to traverse the diagonal elements directly instead of checking every cell. The optimal approach uses a single pass through n elements, adding primary diagonal mat[i][i] and secondary diagonal mat[i][n-1-i] while avoiding double-counting the center. Time: O(n), Space: O(1)

Common Approaches

✓ Hash Map

⏱️ Time: N/A Space: N/A

Brute Force - Check Every Cell

⏱️ Time: O(n²) Space: O(1)

For each cell in the n×n matrix, check if its position (i,j) satisfies the diagonal conditions: i==j for primary diagonal or i+j==n-1 for secondary diagonal. Sum all qualifying elements.

Single Pass Diagonal Traversal

⏱️ Time: O(n) Space: O(1)

Instead of checking every cell, directly access diagonal elements. Iterate through the matrix size n, adding mat[i][i] for primary diagonal and mat[i][n-1-i] for secondary diagonal. Handle the center overlap in odd-sized matrices.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

typedef struct {
    int y;
    int index;
} Pair;

typedef struct {
    int x_val;
    Pair* pairs;
    int count;
} Group;

int comparePairs(const void* a, const void* b) {
    return ((Pair*)b)->y - ((Pair*)a)->y;
}

int parseArray(char* line, int* arr) {
    int n = 0;
    char* start = strchr(line, '[');
    char* end = strchr(line, ']');
    if (!start || !end) return 0;
    
    start++;
    *end = '\0';
    
    char* token = strtok(start, ",");
    while (token != NULL && n < 1000) {
        arr[n] = atoi(token);
        n++;
        token = strtok(NULL, ",");
    }
    return n;
}

int solution(int* x, int* y, int n) {
    if (n < 3) return -1;
    
    Group groups[1000];
    int groupCount = 0;
    
    for (int i = 0; i < n; i++) {
        int found = -1;
        for (int j = 0; j < groupCount; j++) {
            if (groups[j].x_val == x[i]) {
                found = j;
                break;
            }
        }
        
        if (found == -1) {
            groups[groupCount].x_val = x[i];
            groups[groupCount].pairs = malloc(n * sizeof(Pair));
            groups[groupCount].count = 0;
            groups[groupCount].pairs[0].y = y[i];
            groups[groupCount].pairs[0].index = i;
            groups[groupCount].count = 1;
            groupCount++;
        } else {
            groups[found].pairs[groups[found].count].y = y[i];
            groups[found].pairs[groups[found].count].index = i;
            groups[found].count++;
        }
    }
    
    if (groupCount < 3) {
        for (int i = 0; i < groupCount; i++) {
            free(groups[i].pairs);
        }
        return -1;
    }
    
    for (int i = 0; i < groupCount; i++) {
        qsort(groups[i].pairs, groups[i].count, sizeof(Pair), comparePairs);
    }
    
    int maxSum = INT_MIN;
    int found_triplet = 0;
    for (int i = 0; i < groupCount; i++) {
        for (int j = i + 1; j < groupCount; j++) {
            for (int k = j + 1; k < groupCount; k++) {
                int sumVal = groups[i].pairs[0].y + groups[j].pairs[0].y + groups[k].pairs[0].y;
                if (sumVal > maxSum) {
                    maxSum = sumVal;
                }
                found_triplet = 1;
            }
        }
    }
    
    for (int i = 0; i < groupCount; i++) {
        free(groups[i].pairs);
    }
    
    return found_triplet ? maxSum : -1;
}

int main() {
    char line[10000];
    int x[1000], y[1000];
    
    if (!fgets(line, sizeof(line), stdin)) return 1;
    int n = parseArray(line, x);
    
    if (!fgets(line, sizeof(line), stdin)) return 1;
    parseArray(line, y);
    
    int result = solution(x, y, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

24.1K Views

Medium Frequency

~8 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen