# Matrix Chain Multiplication Algorithm: Recursive vs. Dynamic Way Read it later

5/5 - (4 votes)

If you’ve ever wondered how to efficiently multiply matrices or optimize computational costs in linear algebra, you’re in the right place. Matrix chain multiplication is a crucial topic in computer science and mathematics, and understanding it can greatly enhance your ability to handle complex matrix operations.

In this blog, we will dive deep into the world of matrix chain multiplication, exploring its significance, practical applications, and the dynamic programming approach to solving it optimally. Whether you’re a programmer, a data scientist, or simply interested in the fascinating world of matrices, this blog will equip you with the knowledge and techniques to master matrix chain multiplication.

## What is Matrix Chain Multiplication?

Matrix chain multiplication is a crucial algorithm in linear algebra and computer science. It involves the multiplication of multiple matrices in a specific order to obtain the most efficient result.

Unlike traditional matrix multiplication, where the order is straightforward, matrix chain multiplication poses an interesting challenge – finding the optimal sequence of matrix multiplication that minimizes the overall computational cost.

## Understanding the Problem

To grasp the concept of matrix chain multiplication and its significance, let’s start by breaking down the problem into simpler components.

Consider a sequence of matrices: A₁, A₂, A₃, …, Aₙ. Our goal is to find the optimal order of multiplying these matrices that minimizes the overall computational cost. But why is the order of multiplication important? Let’s explore this question further.

#### The Naive Approach

To demonstrate the significance of the multiplication order, let’s take a hypothetical example with three matrices: A, B, and C. Assume the dimensions of these matrices are as follows:

`Matrix A: 10x30Matrix B: 30x5Matrix C: 5x60`

Now, let’s consider two different orders of multiplication:

Order 1: (AB)C
Order 2: A(BC)

To compute the product using Order 1, we first multiply matrices A and B, resulting in a temporary matrix AB. We then multiply the temporary matrix AB with matrix C to obtain the final result. On the other hand, Order 2 first multiplies matrices B and C to obtain a temporary matrix BC. This temporary matrix BC is then multiplied with matrix A to yield the final result.

To compare the computational cost of these orders, we need to calculate the number of scalar multiplications required in each case. Scalar multiplications refer to the number of individual multiplications between elements of two matrices.

Let’s compute the scalar multiplications for both orders and visualize the process in a table:

Order 1: (AB)C

1. Multiply A and B: 10x30x5 = 1500 scalar multiplications
2. Multiply AB and C: 10x5x60 = 3000 scalar multiplications Total scalar multiplications: 1500 + 3000 = 4500

Order 2: A(BC)

1. Multiply B and C: 30x5x60 = 9000 scalar multiplications
2. Multiply A and BC: 10x30x60 = 18000 scalar multiplications Total scalar multiplications: 9000 + 18000 = 27000

From the calculations above, it’s evident that Order 1 requires significantly fewer scalar multiplications compared to Order 2. This showcases the importance of finding the optimal order of matrix multiplication.

#### Matrix Chain Multiplication Algorithm Goal

The goal of the matrix chain multiplication problem is to determine the order that minimizes the number of scalar multiplications and reduces the overall computational cost. Achieving an optimal order allows us to efficiently compute matrix products, especially when dealing with large matrices or performing repetitive matrix calculations.

To solve this problem systematically and effectively, we will employ a dynamic programming approach that breaks it down into smaller subproblems. By constructing a matrix to store intermediate results and making decisions based on the optimal substructure, we can obtain the most efficient sequence for matrix chain multiplication.

## Approaches to Solve Matrix Chain Multiplication

In our journey to master matrix chain multiplication, it’s important to explore different approaches that can be used to solve this problem efficiently.

There are two common approaches:

1. Recursive approach
2. Dynamic programming approach

Each approach has its own advantages and trade-offs in terms of time complexity and space complexity.

Let’s dive into each approach and analyze their complexities.

## Solve Matrix Chain Multiplication (MCM) Using Recursive Approach

The recursive approach is the simplest way to solve the matrix chain multiplication problem. It involves breaking down the problem into subproblems and solving them recursively. Here’s a brief outline of the recursive approach:

• Base Case: If the range of matrices is small (only one matrix), return 0 as there are no scalar multiplications needed.
• Recursive Step: For each possible partition point, compute the number of scalar multiplications required and choose the minimum among them.
• Return the minimum number of scalar multiplications.

Although the recursive approach is straightforward, it suffers from repetitive computations, leading to inefficient time complexity.

#### Matrix Chain Multiplication Algorithm in C++ (Recursive Approach)

Now, let’s see how we can implement this algorithm in C++ using recursive approach.

``````#include <iostream>
#include <vector>
#include <climits>

using namespace std;

int matrix_chain_multiplication(const vector<int>& dimensions, int i, int j) {
if (i == j)
return 0;

int minCost = INT_MAX;

for (int k = i; k < j; k++) {
int cost = matrix_chain_multiplication(dimensions, i, k) +
matrix_chain_multiplication(dimensions, k + 1, j) +
dimensions[i - 1] * dimensions[k] * dimensions[j];

if (cost < minCost)
minCost = cost;
}

return minCost;
}

int main() {
vector<int> dimensions = {10, 30, 5, 60};
int n = dimensions.size();

int optimalCost = matrix_chain_multiplication(dimensions, 1, n - 1);

cout << "Optimal Cost: " << optimalCost << endl;

return 0;
}``````

#### Code Explanation

1. The function `matrix_chain_multiplication` accepts the dimensions of the matrices and the range of matrices to consider (i.e., `i` and `j`).
2. If the range contains only one matrix (`i == j`), the function returns 0 as there are no scalar multiplications needed.
3. Otherwise, the function iterates over each possible split point `k` within the given range.
4. It recursively calls the `matrix_chain_multiplication` function on the two resulting subranges and calculates the cost of multiplying them.
5. The cost is calculated by adding the cost of multiplying the left subrange, the cost of multiplying the right subrange, and the cost of multiplying the resulting matrices.
6. The minimum cost among all split points is stored in the variable `minCost`.
7. Finally, the function returns the minimum cost, which represents the optimal cost for the given range of matrices.
8. In the `main` function, we provide the dimensions of the matrices and call the `matrix_chain_multiplication` function on the entire range of matrices (`1` to `n - 1`).
9. The optimal cost is then printed to the console.

#### Algorithm Performance

Time Complexity: The time complexity of the recursive approach can be expressed as O(2^n), where n is the number of matrices. This is because at each recursive call, we have two choices: either split the range or continue without splitting.

Space Complexity: The space complexity of the recursive approach is O(n), where n is the number of matrices. This is the space required for the function call stack.

## Solve Matrix Chain Multiplication (MCM) Using Dynamic Programming Approach

The dynamic programming approach, as discussed earlier, overcomes the repetitive computations of the recursive approach by storing and reusing intermediate results. It follows a bottom-up iterative approach to fill a matrix and find the optimal solution.

Here’s an outline of the dynamic programming approach:

• Initialize a matrix to store the optimal costs and another matrix to store the split points.
• Iterate over the matrix diagonally, computing and storing the optimal costs for different partition points.
• Trace back the split points to obtain the optimal order.

The dynamic programming approach significantly reduces the computational cost by avoiding redundant calculations, resulting in improved time complexity.

#### Matrix Chain Multiplication Algorithm in C++ (Dynamic Programming Approach)

Now that we have a good understanding of the matrix chain multiplication problem and the dynamic programming approach, let’s implement the algorithm using C++.

``````#include <iostream>
#include <vector>

// Function to perform matrix chain multiplication
std::pair<std::vector<std::vector<int>>, std::vector<std::vector<int>>>
matrixChainMultiplication(const std::vector<int>& dimensions) {
int n = dimensions.size() - 1;
std::vector<std::vector<int>> M(n, std::vector<int>(n, 0));
std::vector<std::vector<int>> S(n, std::vector<int>(n, 0));

for (int l = 2; l <= n; ++l) {
for (int i = 0; i < n - l + 1; ++i) {
int j = i + l - 1;
M[i][j] = INT_MAX;

for (int k = i; k < j; ++k) {
int cost = M[i][k] + M[k + 1][j] +
dimensions[i] * dimensions[k + 1] * dimensions[j + 1];

if (cost < M[i][j]) {
M[i][j] = cost;
S[i][j] = k + 1;
}
}
}
}

return std::make_pair(M, S);
}

// Function to construct the optimal order
std::string constructOptimalOrder(const std::vector<std::vector<int>>& S, int i, int j) {
if (i == j)
return "A" + std::to_string(i + 1);
else
return "(" + constructOptimalOrder(S, i, S[i][j] - 1) +
constructOptimalOrder(S, S[i][j], j) + ")";
}

int main() {
std::vector<int> matrixDimensions = {10, 30, 5, 60};  // Example dimensions of matrices

auto result = matrixChainMultiplication(matrixDimensions);
std::vector<std::vector<int>> M = result.first;
std::vector<std::vector<int>> S = result.second;

std::string optimalOrder = constructOptimalOrder(S, 0, matrixDimensions.size() - 2);

std::cout << "Optimal Order: " << optimalOrder << std::endl;
std::cout << "Minimum Scalar Multiplications: " << M[0][matrixDimensions.size() - 2] << std::endl;

return 0;
}``````

#### Code Explanation

In the C++ implementation, we define two functions: `matrixChainMultiplication` and `constructOptimalOrder`.

The `matrixChainMultiplication` function takes a vector `dimensions` as input, which represents the dimensions of the matrices. It returns a pair of matrices `M` and `S`, which store the optimal costs and split points, respectively.

The `constructOptimalOrder` function recursively constructs the optimal order using the split points matrix `S`. It takes the split range `(i, j)` as parameters and returns the optimal order as a string.

In the `main` function, we initialize the dimensions of the matrices and call the `matrixChainMultiplication` function. We retrieve the matrices `M` and `S` from the result and use the `constructOptimalOrder` function to obtain the optimal order.

Finally, we print the optimal order and the minimum number of scalar multiplications required for the given matrix dimensions.

#### Algorithm Performance

Time Complexity: The time complexity of the dynamic programming approach is O(n^3), where n is the number of matrices. This is because we have nested loops iterating over the matrix dimensions to fill in the optimal costs.

Space Complexity: The space complexity of the dynamic programming approach is O(n^2), where n is the number of matrices. This is the space required to store the matrices for optimal costs and split points.

Let’s take a look at the table below to compare the time and space complexities of both approaches:

By analyzing the time and space complexities of these approaches, we can see the clear advantage of the dynamic programming approach in terms of efficiency and scalability.

## Applications of Matrix Chain Multiplication

Matrix chain multiplication finds its applications in various fields where matrix computations are prevalent. Let’s explore some of the key areas where this technique plays a crucial role:

1. Computer Graphics: Matrix operations are fundamental in computer graphics for transforming and manipulating 2D and 3D objects. Matrix chain multiplication helps optimize transformations such as scaling, rotation, translation, and projection in computer-generated imagery (CGI), video games, virtual reality, and augmented reality.
2. Optimization Problems: Many optimization problems involve matrix computations, and matrix chain multiplication can be utilized to enhance their efficiency. Examples include linear programming, network flow algorithms, dynamic programming, and machine learning algorithms like principal component analysis (PCA) and linear regression.
3. DNA Sequence Alignment: In bioinformatics, DNA sequencing often requires aligning sequences for comparison. Matrix chain multiplication can be employed to optimize the alignment process, enabling faster sequence analysis and biological discoveries.
4. Image and Signal Processing: Image and signal processing algorithms often involve convolutions, transformations, and filtering operations. Matrix chain multiplication can improve the performance of these operations, enabling real-time processing in applications such as image editing software, video processing, and audio processing.
5. Cryptography: Cryptographic algorithms rely on complex matrix operations for encryption, decryption, and key generation. By optimizing matrix multiplications, matrix chain multiplication aids in enhancing the speed and security of cryptographic systems.
6. Data Compression: Matrix chain multiplication finds applications in data compression techniques such as the discrete cosine transform (DCT) used in image and video compression algorithms like JPEG and MPEG. Optimizing matrix computations reduces the computational overhead, leading to faster compression and decompression processes.

## Wrapping Up

In conclusion, mastering matrix chain multiplication is essential for efficient matrix calculations. By finding the optimal order of matrix multiplication, we can significantly reduce computational costs and improve overall performance. Through the dynamic programming approach, we can break down complex problems into smaller subproblems and construct solutions iteratively.

By understanding the algorithm presented in this blog, you now have the tools to tackle matrix chain multiplication with confidence. Remember to consider the dimensions of the matrices and apply the dynamic programming technique to obtain the optimal order. The provided Python implementation serves as a solid foundation for your own projects and further exploration.

Learn how to create Linked List and perform Binary Search in Golang.

## References

1. Introduction to Dynamic Programming. https://en.wikipedia.org/wiki/Dynamic_programming
2. Matrix Chain Multiplication https://en.wikipedia.org/wiki/Matrix_chain_multiplication