Matrix Chain Multiplication

Given the dimension of a sequence of matrices in an array arr[], where the dimension of the i^th matrix is (arr[i-1] * arr[i]), the task is to find the most efficient way to multiply these matrices together such that the total number of element multiplications is minimum. When two matrices of size m*n and n*p when multiplied, they generate a matrix of size m*p and the number of multiplications performed is m*n*p.

Examples:

Input: arr[] = [2, 1, 3, 4]
Output: 20
Explanation: There are 3 matrices of dimensions 2x1, 1x3, and 3x4,
Let the input 3 matrices be M₁, M₂, and M₃. There are two ways to multiply ((M₁ x M₂) x M₃) and (M₁ x (M₂ x M₃)),
Please note that the result of M₁ x M₂ is a 2 x 3 matrix and result of (M₂ x M₃) is a 1 x 4 matrix.
((M₁ x M₂) x M₃) requires (2 x 1 x 3) + (2 x 3 x 4) = 30
(M₁ x (M₂ x M₃)) requires (1 x 3 x 4) + (2 x 1 x 4) = 20
The minimum of these two is 20.

Input: arr[] = [1, 2, 3, 4, 3]
Output: 30
Explanation: There are 4 matrices of dimensions 1×2, 2×3, 3×4, 4×3. Let the input 4 matrices be M₁, M₂, M₃ and M₄. The minimum number of multiplications are obtained by ((M₁M₂)M₃)M₄. The minimum number is 1*2*3 + 1*3*4 + 1*4*3 = 30

Input: arr[] = [3, 4]
Output: 0
Explanation: As there is only one matrix so, there is no cost of multiplication.

[Naive Approach ] Using Recursion - O(2^n) and O(n) Space

We can solve the problem using recursion based on the following facts and observations:

Now, for a given chain of n matrices, the first partition can be done in n-1 ways. For example, sequence of matrices M₁, M₂, M₃ and M₄ can be grouped as (M₁)(M₂ x M₃ x M₄), (M₁x M₂) x (M₃ x M₄) or ((M₁ x M₂ x M₃) x M₄) in these 3 ways. 

For n matrices M₁, M₂, ..... M_n. we can put the first bracket n-1 ways

(M₁) x (M₂ x M₃ x M₄ ......... M_n-1 x M_n)
(M₁ x M₂) x (M₃ x M₄.......... M_n-1 x M_n)
(M₁ x M₂ x M₃) x (M₄ .......... M_n-1 x M_n)
..............................................................................
..............................................................................
(M₁ x M₂ x M₃ x M₄ ..........M_n-1) x (M_n)
We put the first bracket at different n-1 places and then recursively call for the two parts. At the end, we return the minimum of all partitions.

To write a recursive function we use a range of indexes [i, j]. And run a loop for k = i + 1 to j. For k = i + 1, we put the first bracket after the first matrix which has dimensions arr[i] x arr[i+1] and before the remaining matrices which have dimensions arr[i+1] x arr[i+2], arr[i+2] x arr[i+3], ........... arr[j-1] x arr[j]

• For every k, we make two subproblems : (a) Chain from i to k (b) Chain from k to j
• Each of the subproblems can be further partitioned into smaller subproblems and we can find the total required multiplications by solving for each of the groups.
• The base case would be when we have only one matrix left which means when j is equal to i+1.

20

[Better Approach 1 ] Using Top-Down DP (Memoization) - O(n*n*n) and O(n*n) Space

Let's suppose we have four matrices (M₁, M₂, M₃, M₄). Based on the recursive approach described above, we can construct a recursion tree. However, we can observe that some problems are computed multiple times. To avoid this redundant computation, we can implement memoization to store the results of previously computed inputs.

If observed carefully you can find the following two properties:

1) Optimal Substructure: In the above case, we are breaking the bigger groups into smaller subgroups and solving them to finally find the minimum number of multiplications. Therefore, it can be said that the problem has optimal substructure property.

2) Overlapping Subproblems: We can see in the recursion tree that the same subproblems are called again and again and this problem has the Overlapping Subproblems property. 

So Matrix Chain Multiplication problem has both properties of a dynamic programming problem. So recomputations of same subproblems can be avoided by constructing a temporary array memo[][] in a bottom up manner.

Follow the below steps to solve the problem:

• Build a matrix memo[][] of size n*n for memoization purposes.
• Use the same recursive call as done in the above approach:
  • When we find a range (i, j) for which the value is already calculated, return the minimum value for that range (i.e., memo[i][j]).
  • Otherwise, perform the recursive calls as mentioned earlier.
• The value stored at memo[0][n-1] is the required answer.

20

[Better Approach 2 ] Using Bottom-Up DP (Tabulation) - O(n*n*n) and O(n*n) Space

In iterative approach, we initially need to find the number of multiplications required to multiply two adjacent matrices. We can use these values to find the minimum multiplication required for matrices in a range of length 3 and further use those values for ranges with higher length. 

The iterative implementation is going to be tricky here we initially know diagonal values (which are 0), our result is going to be at the top right corner (or dp[0][n-1]) and we never access lower diagonal values. So we cannot fill the matrix with a normal traversal, we rather need to fill in diagonal manner. We fill the matrix using a variable len that stores differences between row and column indexes. We keep increasing len until it becomes n-1 (for the top right element)

20

Related articles:

• Matrix Chain Multiplication (O(n*n) Solution)
• Printing brackets in Matrix Chain Multiplication Problem

Applications:

• Minimum and Maximum values of an expression with * and +