Dynamic Programming

General Method:
Dynamic Programming is an algorithm design method that can be
used when the solution to a problem can be viewed as the result of a
sequence of decisions.
And we wish to get the optimal solution.
EX:
Knapsack problem
Shortest path problem
Consider the shortest path and assume that i,i1,i2, … ik,j is the shortest
path from i to j.starting with the initial vertex i, a decision has been
made to go to vertex i1. Now we need to find the path from i1 to j. let
r1, r2, r3, … j be a shortest i1 to j path. Then I,i1,r1,r2,… rq, j be a
shortest path.
Principle of Optimality: It states that an optimal sequence of decisions
has the property that whatever the initial state and decision are, the
remaining decisions must constitute an optimal decision sequence
with regards to the state resulting from the first decision.
1.Matrix Chain Multiplication
Matrix-chain multiplication problem
Given a chain A1, A2, …, An of n matrices,
where for i=1, 2, …, n, matrix Ai has
dimension pi-1×pi
Parenthesize the product A1A2…An such
that the total number of scalar
multiplications is minimized.
Brute force method of exhaustive
search takes time exponential in n
( 2n ).
Matrix Multiplication

p q
× ×
q r

p
×
r
Cost: Number of scalar multiplications = pqr
 Example
Matrix Dimensions
A1 13 x 5
A2 5 X 89
A3 89 X 3
A4 3 X 34
Parenthesization Scalar multiplications
1 ((A1 A2 ) A3 ) A4 10,582
2 ( A1 A2 ) (A3 A4 ) 54,201
3 (A1 (A2 A3 )) A4 2, 856
4 A1 ((A2 A3 ) A4 ) 4, 055
5 A1 (A2 (A3 A4 )) 26,418
1. 13 x 5 x 89 scalar multiplications to get (A B) 13 x 89
result
13 x 89 x 3 scalar multiplications to get ((AB)C) 13 x 3
result
13 x 3 x 34 scalar multiplications to get (((AB)C)D) 13 x 34
 Dynamic Programming
Approach
The structure of an optimal solution
Let us use the notation Ai..j for the matrix that
results from the product Ai Ai+1 … Aj
An optimal parenthesization of the product
A1A2…An splits the product between Ak and
Ak+1 for some integer k where1 ≤ k < n
First compute matrices A1..k and Ak+1..n ; then
multiply them to get the final matrix A1..n
 Dynamic Programming
Approach …contd
Key observation: parenthesizations of the
subchains A1A2…Ak and Ak+1Ak+2…An must also
be optimal if the parenthesization of the chain
A1A2…An is optimal.
That is, the optimal solution to the problem
contains within it the optimal solution to
subproblems.
 Dynamic Programming
Approach …contd
Recursive definition of the value of
an optimal solution.
Let m[i, j] be the minimum number of
scalar multiplications necessary to
compute Ai..j
Minimum cost to compute A1..n is m[1,
n]
Suppose the optimal parenthesization
of Ai..j splits the product between Ak and
Ak+1 for some integer k where i ≤ k < j
 A1….4
[ A1 ] [ A2 ] [ A3]
[ A4 ]
K=
2
[ A1 ] p0xp1 [ A2 ] p1xp2 [ A3] p2xp3 [ A4 ]
p3xp4

[ M12 ] p0xp2 [M34 ]

p2xp4
p0 x p2 x
p4

Ai….j

[ Ai] ………… [ Aj ]
K

[ Ai ] pi-1 xpi ---- [ Ak ] pk-1xpk [ Ak+1] pk x pk+1 ---- [ Aj ]

pj-1xpj

[ Mi k ] pi-1 x pk [Mk+1 j ] pk x
pj
pi-1 x pk x pj
 Dynamic Programming
Approach …contd
Ai..j = (Ai Ai+1…Ak)·(Ak+1Ak+2…Aj)= Ai..k · Ak+1..j
Cost of computing Ai..j = cost of computing Ai..k
+ cost of computing Ak+1..j + cost of
multiplying Ai..k and Ak+1..j
Cost of multiplying Ai..k and Ak+1..j is pi-1pk pj
m[i, j ] = m[i, k] + m[k+1, j ] + pi-1pk pj
for i ≤ k < j
m[i, i ] = 0 for i=1,2,…,n
 Dynamic Programming
Approach …contd
But… optimal parenthesization occurs
at one value of k among all possible i ≤
k<j
Check all these and select the best one
0 if i=j
m[i, j ]
= min {m[i, k] + m[k+1, j ] + pi-1pk pj }
i≤
if i<j
k< j
 Dynamic Programming
Approach …contd
To keep track of how to construct an
optimal solution, we use a table s
s[i, j ] = value of k at which Ai Ai+1 …
Aj is split for optimal
parenthesization.
Ex:-
[A1]5×4 [A2]4×6 [A3]6×2
[A4]2×7
P0=5, p1=4, p2=6, p3=2,
p4=7 1 2 3 4

Seque
2
nce
Size
3

4
Matrix Chain Multiplication Algorithm

First computes costs for chains of

length l=1
Then for chains of length l=2,3, … and
so on
Computes the optimal cost bottom-up.
Input: Array p[0…n] containing matrix dimensions and n
Result: Minimum-cost table m and split table s
Algorithm Matrix_Chain_Mul(p[], n)
{
for i:= 1 to n do
m[i, i]:= 0 ;
for r:= 2 to n do // for lengths 2,3 and so on
{
for i:= 1 to ( n- r +1 ) do
{
j:= i+ r -1;
m[i, j]:= ∞ ;
for k:=i to j-1 do
{
q:= m[i, k] + m[k+1, j] + p[i-1] p[k] p[j];
if q < m[i, j]
{
m[i, j]:= q;
s[i, j]:= k;
}
}
}
}
return m and s
}

Time complexity of above algorithm is

O(n3)
 Constructing Optimal
Solution
Our algorithm computes the
minimum-cost table m and the split
table s
The optimal solution can be
constructed from the split table s
Each entry s[i, j ]=k shows where to
split the product Ai Ai+1 … Aj for the
minimum cost.
 Algorithm to compute Optimum
Sequence
Algorithm Mul(i,j)
//p=A[i]……A[k]
//q=A[k+1]….A[j]
{
if(i=j) then
return A[i];
else
{
k=s[i,j];
p=Mul(i,k);
q=Mul(k+1,j);
return p*q;
}
}
Optimal Binary Search Tree(OBST)

A binary search tree T is a binary tree,

either it is empty or each node in the tree
contains an identifier and,
All identifiers in the left subtree of T are less
than the identifier in the root node T.
All identifiers in the right subtree are greater
than the identifier in the root node T.
The left and right subtree of T are also binary
search trees.
Ex:- (a1,a2,a3)=( do,if,stop )
Here n=3
The number of possible binary search trees=
(1/(n+1))2n c n
= ¼(6c3)
=5

st
op
i
f

d
o
Algorithm search(x)
{
found:=false;
t:=tree;
while( (t≠0) and not found ) do
{
if( x=t->data ) then found:=true;
else if( x<t->data ) then t:=t->lchild;
else t:=t->rchild;
}
if( not found ) then return 0;
else return 1;
}
Optimal Binary Search Trees
Problem
Given sequence of identifiers (a1,a2 …., an) with
a1<a2 <··· < an.
Let p(i) be the probability with which we search
for ai
Let q(i) be the probability with which we search
for an identifier x such that ai< x <ai+1 .
Want to build a binary search tree (BST) with
minimum expected search cost.
 Identifiers : stop, if, do
st Internal node :
op
successful search, p(i)
i E
f 3 External node :
d E
unsuccessful search,
o 2 q(i)
E E
0 1

n The expected cost of a binary tree:

n n

∑ P ∗ level(a ) + ∑ Q ∗ (level(E ) − 1)
n =1
i i
n =0
i i
 The dynamic programming
Make a decision approach
as which of the a ’s should i be
assigned to the root node of the tree.
If we choose ak, then it is clear that the internal
nodes for a1,a2,……,ak-1 as well as the external
nodes for the classes E0, E1,….,Ek-1 will lie in the
left subtree l of the root. The remaining nodes will
be in the right subtree r.
ak
P1...Pk-1 Pk+1...Pn
Q0...Qk-1 Qk...Qn

a1...ak-1 ak+1...an

C(1,k-1) C(k+1,n)
cost( l)= ∑ p(i)*level(ai) + ∑ q(i)*(level(Ei)-1)
1≤i 0≤i
<k
cost(r)=∑ <k
p(i)*level(ai) + ∑ q(i)*(level(Ei)-1)
K<i K≤i
≤j ≤j

In both the cases the level is measured by considering the

root of the respective sub tree to be at level 1.

Using w(i, j) to represent the sum q(i) +∑ ( q(l)+p(l) ), we

obtain
j

the following as the expected cost of the above search

tree. l
=
i
p(k) + cost(l) + cost(r) + w(0,k-1)
+ + w(k,n)
1
If we use c(i,j) to represent the cost of an optimal
binary search tree tij containing ai+1,……,aj and Ei,
…,Ej, then
cost(l)=c(0,k-1), and cost(r)=c(k,n).

For the tree to be optimal, we must choose k

such that
p(k) + c(0,k-1) + c(k,n) + w(0,k-1) + w(k,n) is minimum.

Hence, for c(0,n) we obtain

0
c(0,n)=
<k
min c(0,k-1) + c(k, n) +p(k)+ w(0,k-1) + w(k,n)
≤
We can n generalize the above formula for any c(i,j) as shown
below i<
c (i, k≤
j)= min c (i,k-1) + c (k,j) + p(k)+ w(i,k-1) + w(k,j)
j

i<
c(i, k≤
j)= min cost(i,k-1) + cost(k,j) + w (i, j)
j
 Therefore, c(0,n) can be solved by first computing all c(i, j)
such that j - i=1, next we compute all c(i,j) such that j - i=2,
then all c(i, j) wiht j – i=3, and so on.

During this computation we record the root r(i, j) of each

tree t ij, then an optimal binary search tree can be
constructed from these r(i, j).

r(i, j) is the value of k that minimizes the cost value.

Note:1. c(i,i) = 0, w(i, j) = q(i), and r(i, j) = 0 for all 0 ≤ i ≤ n

2. w(i, j) = p(j) + q(j) + w(i, j-1 )

3. c(i, j) = min cost(i,k-1) + cost(k,j) + w (i, j)

i<
k≤
Ex 1: Let n=4, and ( a1,a2,a3,a4 ) = (do, if, int, while).
Let p(1 : 4 ) = ( 3, 3, 1, 1) and q(0: 4) = ( 2, 3, 1,1,1 ).
p’s and q’s have been multiplied by 16 for convenience.
Then, we get
w(0,0) = q(0) c(0,0) = 0
r(0,0)=0
w(1,1) = q(1) c(1,1) = 0
r(1,1)=0
w(2,2) = q(2) c(2,2) = 0
r(2,2)=0
w(3,3) = q(3) c(3,3) = 0
r(3,3)=0
w(4,4) = q(4) c(4,4) = 0
r(4,4)=0
 a
1
E E
0 1

w(0,1) = q(0)+p(1)+q(1) = 8
c(0,1) = min { c(0,0) + c(1,1)} +
w(0,1) = 8
r(0,1)=1

a
2
E E
1 2

w(1,2) = q(1)+p(2)+q(2) =
p(2)+q(2)+w(1,1) = 7
c(1,2) = min { c(1,1) + c(2,2)} + w(1,2) =
7
r(0,1)=2
 a
3
E E
2 3

w(2,3) = q(2)+p(3)+q(3) = a
p(3)+q(3)+w(2,2) = 3 4
c(2,3) = min { c(2,2) + c(3,3)} + w(2,3)
=3 E E
r(0,1)=3 3 4

w(3,4) = q(3)+p(4)+q(4) =
p(4)+q(4)+w(3,3) = 3
c(3,4) = min { c(3,3) + c(4,4)} + w(0,1) =
3
r(0,1)=4
 a a
2 1
a E E a
1 2
0 2
E E E E
1 2
0 1

w(0,2) = q(0)+p(1)+q(1)+p(2)+q(2) = 1
p(2)+q(2)+w(0,1) = 21
c(0,2) = min { c(0,0) + c(1,2) , c(0,1)+c(2,2) } 9
0 + 7 8 + 0
+ w(0,2) =
12
r(0,2)=1
 4
1 a
2
5 2
2 a a
1 3
1 a
4

2 a a
2 6
3 a a a
a 7
1 3 5
p = ( 3, 3, 1, 1) and q = ( 2, 3,
1,1,1 ).

1
j-i

2
P: 3 3 1
11
Q: 2 3 3 1
3 11

Computation of c(0,4), w(0,4), and r(0,4)

From the table we can see that c(0,4)=32 is the
minimum cost of a binary search tree for ( a1, a2,
a3, a4 ).
The root of tree t04 is a2.
The left subtree is t01 and the right subtree t24.
Tree t01 has root a1; its left subtree is t00 and right
subtree t11.
Tree t24 has root a3; its left subtree is t22 and right
subtree t34.
Thus we can construct OBST.
i
f

d i
o n
t w
h
il
e
Ex 2: Let n=4, and ( a1,a2,a3,a4 ) = (count, float,
int,while).
Let p(1 : 4 ) =( 1/20, 1/5, 1/10, 1/20) and
q(0: 4) = ( 1/5,1/10, 1/5,1/20,1/20 ).

Using the r(i, j)’s construct an optimal binary search

tree.
Time complexity of above procedure to
evaluate the c’s and r’s
Above procedure requires to compute c(i, j) for
( j - i) = 1,2,…….,n .

When j – i = m, there are n-m+1 c( i, j )’s to

compute.

The computation of each of these c( i, j )’s requires

to find m quantities.

Hence, each such c(i, j) can be computed in time

o(m).
The total time for all c(i,j)’s with j – i= m is
= m( n-m+1)
= mn-m2+m
=O(mn-m2)

Therefore, the total time to evaluate all the c(i,

j)’s and r(i, j)’s is
∑ ( mn – m2 ) = O(n3)
1≤m≤n
We can reduce the time complexity by
using the observation of D.E. Knuth

Observation:
The optimal k can be found by limiting the
search to the range r( i, j – 1) ≤ k ≤ r( i+1,
j)

In this case the computing time is O(n2).

OBST Algorithm
Algorithm OBST(p,q,n)
{
for i:= 0 to n-1 do
{ // initialize.
w[ i, i ] :=q[ i ]; r[ i, i ] :=0; c[ i, i ]=0;
// Optimal trees with one
node.
w[ i, i+1 ]:= p[ i+1 ] + q[ i+1 ] + q[ i ] ;
c[ i, i+1 ]:= p[ i+1 ] + q[ i+1 ] + q[ i ] ;
r[ i, i+1 ]:= i + 1;
}
w[n, n] :=q[ n ]; r[ n, n ] :=0; c[ n, n ]=0;
// Find optimal trees with m nodes.

for m:= 2 to n do
{
for i := 0 to n – m do
{
j:= i + m ;
w[ i, j ]:= p[ j ] + q[ j ] + w[ i, j -1 ];
// Solve using Knuth’s result
x := Find( c, r, i, j );

c[ i, j ] := w[ i, j ] + c[ i, x -1 ] + c[ x,
j ];
r[ i, j ] :=x;
}
}
Algorithm Find( c, r, i, j )
{
for k := r[ i, j -1 ] to r[ i+1, j ] do // k = 1 to n
{ min :=∞;
if ( c[ i, k -1 ] +c[ k, j ] < min ) then
{
min := c[ i, k-1 ] + c[ k, j ]; y:= k;
}
}
return y;
}
 Travelling Salesperson
Problem (TSP)
Problem:-
You are given a set of n cities.
You are given the distances between the cities.
You start and terminate your tour at your
home city.
You must visit each other city exactly once.
Your mission is to determine the shortest tour.
OR
minimize the total distance traveled.
e.g. a directed graph :
2
1 2
2
10
4
6 5 9 3
8
7
4 3
Cost matrix: 4

1 2 3 4
1 ∞ 2 10 5
0
2 2 ∞ 9 ∞
0
3 4 3 ∞ 4
0
4 6 8 7 ∞
0
The dynamic programming approach

Let g( i, S ) be the length of a shortest path starting

at vertex i, going through all vertices in S and
terminating at vertex 1.

The length of an optimal tour :

g(1, V - {1}) = min {c1k + g(k, V - {1, k})}

The general form: 2≤ k ≤ n
1

2
g(i, S) = min{c ij + g(j, S - {j})}
j∈S
Equation 1 can be solved for g( 1, V- {1} ) if
we know g( k, V- {1,k} ) for all choices of k.

The g values can be obtained by using

equation 2 .

Clearly,
g( i, Ø ) = Ci1 , 1≤ i ≤ n.

Hence we can use eq 2 to obtain g( i, S ) for all

S of size 1. Then we can obtain g( i, s) for all S
of size 2 and so on.
Thus,
g(2, Ø)=C21=2
g(3, Ø)=C31=4
g(4, Ø)=C41=6
We can obtain

g(2, {3})=C23 + g(3, Ø)=9+4=13

2
g(2, {4})=C24 + g(4, Ø)=∞ 1
2
2
10
4
g(3, {2})=C32 + g(2, Ø)=3+2=5 6 5 9 3

g(3, {4})=C34 + g(4, Ø)=4+6=10 8

7
4 3
g(4, {2})=C42 + g(2, Ø)=8+2=10 4

g(4, {3})=C43 + g(3, Ø)=7+4=11

 2
1 2
2
10
4
6 5 9 3
8

Next, we compute g(i,S) with |S | =2, 4

7
3
4

g( 2,{3,4} )=min { c23+g(3,{4}), c24+g(4,

{3}) }
=min {19, ∞}=19
g( 3,{2,4} )=min { c32+g(2,{4}), c34+g(4,
{2}) }
=min {∞,14}=14
g(4,{2,3} )=min {c42+g(2,{3}), c43+g(3,
{2}) }
=min {21,12}=12
 2
1 2
2
10
4
6 5 9 3
8
Finally, 7
4 3
We obtain 4

g(1,{2,3,4})=min { c12+ g( 2,{3,4} ), c13+ g( 3,

{2,4} ), c14+ g(4,{2,3} )
=min{ 2+19,10+14,5+12}
=min{21,24,17}
=17.
A tour can be constructed if we retain with each g( i,
s ) the value of j that minimizes the tour distance.
Let J( i, s ) be this value, then J( 1, { 2, 3, 4 } ) = 4.
Thus the tour starts from 1 and goes to 4.

The remaining tour can be obtained from g( 4,

{ 2,3 } ). So J( 4, { 3, 2 } )=3

Thus the next edge is <4, 3>. The remaining tour is

g(3, { 2 } ). So J(3,{ 2 } )=2

The optimal tour is: (1, 4, 3, 2, 1)

Tour distance is 5+7+3+2 = 17
All pairs shortest path
problem
Floyd’s Algorithm
 All-Pairs Shortest Path
Problem
Let G=( V,E ) be a directed graph
consisting of n vertices.
Weight is associated with each edge.

The problem is to find a shortest path between

every pair of nodes.
Ex:-
1
1 2 3 4 5 3 v v
1 0 1 ∞ 1 5 1 9 2
5 1 3
2 9 0 3 2 2
∞ v
3 ∞ ∞ 0 4 ∞ 5 3 2
v v
4 ∞ ∞ 2 0 3 4 4 3

5 3 ∞ ∞ ∞ 0
 Idea of Floyd-Warshall Algorithm
Assume vertices are {1,2,……n}

Let Ak ( i, j ) be the length of a shortest path from i

to j with intermediate vertices numbered not
higher than k where 0 ≤ k ≤ n, then

A0( i, j ) = c( i, j ) (no intermediate vertices at all)

Ak( i, j ) = min { Ak-1( i, j ), Ak-1( i, k )+ Ak-1( k, j ) }

and An( i, j ) is the length of a shortest path
from i to j
In summary, we need to find d n with d 0 =cost
matrix .

General formula

Ak [ i, j ]= min {A k-1
[ i, j ], Ak-1[ i, k ]+ Ak-1[ k, j ] }
Shortest path using intermediate vertices
{ V1 , . . . V k }

d k-1[i, Vk d k-1[k,
k] j]
V
Vi
j
d k-1[i,
j]

Shortest Path using intermediate vertices

{ V1, . . . Vk -1 }
 1
4 1
0 4 5
15
A0 8 0
8 3
2 3
= 2
0
3 4 ∞ 2
15
0
A1 1. 0 2
= 3 7
0
0 4
6
A2 8 0
= 2
3 7
0 4
6
A3 5 0
= 2
3 7
0
Algorithm
Algorithm AllPaths( c, d, n )
// c[1:n,1:n] cost matrix
// d[i,j] is the length of a shortest path from i to j
{
for i := 1 to n do
for j := 1 to n do
d [ i, j ] := c [ i, j ] ; // copy c into d

for k := 1 to n do
for i := 1 to n do
for j := 1 to n do
d [ i, j ] := min ( d [ i, j ] , d [ i, k ] + d [ k, j ] );
}
Time Complexity is O ( n 3
)
 Sequence Of Decisions

Decide the xi values in the order x1, x2,

x3, …, xn.
OR
Decide the xi values in the order xn, xn-1,
xn-2, …, x1.
 0/1 - knapsack problem
The state of the 0/1 knapsack problem
is given by
the weights and profits of the available
items
the capacity of the knapsack
When a decision on one of the xi values
is made, the problem state changes.
item i is no longer available
the remaining knapsack capacity may be
less
 Problem State
Suppose that decisions are made in the
order x1, x2, x3, …, xn.
The initial state of the problem is
described by the pair (1, m).
Items 1 through n are available
The available knapsack capacity is m.
Following the first decision the state
becomes one of the following:
(2, m) … when the decision is to set x1= 0.
(2, m-w1) … when the decision is to set x1=
1.
 Problem State
Suppose that decisions are made in the
order xn, xn-1, xn-2, …, x1.
The initial state of the problem is
described by the pair (n, m).
Items 1 through n are available
The available knapsack capacity is m.
Following the first decision the state
becomes one of the following:
(n-1, m) … when the decision is to set xn= 0.
(n-1, m-wn) … when the decision is to set
xn= 1.
Dynamic programming approach

Let fn(m) be the value of an optimal

solution, then
fn(m)= max { fn-1(m), fn-1( m-wn) + p
n }

General formula

fi(y)= max { fi-1(y), fi-1( y-w i) + p i }

 Recursion Tree

f(1,c)

f(2,c) f(2,c-w1)

f(3,c) f(3,c-w2) f(3,c-w1) f(3,c-w1 –w2)

f(4, f(4,c-w3)f(4,c- f(4,c-w1 –w3)

c) w 2)
f(5,
c) f(5,c-w1 –w3 –
w 4)
We use set si is a pair ( P, W )
where P= fi(y), W=y

Note That s0 =( 0, 0 )

We can compute si+1 from si by first

computing

si ={ ( P, W ) ( P- pi+1, W- wi+1)€ s i

}
1
 OR
Si = Si-1 + (pi, wi)
1

Merging :- si+1 can be computed by merging

the
pairs in s i and s1i
Purging :- if si+1 contains two pairs ( p j, w j ) and
( p k, w k )
with the property that p j ≤ p k and w j ≥
wk

When generating s i’s, we can also purge all pairs ( p,

w ) with w > m as these pairs determine the value of f
n (x) only for x > m.

The optimal solution f n (m) is given by the highest

profit pair.
Set of 0/1 values for the x i
’
s
Set of 0/1 values for x i ’ s can be determined
by a search through the si s
Let ( p, w ) be the highest profit tuple in s n

Step1: if ( p, w ) € s n
and ( p, w ) €
s n -1
xn=1
otherwise x n = 0
This leaves us to determine how either ( p, w
) or
( p – pn, w- wn ) was obtained in Sn-1 .
This can be done recursively ( Repeat
Step1 ).
 Knapsack Algorithm
Algorithm DKP(p,w,n,m)
{
S0 ={(0,0)};
for i=1 to n-1 do
{
Si-1 ={(P,W)|(P-pi ,W-wi ) (- Si-1 and
W<=m);
Si =MergePurge(Si-1 ,S1i-1 );
}
(PX,WX)=last pair in Sn-1 ;
(PY,WY)=(P‘+pn ,W‘+wn ) where W‘ is
the largest W in any pair in Sn-1 such
that
W+wn <=m;
if(PX>PY) then xn =0;
else xn=1;
TraceBackFor(xn-1,…..,x1);
}
Example: solve the following knapsack problem by using
dynamic programming:
Knap sack with n=4 and m=8.
Sol: create the sequence of decision as Sa = {(w, p)}
S0 = { (0,0) } // initially no item got selected in the
knapsack
S01 = { (2,1) }
So S1 = { (0,0) , (2,1) } // Merge the S0 and S01
S12 = { (3,2) , (5,3) }
So S2 = {(0,0) , (2,1) , (3,2) , (5,3) }
S23= {(4,5) , (6,6) , (7,7) , (9,8) }
So S3 = {(0,0) , (2,1) , (3,2) , (4,5) , (5,3), (6,6) , (7,7) , (9,8) }
S3 = {(0,0) , (2,1) , (3,2) , (4,5) , (6,6) , (7,7) }
S34= {(5,6), (7,7), (8,8), (9,11), (11,12), (12,13) }

S4 = {0,0) , (2,1) , (3,2) , (4,5) , (5,6), (6,6), (7,7), (8,8),(9,11),

(11,12), (12,13)
S4 = {0,0) , (2,1) , (3,2) , (4,5) , (5,6), (7,7), (8,8)}
 Reliability Design
The problem is to design a system
that is composed of several devices
connected in series.

D1 D2 D3
… Dn

n devices connected in series

Let r i be the reliability of device Di ( that is, ri is
the probability that device i will function
properly ).

Then, the reliability of entire system is π ri

Even if the individual devices are very reliable,

the reliability of the entire system may not be
very good.

Ex. If n=10 and ri = 0.99, 1≤ i ≤ 10, then π ri

=0.904

Hence, it is desirable to duplicate devices.

Multiple copies of the same device type are
connected in parallel as shown below.

D1 D2 D3 Dn
D1 D2 D3
D1 D3 … Dn
Dn
D3

Multiple devices connected in parallel in

each stage
If stage i contains mi copies of device Di , then the
probability that all mi have malfunction is ( 1-i
ri ) . Hence the reliability of stage i becomes
m
i 1-
(1-ri ) m.

Ex:- If r I =.99 and m I =2 , the stage reliability becomes

0.9999
Let Фi ( m i ) be the reliability of stage i, i ≤ n
Then, the reliability of system of n stages
≤ nis
1≤i
π Ф
i( m i )
 Dynamic programming approach

Since, each c i >0, each mi must be in the range

1≤ m i ≤ u i, where

ui= ( c + c i - ∑ cj )
1 C
i
≤
The upper bound u i follows from the observation
that j
m i ≥ 1. ≤
The optimal solution m 1,m 2,……,m n is the result
n
of a sequence of decisions, one decision for each
mi
 Let fn(c) be the reliability of an
optimal solution, then
fn(c)= max { Ф ( m ) f ( c- c m ) }
n n n-1 n n
1≤ m n
≤un
General formula

fi(x)= max {Ф ( m ) fi-1(x - c

i i i mi ) }

Clearly,
1≤ m f0(x)=1, for all x, 0 ≤ x ≤ c
i
≤ ui
Let s i
consist of tuples of the form ( f, x )

Where f = f i( x )

Purging rule :- if si+1 contains two pairs ( f j, x j

) and ( fk, x k ) with the property that
fj ≤ f k and x j ≥ x k , then we
can
purge ( f k, x k )
When generating s i’s, we can also purge all pairs
( f, x ) with c - x < ∑ ck as such pairs will not
leave sufficient
i
+1≤
k≤n
funds to complete the system.

The optimal solution f n (c ) is given

by the highest reliability pair.

Start wit S0 =(1, 0 )

Design a 3 stage system with device types D1,D2,D3. The Costs are Rs.
30, 15, 20 resp. the cost of the system is to be not morethan 105. The
reliability of each device type is 0.9, 0.8, 0.5.
Let us compute u1 u2 u3 first
u1 = (105 + 30 – (30+15+20))/30
= 2.33
u1 = 2
u2 = 3
u3 = 3
S0 = { (0,0) }
_____________________________

S1 = {(30,0.9)}
1
D1= I unit
S = {(60,0.99)} D(30,0.9)
1
2
1= 2 unit (60,0.99) (30+30 , 1-(1-
0.9)2 )
S1= { (30,0.9), (60,0.99) }

___________________________
S2 = { (45,0.72) , (75,0.792) }
1
S2 = { (60,0.864) , (90,0.95) }
2
D2= I unit
S = { (75,0.893) , (105,0.982) }
2
3
(15,0.8)
D2= 2 unit(75,0.893), (90,0.95), (105,0.982)
S = {(45,0.72) , (60,0.864) ,(75,0.792),
2

} (30,0.96)
D2= 3 unit
(45,0.992)
S2= {(45,0.72) , (60,0.864) , (75,0.893)}
____________________________________
S31= { (65,0.36) , (80,0.432),(95,0.446) }
S32= { (85,0.54) , (100,0.648),(115,0.669)}
S33= { (105,0.63) , (120,0.756),(135,0.783D3=}I unit
D3= 2 unit
(20,0.5)
S 3= {(65,0.36) , (80,0.432), (85,0.54) , (95,0.446),
3
(40,0.75) (100,0.648),
D3= 3 unit
(105,0.63) , (60,0.875)
(115,0.669), (120,0.756),(135,0.783 }
S 3= {(65,0.36) , (80,0.432), (85,0.54), (100,0.648)}
3

_____________________________________________