Sparse Matrix Multiplication

Sparse Matrix Multiplication - Problem

Given two sparse matrices mat1 of size m x k and mat2 of size k x n, return the result of mat1 x mat2.

You may assume that multiplication is always possible.

A sparse matrix is a matrix in which most of the elements are zero. The key insight is to avoid unnecessary multiplications with zero values to optimize performance.

Input & Output

Example 1 — Basic Sparse Matrix

$ 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: Row 0: 1×7 + 0×0 + 0×0 = 7, 1×0 + 0×0 + 0×0 = 0, 1×0 + 0×0 + 0×1 = 0. Row 1: -1×7 + 0×0 + 3×0 = -7, -1×0 + 0×0 + 3×0 = 0, -1×0 + 0×0 + 3×1 = 3

Example 2 — Dense Matrix

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

› Output: [[7]]

💡 Note: Single element multiplication: 1×7 + 0×0 = 7

Example 3 — All Zeros Result

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

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

💡 Note: Row 0: 0×1 + 1×0 = 0, 0×0 + 1×0 = 0. Row 1: 0×1 + 0×0 = 0, 0×0 + 0×0 = 0

Constraints

m == mat1.length
k == mat1[i].length == mat2.length
n == mat2[i].length
1 ≤ m, n, k ≤ 100
-100 ≤ mat1[i][j], mat2[i][j] ≤ 100

Visualization

Tap to expand

Asked in

F Facebook 15 G Google 12 Li LinkedIn 8 M Microsoft 6

The key insight is to avoid multiplying by zero elements in sparse matrices. The optimized approach checks for zero values before performing multiplications, while the hash map approach stores only non-zero elements for maximum efficiency. Best approach depends on sparsity: simple optimization for moderately sparse, hash maps for extremely sparse. Time: O(m × n × k), Space: O(m × n)

Common Approaches

✓ Brute Force Matrix Multiplication

⏱️ Time: O(m × n × k) Space: O(m × n)

Use the standard matrix multiplication formula: result[i][j] = sum of mat1[i][k] * mat2[k][j] for all k. This approach doesn't take advantage of the sparse nature.

Hash Map for Sparse Representation

⏱️ Time: O(A × B × n) Space: O(A + B + C)

Convert matrices to sparse representation using hash maps. Store only non-zero elements with their coordinates as keys. This saves both time and space for very sparse matrices.

Skip Zero Elements

⏱️ Time: O(m × n × k) Space: O(m × n)

Optimize by checking if mat1[i][k] is zero before computing the inner product. If it's zero, skip the entire inner loop since the result will be zero anyway.

Brute Force Matrix Multiplication — Algorithm Steps

Create result matrix of size m x n
For each position (i,j), calculate dot product of row i and column j
Sum all products mat1[i][k] * mat2[k][j]

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup

Initialize result matrix and iterate positions

Calculate

For each (i,j), compute dot product including zeros

Result

Final matrix with all computed values

Code -

solution.c — C

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

int** solution(int** mat1, int mat1Size, int* mat1ColSize, int** mat2, int mat2Size, int* mat2ColSize, int* returnSize, int** returnColumnSizes) {
    int m = mat1Size, k = mat1ColSize[0];
    int n = mat2ColSize[0];
    
    int** result = (int**)malloc(m * sizeof(int*));
    *returnColumnSizes = (int*)malloc(m * sizeof(int));
    *returnSize = m;
    
    for (int i = 0; i < m; i++) {
        result[i] = (int*)calloc(n, sizeof(int));
        (*returnColumnSizes)[i] = n;
        
        for (int j = 0; j < n; j++) {
            for (int p = 0; p < k; p++) {
                result[i][j] += mat1[i][p] * mat2[p][j];
            }
        }
    }
    
    return result;
}

static char input[10000];

int** parseMatrix(char* line, int* rows, int** colSizes) {
    *rows = 0;
    if (strlen(line) <= 2) return NULL;
    
    char* temp = (char*)malloc(strlen(line) + 1);
    strcpy(temp, line);
    
    // Count rows
    char* p = temp;
    while (*p) {
        if (*p == '[' && *(p+1) != '[') (*rows)++;
        p++;
    }
    
    if (*rows == 0) {
        free(temp);
        return NULL;
    }
    
    int** matrix = (int**)malloc(*rows * sizeof(int*));
    *colSizes = (int*)malloc(*rows * sizeof(int));
    
    strcpy(temp, line);
    p = temp;
    int row = 0;
    
    while (*p && row < *rows) {
        if (*p == '[' && *(p+1) != '[') {
            p++; // Skip '['
            
            // Count columns in this row
            char* rowStart = p;
            int cols = 0;
            int depth = 0;
            char* q = p;
            
            while (*q && !(*q == ']' && depth == 0)) {
                if (*q == '[') depth++;
                else if (*q == ']') depth--;
                else if (*q == ',' && depth == 0) cols++;
                q++;
            }
            if (q > p) cols++; // Last element
            
            (*colSizes)[row] = cols;
            matrix[row] = (int*)malloc(cols * sizeof(int));
            
            // Parse numbers
            int col = 0;
            char* endptr;
            while (*p && *p != ']' && col < cols) {
                while (*p && (*p == ' ' || *p == ',')) p++;
                if (*p && *p != ']') {
                    matrix[row][col] = (int)strtol(p, &endptr, 10);
                    p = endptr;
                    col++;
                }
            }
            row++;
        }
        if (*p) p++;
    }
    
    free(temp);
    return matrix;
}

void printMatrix(int** matrix, int rows, int* colSizes) {
    printf("[");
    for (int i = 0; i < rows; i++) {
        if (i > 0) printf(",");
        printf("[");
        for (int j = 0; j < colSizes[i]; j++) {
            if (j > 0) printf(",");
            printf("%d", matrix[i][j]);
        }
        printf("]");
    }
    printf("]\n");
}

int main() {
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    int mat1Rows, mat2Rows;
    int* mat1ColSizes;
    int* mat2ColSizes;
    
    int** mat1 = parseMatrix(input, &mat1Rows, &mat1ColSizes);
    
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = 0;
    
    int** mat2 = parseMatrix(input, &mat2Rows, &mat2ColSizes);
    
    int returnSize;
    int* returnColumnSizes;
    
    int** result = solution(mat1, mat1Rows, mat1ColSizes, mat2, mat2Rows, mat2ColSizes, &returnSize, &returnColumnSizes);
    
    printMatrix(result, returnSize, returnColumnSizes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n × k)

Triple nested loops: m rows × n columns × k dot product calculations

✓ Linear Growth

Space Complexity

O(m × n)

Result matrix stores m × n elements

⚡ Linearithmic Space

89.5K Views

Medium Frequency

~25 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

Brute Force Matrix Multiplication — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler