Data Structures and Algorithms

Lecture notes: Algorithm paradigms: Dynamic

programming

Lecturer: Michel Toulouse

Hanoi University of Science and Technology

[email protected]

6 octobre 2020
Outline
Problems with divide-and-conquer
Introduction to dynamic programming
The making change problem
Optimal substructure
0-1 Knapsack Problem
Matrix-chain multiplication
Longest common subsequence
Floyd’s algorithm
Problems that fail the optimal substructure test
Conclusion
Final exercises
Problems with divide-and-conquer

During the divide part of divide-and-conquer some subproblems could

could be generated more than one time.

If subproblems are duplicated, the computation of the solution of the

subproblems is also duplicated, solving the same subproblems several
times obviously yield very poor running times.
Example : D&C algo for computing the Fibonacci numbers

It is a sequence of integers. After the first two numbers in the

sequence, each other number is the sum of the two previous numbers
in the sequence :

1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89

The following divide-and-conquer algorithm computes the first n + 1

values of the Fibonacci sequence :

function Fib(n)
if (n ≤ 1) then return n ;
else
return Fib(n − 1) + Fib(n − 2)
Computing Fibonacci numbers

function Fib(n)
if (n ≤ 1) then return n ;
else
return(Fib(n − 1) + Fib(n − 2)) ;

First the following divide steps take place :

Fib(7) = Fib(6) + Fib(5)
Fib(6) = Fib(5) + Fib(4)
Fib(5) = Fib(4) + Fib(3)
Fib(4) = Fib(3) + Fib(2)
Fib(3) = Fib(2) + Fib(1)
Fib(2) = Fib(1) + Fib(0)
Fib(1) = 1
Fib(0) = 0
Computing Fibonacci numbers

function Fib(n)
if (n ≤ 1) then return n ;
else
return Fib(n − 1) + Fib(n − 2) ;

Next solutions to sub-problems are combined to obtain the solution of

the original problem instance :
Fib(0) = 0
Fib(1) = 1
Fib(2) = Fib(1) + Fib(0) = 1+0 = 1
Fib(3) = Fib(2) + Fib(1) = 1+1 = 2
Fib(4) = Fib(3) + Fib(2) = 2+1 = 3
Fib(5) = Fib(4) + Fib(3) = 3+2 = 5
Fib(6) = Fib(5) + Fib(4) = 5+3 = 8
Fib(7) = Fib(6) + Fib(5) = 8+5 = 13
Time complexity of DC Fibonacci

function Fib(n)
if (n ≤ 1) then return n ;
else
return Fib(n − 1) + Fib(n − 2) ;

One possible recurrence relation for this algorithm that counts the
number of time the function Fib is called is the following :

 1 if n=0
T(n) = 1 if n=1
T(n − 1) + T(n − 2) + 1 if n > 1


√
The solution of this recurrence is O(( 1+2 5 )n ), the time complexity is
exponential.
Call tree of D&C Fibonacci

function Fib(n)
if (n ≤ 1) then return n ;
else
return Fib(n − 1) + Fib(n − 2) ;

The poor time complexity of Fib derived from re-solving the same
sub-problems several times.

D&C generates the following call tree :

F(n)
F(n-1) F(n-2)

F(n-2) F(n-3) F(n-3) F(n-4)

F(n-3) F(n-4) F(n-4) F(n-5) F(n-4) F(n-5) F(n-5) F(n-6)

Dynamic Programming

Dynamic programming algorithms avoid recomputing the solution of

same subproblems by storing the solution of subproblems the first time
they are computed, and referring to the stored solution when needed.

So, instead of solving the same subproblem repeatedly, arrange to solve

each subproblem only one time

Save the solution to a subproblem in a table (an array), and refer back
to the table whenever we revisit the subproblem
Dynamic programming main ideas

Instead of solving the same subproblem repeatedly, arrange to solve

each subproblem only one time

Save the solution to a subproblem in a table, and refer back to the

table whenever we revisit the subproblem

”Store, don’t recompute”

0 1 2 3 4 5 6 7 8 9 10
0 1 2 3

I here computing Fib(4) and Fib(5) both require Fib(3), but Fib(3)
is computed only once

Can turn an exponential-time solution into a polynomial-time solution

Designing dynamic programming algorithms

There are two dynamic programming algorithm design options :

I Top down : start to compute with the whole problem
I Bottom up : start to compute with the D&C base case
Top-down dynamic programming for Fibonacci
A top-down design is a recursive algorithm where the original problem
is decomposed into smaller problems and once the base cases are
solved, solutions to subproblems are computed out of results in the
table :

function DyFib(n)
if (n == 0) return 0 ;
if (n == 1) return 1 ;
if (table[n] != 0) return table[n] ;
else
table[n] = DyFib(n − 1) + DyFib(n − 2)
return table[n] ;

input 0 1 2 3 4 5 6 7 8 9 10 11 12 13
solution 0 1
Bottom up dynamic programming for Fibonacci
Bottom up design is an iterative algorithm which first compute the
base cases and then uses the solutions to the base cases to start
computing the solutions to the other larger subproblems :
function fib dyn(n)
int *table, i ;
table = malloc((n + 1) ∗ sizeof(int)) ;
for (i = 0; i ≤ n; i + +)
if (i ≤ 1)
table[i] = i ;
else
table[i] = table[i − 1] + table[i − 2] ;
return f [n] ;

input 0 1 2 3 4 5 6 7 8 9 10 11 12 13
solution 0 1

√
fib dyn ∈ Θ(n) as opposed to the exponential complexity O(( 1+2 5 )n )
for fib rec.
When do we need DP

Before writing a dynamic programming algorithm, first do the

following :
I Write a divide-and-conquer algorithm to solve the problem
I Next, analyze its running time, if it is exponential then :
I it is likely that the divide-and-conquer generates a large number of
identical subproblems
I therefore solving many times the same subproblems
If D&C has poor running times, we can consider DP.

But successful application of DP requires that the problem satisfies

some conditions, which will be introduced later...
Writing a DP algorithm : the bottom-up approach

Writing a DP often starts by writing a D&C recursive algorithm and

use the D&C recursive code to write an iterative bottom up DP
algorithm :
I Create a table that will store the solution of the subproblems
I Use the “base case” of recursive D&C to initialize the table
I Devise look-up template using the recursive calls of the D&C
algorithm
I Devise for-loops that fill the table using look-up template
I The function containing the for loop returns the last entry that
has been filled in the table.
An example : making change

Devise an algorithm for paying back a customer a certain amount using

the smallest possible number of coins.

For example, what is the smallest amount of coins needed to pay back
$2.89 (289 cents) using as denominations ”one dollars”, ”quaters”,
”dimes” and ”pennies”.

The solution is 10 coins, i.e. 2 one dollars, 3 quaters, 1 dime and 4

pennies.
Making change : a recursive solution

Assume we have an infinite supply of n different denominations of

coins.

A coin of denomination i worth di units, 1 ≤ i ≤ n. We need to return

change for N units.

Here is a recursive D&C algorithm for returning change :

function Make Change(i,j)
if (j == 0) then return 0 ;
else
return min(make change(i − 1, j), make change(i, j − di ) + 1) ;

The function is called initially as Make Change(n,N).

C code implementing recursive make change

#include <stdio.h>
#define min(a,b)((a<b)? a:b)
int make_change(int d[], int n, int N)
{
if(N == 0) return 0;
else if (N < 0 || (N > 0 && n <= 0)) return 1000;
else{
return min(make_change(d,n-1,N), make_change(d,n,N-d[n-1]) + 1);
}
}
int main()
{
int d[] = {1, 5, 10, 25};
int N = 13;
int n = sizeof(d)/sizeof(d[0]);
int ans = make_change(d, n, N);
printf("Minimal # of coins = %d\n",ans);
return 0;
}
Making change : DP approach

Assume n = 3, d1 = 1, d2 = 4 and d3 = 6. Let N = 8.

To solve this problem by dynamic programming we set up a table

t[1..n, 0..N], one row for each denomination and one column for each
amount from 0 unit to N units.

Amount 0 1 2 3 4 5 6 7 8
d1 = 1
d2 = 4
d3 = 6

The entry t[i, j] indicates the minimum number of coins needed to

refund an amount of j units using only coins from denominations 1 to i.
Making change : DP approach

The initialization of the table is obtained from the D&C base case :

if (j == 0) then return 0

i.e. t[i, 0] = 0, for i = 1, 2, 3

Amount 0 1 2 3 4 5 6 7 8
d1 = 1 0
d2 = 4 0
d3 = 6 0
Making change : DP approach

If i = 1, then only denomination d1 = 1 can be used to return change.

Therefore t[1, j] for j = 1..8 is t[i, j] = t[i, j − di ] + 1

Amount 0 1 2 3 4 5 6 7 8
d1 = 1 0 1 2 3 4 5 6 7 8
d2 = 4 0
d3 = 6 0

For example, the content of entry t[1, 4] = t[1, 3] + 1 means that the
minimum number of coins to return 4 units using only denomination 1
is the minimum number of coins to return 3 units + 1 = 4 coins.
Making change : DP approach

If the amount of change to return is smaller than domination di , then

the change needs to be return using denominations smaller than di

For those cases, i.e. if (j < di ) then t[i, j] = t[i − 1, j]

Amount 0 1 2 3 4 5 6 7 8
d1 = 1 0 1 2 3 4 5 6 7 8
d2 = 4 0 1 2 3
d3 = 6 0 1 2 3 1 2

For all the other entries of the table we write the code of the DP
algorithm using the recursive function
Designing DP from the D&C recursive calls
Here we look at the recursive call of the D&C to design the table
look-up of the DP algorithm :
function Make Change(i,j)
if (j == 0) then return 0 ;
else
return min(make change(i − 1, j), make change(i, j − di )+ 1) ;

The recursive call

min(make change(i − 1, j), make change(i, j − di ) + 1)

indicates two options to fill entry t[i, j] :

1. Don’t use a coin from di , then t[i, j] = t[i − 1, j]
2. Use at least one coin from di , then t[i, j] = t[i, j − di ] + 1.

We deduce the following table look-ups :

t[i, j] = min(t[i − 1, j], t[i, j − di ] + 1)

DP bottom-up algorithm

coins(n, N)
int d[1..n] = d[1, 4, 6] ;
int t[1..n, 0..N] ;
for (i = 1; i ≤ n; i + +) t[i, 0] = 0 ; */base case */
for (i = 1; i ≤ n; i + +)
for (j = 1; j ≤ N; j + +)
if (i == 1) then t[i, j] = t[i, j − di ] + 1
else if (j < d[i]) then t[i, j] = t[i − 1, j]
else t[i, j] = min(t[i − 1, j], t[i, j − d[i]] + 1)
return t[n, N] ;

The algorithm runs in Θ(nN).

Making change : DP approach

Amount 0 1 2 3 4 5 6 7 8
d1 = 1 0 1 2 3 4 5 6 7 8
d2 = 4 0 1 2 3 1 2 3 4 2
d3 = 6 0 1 2 3 1 2 1 2 2

To fill entry t[i, j], j > 0, we have two choices :

1. Don’t use a coin from di , then t[i, j] = t[i − 1, j]
2. Use at least one coin from di , then t[i, j] = t[i, j − di ] + 1.
Since we seek to minimize the number of coins returned, we have

t[i, j] = min(t[i − 1, j], t[i, j − di ] + 1)

The solution is in entry t[n, N]

Making change : getting the coins

Amount 0 1 2 3 4 5 6 7 8
d1 = 1 0 1 2 3 4 5 6 7 8
d2 = 4 0 1 2 3 1 2 3 4 2
d3 = 6 0 1 2 3 1 2 1 2 2

We can use the information in the table to get the list of coins that
should be returned :
I Start at entry t[n, N] ;
I If t[i, j] = t[i − 1, j] then no coin of denomination i has been used
to calculate t[i, j], then move to entry t[i − 1, j] ;
I If t[i, j] = t[i, j − di ] + 1, then add one coin of denomination i and
move to entry t[i, j − di ].
Exercises 1 and 2

1. Construct the table and solve the making change problem where
n = 3 with denominations d1 = 1, d2 = 2 and d3 = 3 where the
amount of change to be returned is N = 7
2. Construct the table and solve the making change problem where
n = 4 with denominations d1 = 1, d2 = 3, d3 = 4 and d4 = 5
where the amount of change to be returned is N = 12
Solutions table
Amount 0 1 2 3 4 5 6 7 8
d1 = 1 0 1 2 3 4 5 6 7 8
d2 = 4 0 1 2 3 1 2 3 4 2
d3 = 6 0 1 2 3 1 2 1 2 2

Each entry in the above table is a solution to a subproblem.

For example, entry t[1, 3] is the solution to the subproblem where an
amount of 3 needs to be returned using only coins of denomination 1.
Amount 0 1 2 3
d1 = 1 0 1 2 3

Entry t[2, 6] is the number of coins that have to be returned when an

amount of 6 needs to be returned using only coins of denomination 1
or 4.
Amount 0 1 2 3 4 5 6
d1 = 1 0 1 2 3 4 5 6
d2 = 4 0 1 2 3 1 2 3
Optimization problems

DP is often used to solve optimization problems that have the

following form
min f (x) or
max f (x) (1)
s.t. some constraints

Making change is an optimization problem. The problem consists to

minimize the function f (x), i.e. to minimize the number of coins
returned

There is only one constraint : the sum of the value of the coins is equal
to the amount to be returned
Optimal Substructure

In solving optimization problems with DP, we find the optimal solution

of a problem of size n by solving smaller problems of same type

The optimal solution of the original problem is made of optimal

solutions from subproblems

Thus the subsolutions within an optimal solution are optimal

subsolutions

Solutions to optimization problems that exhibit this property are say to

be based on optimal substructures
Optimal Substructure

Make Change() exhibits the optimal substructure property :

I Each entry t[i, j] in the table is the optimal solution (minimum
number of coins) that can be used to return an amount of j units
using only denominations d1 to di .
I The optimal solution of problem (i, j) is obtained using optimal
solutions (minimum number of coins) of sub-problems (i − 1, j)
and (i, j − di ).

Amount 0 1 2 3 4 5 6 7 8
d1 = 1 0 1 2 3 4 5 6 7 8
d2 = 4 0 1 2 3 1 2 3 4 2
d3 = 6 0 1 2 3 1 2 1 2 2

The optimal solution for t[i, j] is obtained by comparing t[i − 1, j] and

t[i, j − di ] + 1, taking the smallest of the two.
Optimal Substructure

To compute the optimal solution, we can compute all optimal

subsolutions

Often we start with all optimal subsolutions of size 1, then compute all
optimal subsolutions of size 2 combining some subsolutions of size 1.
We continue in this fashion until we have the solution for n.

Note, not all optimization problems satisfy the optimal substructure

property. When it fails to apply, we cannot use DP.
DP for optimization problems

The basic steps are :

1. Characterize the structure of an optimal solution, i.e. the problem
meet the optimal substructure property
2. Give a recursive definition for computing the optimal solution
based on optimal solutions of smaller problems.
3. Compute the optimal solutions and/or the value of the optimal
solution in a bottom-up fashion.
Integer 0-1 Knapsack Problem

Given n objects with integer weights wi and values vi , you are asked to
pack a knapsack with no more than W weight (W is integer) such
that the load is as valuable as possible (maximize). You cannot take
part of an object, you must either take an object or leave it out.

Example : Suppose we are given 4 objects with the following weights

and values :
Object 1 2 3 4
Weight 1 1 2 2
Value 3 4 5 1

Suppose W = 5 units of weight in our knapsack.

Seek a load that maximize the value

Problem formulation

Given
I n integer weights w1 , . . . , wn ,
I n values v1 , . . . , vn , and
I an integer capacity W ,
assign either 0 or 1 to each of x1 , . . . , xn so that the sum
n
X
f (x) = xi vi
i=1

is maximized, s.t.
n
X
xi wi ≤ W .
i=1
Explanation

xi = 1 represents putting Object i into the knapsack and xi = 0

represents leaving Object i out of the knapsack.

The value of the chosen load is ni=1 xi vi . We want the most valuable
P
load, so we want to maximize this sum.

The weight of the chosen load is ni=1 xi wi . We can’t carry more than
P
W units of weight, so this sum must be ≤ W .
Solving the 0-1 Knapsack

0-1 knapsack is an optimization problem.

Should we apply dynamic programming to solve it ? To answer this

question we need to investigate two things :
1. Whether subproblems are solved repeatedly when using a recursive
algorithm.
2. An optimal solution contains optimal sub-solutions, the problem
exhibits optimal substructure
Optimal Substructure

Does integer 0-1 knapsack exhibits the optimal substructure property ?

Let {x1 , x2 , . . . , xk } be the objects in an optimal solution x.

The optimal value is V = vx1 + vx2 + · · · + vxk .

We must also have that wx1 + wx2 + · · · + wxk ≤ W since x is a

feasible solution.

Claim :
If {x1 , x2 , . . . , xk } is an optimal solution to the knapsack problem with
weight W , then {x1 , x2 , . . . , xk−1 } is an optimal solution to the knapsack
problem with W 0 = W − wxk .
Optimal Substructure
Proof : Assume {x1 , x2 , . . . , xk−1 } is not an optimal solution to the
subproblem. Then there are objects {y1 , y2 , . . . , yl } such that

wy1 + wy2 + · · · + wyl ≤ W 0 ,

and
vy1 + vy2 + · · · + vyl > vx1 + vx2 + · · · + vxk−1 .
Then

vy1 + vy2 + · · · + vyl + vxk > vx1 + vx2 + · · · + vxk−1 + vxk .

However, this implies that the set {x1 , x2 , . . . , xk } is not an optimal

solution to the knapsack problem with weight W .

This contradicts our assumption. Thus {x1 , x2 , . . . , xk−1 } is an optimal

solution to the knapsack problem with W 0 = W − wxk .
Recursive solution : problem decomposition

Seeking for a recursive algorithm to a problem one must think about

the ways the problem can be reduced to subproblems.
Let K [n, W ] denote the 0-1 knapsack problem instance to be solved
where n is the initial number of objects to be considered and W is the
initial capacity of the sack.
There are two ways this problem can be decomposed into smaller
problems. If K [i, j] be the recursive function :
I one can add the ith object in the knapsack, thus reducing the
initial problem to one with i − 1 objects yet to consider and
capacity j − wi : K [i − 1, j − wi ]
I one can choose to disregard object i (don’t put in the sack), thus
generating a new subproblem with i − 1 objects and capacity j
unchanged : K [i − 1, j]
Recursive solution : writing the algorithm

The base case will be when one object is left to consider. The solution
is

v1 if w1 ≤ j
K [1, j] =
0 if w1 > j.

Once the value of the base case is computed, the solution to the other
subproblems is obtained as followed :

K [i − 1, j] if wi > j
K [i, j] =
max(K [i − 1, j], K [i − 1, j − wi ] + vi ) if wi ≤ j.

This recursive function is initially called with K [n, W ].

C code implementing recursive 0-1 knapsack
Here the base case is n = 0 or W = 0, same thing, just generate more
subproblems

#include <stdio.h>
int max(int a, int b) { return (a > b) ? a : b; }
int K(int W, int wt[], int val[], int n) {
// Base Case
if (n == 0 || W == 0) return 0;
if (wt[n - 1] > W) return K(W, wt, val, n - 1);
else return max( val[n - 1] + K(W - wt[n - 1], wt, val, n - 1), K(W, wt, val, n - 1));
}
int main() {
int val[] = { 6, 3, 5, 4, 6};
int wt[] = { 6, 5, 4, 2, 2 };
int W = 10;
int n = sizeof(val) / sizeof(val[0]);
printf("The solution is %d\n", K(W, wt, val, n));
return 0;
}
Divide & Conquer 0-1 Knapsack

int K(i, W )
if (i == 1) return (W < w[1]) ? 0 : v[1]
if (W < w [i]) return K(i − 1, W ) ;
return max(K(i − 1, W ), K(i − 1, W − w [i]) + v [i]) ;

Solve for the following problem instance where W = 10 :

i 1 2 3 4 5
wi 6 5 4 2 2
vi 6 3 5 4 6
 i 1 2 3 4 5
wi 6 5 4 2 2
int K(i, W ) vi 6 3 5 4 6
if (i == 1) return (W < w[1]) ? 0 : v[1] ;
if (W < w [i]) return K(i − 1, W ) ;
return max(K(i − 1, W ), K(i − 1, W − w [i]) + v [i]) ;

5 16 10

4 11 10 4 10 8

3 11 10 3 6 8 3 6 8 3 6 6

2 6 10 2 6 6 2 6 8 2 0 4 2 6 8 2 0 4 2 6 6 2 0 2

1 6 10 1 0 5 1 6 6 1 0 1 1 6 8 1 0 3 1 0 4 1 6 8 1 0 3 1 0 4 1 6 6 1 0 1 1 0 2
Analysis of the Recursive Solution

Let T (n) be the worst-case running time on an input with n objects.

If there is only one object, we do a constant amount of work.

T (1) = 1.

If there is more than one object, this algorithm does a constant

amount of work plus two recursive calls involving n − 1 objects.

1 if n = 1
T (n) =
2T (n − 1) + 1 if n > 1

The solution to this recurrence is T (n) ∈ Θ(2n )

Overlapping Subproblems

We have seen that the maximal value is K [n, W ].

But computing K [n, W ] recursively cost 2n − 1.

While the number of subproblems is only nW .

Thus, if nW < 2n , then the 0-1 knapsack problem will certainly have
overlapping subproblems, therefore using dynamic programming is
most likely to provide a more efficient algorithm.

0-1 knapsack satisfies the two pre-conditions (optimal substructure and

repeated solutions of identical subproblems) justifying the design of an
DP algorithm for this problem.
0-1 Knapsack : Bottom up DP algorithm

Declare a table K of size n × W + 1 that stores the optimal solutions

of all the possible subproblems. Let n = 6, W = 10 and
i 1 2 3 4 5 6
wi 3 2 6 1 7 4
vi 7 10 2 3 2 6

i\j 0 1 2 3 4 5 6 7 8 9 10
1
2
3
4
5
6
0-1 Knapsack : Bottom up DP algorithm

Initialization of the table :

The value of the knapsack is 0 when the capacity is 0. Therefore,

K [i, 0] = 0, i = 1..6.
i\j 0 1 2 3 4 5 6 7 8 9 10
1 0
2 0
3 0
4 0
5 0
6 0
0-1 Knapsack : Bottom up DP algorithm

Initialization of the table using the base case of the recursive function :
if (i == 1) return (W < w[1]) ? 0 : v[1]

This said that if the capacity is smaller than the weight of object 1,
then the value is 0 (cannot add object 1), otherwise the value is v [1]

Since w [1] = 3 we have :

i\j 0 1 2 3 4 5 6 7 8 9 10
1 0 0 0 7 7 7 7 7 7 7 7
2 0
3 0
4 0
5 0
6 0
0-1 Knapsack : Bottom up DP algorithm
The DP code for computing the other entries of the table is based on
the recursive function for 0-1 knapsack :

int K(i, W )
if (i == 1) return (W < w [1]) ? 0 : v [1] ;
if (W < w [i]) return K(i − 1, W ) ;
return max(K(i − 1, W ), K(i − 1, W − w [i]) + v [i]) ;

i\j 0 1 2 3 4 5 6 7 8 9 10
1 0 0 0 7 7 7 7 7 7 7 7
2 0
3 0
4 0
5 0
6 0
0-1 Knapsack : Bottom up DP algorithm
The bottom-up dynamic programming algorithm is now (more or less)
straightforward.
function 0-1-Knapsack(w , v , n, W )
int K[n, W + 1] ;
for(i = 1; i ≤ n; i + +) K [i, 0] = 0 ;
for(j = 0; j ≤ W ; j + +)
if (w [1] ≤ j) then K [1, j] = v [1] ;
else K [1, j] = 0 ;
for (i = 2; i ≤ n; i + +)
for (j = 1; j ≤ W ; j + +)
if (j ≥ w [i] && K [i − 1, j − w [i]] + v [i] > K [i − 1, j])
K [i, j] = K [i − 1, j − w [i]] + v [i] ;
else
K [i, j] = K [i − 1, j] ;
return K[n, W ] ;
0-1 Knapsack Example
i 1 2 3 4 5 6
wi 3 2 6 1 7 4
vi 7 10 2 3 2 6

for (i = 2; i ≤ n; i + +)
for (j = 1; j ≤ W ; j + +)
if (j ≥ w [i] && K [i − 1, j − w [i]] + v [i] > K [i − 1, j])
K [i, j] = K [i − 1, j − w [i]] + v [i] ;
else
K [i, j] = K [i − 1, j] ;

i\j 0 1 2 3 4 5 6 7 8 9 10
1 0 0 0 7 7 7 7 7 7 7 7
2 0 0 10 10 10 17 17 17 17 17 17
3 0 0 10 10 10 17 17 17 17 17 17
4 0 3 10 13 13 17 20 20 20 20 20
5 0 3 10 13 13 17 20 20 20 20 20
6 0 3 10 13 13 17 20 20 20 23 26
Finding the Knapsack

How do we compute an optimal knapsack ?

With this problem, we don’t have to keep track of anything extra. Let
K [n, k] be the maximal value.

If K [n, k] 6= K [n − 1, k], then K [n, k] = K [n − 1, k − wn ] + vn , and the

nth item is in the knapsack.

Otherwise, we know K [n, k] = K [n − 1, k], and we assume that the

nth item is not in the optimal knapsack.
Finding the Knapsack

In either case, we have an optimal solution to a subproblem.

Thus, we continue the process with either K [n − 1, k] or

K [n − 1, k − wn ], depending on whether n was in the knapsack or not.

When we get to the K [1, k] entry, we take item 1 if K [1, k] 6= 0

(equivalently, when k ≥ w [1])
Finishing the Example
I Recall we had :
i 1 2 3 4 5 6
wi 3 2 6 1 7 4
vi 7 10 2 3 2 6

I We work backwards through the table

i\j 0 1 2 3 4 5 6 7 8 9 10
1 0 0 0 7 7 7 7 7 7 7 7
2 0 0 10 10 10 17 17 17 17 17 17
3 0 0 10 10 10 17 17 17 17 17 17
4 0 3 10 13 13 17 20 20 20 20 20
5 0 3 10 13 13 17 20 20 20 20 20
6 0 3 10 13 13 17 20 20 20 23 26

I The optimal knapsack contains {1, 2, 4, 6}

Exercise 3 : 0-1 Knapsack

Solve the following 0-1 knapsack instance with W = 10 :

i 1 2 3 4 5
wi 6 5 4 2 2
vi 6 3 5 4 6

i\j 0 1 2 3 4 5 6 7 8 9 10
1 0
2 0
3 0
4 0
5 0

What is the optimal value ? Which objects are part of the optimal
solution ?
Exercise 4 : 0-1 Knapsack

Solve the following 0-1 knapsack problem : W = 10

i 1 2 3 4 5 6
wi 4 2 3 1 6 4
vi 6 4 5 3 9 7
Matrix-Chain Multiplication Problem (MCM)

Given a sequence of matrices A1 , A2 , . . . , An , where matrix Ai has size

a × b, find a full parenthesization of the product A1 A2 · · · An such that
the number of scalar multiplications required to compute A1 A2 · · · An
is minimized.

Recall that to compute the product of an a × b matrix with a matrix

b × c requires abc scalar multiplications.
MCM Example

We can express the sizes of the sequence of matrices as a sequence

d0 , d1 , . . . , dn of n + 1 positive integers, since the number of columns
of Ai is the number of rows of Ai+1 for each i.

If we are given four matrices, A1 , A2 , A3 , and A4 with sizes 100 × 3,

3 × 20, 20 × 50, 50 × 150, they can be represented by the sequence
100, 3, 20, 50, 150.

Assume we want to compute the product A1 A2 A3 A4 .

Two (of the 5) ways to compute this product are (A1 (A2 (A3 A4 ))) and
((A1 A2 )(A3 A4 )).
MCM Example

Computing the product as (A1 (A2 (A3 A4 ))) requires 208,500

operations, and computing it as ((A1 A2 )(A3 A4 )) requires 456,000
operations.

(A1 ( A2 ( A3 A4 )) ) ( (A1 A2 ) ( A3 A4 ))
100x3 3x20 20x50 50x150 100x3 3x20 20x50 50x150
A1 A2 A3 A4 A1 A2 A3 A4

100x3 3x20 20x150 20*50*150 100x3 3x20 20x150 20*50*150

A1 A2 B A1 A2 B

100x3 3x150 3*20*150 100*3*20 100x20 20x150

A1 C C B
100*3*150 100x150 100*20*150
100x150
Total=204,000 Total=456,000
D D
An Optimal Solution

Notice that an optimal solution will look like (A1 · · · Ak )(Ak+1 · · · An ),

where 1 ≤ k < n, and the two halves are parenthesized in some way.

The cost of the optimal solution is the cost of each of the two
subsolutions plus the cost of multiplying the final two matrices.

The parenthesization of A1 · · · Ak and Ak+1 · · · An must be optimal.

Solving MCM

Let M[i, j] be the minimum number of scalar multiplications for

parenthesizing Ai Ai+1 · · · Aj .

Notice that M[i, i] = 0 for all i.

We need to compute M[1, n], the optimal solution to parenthesizing

A1 A2 · · · An .

An optimal subsolution will split the subproduct into two halves, each
half of which is optimal as well.
Solving MCM

Since the split occurs at some k, where i ≤ k < j, we can compute

M[i, j] = min {M[i, k] + M[k + 1, j] + di−1 dk dj }.

i≤k<j

We have two possibilities at this point.

1. Find M[1, n] using a divide-and-conquer algorithm.
2. Compute the entries M[i, j], 1 ≤ i, j < n, from the bottom up.
The first method results in an algorithm with an exponential time
complexity
Divide-and-Conquer for MCM

int M(i, j)
if i == j then return (0) ;
else
return mini≤k<j (M(i, k) + M(k + 1, j) + di−1 dk dj ) ;

The recursion tree for the MCM problem with 4 matrices :

M[1,4] =Already Computed

M[1,1] M[2,4] M[1,2] M[3,4] M[1,3] M[4,4]

M[2,2] M[3,4] M[2,3] M[4,4] M[1,1] M[2,2] M[3,3] M[4,4] M[1,1] M[2,3] M[1,2] M[3,3]

M[3,3] M[4,4] M[2,2] M[3,3]

M[2,2] M[3,3] M[1,1] M[2,2]
Divide-and-Conquer for MCM

M[1,4]
=Already Computed

M[1,1] M[2,4] M[1,2] M[3,4] M[1,3] M[4,4]

M[2,2] M[3,4] M[2,3] M[4,4] M[1,1] M[2,2] M[3,3] M[4,4] M[1,1] M[2,3] M[1,2] M[3,3]

M[3,3] M[4,4] M[2,2] M[3,3]

M[2,2] M[3,3] M[1,1] M[2,2]

I Notice that many of the calls are repeated (all the shaded boxes).
I The divide-and-conquer algorithm has the following recurrence
n−1
X
T (n) = (T (k) + T (n − k)) + cn
k=1

with T (0) = 0 and T (1) = 1.

Analysis of the recurrence for MCM

If n > 0,
n−1
X
T (n) = 2 T (k) + cn
k=1

Therefore Pn−1
T (n) − T (n − 1) = (2 k=1 T (k) + cn)
Pn−2
− (2 k=1 T (k) + c(n − 1))
= 2T (n − 1) + c
That is

T (n) = 3T (n − 1) + c
Analysis of the recurrence for MCM

T (n) = 3T (n − 1) + c
= 3(3T (n − 2) + c) + c
= 9T (n − 2) + 3c + c
= 9(3T (n − 3) + c) + 3c + c
= 27T (n − 3) + 9c + 3c + c
Pk−1
= 3k T (n − k) + c l=0 3l
Pn−1
= 3n T (0) + c l=0 3l
n
= c3n + c 3 2−1
= (c + c2 )3n − c2
T (n) ∈ Θ(3n ).

With T (n) ∈ Θ(3n ), i.e., with exponential complexity, this

divide-and-conquer algorithm is impracticable for large values of n.
Dynamic programming solution

If we have the optimal solutions to all subproblems involving k

matrices, we can use the recurrence to find optimal solutions to
subproblems involving k + 1 matrices without any recursive calls.

We then can compute each optimal subsolution in at most n steps.

Dynamic programming solution

There are about n2 /2 subproblems.

Thus, computing all of the optimal subsolutions, including the solution

itself, from the bottom up requires n × n2 /2 ∈ Θ(n3 ) time.

In summary, to solve the problem, we compute all subproblems

involving 1 matrix (trivial), then 2 matrices, then 3 matrices, . . ., then
n matrices.
MCM Example

We are given the sequence (4, 10, 3, 12, 20, 7).

The matrices have sizes 4 × 10, 10 × 3, 3 × 12, 12 × 20, and 20 × 7.

We need to compute M[i, j], 1 ≤ i, j ≤ 5.

We know M[i, i] = 0 for all i.

1 2 3 4 5
0 1
0 2
0 3
0 4
0 5
MCM Example

We proceed, working away from the diagonal. We compute the optimal

solutions for products of 2 matrices.
1 2 3 4 5
0 120 1
0 360 2
0 720 3
0 1680 4
0 5
MCM Example (continued)

Now products of 3 matrices. d = (4, 10, 3, 12, 20, 7)


M[1, 2] + M[3, 3] + d0 d2 d3 = 120 + 0 + 4 · 3 · 12 = 264
M[1, 3] = min
M[1, 1] + M[2, 3] + d0 d1 d3 = 0 + 360 + 4 · 10 · 12 = 840

M[2, 3] + M[4, 4] + d1 d3 d4 = 360 + 0 + 10 · 12 · 20 = 2760
M[2, 4] = min
M[2, 2] + M[3, 4] + d1 d2 d4 = 0 + 720 + 10 · 3 · 20 = 1320

M[3, 4] + M[5, 5] + d2 d4 d5 = 720 + 0 + 3 · 20 · 7 = 1140
M[3, 5] = min
M[3, 3] + M[4, 5] + d2 d5 d5 = 0 + 1680 + 3 · 12 · 7 = 1932

1 2 3 4 5 1 2 3 4 5
0 120 1 0 120 264 1
0 360 2 0 360 1320 2
⇒
0 720 3 0 720 1140 3
0 1680 4 0 1680 4
0 5 0 5
MCM Example (continued again)

Now products of 4 matrices. p = (4, 10, 3, 12, 20, 7)


 M[1, 3] + M[4, 4] + d0 d3 d4 = 264 + 0 + 4 · 12 · 20 = 1224
M[1, 4] = min M[1, 2] + M[3, 4] + d0 d2 d4 = 120 + 720 + 4 · 3 · 20 = 1080
M[1, 1] + M[2, 4] + d0 d1 d4 = 0 + 1320 + 4 · 10 · 20 = 2120


 M[2, 4] + M[5, 5] + d1 d4 d5 = 1320 + 0 + 10 · 20 · 7 = 2720
M[2, 5] = min M[2, 3] + M[4, 5] + d1 d3 d5 = 360 + 1680 + 10 · 12 · 7 = 2880
M[2, 2] + M[3, 5] + d1 d2 d5 = 0 + 1140 + 10 · 3 · 7 = 1350


1 2 3 4 5 1 2 3 4 5
0 120 264 1 0 120 264 1080 1
0 360 1320 2 0 360 1320 1350 2
⇒
0 720 1140 3 0 720 1140 3
0 1680 4 0 1680 4
0 5 0 5
MCM Example (continued again)

Now the product of 5 matrices. p = (4, 10, 3, 12, 20, 7)



 M[1, 4] + M[5, 5] + d0 d4 d5 = 1080 + 0 + 4 · 20 · 7 = 1640
M[1, 3] + M[4, 5] + d0 d3 d5 = 264 + 1680 + 4 · 12 · 7 = 2016

M[1, 5] = min

 M[1, 2] + M[3, 5] + d0 d2 d5 = 120 + 1140 + 4 · 3 · 7 = 1344
M[1, 1] + M[2, 5] + d0 d1 d5 = 0 + 1350 + 4 · 10 · 7 = 1630


1 2 3 4 5 1 2 3 4 5
0 120 264 1080 1 0 120 264 1080 1344 1
0 360 1320 1350 2 0 360 1320 1350 2
⇒
0 720 1140 3 0 720 1140 3
0 1680 4 0 1680 4
0 5 0 5
MCM Example : Optimal Cost and Solution

The optimal cost is M[1, 5] = 1344.

What is the optimal parenthesization ?

We didn’t keep track of enough information to find that out.

We can modify the algorithm slightly and keep enough information to

get the optimal parenthesization.

Each time we find the optimal value for M[i, j], we also store the value
of k that we used.

Then we can just work backwards, partitioning the matrices according

to the optimal split.
MCM Example : Optimal Solution

If we did this for the example, we would get

1 2 3 4 5
0 120/1 264/2 1080/2 1344/2 1
0 360/2 1320/2 1350/2 2
0 720/3 1140/4 3
0 1680/4 4
0 5

The k value for the solution is 2, so we have (A1 A2 )(A3 A4 A5 ). The

first half is done.
MCM Example : Optimal Solution

1 2 3 4 5
0 120/1 264/2 1080/2 1344/2 1
0 360/2 1320/2 1350/2 2
0 720/3 1140/4 3
0 1680/4 4
0 5

The optimal solution for the second half comes from entry M[3, 5].

The value of k here is 4, so now we have (A1 A2 )((A3 A4 )A5 ).

Thus the optimal solution is to parenthesize as (A1 A2 )((A3 A4 )A5 ).

MCM : Dynamic Programming Algo.

int MCM(int *MM, int n) {

int M[n, n], min ;
for (i = 1; i ≤ n; i + +) M[i, i] := 0 ;
for (s = 1; s < n; s + +)
for (i = 1; i ≤ n − s; i + +)
min = ∞ ;
for (k = i; k < i + s; k + +)
if (M[i, k] + M[k + 1, i + s] + di−1 dk di+s < min)
min = M[i, k] + M[k + 1, i + s] + di−1 dk di+s ;
M[i, i + s] = min ;}

This
Pn algorithm has 3 nested loops. The summation is
Pn−1 Pi+s
s=1 i=1 k=i 1. The complexity of dynamic programming MCM is
3
Θ(n ).
Exercises 6 and 7 on matrix-chain multiplications

6. Given the sequence 2, 3, 5, 2, 4, 3, how many matrices do we

have and what is the dimension of each matrix. Using the previous
dynamic programming algorithm for matrix-chain multiplication,
compute the parenthetization of these matrices that minimize the
number of scalar multiplications.
7. Given the sequence 5, 4, 6, 2, 7, how many matrices do we have
and what is the dimension of each matrix. Using the previous
dynamic programming algorithm for matrix-chain multiplication,
compute the parenthetization of these matrices that minimize the
number of scalar multiplications.
Longest common subsequence (LCS)

A subsequence is a sequence that appears in the same relative order,

but not necessarily contiguous. For example, ”abc” and ”ace” are
subsequences of ”abcdef”.

LCS problem : Given 2 sequences, X = [x1 . . . xm ] and Y = [y1 . . . yn ],

find a subsequence common to both whose length is longest.

For example, ”ADH” is a subsequence of length 3 of the input

sequences ”ABCDGH” and ”AEDFHR”.
Brute-force algorithm for LCS

Brute-force algorithm : For every subsequence of X , check whether it

is a subsequence of Y . Time : Θ(n2m )
I 2m subsequences of X to check
I Each subsequence takes Θ(n) time to check : scan Y for first
letter, from there scan for second, and so on.
Optimal substructure

Consider the input sequences be X = [x1 . . . xm ] and Y = [y1 . . . yn ]

respectively of length m and n.

Let lcs(X [1..m], Y [1..n]) be the length of the LCS of X and Y . The
length of the LCS is computed recursively as follow :

I if the last character of both sequences match, i.e. if

X [m] == Y [n] then
lcs(X [1..m], Y [1..n]) = 1 + lcs(X [1..m − 1], Y [1..n − 1])

I if the last character of both sequences do not match, i.e. if

X [m] 6= Y [n] then lcs(X [1..m], Y [1..n]) =
max(lcs(X [1..m − 1], Y [1..n]), lcs(X [1..m], Y [1..n − 1]))
Optimal substructure

Given sequences ”AGGTAB” and ”GXTXAYB”, last characters match,

so length of LCS can be written as :
lcs(”AGGTAB”, ”GXTXAYB”) = 1 + lcs(”AGGTA”, ”GXTXAY ”)

For sequences ”ABCDGH” and ”AEDFHR”, the last characters do not

match, so length of LCS is : lcs(”ABCDGH”, ”AEDFHR”) =
max(lcs(”ABCDG ”, ”AEDFHR”), lcs(”ABCDGH”, ”AEDFH”))

So the LCS problem has optimal substructure property as the optimal

solution of the main problem can be solved using optimal solutions to
subproblems.
A recursive algorithm for LCS

int lcs(char *X, char *Y, int i, int j )

if (i == 0||j == 0) return 0 ;
if (X [i] == Y [j])
return 1 + lcs(X , Y , i − 1, j − 1) ;
else
return max(lcs(X , Y , i, j − 1), lcs(X , Y , i − 1, j)) ;

Time complexity of this recursive algorithm is O(2n ) in worst case and

worst case happens when all characters of X and Y mismatch i.e.,
length of LCS is 0.

Building a partial call tree for sequences ”AXYT” and ”AYZX”, it can
be verified that the recursive algorithm solves the same subproblems
several times. Soon you will observe that lcs(”AXY ”, ”AYZ ”) is being
solved twice.
Top Down DP algorithm for LCS

int TD − DP − lcs(char ∗X, char ∗Y , int i, int j)

if (i == 0||j == 0)
table[i, j] = 0 ; /* re-calculate each time */
return table[i, j] ;
if (X [i] == Y [j])
if (table[i, j] == −1)
table[i, j] = 1 + TD − DP − lcs(X , Y , i − 1, j − 1) ;
return table[i, j]
else return table[i, j] ;
if (X [i] 6= Y [j])
if (table[i, j] == −1)
table[i, j] = max(TD − DP − lcs(X , Y , i, j − 1),
TD − DP − lcs(X , Y , i − 1, j)) ;
return table[i, j]
else return table[i, j] ;
Bottom up DP for LCS

LCS-Length(X,Y,m,n)
let b[1..m, 1..n] and c[0..m, 0..n]
for i = 1 to m c[i, 0] = 0
for j = 0 to n c[0, j] = 0
for i = 1 to m
for j = 1 to n
if X [i] == Y [j]
c[i, j] = c[i − 1, j − 1] + 1
b[i, j] =”-”
else if c[i − 1, j] ≥ c[i, j − 1]
c[i, j] = c[i − 1, j]
b[i, j] =”↑”
else c[i, j] = c[i, j − 1]
b[i, j] =”←”
return c and b

Computational complexity is Θ(mn)

Example

LCS-Length(X,Y,m,n)
let b[1..m, 1..n] and c[0..m, 0..n]
for i = 1 to m c[i, 0] = 0
for j = 0 to n c[0, j] = 0
for i = 1 to m
for j = 1 to n
if X [i] == Y [j]
c[i, j] = c[i − 1, j − 1] + 1
b[i, j] =”-”
else if c[i − 1, j] ≥ c[i, j − 1]
c[i, j] = c[i − 1, j] X = [ABCBDAB]
b[i, j] =”↑”
Y = [BDCABA]
else c[i, j] = c[i, j − 1]
b[i, j] =”←” m = 7; n = 6
return c and b LCS is [BCBA]
Printing the LCS

Print-LCS(b,X,i,j)
if i == 0 or j == 0 return
if b[i, j] == ”-”
Print-LCS(b,X,i-1,j-1)
print xi
else if b[i, j] == ”↑”
Print-LCS(b,X,i-1,j)
else if b[i, j] == ”←”
Print-LCS(b,X,i,j-1)

Computational complexity is Θ(m + n)

Printing the LCS

I Initial call is Print-LCS(b,X,m,n)

I b[i, j] points to table entry whose subproblem we used in solving
LCS of Xi and Yj .
I When b[i, j] =-, we have extended LCS by one character. So
longest common subsequence = entries with - in them
Exercises : longest common subsequences

8. Find the LCS for X = [ABAZDC ] and Y = [BACBAD]

9. Prove that the LCS for the input sequences X = [ABCDGH] and
Y = [AEDFHR] is ”ADH” of length 3.
The All-Pairs Shortest-Path Problem

Problem definition :
I Let G = {V , E } be a connected “directed” graph where V is the
set of nodes (|V | = n) and E is the set of edges.
I Each edge has an associated nonnegative length
The All-Pairs Shortest-Path Problem

We have a distance matrix L[i, j] that gives the length of each edge :
I L[i, i] = 0, L[i, j] ≥ 0 if i 6= j,
I L[i, j] = ∞ if the edge (i, j) does not exist.

Finally we have a function S − Path(i, j, k) that returns the length of

the shortest path from node i to j using only nodes in the set
{1, 2, . . . , k} as intermediate points.

The goal is to find the shortest path between each pair of nodes i and
j using {1, 2, . . . , n}
Shortest path D&C

For each of these pairs of vertices, S − Path(i, j, k) could be either

1. a path that doesn’t go through node k (only uses nodes in the set
{1, 2, . . . , k − 1} or
2. a path that does go through node k, from i to k then from k to j
using only intermediate nodes {1, 2, . . . , k − 1}
The shortest path from i to j using only nodes in {1, 2, . . . , k − 1} is
computed by S − Path(i, j, k − 1)

If there is a better path from i to k to j, then the length of this path

would be the concatenation of the shortest path from i to k (only
using intermediate vertices in {1, 2, . . . , k − 1}) and the shortest path
from k to j (only using intermediate vertices in {1, 2, . . . , k − 1}).
Shortest path D&C

Then we can define S − Path(i, j, k) as a recursive function to

compute the shortest path between nodes i and j

function S − Path(i, j, k)
if (k == 0) then return L[i, j] ; /* Base case */
else
return min(S − Path(i, j, k − 1),
S − Path(i, k, k − 1) + S − Path(k, j, k − 1))

The initial call is S − Path(i, j, n). This function is run for each pair of
node i and j

The above algorithm is at the core of the Floyd-Warshall dynamic

programming algorithm to solve the all pairs of shortest paths problem.
Floyd-Warshall Algorithm
It is a bottom up dynamic programming algorithm. It starts by
computing the shortest path for all pairs of nodes for k = 1. Then it
considers k = 2, until k = n.

A matrix D that gives the length of the shortest path between each
pair of nodes.

D is initialized to L, the direct distances between nodes.

Algorithm Floyd(L[n, n])

D=L
for (k = 1; k ≤ n; k + +)
for (i = 1; i ≤ n; i + +)
for (j = 1; j ≤ n; j + +)
D[i, j] = min(D[i, j], D[i, k] + D[k, j])
return D

After each iteration k, D contains the length of the shortest paths that
only use nodes in {1, 2, . . . , k} as intermediate nodes.
Floyd Algorithm

Algorithm Floyd(L[n, n])

D=L
for (k = 1; k ≤ n; k + +)
for (i = 1; i ≤ n; i + +)
for (j = 1; j ≤ n; j + +)
D[i, j] = min(D[i, j], D[i, k] + D[k, j])
return D

At iteration k, the algo checks each pair of nodes (i, j) whether or not
there exists a path from i to j passing through node k that is better
than the present optimal path passing only through nodes in
{1, 2, . . . , k − 1}.

If Dk represents the matrix D after the k-th iteration (so D0 = L), the
necessary check can be implemented by

D[i, j] = min(D[i, j], D[i, k] + D[k, j])

Execution of Floyd’s algorithm
Algorithm Floyd(L[n, n])
D=L
for (k = 1; k ≤ n; k + +)
for (i = 1; i ≤ n; i + +)
for (j = 1; j ≤ n; j + +)
D[i, j] = min(D[i, j], D[i, k] + D[k, j])
return D
Base case D = L, the smallest problem instances
Execution of Floyd’s algorithm
Algorithm Floyd(L[n, n])
D =L
for (k = 1; k ≤ n; k + +)
for (i = 1; i ≤ n; i + +)
for (j = 1; j ≤ n; j + +)
D[i, j] = min(D[i, j], D[i, k] + D[k, j])
return D

For k = 1, compute the shortest path between each pair of nodes (i, j)
when the path is allowed to pass through node 1.
Execution of Floyd’s algorithm
Algorithm Floyd(L[n, n])
D =L
for (k = 1; k ≤ n; k + +)
for (i = 1; i ≤ n; i + +)
for (j = 1; j ≤ n; j + +)
D[i, j] = min(D[i, j], D[i, k] + D[k, j])
return D

For k = 2, compute the shortest path between each pair of nodes (i, j)
when the path is allowed to pass through nodes 1 and 2.
Execution of Floyd’s algorithm
Algorithm Floyd(L[n, n])
D =L
for (k = 1; k ≤ n; k + +)
for (i = 1; i ≤ n; i + +)
for (j = 1; j ≤ n; j + +)
D[i, j] = min(D[i, j], D[i, k] + D[k, j])
return D

For k = 3, compute the shortest path between each pair of nodes (i, j)
when the path is allowed to pass through nodes {1, 2, 3}.
Execution of Floyd’s algorithm
Algorithm Floyd(L[n, n])
D =L
for (k = 1; k ≤ n; k + +)
for (i = 1; i ≤ n; i + +)
for (j = 1; j ≤ n; j + +)
D[i, j] = min(D[i, j], D[i, k] + D[k, j])
return D

For k = 4, solution, compute the shortest path between each pair of

nodes (i, j) when the path is allowed to pass through any nodes.
Computing the shortest paths

We want to know the shortest paths, not just their length.

For that we create a new matrix P of size n × n.

Then use the following algorithm in place of the previous one :

Algorithm Floyd(D[n, n])

Input : An array D of shortest path lenghts
Output : The shortest path between every pair of nodes
P[n, n] an n × n array initialized to 0
for (k = 1; k ≤ n; k + +)
for (i = 1; i ≤ n; i + +)
for (j = 1; j ≤ n; j + +)
if D[i, k] + D[k, j] < D[i, j] then
D[i, j] = D[i, k] + D[k, j]
P[i, j] = k ;
Computing the shortest pathsK k = 1

Algorithm Floyd(D[n, n])

Input : An array D of shortest path lenghts
Output : The shortest path between every pair of nodes
P[n, n] an n × n array initialized to 0
for (k = 1; k ≤ n; k + +)
for (i = 1; i ≤ n; i + +)
for (j = 1; j ≤ n; j + +)
if D[i, k] + D[k, j] < D[i, j] then
D[i, j] = D[i, k] + D[k, j]
P[i, j] = k ;

0 0 0 0
0 0 0 0
0 1 0 0
0 1 0 0
Computing the shortest paths : k = 2

Algorithm Floyd(D[n, n])

Input : An array D of shortest path lenghts
Output : The shortest path between every pair of nodes
P[n, n] an n × n array initialized to 0
for (k = 1; k ≤ n; k + +)
for (i = 1; i ≤ n; i + +)
for (j = 1; j ≤ n; j + +)
if D[i, k] + D[k, j] < D[i, j] then
D[i, j] = D[i, k] + D[k, j]
P[i, j] = k ;

0 0 2 2
0 0 0 0
0 1 0 0
0 1 0 0
Computing the shortest paths : k = 3

Algorithm Floyd(D[n, n])

Input : An array D of shortest path lenghts
Output : The shortest path between every pair of nodes
P[n, n] an n × n array initialized to 0
for (k = 1; k ≤ n; k + +)
for (i = 1; i ≤ n; i + +)
for (j = 1; j ≤ n; j + +)
if D[i, k] + D[k, j] < D[i, j] then
D[i, j] = D[i, k] + D[k, j]
P[i, j] = k ;

0 0 2 2
3 0 0 0
0 1 0 0
0 1 0 0
Computing the shortest paths : k = 4

Algorithm Floyd(D[n, n])

Input : An array D of shortest path lenghts
Output : The shortest path between every pair of nodes
P[n, n] an n × n array initialized to 0
for (k = 1; k ≤ n; k + +)
for (i = 1; i ≤ n; i + +)
for (j = 1; j ≤ n; j + +)
if D[i, k] + D[k, j] < D[i, j] then
D[i, j] = D[i, k] + D[k, j]
P[i, j] = k ;

0 0 4 2
4 0 4 0
0 1 0 0
0 1 0 0
Computing the shortest paths

I The matrix P is initialized to 0.

I When the previous algorithm stops, P[i, j] contains the number of
the last iteration that caused a change in D[i, j].
 
0 0 4 2
 4 0 4 0 
P=
 0

1 0 0 
0 1 0 0

I If P[i, j] = 0, then the shortest path between i and j is directly

along the edge (i, j).
I If P[i, j] = k, the shortest path from i to j goes through k.
Computing the shortest paths

 
0 0 4 2
 4 0 4 0 
P=
 0

1 0 0 
0 1 0 0

I Look recursively at P[i, k] and P[k, j] to find other intermediate

vertex along the shortest path.
I In the table above, since, P[1, 3] = 4, the shortest path from 1 to
3 goes through 4. If we look recursively at P[1, 4] we find that the
path between 1 and 4 goes through 2. Recursively again, if we
look at P[1, 2] and P[2, 4] we find direct edge.
I Similarly if we look recursively to P[4, 3] we find a direct edge
(because P[4, 3] = 0). Then the shortest path from 1 to 3 is
1,2,4,3.
Exercises : All pairs shortest paths

10. Compute the all pairs of shortest paths for the following oriented
graph.  
0 5 10 3
 ∞ 0 1 4 
L=
 ∞

∞ 0 ∞ 
∞ ∞ 2 0

11. Compute the all pairs of shortest paths for the following oriented
graph.  
0 3 8 ∞ 4
 ∞ 0 ∞ 1 7 
 
 ∞
L= 4 0 ∞ ∞ 

 2 ∞ 5 0 ∞ 
∞ ∞ ∞ 6 0
Cost of dynamic programs

Calculate how many table or list entries you fill in (sometimes you
don’t use the entire table, just all entries under the diagonal or
something like that).

Calculate how much work it takes to compute each entry.

Multiply the two numbers.

Then add the cost of retrieving the answer from the table.
Example : problem fails the optimal substructure test

Unweighted longest simple path : Find a “simple” path from u to v

consisting of the most edges.
We may assume that the problem of finding an unweighted longest
simple path exhibits optimal substructure, i.e. if we decompose the
longest simple path from u to v into subpaths p1 = u → w and
p2 = w → v then p1 and p2 must also be the longest subpaths between
u − w and w − v . The figure below shows that this is not the case :

Consider the path q → r → t, the longest simple path from q to t.

q → r is not the longest, rather q → s → t → r is.
Dynamic Programming : Conclusion

As we have seen, dynamic programming is a technique that can be

used to find optimal solutions to certain problems.

Dynamic programming works when a problem has the following

characteristics :
I Optimal Substructure : If an optimal solution contains optimal
subsolutions, then a problem exhibits optimal substructure.
I Overlapping subproblems : When a recursive algorithm would
visit the same subproblems repeatedly, then a problem has
overlapping subproblems.

Dynamic programming takes advantage of these facts to solve

problems more efficiently.

It works well only for problems that exhibit both properties.

Exercise 12 : write a dynamic programming algorithm
You have a scheduling problem in which the input consists of a list L of
requested activities to be executed where each request i consists of the
following elements :

I a time interval [si , fi ] where si is the start time when the activity should
begin and fi is the moment when the activity should finish

I a benefit bi which is an indicator of the benefit for performing this

activity.

Below is a list of 7 requests that need to be scheduled over a period of 9 time

units. On the right side of the requests table is the benefit associated to each
request. For example, request 3 has to run during the interval [2, 4] for a
benefit of b3 = 5.
 0 1 2 3 4 5 6 7 8 9

1 5
2 3
3 5
4 4
5 2
6 5
7 3

Given a list L of activity requests, the optimization problem is to schedule the

requests in a non-conflicting way such to maximize the total benefit of the
activities that are included in the schedule (requests i and j conflict if the
time interval [si , fi ] intersects with the time interval [sj , fj ]).
Write a dynamic programming algorithm for this scheduling problem. The
recursive algorithm is as follow. In the request table above, the list L of
requests is ordered in increasing order of the requests finishing time. We use
this ordering to decompose the problem into sub-problems. Let
Bi = the maximum benefit that can be achieved using the first i requests in L
So Bi is the value of the optimal solution while considering the subproblem
consisting the i first requests. The base case is B0 = 0. We are given a
predecessor function pred(i) which for each request i is the largest index j < i
such that request i and j don’t conflict. If there is no such index, then
pred(i) = 0. For example, pred(3) = 1 while pred(2) = 0.
We can now define a recursive function that we call HST (L, i) :

I If the optimal schedule achieving the benefit Bi includes request i, then

Bi = Bpred(i) + bi

I If the optimal schedule achieving the benefit Bi does not include request
i, then Bi = Bi−1

HST (L, i)
if (i == 0) Bi = 0 ;
else
Bi = max{HST (L, i − 1), HST (L, pred(i)) + bi }

Answer the following questions :

13. Write a bottom up dynamic programming algorithm corresponding to

the above HST recursive algorithm
14. For the problem instance described in the request table above, construct
the table of all the subproblems considered by your dynamic
programming algorithm and fill it with the optimal benefit for each
subproblem
Exercise 15 : Longest decreasing subsequence

Write a dynamic programming algorithm to solve the longest

decreasing subsequence problem (LDS) : Given a sequence of integers
s1 , . . . , sn find a subsequence si1 > si2 > . . . > sik with i1 < . . . < ik so
that k is the largest possible. For example, for the sequence 15, 27, 14,
38, 63, 55, 46, 65, 85, the length of the LDS is 3 and that sequence is
63, 55, 46. In the case of the following sequence 50, 3, 10, 7, 40, 80,
the LDS is 50, 10, 7 of length 3.
1. Give a recursive function for computing this problem
2. Using your recurrence, give a dynamic programming algorithm
3. Test your algorithm on this simple sequence [5,0,3,2,1,8]
Dynamic Programming
1. Give a recurrence relation for this problem
int M(i, j)
if j == 1 then return 1 ;
else
return 1 + max1≤k<j {M(1, k) and sk > sj } ;

L[j] = 1 + max{L[i] : i < j and si > sj } (where max equal 1 if j == 1)

2. Using your recurrence relation, give a dynamic programming algorithm

function LDS(s)
for j=1 to n do
L[j] = 1
P[j] = 0
for i=1 to j-1 do
if (si > sj &L[i] + 1 > L[j]) then
P[j] = i
L[j] = L[i]+1

3. Test your algorithm on this simple sequence [5,0,3,2,1,8]