Sparse Matrix Operations - Problem

Implement efficient operations on sparse matrices (matrices with mostly zero elements). A sparse matrix should only store non-zero elements to save memory and computation time.

Given two sparse matrices represented as lists of [row, col, value] triplets, implement:

Addition: Add two sparse matrices and return the result
Multiplication: Multiply two sparse matrices and return the result

The operation type is specified as a string: "add" for addition or "multiply" for multiplication.

Note: Only non-zero elements should be stored in the result. Elements with value 0 should be omitted from the output.

Input & Output

Example 1 — Matrix Addition

$ Input: matrix1 = [[0,1,3],[1,0,4]], matrix2 = [[0,0,1],[1,1,2]], operation = "add"

› Output: [[0,0,1],[0,1,3],[1,0,4],[1,1,2]]

💡 Note: Add corresponding elements: matrix1 has (0,1)=3 and (1,0)=4, matrix2 has (0,0)=1 and (1,1)=2. Combined result includes all non-zero positions.

Example 2 — Matrix Multiplication

$ Input: matrix1 = [[0,0,1],[0,1,2]], matrix2 = [[0,0,3],[1,0,4]], operation = "multiply"

› Output: [[0,0,3],[1,0,12]]

💡 Note: Matrix multiplication: C[0,0] = A[0,0]*B[0,0] = 1*3 = 3, C[1,0] = A[0,1]*B[1,0] = 2*4 = 8. Wait, let me recalculate: C[1,0] = A[1,0]*B[0,0] + A[1,1]*B[1,0] = 0*3 + 0*4 = 0. Actually C[0,0] = A[0,0]*B[0,0] + A[0,1]*B[1,0] = 1*3 + 2*4 = 11.

Example 3 — Empty Result

$ Input: matrix1 = [[0,0,5]], matrix2 = [[0,0,-5]], operation = "add"

› Output: []

💡 Note: 5 + (-5) = 0, so the result has no non-zero elements and returns empty array.

Constraints

1 ≤ matrix1.length, matrix2.length ≤ 100
-100 ≤ row, col ≤ 100
-10⁴ ≤ value ≤ 10⁴
operation is either "add" or "multiply"

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8 M Microsoft 10

The key insight is using hash maps with position keys to avoid creating full dense matrices. The optimal hash map approach processes only non-zero elements, achieving O(k1 + k2) time for addition where k1, k2 are the number of non-zero elements. Time: O(k1 + k2), Space: O(k1 + k2).

Common Approaches

✓ Brute Force Dense Matrix

⏱️ Time: O(m×n×p) Space: O(m×n + n×p)

Create full 2D arrays for both matrices, fill with zeros and populate non-zero elements, then perform standard matrix operations on the dense arrays.

Hash Map Approach

⏱️ Time: O(k1 + k2 + k1×k2) Space: O(k1 + k2)

Store matrix elements in hash maps using position keys, then iterate through both maps to perform operations without creating dense matrices.

Brute Force Dense Matrix — Algorithm Steps

Convert sparse matrices to dense 2D arrays
Perform standard matrix addition or multiplication
Convert result back to sparse format by scanning all elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Sparse to Dense

Convert triplets to full 2D arrays

Standard Operation

Perform addition/multiplication on dense matrices

Dense to Sparse

Scan result and extract non-zero elements

Code -

solution.c — C

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

#define MAX_SIZE 1000

typedef struct {
    int row, col, val;
} Triplet;

int solution(Triplet* matrix1, int size1, Triplet* matrix2, int size2, char* operation, Triplet* result) {
    if (size1 == 0 && size2 == 0) return 0;
    
    // Find dimensions
    int maxRow = 0, maxCol = 0;
    for (int i = 0; i < size1; i++) {
        if (matrix1[i].row > maxRow) maxRow = matrix1[i].row;
        if (matrix1[i].col > maxCol) maxCol = matrix1[i].col;
    }
    for (int i = 0; i < size2; i++) {
        if (matrix2[i].row > maxRow) maxRow = matrix2[i].row;
        if (matrix2[i].col > maxCol) maxCol = matrix2[i].col;
    }
    
    int rows = maxRow + 1, cols = maxCol + 1;
    
    // Create dense matrices
    int** dense1 = (int**)calloc(rows, sizeof(int*));
    int** dense2 = (int**)calloc(rows, sizeof(int*));
    for (int i = 0; i < rows; i++) {
        dense1[i] = (int*)calloc(cols, sizeof(int));
        dense2[i] = (int*)calloc(cols, sizeof(int));
    }
    
    // Fill dense matrices
    for (int i = 0; i < size1; i++) {
        dense1[matrix1[i].row][matrix1[i].col] = matrix1[i].val;
    }
    for (int i = 0; i < size2; i++) {
        dense2[matrix2[i].row][matrix2[i].col] = matrix2[i].val;
    }
    
    int resultCount = 0;
    
    if (strcmp(operation, "add") == 0) {
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                int val = dense1[i][j] + dense2[i][j];
                if (val != 0) {
                    result[resultCount].row = i;
                    result[resultCount].col = j;
                    result[resultCount].val = val;
                    resultCount++;
                }
            }
        }
    }
    
    // Free memory
    for (int i = 0; i < rows; i++) {
        free(dense1[i]);
        free(dense2[i]);
    }
    free(dense1);
    free(dense2);
    
    return resultCount;
}

int main() {
    // Simplified I/O - in real implementation, parse JSON properly
    Triplet matrix1[MAX_SIZE], matrix2[MAX_SIZE], result[MAX_SIZE];
    int size1 = 0, size2 = 0;
    char operation[10];
    
    int resultSize = solution(matrix1, size1, matrix2, size2, operation, result);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        printf("[%d,%d,%d]", result[i].row, result[i].col, result[i].val);
        if (i < resultSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n×p)

For multiplication: m×n matrix times n×p matrix requires m×n×p operations

✓ Linear Growth

Space Complexity

O(m×n + n×p)

Store full dense matrices even though most elements are zero

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~25 min Avg. Time

890 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

Sparse Matrix Operations - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Dense Matrix — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler