Matrix Chain Multiplication - Problem

Given a sequence of matrices, find the most efficient way to multiply these matrices together. The problem is not actually to perform the multiplications, but merely to decide in which order to perform the multiplications.

We have many options to multiply a chain of matrices because matrix multiplication is associative. In other words, no matter how we parenthesize the product, the result will be the same. For example, if we had four matrices A, B, C, and D, we would have:

(ABC)D = (AB)(CD) = A(BCD) = ...

However, the order in which we parenthesize the product affects the number of simple scalar multiplications needed to compute the product, or the efficiency. For example, suppose A is a 10×30 matrix, B is a 30×5 matrix, and C is a 5×60 matrix. Then:

(AB)C = (10×30×5) + (10×5×60) = 1,500 + 3,000 = 4,500 multiplications
A(BC) = (30×5×60) + (10×30×60) = 9,000 + 18,000 = 27,000 multiplications

Given an array dimensions which represents the dimensions of each matrix where dimensions[i] is the number of rows of matrix i and dimensions[i+1] is the number of columns of matrix i, return the minimum number of scalar multiplications needed to multiply all the matrices.

Input & Output

Example 1 — Basic Chain

$ Input: dimensions = [1,2,3,4]

› Output: 18

💡 Note: Matrices are 1×2, 2×3, 3×4. Optimal: ((1×2) × (2×3)) × (3×4) = 6 + 12 = 18 operations

Example 2 — Two Matrices

$ Input: dimensions = [10,20,30]

› Output: 6000

💡 Note: Only one way to multiply: 10×20×30 = 6000 operations

Example 3 — Larger Chain

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

› Output: 38

💡 Note: Four matrices: 1×2, 2×3, 3×4, 4×5. Optimal parenthesization gives 38 operations

Constraints

2 ≤ dimensions.length ≤ 200
1 ≤ dimensions[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 35 A Amazon 28 M Microsoft 22 F Facebook 18

The key insight is to break down the matrix multiplication problem into overlapping subproblems. Instead of trying all possible parenthesizations, we use dynamic programming to build up solutions from smaller chains to larger ones. The optimal approach uses a 2D DP table with Time: O(n³), Space: O(n²).

Common Approaches

✓ Bottom-Up Dynamic Programming

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

Fill a 2D table bottom-up by solving smaller subproblems first. For each chain length, compute the minimum cost for all possible starting positions.

Recursive Brute Force

⏱️ Time: O(2ⁿ) Space: O(n)

For each possible split point in the chain, recursively calculate the cost of multiplying the left part, the right part, and the cost of multiplying the two results together. Take the minimum among all split points.

Top-Down Dynamic Programming (Memoization)

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

Same as brute force but store the results of subproblems in a 2D memoization table to avoid recalculating the same subproblems multiple times.

Bottom-Up Dynamic Programming — Algorithm Steps

Step 1: Create 2D DP table where dp[i][j] represents min cost for matrices i to j
Step 2: Fill base cases - single matrices have 0 cost
Step 3: For each chain length from 2 to n, fill all positions
Step 4: For each position, try all split points and take minimum

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize base cases

Single matrices have cost 0

Fill by chain length

Length 2, then 3, then 4, etc.

Optimal solution

Answer is in dp[0][n-2]

Code -

solution.c — C

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

int solution(int* dimensions, int size) {
    if (size < 2) return 0;
    
    // dp[i][j] represents minimum cost to multiply matrices from i to j
    int dp[100][100];
    memset(dp, 0, sizeof(dp));
    
    // Length of chain
    for (int length = 2; length < size; length++) {
        for (int i = 0; i < size - length; i++) {
            int j = i + length - 1;
            dp[i][j] = INT_MAX;
            
            // Try all possible split points
            for (int k = i; k < j; k++) {
                int cost = dp[i][k] + dp[k + 1][j] + 
                          dimensions[i] * dimensions[k + 1] * dimensions[j + 1];
                if (cost < dp[i][j]) {
                    dp[i][j] = cost;
                }
            }
        }
    }
    
    return dp[0][size - 2];
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    int dimensions[100];
    int size = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        dimensions[size++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(dimensions, size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: chain length, starting position, and split point

✓ Linear Growth

Space Complexity

O(n²)

2D DP table of size n×n

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~35 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 Chain Multiplication - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler