Sparse Matrix Multiplication - Practice Coding Problems

Sparse Matrix Multiplication - Problem

You're working with sparse matrices - matrices where most elements are zero. Given two sparse matrices mat1 of size m × k and mat2 of size k × n, your task is to compute their matrix multiplication mat1 × mat2.

The key insight is that in sparse matrices, we can skip multiplications involving zero elements to achieve better performance than the standard O(m×n×k) matrix multiplication algorithm.

Matrix Multiplication Refresher:
The element at position (i,j) in the result matrix equals the dot product of row i from mat1 and column j from mat2:
result[i][j] = sum(mat1[i][p] * mat2[p][j] for p in range(k))

Example:
If mat1 = [[1,0,0],[-1,0,3]] and mat2 = [[7,0,0],[0,0,0],[0,0,1]], then:
result[0][0] = 1×7 + 0×0 + 0×0 = 7
result[1][2] = -1×0 + 0×0 + 3×1 = 3

Input & Output

example_1.py — Basic Sparse Matrices

$ Input: mat1 = [[1,0,0],[-1,0,3]], mat2 = [[7,0,0],[0,0,0],[0,0,1]]

› Output: [[7,0,0],[-7,0,3]]

💡 Note: mat1[0][0] * mat2[0][0] = 1 * 7 = 7 for result[0][0]. mat1[1][0] * mat2[0][0] = -1 * 7 = -7 and mat1[1][2] * mat2[2][2] = 3 * 1 = 3 for result[1][0] and result[1][2] respectively. All other multiplications involve zeros.

example_2.py — Dense Result from Sparse Inputs

$ Input: mat1 = [[1,1]], mat2 = [[1],[1]]

› Output: [[2]]

💡 Note: Single element result: mat1[0][0] * mat2[0][0] + mat1[0][1] * mat2[1][0] = 1 * 1 + 1 * 1 = 2

example_3.py — All Zeros Matrix

$ Input: mat1 = [[0,0],[0,0]], mat2 = [[1,2],[3,4]]

› Output: [[0,0],[0,0]]

💡 Note: When mat1 contains all zeros, the result is always a zero matrix regardless of mat2 values. The optimized solution will skip all computations.

Constraints

m, k, n ≤ 100
-100 ≤ mat1[i][j], mat2[i][j] ≤ 100
The number of zeros in the matrices is in the range [0, (m×k + k×n)]
Matrices are sparse - most elements are zero

Visualization

Tap to expand

Understanding the Visualization

Identify Sparsity

Locate non-zero elements in the first matrix

Skip Zeros

Avoid computations when mat1[i][k] = 0

Process Non-Zeros

Only multiply and accumulate for non-zero elements

Build Result

Construct the result matrix efficiently

Key Takeaway

🎯 Key Insight: Skip multiplications involving zero elements to achieve dramatic performance improvements on sparse matrices

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal approach skips zero elements in mat1 by checking if mat1[i][k] != 0 before performing the inner multiplication loop. This reduces time complexity from O(m×n×k) to approximately O(nnz × n) where nnz is the number of non-zero elements in mat1, making it significantly faster for sparse matrices.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Sparse Multiplication	O(m × k × n)	O(m × n)	Skip zero elements by only processing non-zero values in the first matrix
Brute Force (Standard Matrix Multiplication)	O(m × n × k)	O(m × n)	Apply the standard O(m×n×k) matrix multiplication algorithm

Optimized Sparse Multiplication — Algorithm Steps

Initialize result matrix with zeros
For each row i in mat1
For each non-zero element mat1[i][k] in row i
For each column j, add mat1[i][k] * mat2[k][j] to result[i][j]

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Non-Zero

Only process when mat1[i][k] ≠ 0

Multiply Row

Multiply mat1[i][k] with entire row k of mat2

Skip Zeros

When mat1[i][k] = 0, skip entire inner loop

Accumulate

Add partial results to result[i][j]

Code -

solution.c — C

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

int** multiply(int** mat1, int m1, int n1, int** mat2, int m2, int n2) {
    int** result = (int**)malloc(m1 * sizeof(int*));
    for (int i = 0; i < m1; i++) {
        result[i] = (int*)calloc(n2, sizeof(int));
    }
    
    for (int i = 0; i < m1; i++) {
        for (int kIdx = 0; kIdx < n1; kIdx++) {
            // Skip if mat1[i][kIdx] is zero
            if (mat1[i][kIdx] != 0) {
                for (int j = 0; j < n2; j++) {
                    result[i][j] += mat1[i][kIdx] * mat2[kIdx][j];
                }
            }
        }
    }
    
    return result;
}

int main() {
    // Input parsing and function call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × k × n)

In worst case same as brute force, but much faster for sparse mat1 since we skip zero elements

✓ Linear Growth

Space Complexity

O(m × n)

Only the output matrix, no additional data structures needed

⚡ Linearithmic Space

52.3K Views

Medium Frequency

~15 min Avg. Time

1.8K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Optimized Sparse Multiplication — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler