Unit 4

13-mark questions:
1. Explain about dynamic programming and its elements.

Dynamic programming helps to solve a complex problem by breaking it down into a

collection of simpler subproblems, solving each of those sub-problems just once, and
storing their solutions.

A dynamic programming algorithm will examine the previously solved sub problems
and will combine their solutions to give the best solution for the given problem.

Dynamic programming is used where we have problems, which can be divided into
similar sub-problems, so that their results can be re-used. Mostly, these algorithms are
used for optimization. Before solving the in-hand sub-problem, dynamic algorithm will
try to examine the results of the previously solved sub-problems. The solutions of sub-
problems are combined in order to achieve the best solution. It is used when the solution
can be recursively described in terms of solutions to subproblems (optimal
substructure).

The following computer problems can be solved using dynamic programming approach
–

• Fibonacci sequence
• 0-1 knapsack problem
• Longest Common Subsequence problem
• Matrix chain multiplication
• All pairs shortest path problem
• Subset-sum problem
• Optimal Binary Search Tree

In the case of any dynamic programming problem, when we divide the problem, the
subproblems are not independent, instead the solutions to these subproblems are used
to compute the values for the larger problems.

These repeating subproblems are used again and again and hence their results are
stored. If the results of subproblems are not stored, we would have to compute them
again and again, which will be very costly.

So, even if we can solve a problem with plain iteration/recursion, dynamic

programming makes it faster and more efficient by using some extra space.

By storing the solutions of sub-problems in extra memory space, we thereby reduce the
time taken to calculate the complete solution for a problem. This method of storing the
answers to similar subproblems is called memoization.

Because of this, dynamic programming can solve a vast variety of problems involving
optimal solutions, which means finding the best case out of all. In these cases, also,
dynamic programming takes help of smaller subproblems to reach to the final optimal
solution.

In Dynamic Programming, we analyse all subproblems to find out the most optimal
solution, but because we store these values, no subproblem is recomputed. This
increases the efficiency of a Dynamic Programming solution and also assures a correct
solution as we are basically checking all the cases, but efficiently.

Dynamic Programming algorithm works by computing the answer to all possible

subproblems and stores them to find the final answer. This process of storing values of
subproblems is called memoization which helps in reaching the final solution
efficiently.

Characteristics of Dynamic Programming

Two characteristics that a problem has for a Dynamic Programming solution to work
are:

1. Optimal Substructure
2. Overlapping Subproblems

Optimal Substructure

If a complex problem has an Optimal Substructure property it means that to find an

optimal solution for the problem, the optimal solutions of its smaller subproblems are
needed.

So, by combining the optimal solutions of subproblems, we can obtain a solution

efficiently.

This property is used by the Dynamic Programming algorithm to ensure a correct

solution to the given problem.

Taking the example of the Fibonacci Sequence again, the nth term is given by :

F(n) = F(n-1) + F(n-2)

So, to find the nth term, we need to find the correct solution for the (n-1) th and
the (n-2)th term, which are smaller subproblems of the complete problem. And again
to find the (n-1)th term and the (n-2)th term, we need to find the solution to even
smaller subproblems.

Overlapping Subproblems

A problem is said to have Overlapping Subproblems property if it can be broken down

into smaller parts called subproblems, which need to be solved again and again. This
means that the same subproblem is needed again and again to generate the final
solution.
This property is used by Dynamic Programming in the sense that it stores the solutions
to these recurring subproblems so that we do not need to compute it again and again.

For example, in the Fibonacci Sequence problem, we have

F(n) = F(n-1) + F(n-2)

F(n-1) = F(n-2) + F(n-3)
F(n-2) = F(n-3) + F(n-4)
F(n-3) = F(n-4) + F(n-5)

From this, it is clear that the subproblems F(n-2), F(n-3), and F(n-4) are used again and
again to find the final solution.

Components of Dynamic Programming

The major components in any Dynamic Programming solution are:

1. Stages
2. States and state variables
3. State Transition
4. Optimal Choice

1. Stages

When a complex problem is divided into several subproblems, each subproblem forms
a stage of the solution. After calculating the solution for each stage and choosing the
best ones we get to the final optimized solution.

2. States and State Variables

Each subproblem can be associated with several states. States differ in their solutions
because of different choices. A state for a subproblem is therefore defined more clearly
based on a parameter, which is called the state variable. It is possible in some problems,
that one than one variable is needed to define a state distinctly. In these cases, there are
more than one state variables.

3. State Transition

State Transition simply refers to how one subproblem relates to other subproblems. By
using this state transition, we calculate our end solution.

4. Optimal Choice

At each stage, we need to choose the option which leads to the most desirable solution.
Choosing the most desirable option at every stage will eventually lead to an optimal
solution in the end.
 Elements Of Dynamic Programming

Three elements of the Dynamic Programming algorithm are :

1. Substructure
2. Table Structure
3. Bottom-Up Computation (Memoization)

The elements in a Dynamic Programming Solution are discussed below:

• To solve a given complex problem and to find its optimal solution, it is broken
down into similar but smaller and easily computable problems called
subproblems. Hence, the complete solution depends on many smaller problems
and their solutions. We get to the final optimal solution after going through all
subproblems and selecting the most optimal ones. This is the substructure
element of any Dynamic Programming solution.
• Any Dynamic Programming solution involves storing the optimal solutions of
the subproblems so that they don't have to be computed again and again. To
store these solutions a table structure is needed. So, for example arrays in C++
or ArrayList in Java can be used. By using this structured table, the solutions of
previous subproblems are reused.
• The solutions to subproblems need to be computed first to be reused again. This
is called Bottom-Up Computation because we start storing values from the
bottom and then consequently upwards. The solutions to the smaller
subproblems are combined to get the final solution to the original problem.

2. Explain how to solve the following problems using dynamic programming with
example.

a) Longest Common Subsequence.

b) Matrix Chain Multiplication.

Longest Common Subsequence

LCS Problem Statement: Given two sequences, find the length of longest
subsequence present in both of them. A subsequence is a sequence that appears in the
same relative order, but not necessarily contiguous. For example, “abc”, “abg”, “bdf”,
“aeg”, ‘”acefg”, .. etc are subsequences of “abcdefg”.
The naive solution for this problem is to generate all subsequences of both given
sequences and find the longest matching subsequence. This solution is exponential
in term of time complexity. Let us see how this problem possesses both important
properties of a Dynamic Programming (DP) Problem.
1) Optimal Substructure:
Let the input sequences be X[0..m-1] and Y[0..n-1] of lengths m and n respectively.
And let L(X[0..m-1], Y[0..n-1]) be the length of LCS of the two sequences X and Y.
Following is the recursive definition of L(X[0..m-1], Y[0..n-1]).
If last characters of both sequences match (or X[m-1] == Y[n-1]) then
L(X[0..m-1], Y[0..n-1]) = 1 + L(X[0..m-2], Y[0..n-2])
If last characters of both sequences do not match (or X[m-1] != Y[n-1]) then
L(X[0..m-1], Y[0..n-1]) = MAX ( L(X[0..m-2], Y[0..n-1]), L(X[0..m-1], Y[0..n-2]) )
Examples:
1) Consider the input strings “AGGTAB” and “GXTXAYB”. Last characters match
for the strings. So length of LCS can be written as:
L(“AGGTAB”, “GXTXAYB”) = 1 + L(“AGGTA”, “GXTXAY”)

2) Consider the input strings “ABCDGH” and “AEDFHR. Last characters do not
match for the strings. So length of LCS can be written as:
L(“ABCDGH”, “AEDFHR”) = MAX ( L(“ABCDG”, “AEDFHR”), L(“ABCDGH”,
“AEDFH”) )
So the LCS problem has optimal substructure property as the main problem can be
solved using solutions to subproblems.
2) Overlapping Subproblems:
Following is simple recursive implementation of the LCS problem. The
implementation simply follows the recursive structure mentioned above .

#include <bits/stdc++.h>
using namespace std;
/* Returns length of LCS for X[0..m-1], Y[0..n-1] */
int lcs( char *X, char *Y, int m, int n )
{
if (m == 0 || n == 0)
return 0;
if (X[m-1] == Y[n-1])
return 1 + lcs(X, Y, m-1, n-1);
else
return max(lcs(X, Y, m, n-1), lcs(X, Y, m-1, n));
}
/* Driver code */
int main()
{
char X[] = "AGGTAB";
char Y[] = "GXTXAYB";
int m = strlen(X);
int n = strlen(Y);
cout<<"Length of LCS is "<< lcs( X, Y, m, n ) ;
return 0;
}
Output: Length of LCS is 4
Matrix Chain Multiplication
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
arithmetic operations 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) = 1500 + 3000 = 4500 operations
A(BC) = (30×5×60) + (10×30×60) = 9000 + 18000 = 27000 operations.
Clearly the first parenthesization requires less number of operations.
Given an array p[] which represents the chain of matrices such that the ith matrix Ai
is of dimension p[i-1] x p[i]. We need to write a function MatrixChainOrder() that
should return the minimum number of multiplications needed to multiply the chain.
Input: p[] = {10, 20, 30}
Output: 6000
There are only two matrices of dimensions 10x20 and 20x30. So there
is only one way to multiply the matrices, cost of which is 10*20*30
1) Optimal Substructure:
A simple solution is to place parenthesis at all possible places, calculate the cost for
each placement and return the minimum value. In a chain of matrices of size n, we
can place the first set of parenthesis in n-1 ways. For example, if the given chain is
of 4 matrices. let the chain be ABCD, then there are 3 ways to place first set of
parenthesis outer side: (A)(BCD), (AB)(CD) and (ABC)(D). So when we place a set
of parenthesis, we divide the problem into subproblems of smaller size. Therefore,
the problem has optimal substructure property and can be easily solved using
recursion.
Minimum number of multiplication needed to multiply a chain of size n = Minimum
of all n-1 placements (these placements create subproblems of smaller size)
2) Overlapping Subproblems
Following is a recursive implementation that simply follows the above optimal
substructure property.
Below is the implementation of the above idea:
#include <bits/stdc++.h>
using namespace std;
// Matrix Ai has dimension p[i-1] x p[i]
// for i = 1..n
int MatrixChainOrder(int p[], int i, int j)
{
if (i == j)
return 0;
int k;
int min = INT_MAX;
int count;
// place parenthesis at different places
// between first and last matrix, recursively
// calculate count of multiplications for
// each parenthesis placement and return the
// minimum count
for (k = i; k < j; k++)
{
count = MatrixChainOrder(p, i, k) + MatrixChainOrder(p, k + 1, j)+ p[i - 1] *
p[k] * p[j];
if (count < min)
min = count;
}
// Return minimum count
return min;
 }
// Driver Code
int main()
{
int arr[] = { 1, 2, 3, 4, 3 };
int n = sizeof(arr) / sizeof(arr[0]);

cout << "Minimum number of multiplications is "

<< MatrixChainOrder(arr, 1, n - 1);
}
Output
Minimum number of multiplications is 30
3. Explain about Greedy Algorithm and its elements.
Among all the algorithmic approaches, the simplest and straightforward approach is
the Greedy method. In this approach, the decision is taken on the basis of current
available information without worrying about the effect of the current decision in
future.
Greedy algorithms build a solution part by part, choosing the next part in such a way,
that it gives an immediate benefit. This approach never reconsiders the choices taken
previously. This approach is mainly used to solve optimization problems. Greedy
method is easy to implement and quite efficient in most of the cases. Hence, we can
say that Greedy algorithm is an algorithmic paradigm based on heuristic that follows
local optimal choice at each step with the hope of finding global optimal solution.
In many problems, it does not produce an optimal solution though it gives an
approximate (near optimal) solution in a reasonable time.
Greedy algorithms have the following five components −
• A candidate set − A solution is created from this set.
• A selection function − Used to choose the best candidate to be added to the solution.
• A feasibility function − Used to determine whether a candidate can be used to
contribute to the solution.
• An objective function − Used to assign a value to a solution or a partial solution.
• A solution function − Used to indicate whether a complete solution has been reached.
Greedy approach is used to solve many problems, such as
• Finding the shortest path between two vertices using Dijkstra’s algorithm.
• Finding the minimal spanning tree in a graph using Prim’s /Kruskal’s algorithm, etc.
In many problems, Greedy algorithm fails to find an optimal solution, moreover it may
produce a worst solution. Problems like Travelling Salesman and Knapsack cannot be
solved using this approach.

Characteristics of Greedy method

The following are the characteristics of a greedy method:

• To construct the solution in an optimal way, this algorithm creates two sets where
one set contains all the chosen items, and another set contains the rejected items.
• A Greedy algorithm makes good local choices in the hope that the solution should
be either feasible or optimal.

Advantages
The biggest advantage that the Greedy algorithm has over others is that it is easy to

implement and very efficient in most cases.

Disadvantages of using Greedy algorithm

Greedy algorithm makes decisions based on the information available at each phase
without considering the broader problem. So, there might be a possibility that the
greedy solution does not give the best solution for every problem.

It follows the local optimum choice at each stage with a intend of finding the global
optimum.

Greedy Algorithm

1. To begin with, the solution set (containing answers) is empty.

2. At each step, an item is added to the solution set until a solution is reached.

3. If the solution set is feasible, the current item is kept.

4. Else, the item is rejected and never considered again.

Greedy is an algorithmic paradigm that builds up a solution piece by piece, always

choosing the next piece that offers the most obvious and immediate benefit. Greedy
algorithms are used for optimization problems. An optimization problem can be solved
using Greedy if the problem has the following property: At every step, we can make a
choice that looks best at the moment, and we get the optimal solution of the complete
problem.

If a Greedy Algorithm can solve a problem, then it generally becomes the best method
to solve that problem as the Greedy algorithms are in general more efficient than other
techniques like Dynamic Programming. But Greedy algorithms cannot always be
applied. For example, the Fractional Knapsack problem can be solved using Greedy,
but 0-1 Knapsack cannot be solved using Greedy.
Following are some standard algorithms that are Greedy algorithms.

1) Kruskal’s Minimum Spanning Tree (MST): In Kruskal’s algorithm, we create a MST

by picking edges one by one. The Greedy Choice is to pick the smallest weight edge
that doesn’t cause a cycle in the MST constructed so far.

2) Prim’s Minimum Spanning Tree: In Prim’s algorithm also, we create a MST by

picking edges one by one. We maintain two sets: a set of the vertices already included
in MST and the set of the vertices not yet included. The Greedy Choice is to pick the
smallest weight edge that connects the two sets.

3) Dijkstra’s Shortest Path: Dijkstra’s algorithm is very similar to Prim’s algorithm.

The shortest-path tree is built up, edge by edge. We maintain two sets: a set of the
vertices already included in the tree and the set of the vertices not yet included. The
Greedy Choice is to pick the edge that connects the two sets and is on the smallest
weight path from source to the set that contains not yet included vertices.

4) Huffman Coding: Huffman Coding is a loss-less compression technique. It assigns

variable-length bit codes to different characters. The Greedy Choice is to assign the
least bit length code to the most frequent character.

The greedy algorithms are sometimes also used to get an approximation for Hard
optimization problems. For example, Traveling Salesman Problem is an NP-Hard
problem. A Greedy choice for this problem is to pick the nearest unvisited city from the
current city at every step. These solutions don’t always produce the best optimal
solution but can be used to get an approximately optimal solution.

Activity Selection Problem

Given n activities with their start and finish times. Select the maximum number of
activities that can be performed by a single person, assuming that a person can only
work on a single activity at a time.
Example : Consider the following 6 activities sorted by by finish time.
start[] = {1, 3, 0, 5, 8, 5};
finish[] = {2, 4, 6, 7, 9, 9};
A person can perform at most four activities. The maximum set of activities that can
be executed is {0, 1, 3, 4} [ These are indexes in start[] and finish[] ]
The greedy choice is to always pick the next activity whose finish time is least
among the remaining activities and the start time is more than or equal to the finish
time of the previously selected activity. We can sort the activities according to their
finishing time so that we always consider the next activity as minimum finishing
time activity.
1) Sort the activities according to their finishing time
2) Select the first activity from the sorted array and print it.
3) Do the following for the remaining activities in the sorted array.
If the start time of this activity is greater than or equal to the finish time of the
previously selected activity then select this activity and print it.
4. Explain Huffman Coding with example.
Huffman coding is a lossless data compression algorithm. The idea is to assign
variable-length codes to input characters, lengths of the assigned codes are based on
the frequencies of corresponding characters. The most frequent character gets the
smallest code and the least frequent character gets the largest code.
The variable-length codes assigned to input characters are Prefix Codes, means the
codes (bit sequences) are assigned in such a way that the code assigned to one
character is not the prefix of code assigned to any other character. This is how
Huffman Coding makes sure that there is no ambiguity when decoding the generated
bitstream.
Example: Let there be four characters a, b, c and d, and their corresponding variable
length codes be 00, 01, 0 and 1. This coding leads to ambiguity because code assigned
to c is the prefix of codes assigned to a and b. If the compressed bit stream is 0001,
the de-compressed output may be “cccd” or “ccb” or “acd” or “ab”.
There are mainly two major parts in Huffman Coding
• Build a Huffman Tree from input characters.
• Traverse the Huffman Tree and assign codes to characters.
Steps to build Huffman Tree
Input is an array of unique characters along with their frequency of occurrences and
output is Huffman Tree.
1. Create a leaf node for each unique character and build a min heap of all leaf nodes
(Min Heap is used as a priority queue. The value of frequency field is used to
compare two nodes in min heap. Initially, the least frequent character is at root)
2. Extract two nodes with the minimum frequency from the min heap.
3. Create a new internal node with a frequency equal to the sum of the two nodes
frequencies. Make the first extracted node as its left child and the other extracted
node as its right child. Add this node to the min heap.
4. Repeat steps#2 and #3 until the heap contains only one node. The remaining node
is the root node and the tree is complete.
Example:
Character Frequency
a 5
b 9
c 12
d 13
e 16
f 45
Step 1: Build a min heap that contains 6 nodes where each node represents root of
a tree with single node.

Step 2: Extract two minimum frequency nodes from min heap. Add a new internal
node with frequency 5 + 9 = 14.

Huffman Coding step 2

Now min heap contains 5 nodes where 4 nodes are roots of trees with single
element each, and one heap node is root of tree with 3 elements

character Frequency
c 12
d 13
Internal Node 14
e 16
f 45
Step 3: Extract two minimum frequency nodes from heap. Add a new internal
node with frequency 12 + 13 = 25

Huffman Coding step 3

Now min heap contains 4 nodes where 2 nodes are roots of trees with single
element each, and two heap nodes are root of tree with more than one nodes

character Frequency
Internal Node 14
e 16
Internal Node 25
f 45
Step 4: Extract two minimum frequency nodes. Add a new internal node with
frequency 14 + 16 = 30
Huffman Coding step 4

Now min heap contains 3 nodes.

character Frequency
Internal Node 25
Internal Node 30
f 45
Step 5: Extract two minimum frequency nodes. Add a new internal node with
frequency 25 + 30 = 55

Huffman Coding step 5

Now min heap contains 2 nodes.

character Frequency
f 45
Internal Node 55
Step 6: Extract two minimum frequency nodes. Add a new internal node with
frequency 45 + 55 = 100

Huffman Coding step 6

Now min heap contains only one node.

character Frequency
Internal Node 100
Since the heap contains only one node, the algorithm stops here.

Steps to print codes from Huffman Tree:

Traverse the tree formed starting from the root. Maintain an auxiliary array. While
moving to the left child, write 0 to the array. While moving to the right child,
write 1 to the array. Print the array when a leaf node is encountered.

Steps to print codes from Huffman Tree

The codes are as follows:

character code-word
f 0
c 100
d 101
a 1100
b 1101
e 111
5. Consider the given sequence {4, 10, 3, 12, 20, and 7}. The matrices have size 4 x
10, 10 x 3, 3 x 12, 12 x 20, 20 x 7. The objective is to compute M [i,j], 0 ≤ i, j≤ 5.
We know M [i, i] = 0 for all i.

Matrix Chain Multiplication

Matrix Multiplication operation is associative in nature rather commutative. By this, we

mean that we have to follow the above matrix order for multiplication but we are free
to parenthesize the above multiplication depending upon our need.

In general, for 1≤ i≤ p and 1≤ j ≤ r

It can be observed that the total entries in matrix 'C' is 'pr' as the matrix is of dimension
p x r Also each entry takes O (q) times to compute, thus the total time to compute all
possible entries for the matrix 'C' which is a multiplication of 'A' and 'B' is proportional
to the product of the dimension p q r.

It is also noticed that we can save the number of operations by reordering the
parenthesis.

Dynamic Programming Approach

Let Ai,j be the result of multiplying matrices i through j. It can be seen that the dimension
of Ai,j is pi-1 x pj matrix.

Dynamic Programming solution involves breaking up the problems into subproblems

whose solution can be combined to solve the global problem.

At the greatest level of parenthesization, we multiply two matrices

A1.....n=A1....k x Ak+1....n)

1
Thus we are left with two questions:

o How to split the sequence of matrices?

o How to parenthesize the subsequence A1.....k andAk+1......n?

One possible answer to the first question for finding the best value of 'k' is to check all
possible choices of 'k' and consider the best among them. But that it can be observed
that checking all possibilities will lead to an exponential number of total possibilities. It
can also be noticed that there exists only O (n2 ) different sequence of matrices, in this
way do not reach the exponential growth

Step1: Structure of an optimal parenthesization: Our first step in the dynamic

paradigm is to find the optimal substructure and then use it to construct an optimal
solution to the problem from an optimal solution to subproblems.

Let Ai....j where i≤ j denotes the matrix that results from evaluating the product

Ai Ai+1....Aj.

If i < j then any parenthesization of the product A i Ai+1 ......Aj must split that the product
between Ak and Ak+1 for some integer k in the range i ≤ k ≤ j. That is for some value of
k, we first compute the matrices Ai.....k & Ak+1....j and then multiply them together to
produce the final product Ai....j. The cost of computing Ai....k plus the cost of computing
Ak+1....j plus the cost of multiplying them together is the cost of parenthesization.

Step 2: A Recursive Solution: Let m [i, j] be the minimum number of scalar

multiplication needed to compute the matrixAi....j.

If i=j the chain consist of just one matrix Ai....i=Ai so no scalar multiplication are necessary
to compute the product. Thus m [i, j] = 0 for i= 1, 2, 3....n.

If i<j we assume that to optimally parenthesize the product we split it between A k and
Ak+1 where i≤ k ≤j. Then m [i,j] equals the minimum cost for computing the subproducts
Ai....k and Ak+1....j+ cost of multiplying them together. We know Ai has dimension pi-1 x pi,
so computing the product Ai....k and Ak+1....jtakes pi-1 pk pj scalar multiplication, we obtain

m [i,j] = m [i, k] + m [k + 1, j] + pi-1 pk pj

There are only (j-1) possible values for 'k' namely k = i, i+1.....j-1. Since the optimal
parenthesization must use one of these values for 'k' we need only check them all to
find the best.

So the minimum cost of parenthesizing the product Ai Ai+1......Aj becomes

2
To construct an optimal solution, let us define s [i,j] to be the value of 'k' at which we
can split the product Ai Ai+1 .....Aj To obtain an optimal parenthesization i.e. s [i, j] = k
such that

m [i,j] = m [i, k] + m [k + 1, j] + pi-1 pk pj

Example of Matrix Chain Multiplication

Example: We are given the sequence {4, 10, 3, 12, 20, and 7}. The matrices have size 4 x
10, 10 x 3, 3 x 12, 12 x 20, 20 x 7. We need to compute M [i,j], 0 ≤ i, j≤ 5. We know M [i, i]
= 0 for all i.

Let us proceed with

working away from the diagonal. We compute the optimal solution for the product of 2
matrices.

Here P0 to P5 are Position and M1 to M5 are matrix of size (pi to pi-1)

On the basis of sequence, we make a formula

3
In Dynamic Programming, initialization of every method done by '0'.So we initialize it by
'0'.It will sort out diagonally.

We have to sort out all the combination but the minimum output combination is taken
into consideration.

Calculation of Product of 2 matrices:

1. m (1,2) = m1 x m2
= 4 x 10 x 10 x 3
= 4 x 10 x 3 = 120

2. m (2, 3) = m2 x m3
= 10 x 3 x 3 x 12
= 10 x 3 x 12 = 360

3. m (3, 4) = m3 x m4
= 3 x 12 x 12 x 20
= 3 x 12 x 20 = 720

4. m (4,5) = m4 x m5
= 12 x 20 x 20 x 7
= 12 x 20 x 7 = 1680

o We initialize the diagonal element with equal i,j value with '0'.

4
 o After that second diagonal is sorted out and we get all the values corresponded to
it

Now the third diagonal will be solved out in the same way.

Now product of 3 matrices:

M [1, 3] = M1 M2 M3

1. There are two cases by which we can solve this multiplication: ( M1 x M2) + M3, M1+
(M2x M3)
2. After solving both cases we choose the case in which minimum output is there.

M [1, 3] =264

As Comparing both output 264 is minimum in both cases so we insert 264 in table and (
M1 x M2) + M3 this combination is chosen for the output making.

M [2, 4] = M2 M3 M4

1. There are two cases by which we can solve this multiplication: (M2x M3)+M4, M2+(M3 x
M4 )
2. After solving both cases we choose the case in which minimum output is there.

M [2, 4] = 1320

As Comparing both output 1320 is minimum in both cases so we insert 1320 in table
and M2+(M3 x M4) this combination is chosen for the output making.

M [3, 5] = M3 M4 M5
1. There are two cases by which we can solve this multiplication: ( M3 x M4) + M5,
M3+ ( M4xM5)
2. After solving both cases we choose the case in which minimum output is there.

5
 M [3, 5] = 1140

As Comparing both output 1140 is minimum in both cases so we insert 1140 in table
and ( M3 x M4) + M5this combination is chosen for the output making.

Now Product of 4 matrices:

M [1, 4] = M1 M2 M3 M4

There are three cases by which we can solve this multiplication:

1. ( M1 x M2 x M3) M4
2. M1 x(M2 x M3 x M4)
3. (M1 xM2) x ( M3 x M4)

After solving these cases we choose the case in which minimum output is there

M [1, 4] =1080

As comparing the output of different cases then '1080' is minimum output, so we insert
1080 in the table and (M1 xM2) x (M3 x M4) combination is taken out in output making,

M [2, 5] = M2 M3 M4 M5

There are three cases by which we can solve this multiplication:

1. (M2 x M3 x M4)x M5
2. M2 x( M3 x M4 x M5)

6
 3. (M2 x M3)x ( M4 x M5)

After solving these cases we choose the case in which minimum output is there

M [2, 5] = 1350

As comparing the output of different cases then '1350' is minimum output, so we insert
1350 in the table and M2 x( M3 x M4 xM5)combination is taken out in output making.

Now Product of 5 matrices:

M [1, 5] = M1 M2 M3 M4 M5

There are five cases by which we can solve this multiplication:

1. (M1 x M2 xM3 x M4 )x M5
2. M1 x( M2 xM3 x M4 xM5)
3. (M1 x M2 xM3)x M4 xM5
4. M1 x M2x(M3 x M4 xM5)

After solving these cases we choose the case in which minimum output is there

M [1, 5] = 1344
As comparing the output of different cases then '1344' is minimum output, so we
insert 1344 in the table and M1 x M2 x(M3 x M4 x M5)combination is taken out in output
making.
7
Final Output is:

Step 3: Computing Optimal Costs: let us assume that matrix Ai has dimension pi-1x
pi for i=1, 2, 3....n. The input is a sequence (p0,p1,......pn) where length [p] = n+1. The
procedure uses an auxiliary table m [1....n, 1.....n] for storing m [i, j] costs an auxiliary
table s [1.....n, 1.....n] that record which index of k achieved the optimal costs in
computing m [i, j].

The algorithm first computes m [i, j] ← 0 for i=1, 2, 3.....n, the minimum costs for the
chain of length 1.

Algorithm of Matrix Chain Multiplication

MATRIX-CHAIN-ORDER (p)

1. n length[p]-1
2. for i ← 1 to n
3. do m [i, i] ← 0
4. for l ← 2 to n // l is the chain length
5. do for i ← 1 to n-l + 1
6. do j ← i+ l -1
7. m[i,j] ← ∞
8. for k ← i to j-1
9. do q ← m [i, k] + m [k + 1, j] + pi-1 pk pj
10. If q < m [i,j]
11. then m [i,j] ← q
12. s [i,j] ← k
13. return m and s.

We will use tables to construct an optimal solution.

8
 6. Let's try to trace the steps of above algorithm using an example:

In the table below, we have 6 activities with corresponding start and end time, the
objective is to compute an execution schedule having maximum number of non-
conflicting activities:

Start Time (s) Finish Time (f) Activity Name

5 9 a1
1 2 a2
3 4 a3
0 6 a4
5 7 a5
8 9 a6

Activity Selection Problem

The Activity Selection Problem is an optimization problem which deals with the selection
of non-conflicting activities that needs to be executed by a single person or machine in
a given time frame.

Each activity is marked by a start and finish time. Greedy technique is used for finding
the solution since this is an optimization problem.

What is Activity Selection Problem?

Let's consider that you have n activities with their start and finish times, the objective is
to find solution set having maximum number of non-conflicting activities that can be
executed in a single time frame, assuming that only one person or machine is available
for execution.

Some points to note here:

 It might not be possible to complete all the activities, since their timings can
collapse.

 Two activities, say i and j, are said to be non-conflicting if si >= fj or sj >=

fi where si and sj denote the starting time of activities i and j respectively,
and fi and fj refer to the finishing time of the activities i and j respectively.

 Greedy approach can be used to find the solution since we want to maximize
the count of activities that can be executed. This approach will greedily choose an
activity with earliest finish time at every step, thus yielding an optimal solution.
9
Input Data for the Algorithm:

 act[] array containing all the activities.

 s[] array containing the starting time of all the activities.

 f[] array containing the finishing time of all the activities.

Ouput Data from the Algorithm:

 sol[] array refering to the solution set containing the maximum number of non-
conflicting activities.

Steps for Activity Selection Problem

Following are the steps we will be following to solve the activity selection problem,

Step 1: Sort the given activities in ascending order according to their finishing time.

Step 2: Select the first activity from sorted array act[] and add it to sol[] array.

Step 3: Repeat steps 4 and 5 for the remaining activities in act[].

Step 4: If the start time of the currently selected activity is greater than or equal to the
finish time of previously selected activity, then add it to the sol[] array.

Step 5: Select the next activity in act[] array.

Step 6: Print the sol[] array.

Activity Selection Problem Example

Let's try to trace the steps of above algorithm using an example:

In the table below, we have 6 activities with corresponding start and end time, the
objective is to compute an execution schedule having maximum number of non-
conflicting activities:

10
 Start Time (s) Finish Time (f) Activity Name
5 9 a1
1 2 a2
3 4 a3
0 6 a4
5 7 a5
8 9 a6
A possible solution would be:

Step 1: Sort the given activities in ascending order according to their finishing time.

The table after we have sorted it:

Start Time (s) Finish Time (f) Activity Name

1 2 a2
3 4 a3
0 6 a4
5 7 a5
5 9 a1
8 9 a6
Step 2: Select the first activity from sorted array act[] and add it to the sol[] array,
thus sol = {a2}.
Step 3: Repeat the steps 4 and 5 for the remaining activities in act[].
Step 4: If the start time of the currently selected activity is greater than or equal to the
finish time of the previously selected activity, then add it to sol[].
Step 5: Select the next activity in act[]
For the data given in the above table,

A. Select activity a3. Since the start time of a3 is greater than the finish time
of a2 (i.e. s(a3) > f(a2)), we add a3 to the solution set. Thus sol = {a2, a3}.
B. Select a4. Since s(a4) < f(a3), it is not added to the solution set.
C. Select a5. Since s(a5) > f(a3), a5 gets added to solution set. Thus sol = {a2, a3,
a5}
D. Select a1. Since s(a1) < f(a5), a1 is not added to the solution set.
E. Select a6. a6 is added to the solution set since s(a6) > f(a5). Thus sol = {a2, a3,
a5, a6}.
Step 6: At last, print the array sol[]
Hence, the execution schedule of maximum number of non-conflicting activities will be:

11
(1,2)

(3,4)

(5,7)

(8,9)

In the above diagram, the selected activities have been highlighted in grey.

12