Ada 4

Download as docx, pdf, or txt
Download as docx, pdf, or txt
You are on page 1of 3

Practical-5

Aim:- Algorithm and Implementation of Matrix Chain


Multiplication(using dynamic programming).
Algorithm:-
 Count the number of parenthesizations. Find the number of ways in which the
input matrices can be multiplied using the formulae −
P(n)={1 if n=1

∑n-1k=1P(k)P(n−k) if n≥2
 Once the parenthesization is done, the optimal substructure must be devised as
the first step of dynamic programming approach so the final product achieved
is optimal. In matrix chain multiplication, the optimal substructure is found by
dividing the sequence of matrices A[i….j] into two parts A[i,k] and A[k+1,j]. It
must be ensured that the parts are divided in such a way that optimal solution is
achieved.
 Using the formula

C[i, j]={0 if i=j

Min i≤k<j{C[i, k]+C[k+1,j]+di−1dkdj if i<j


 find the lowest cost parenthesization of the sequence of matrices by
constructing cost tables and corresponding k values table.
 Once the lowest cost is found, print the corresponding parenthesization as the
output.

Program:-
def matrix_product(p):
length = len(p) # len(p) = number of matrices + 1
m = [[-1]*length for _ in range(length)]
s = [[-1]*length for _ in range(length)]
 
matrix_product_helper(p, 1, length - 1, m, s)
 
return m, s
 
 
def matrix_product_helper(p, start, end, m, s):
if m[start][end] >= 0:
return m[start][end]
 
if start == end:
q = 0
else:
q = float('inf')
for k in range(start, end):
temp = matrix_product_helper(p, start, k, m, s) \
+ matrix_product_helper(p, k + 1, end, m, s) \
+ p[start - 1]*p[k]*p[end]
if q > temp:
q = temp
s[start][end] = k
 
m[start][end] = q
return q
 
 
def print_parenthesization(s, start, end):
if start == end:
print('A[{}]'.format(start), end='')
return
 
k = s[start][end]
 
print('(', end='')
print_parenthesization(s, start, k)
print_parenthesization(s, k + 1, end)
print(')', end='')
 
 
n = int(input('Enter number of matrices: '))
p = []
for i in range(n):
temp = int(input('Enter number of rows in matrix {}: '.format(i + 1)))
p.append(temp)
temp = int(input('Enter number of columns in matrix {}: '.format(n)))
p.append(temp)
 
m, s = matrix_product(p)
print('The number of scalar multiplications needed:', m[1][n])
print('Optimal parenthesization: ', end='')
print_parenthesization(s, 1, n)

Output:-
Enter number of matrices: 3
Enter number of rows in matrix 1: 10
Enter number of rows in matrix 2: 100
Enter number of rows in matrix 3: 5
Enter number of columns in matrix 3: 50
The number of scalar multiplications needed: 7500
Optimal parenthesization: ((A[1]A[2])A[3])

Time Complexity:-
O(N3), Where ‘N’ is the size of the array.

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy