Matrix Multiplication - Problem

Given two matrices A and B, multiply them together and return the resulting matrix.

Matrix multiplication is only possible when the number of columns in the first matrix equals the number of rows in the second matrix. If the matrices are incompatible for multiplication, return "Error: Incompatible dimensions".

For compatible matrices A (m×n) and B (n×p), the result will be a matrix C (m×p) where each element C[i][j] is the dot product of row i from matrix A and column j from matrix B.

Formula: C[i][j] = Σ(A[i][k] * B[k][j]) for k from 0 to n-1

Input & Output

Example 1 — Basic 2×3 and 3×2 Matrices

$ Input: matrixA = [[1,2,3],[4,5,6]], matrixB = [[7,8],[9,10],[11,12]]

› Output: [[58,64],[139,154]]

💡 Note: Matrix A is 2×3 and Matrix B is 3×2, so result is 2×2. C[0][0] = 1×7 + 2×9 + 3×11 = 7+18+33 = 58. C[0][1] = 1×8 + 2×10 + 3×12 = 8+20+36 = 64.

Example 2 — Square Matrices

$ Input: matrixA = [[1,2],[3,4]], matrixB = [[5,6],[7,8]]

› Output: [[19,22],[43,50]]

💡 Note: Both matrices are 2×2. C[0][0] = 1×5 + 2×7 = 5+14 = 19. C[1][1] = 3×6 + 4×8 = 18+32 = 50.

Example 3 — Incompatible Dimensions

$ Input: matrixA = [[1,2]], matrixB = [[3],[4],[5]]

› Output: "Error: Incompatible dimensions"

💡 Note: Matrix A is 1×2 and Matrix B is 3×1. Since columns of A (2) ≠ rows of B (3), multiplication is impossible.

Constraints

1 ≤ matrixA.length, matrixA[0].length ≤ 100
1 ≤ matrixB.length, matrixB[0].length ≤ 100
-1000 ≤ matrixA[i][j], matrixB[i][j] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 35 M Microsoft 28 a Amazon 22 f Facebook 18

Matrix multiplication requires checking dimension compatibility first, then using a triple nested loop to compute each result element as a dot product. The key insight is that C[i][j] = sum of A[i][k] × B[k][j] for all k. Best approach uses cache-optimized loop ordering (i-k-j). Time: O(m×n×p), Space: O(m×p).

Common Approaches

✓ Cache-Optimized Matrix Multiplication

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

Same algorithm but with loop reordering (i-k-j instead of i-j-k) to improve cache locality and reduce memory access time for large matrices.

Triple Nested Loop

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

Check dimension compatibility first, then use three nested loops: outer for result rows, middle for result columns, inner for computing dot product of row-column pairs.

Cache-Optimized Matrix Multiplication — Algorithm Steps

Step 1: Validate matrix dimensions for compatibility
Step 2: Initialize result matrix with appropriate dimensions
Step 3: Use i-k-j loop order for better cache performance
Step 4: Inner loop accesses result row sequentially

Visualization

Tap to expand

Step-by-Step Walkthrough

Row Focus

Fix row i of matrix A

Element Access

Access A[i][k] once per k iteration

Sequential Update

Update entire result row sequentially

Cache Benefit

Better locality reduces memory stalls

Code -

solution.c — C

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

int** solution(int** matrixA, int rowsA, int colsA, int** matrixB, int rowsB, int colsB, int* resultRows, int* resultCols, int* isError) {
    *isError = 0;
    
    if (rowsA == 0 || colsA == 0 || rowsB == 0 || colsB == 0 || colsA != rowsB) {
        *isError = 1;
        return NULL;
    }
    
    *resultRows = rowsA;
    *resultCols = colsB;
    
    int** result = (int**)malloc(rowsA * sizeof(int*));
    for (int i = 0; i < rowsA; i++) {
        result[i] = (int*)calloc(colsB, sizeof(int));
    }
    
    // Cache-optimized loop order
    for (int i = 0; i < rowsA; i++) {
        for (int k = 0; k < colsA; k++) {
            for (int j = 0; j < colsB; j++) {
                result[i][j] += matrixA[i][k] * matrixB[k][j];
            }
        }
    }
    
    return result;
}

int main() {
    // Simplified parsing for demonstration
    int rowsA = 2, colsA = 3, rowsB = 3, colsB = 2;
    
    int** matrixA = (int**)malloc(rowsA * sizeof(int*));
    int** matrixB = (int**)malloc(rowsB * sizeof(int*));
    
    for (int i = 0; i < rowsA; i++) {
        matrixA[i] = (int*)malloc(colsA * sizeof(int));
    }
    for (int i = 0; i < rowsB; i++) {
        matrixB[i] = (int*)malloc(colsB * sizeof(int));
    }
    
    // Read matrices (simplified)
    for (int i = 0; i < rowsA; i++) {
        for (int j = 0; j < colsA; j++) {
            scanf("%d", &matrixA[i][j]);
        }
    }
    
    for (int i = 0; i < rowsB; i++) {
        for (int j = 0; j < colsB; j++) {
            scanf("%d", &matrixB[i][j]);
        }
    }
    
    int resultRows, resultCols, isError;
    int** result = solution(matrixA, rowsA, colsA, matrixB, rowsB, colsB, &resultRows, &resultCols, &isError);
    
    if (isError) {
        printf("Error: Incompatible dimensions\n");
    } else {
        printf("[[");
        for (int i = 0; i < resultRows; i++) {
            if (i > 0) printf(",[");
            for (int j = 0; j < resultCols; j++) {
                if (j > 0) printf(",");
                printf("%d", result[i][j]);
            }
            printf("]]");
        }
        printf("\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n×p)

Same three nested loops but with better memory access patterns

✓ Linear Growth

Space Complexity

O(m×p)

Result matrix of size m×p, no additional space overhead

✓ Linear Space

23.5K Views

Medium Frequency

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

Matrix Multiplication - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Cache-Optimized Matrix Multiplication — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler