Module 4: Dynamic Programming - TechJourney.intechjourney.in/docs/DAA/hn-daa-m4-slides.pdf · 2020....

Module 4: Dynamic Programming

Harivinod NDept. of Computer Science and Engineering

VCET Puttur

Design and Analysis of Algorithms18CS42

Outline

• Introduction to Dynamic Programming

– General method with Examples

– Multistage Graphs

• Transitive Closure:

– Warshall’s Algorithm,

• All Pairs Shortest Paths:

– Floyd's Algorithm,

• Optimal Binary Search Trees

• Knapsack problem

• Bellman-Ford Algorithm

• Travelling Sales Person problem

• Reliability design

Harivinod N 218CS42-Design and Analysis of Algorithms

Feb-May 2020

Outline














Feb-May 2020

Dynamic Programming

• Dynamic programming is a technique for solving problems with overlapping subproblems.

– subproblems arise from a recurrence relating a given problem’s solution to solutions of its smaller subproblems.

– DP suggests solving each of the smaller subproblems only once and recording the results in a table from which a solution to the original problem can then be obtained.

• The Dynamic programming can be used when the solution to a problem can be viewed as the result of sequence of decisions.

Harivinod N 418CS42-Design and Analysis of Algorithms Feb-May 2020

Example-1: Knapsack Problem


Example-2: File merging problem


Principle of Optimality

Difference between greedy and DP?


Outline














Feb-May 2020

Multistage Graphs


Cost of node j at stage i to reach terminal node t

DP Solution using forward approach

Stage number

Node


cost(5,12)=0

cost(4,9)=c(9,12) = 4cost(4,10)=c(10,12)=2cost(4,11)=c(11,12)=5


Feb-May 2020

cost(4,I) = c(I,L) = 7

cost(4,J) = c(J,L) = 8

cost(4,K) = c(K,L) = 11

cost(3,F) = min { c(F,I) + cost(4,I) | c(F,J) + cost(4,J) }

cost(3,F) = min { 12 + 7 | 9 + 8 } = 17

cost(3,G) = min { c(G,I) + cost(4,I) | c(G,J) + cost(4,J) }

cost(3,G) = min { 5 + 7 | 7 + 8 } = 12

cost(3,H) = min { c(H,J) + cost(4,J) | c(H,K) + cost(4,K) }

cost(3,H) = min { 10 + 8 | 8 + 11 } = 18

cost(2,B) = min { c(B,F) + cost(3,F) | c(B,G) + cost(3,G) | c(B,H) + cost(3,H) }

cost(2,B) = min { 4 + 17 | 8 + 12 | 11 + 18 } = 20

cost(2,C) = min { c(C,F) + cost(3,F) | c(C,G) + cost(3,G) }

cost(2,C) = min { 10 + 17 | 3 + 12 } = 15

cost(2,D) = min { c(D,H) + cost(3,H) }

cost(2,D) = min { 9 + 18 } = 27

cost(2,E) = min { c(E,G) + cost(3,G) | c(E,H) + cost(3,H) }

cost(2,E) = min { 6 + 12 | 12 + 18 } = 18

cost(1,A) = min { c(A,B) + cost(2,B) | c(A,C) + cost(2,C) | c(A,D) + cost(2,D) | c(A,E) +cost(2,E) }

cost(1,A) = min { 7 + 20 | 6 + 15 | 5 + 27 | 9 + 18 } = 21

Optimal Path: A-C-G-I-L Reused costs are colored!Harivinod N 1218CS42-Design and Analysis of Algorithms Feb-May 2020

Principle of optimality w.r.t. Multistage graph


cost(3,D) = c(D,T) = 18

cost(3,E) = c(E,T) = 13

cost(3,F) = c(F,T) = 2

cost(2,A) = min { c(A,D) + cost(3,D) | c(A,E) + cost(3,E) }

cost(2,A) = min { 4 + 18 | 11 + 13 } = 22

cost(2,B) = min { c(B,D) + cost(3,D) | c(B,E) + cost(3,E) | c(B,F) + cost(3,F) }

cost(2,B) = min { 9 + 18 | 5 + 13 | 16+2 } = 18

cost(2,C) = min { c(C,F) + cost(3,F) }

cost(2,C) = min { 2 + 2 } = 4

cost(1,S) = min { c(S,A) + cost(2,A) | c(S,B) + cost(2,B) | c(S,C) + cost(2,C) }

cost(1,S) = min { 1 + 22 | 2 + 18 | 5 + 4 } = 9

Optimal Path: S-C-F-L


When j=11, only one candidate for r, r=12 cost(11) = c(11,12)+cost(12)=5+0=5; d(11)=12When j=10, only one candidate for r, r=12 cost(10) = c(10,12)+cost(12)=2+0=2; d(10)=12When j=9, only one candidate for r, r=12 cost(9) = c(9,12)+cost(12)=4+0=4; d(9)=12

When j=8, two candidates for r, r=10,11 cost(8) = min { c(8,10)+cost(10)=5+2=7; c(8,11)+cost(11)=6+5=11; } = 7 d(8)=10



When j=11, cost(11) =5; d(11)=12When j=10, cost(10) =2; d(10)=12When j=9, cost(9) =4; d(9)=12When j=8, cost(8) = 7 d(8)=10When j=7, cost(7) = 5 d(7)=10When j=6, cost(6) = 7 d(6)=10

When j=5, two candidates for r, r=7,8 Cost(5) = d(5)=

When j=4, r=11 Cost(4) = d(4)=

When j=3, two candidates for r, r=6,7 `Cost(3) = d(3)=

When j=2, three candidates for r, r=6,7,8 Cost(2) = d(2)=

5

2

4

7

5

7

20

Analysis

Θ( |V| + |E|)


Backward Approach

Cost of node j at stage i to from source node s


bcost(2,2) = 9bcost(2,3)=7bcost(2,4)=3bcost(2,5)=2


Example

bcost(2,B) = c(A,B) = 7

bcost(2,C) = c(A,C) = 6

bcost(2,D) = c(A,D) = 5

bcost(2,E) = c(A,E) = 9.

bcost(3,F) = min { c(B,F) + bcost(2,B) | c(C,F) + bcost(2,C) }

bcost(3,F) = min { 4 + 7 | 10 + 6 } = 11

bcost(3,G) = min { c(B,G) + bcost(2,B) | c(C,G) + bcost(2,C) | c(E,G)+ bcost(2,E) }

bcost(3,G) = min { 8 + 7 | 3 + 6 | 6 + 9 } = 9

bcost(3,H) = min { c(B,H) + bcost(2,B) | c(D,H) + bcost(2,D) | c(E,H)+ bcost(2,E) }

bcost(3,H) = min { 11 + 7 | 9 + 5 | 12 + 9 } = 14

bcost(4,I) = min { c(F,I) + bcost(3,F) | c(G,I) + bcost(3,G) }

bcost(4,I) = min { 12 + 11 | 5 + 9 } = 14

bcost(4,J) = min { c(F,J) + bcost(3,F) | c(G,J) + bcost(3,G) | c(H,J)+ bcost(3,H) }

bcost(4,J) = min { 9 + 11 | 7 + 9 | 10 + 14 } = 16

bcost(4,K) = min { c(H,K) + cost(3,H) }

bcost(4,K) = min { 8 + 14 } = 22

bcost(5,L) = min { c(I,L) + bcost(4,I) | c(J,L) + bcost(4,J) | c(K,L)+ bcost(4,K) }

bcost(5,L) = min { 7 + 14 | 8 + 16 | 11 + 22 } = 21

Path: A-C-G-I-L cost:21 Reused costs are colored!24


Feb-May 2020

Multistage Graph


Outline














Feb-May 2020

Transitive Closure

Definition: The transitive closure of a directed graph with n vertices can be defined as the n x n boolean matrix T = {tij }, in which the element in the ith row `and the jth column is 1 if there exists a nontrivial path (i.e., directed path of a positive length) from the ith vertex to the jth vertex; otherwise, tij is 0.


Transitive Closure

• We can generate the transitive closure of a digraph with the help of depth-first search or breadth-first search.

• Since this method traverses the same digraph several times, we can use a better algorithm called Warshall’s algorithm.

• Warshall’s algorithm constructs the transitive closure through a series of n × n boolean matrices:


Warshalls Algorithm

• The element in the ith row and jth column of matrix R(k) is equal to 1 if and only if

– there exists a directed path of a positive length from the ith vertex to the jth vertex with each intermediate vertex, if any, numbered not higher than k.

• This means that there exists a path from the ith vertex vi

to the jth vertex vj with each intermediate vertex numbered not higher than k:

vi, a list of intermediate vertices each numbered not higher than k, vj


Warshalls Algorithm

Two situations regarding this path are possible.

1. In the first, the list of its intermediate vertices does not contain the kth vertex.

2. The second possibility is that path does contain the kth vertex vk among the intermediate vertices.


Algorithm


Analysis

• Its time efficiency is Θ(n3).

• We can make the algorithm to run faster by treating matrix rows as bit strings and employ the bitwise or operation available in most modern computer languages.

• Space efficiency

– Although separate matrices for recording intermediate results of the algorithm are used, that can be avoided.


Outline














Feb-May 2020

All Pairs Shortest Paths

• Problem definition: Given a weighted connected graph (undirected or directed), the all-pairs shortest paths problem asks to find the distances—i.e., the lengths of the shortest paths - from each vertex to all other vertices.

• Applications:

– Communications, transportation networks, and operations research.

– pre-computing distances for motion planning in computer games.


All Pairs Shortest Paths

(a) Digraph. (b) Its weight matrix. (c) Its distance matrix

We can generate the distance matrix with analgorithm that is very similar to Warshall’s algorithm.

It is called Floyd’s algorithm.


Floyds Algorithm


Analysis

• Its time efficiency is Θ(n3),

– similar to the warshall’s algorithm.


Example


Outline














Feb-May 2020

Optimal Binary Search Tree

• A binary search tree is one of the most important data structures in computer science.

• One of its principal applications is to implement a dictionary, a set of elements with the operations of searching, insertion, and deletion.

• The binary search tree for which the average number of comparisons in a search is the smallest as possible is called as optimal binary search tree.

• If probabilities of searching for elements of a set are known an optimal binary search tree can be constructed.


Optimal Binary Search Tree

Example

• Consider four keys A, B, C, and D to be searched for with probabilities 0.1, 0.2, 0.4, and 0.3, respectively.

• 14 different binary search trees are possible

• Two are shown here

• The average number of comparisons in a successful search in the first of these trees is

0.1 *1 + 0.2 * 2 + 0.4 *3+ 0.3 *4 = 2.9,

0.1 * 2 + 0.2 * 1+ 0.4 * 2 + 0.3 *3= 2.1.

Neither of these two trees is, in fact, optimal. Harivinod N 4718CS42-Design and Analysis of Algorithms Feb-May 2020

Optimal BST

• For our tiny example, we could find the optimal tree by generating all 14 binary search trees with these keys.

• As a general algorithm, this exhaustive-search approach is unrealistic:

– the total number of binary search trees with n keys is equal to the nth Catalan number,

which grows to infinity as fast as 4n / n1.5


Optimal BST

Problem definition:

• Given a sorted array a1, . . . , an of search keys and an array p1, . . . , pn of probabilities of searching, where pi is the probability of searches to ai.

• Construct a binary search tree of all keys such that, smallest average number of comparisons made in a successful search.


Optimal BST – Solution using DP

• So let a1, . . . , an be distinct keys ordered from the smallest to the largest and let p1, . . . , pn be the probabilities of searching for them.

• Let C(i, j) be the smallest average number of comparisons made in a successful search in a binary search tree Ti

j made up of keys ai, . . , aj, where i, j are some integer indices, 1≤ i ≤ j ≤ n.

• We are interested just in C(1, n).


Optimal BST – Solution using DP

• To derive a recurrence, we will consider all possible ways to choose a root ak among the keys ai, . . . , aj .


Exampleindex 1 2 3 4



C(1,2) = Mink = 1, C(1,0) + C(2,2),k = 2, C(1 ,1) + C(3,2)

+ 0.3 = Min0.20.1

+ 0.3 = 0.4

?



How to construct the optimal binary search tree?


Analysis

• The algorithm requires O(n2) time and O(n2) storage.

• Therefore, as ‘n’ increases it will run out of storage even before it runs out of time.

• The storage needed can be reduced by almost half by implementing the two-dimensional arrays as one-dimensional arrays.


Home Work

• Find the optimal binary search tree for the keys A, B, C, D, E with search probabilities 0.1, 0.1, 0.2, 0.2, 0.4 respectively.


Outline




• Transitive Closure










Feb-May 2020

Knapsack problem using DP

• Given n items of known weights w1, . . . , wn and values v1, . . . , vn and a knapsack of capacity W, find the most valuable subset of the items that fit into the knapsack.

• To design a DP algorithm, we need to derive a recurrence relation that expresses a solution in terms of its smaller sub instances.

• Let us consider an instance defined by the first iitems, 1≤ i ≤ n, with weights w1, . . . , wi, values v1, . . . , vi , and knapsack capacity j, 1 ≤ j ≤ W.



• Let F(i, j) be the value of an optimal solution to this instance.

• We can divide all the subsets of the first i items that fit the knapsack of capacity j into two categories:

– those that do not include the ith item

– and those that do.

• Among the subsets that do not include the ith item,

– the value of an optimal subset is, by definition,

– i.e F(i , j) = F(i − 1, j).



• Among the subsets that do include the ith item(hence, j − wi ≥ 0),

– an optimal subset is made up of this item and

– an optimal subset of the first i−1 items that fits into the knapsack of capacity j − wi .

– The value of such an optimal subset is

F(i , j) = vi + F(i − 1, j − wi)

• Thus, optimal solution among all feasible subsets of the first I items is the maximum of these two values.



• It is convenient to define the initial conditions as follows: F(0, j) = 0 for j ≥ 0 and F(i, 0) = 0 for i ≥ 0.

• Our goal is to find F(n, W), the maximal value of a subset of the n given items that fit into the knapsack of capacity W, and an optimal subset itself.


Algorithm

vi

vi


Example-1

Find the composition of an optimal subset by backtracing the computations Harivinod N 6918CS42-Design and Analysis of Algorithms Feb-May 2020

Example-1

Find the composition of an optimal subset by backtracing the computations Harivinod N 7018CS42-Design and Analysis of Algorithms Feb-May 2020

Analysis

• The classic dynamic programming approach, works bottom up: it fills a table with solutions to all smaller subproblems, each of them is solved only once.

• Drawback: Some unnecessary subproblems are also solved

• The time efficiency and space efficiency of this

algorithm are both in Θ(nW).

• The time needed to find the composition of an optimal solution is in O(n).


Discussion

• The direct top-down approach to finding a solution to such a recurrence leads to an algorithm that solves common subproblems more than once and hence is very inefficient.

• Since this drawback is not present in the top-down approach, it is natural to try to combine the strengths of the top-down and bottom-up approaches.

• The goal is to get a method that solves only subproblems that are necessary and does so only once. Such a method exists; it is based on using memory functions.


Algorithm MFKnapsack(i, j )

• Implements the memory function method for the knapsack problem

• Input: A nonnegative integer i indicating the number of the first items being considered and a nonnegative integer jindicating the knapsack capacity

• Output: The value of an optimal feasible subset of the first iitems

• Note: Uses as global variables input arrays Weights[1..n], V alues[1..n], and table F[0..n, 0..W ] whose entries are initialized with −1’s except for row 0 and column 0 initialized with 0’s


Algorithm MFKnapsack(i, j )


Example


Outline














Feb-May 2020

Single Source shortest path with –ve wts

Problem definition

• Single source shortest path - Given a graph and a source vertex s in graph, find shortest paths from s to all vertices in the given graph.

• The graph may contain negative weight edges.

• Dijkstra’s algorithm [ O(VlogV) ], doesn’t work for graphs with negative weight edges.

• Bellman-Ford works in O(VE)


Bellman Ford Algorithm

• Like other Dynamic Programming Problems, the algorithm calculates shortest paths in bottom-up manner.

• It first calculates the shortest distances

– for the shortest paths which have at-most one edge in the path.

– Then, it calculates shortest paths with at-most 2 edges, and so on.

• Iteration i finds all shortest paths that use i edges.


dist1(1) = 0dist1(2) = 6dist1(3) = 5dist1(4) = 5dist1(5) = ∞dist1(6) = ∞dist1(7) = ∞

k=1


dist2(1) = 0

dist2(2) = mindist1(2)

dist1(3) + cost(3,2)= min

65 − 2

= 3



55 − 2

= 3

dist2(4) = 5

dist2(5) = min

dist1(5)

dist1(2) + cost(2,5)


= min∞6−15 + 1

= 5



∞5 − 1

= 4

dist2(7) = min

dist1(7)



= min∞∞+ 3∞+ 3

= ∞

For every vertex (except source) look for the incoming edge (except from source)

k=2


dist3(1) = 0



33 − 2

= 1



35 − 2

= 3

dist3(4) = 5

dist3(5) = min

dist2(5)



= min53−13 + 1

= 2



45 − 1

= 4

dist3(7) = min

dist2(7)



= min∞5 + 34 + 3

= 7


k=3


dist4(1) = 0



13 − 2

= 1



35 − 2

= 3

dist4(4) = 5

dist4(5) = min

dist3(5)



= min21−13 + 1

= 0



45 − 1

= 4

dist4(7) = min

dist3(7)



= min72 + 34 + 3

= 5


k=4


dist5(1) = 0



13 − 2

= 1



35 − 2

= 3

dist5(4) = 5

dist5(5) = min

dist4(5)



= min01−13 + 1

= 0



45 − 1

= 4

dist5(7) = min

dist4(7)



= min50 + 34 + 3

= 3


k=5


dist6(1) = 0



13 − 2

= 1



35 − 2

= 3

dist6(4) = 5

dist6(5) = min

dist5(5)



= min01−13 + 1

= 0



45 − 1

= 4

dist6(7) = min

dist5(7)



= min50 + 34 + 3

= 3


k=6


Algorithm


Analysis

• Bellman-Ford works in O(VE)


Example-2 Home work

1

1

Find shortest path from S to all other vertices using Bellman Ford algorithm


Example-2


Outline














Feb-May 2020

Travelling Salesman Problem

Problem Statement

• The travelling salesman problem consists of a salesman and a set of cities.

• The salesman has to visit each one of the cities exactly once starting from a certain one (e.g. the hometown) and returning to the same city.

• The challenge of the problem is that the traveling salesman wants to minimize the total length of the trip

• It is assumed that all cities are connected to all other cities


Travelling Salesman Problem

Naive Solution:

1. Consider city 1 as the starting and ending point.

2. Generate all (n-1)! Permutations of cities.

3. Calculate cost of every permutation and keep track of minimum cost permutation.

4. Return the permutation with minimum cost.

Time Complexity: ?

n!


TSP using DP

• Assume tour to be a simple path that starts & ends at 1

• Every tour consists of

– an edge <1, k> for some k ∈ V − {1} and

– a path from vertex k to vertex 1

• The path from k to 1 goes through each vertex in V − {1, k} exactly once

• If the tour is optimal, then the path from k to 1 must be a shortest path going through all vertices in V − {1, k}

• 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

• g(1, V − {1}) is the length of an optimal salesperson tour


TSP using DP

• From the principal of optimality

• Generalizing

• Example

g(1,{2,3,4,5}) = min

k = 2, c12 + g(2,{3,4,5})

k = 3, c13 + g(3,{2,4,5})

k = 4, c14 + g(4,{2,3,5})

k = 5, c15 + g(5,{2,3,4})


Example-1

Successor of node 1: p(1,{2,3,4}) = 2Successor of node 3: p(2, {3,4}) = 4Successor of node 4: p(4, {3}) = 3Optimal tour 1-2-4-3-1Harivinod N 9918CS42-Design and Analysis of Algorithms Feb-May 2020

Example-2 ( Home Work )

Complete the exercise….


Analysis


Outline














Feb-May 2020

Reliability Design

• If

the reliability of whole system is

ෑ

𝑖=1

𝑛

𝑟𝑖


Reliability Design

• Let ri be the reliability of the device at stage i.

• If stage i has mi devices of type i in parallel then reliability of stage i is

𝜑𝑖 𝑚𝑖 = 1 − (1 − 𝑟𝑖)𝑚𝑖


Example

• Design a 3-stage system with device types A,B,C. There costs are 30, 15, 20 and reliability are 0.9, 0.8, 0.5 respectively. Budget available is 105. Design a system with highest reliability.

Devices A B C

cost 30 15 20

Reliability 0.9 0.8 0.5

Maximum number of devices can be purchased (by guaranteed purchase of

one unit of other devices)u1=2 u2=3 u3=2

u1= floor((105-(15+20))/30) = 2u2= floor((105-(30+20))/15) = 3 u3= floor((105-(30+15))/20) = 2

Budget =105


Example Budget =105

No. of devices in llel

A B C

Reliability Cost Reliability Cost Reliability Cost

10.9

m1=130

0.8m2=1

150.5

m3=120

20.99

m1=260

0.96m2=2

300.75

m3=240

3 - -0.992m2=3

450.875m3=3

60

𝜑𝑖 𝑚𝑖 = 1 − (1 − 𝑟𝑖)𝑚𝑖

• 𝑺𝒊 - Set of all tuples of the from (f,x) generated from various sequences of m1, m2.. mi considering i stages where f is reliability and x is cost

• 𝑺𝒋𝒊 - i is the stage no., j is the no. of devices used at stage i

• Example

– 𝑺𝟏𝟏 means 1 device of type A at stage 1

– 𝑺𝟐𝟏 means 2 device of type A at stage 1


𝑺𝟏𝟏 = 𝟎. 𝟗, 𝟑𝟎

𝑺𝟐𝟏 = 𝟎. 𝟗𝟗, 𝟔𝟎 𝐶𝑜𝑚𝑏𝑖𝑛𝑖𝑛𝑔: 𝑺𝟏 = 𝟎. 𝟗, 𝟑𝟎 , 𝟎. 𝟗𝟗, 𝟔𝟎

m1=1 m1=2

# of devices in llel

A B C


1 0.9 m1=1 30 0.8 m2=1 15 0.5 m3=1 20

2 0.99 m1=2 60 0.96 m2=2 30 0.75 m3=2 40

3 - - 0.992 m2=3 45 0.875 m3=3 60

Note #1: This configuration will not leave adequate funds to complete systemNote #2: For the same cost, retain the one with highest reliability

𝑺𝟏𝟐 = 𝟎. 𝟕𝟐, 𝟒𝟓 , (𝟎. 𝟕𝟗𝟐, 𝟕𝟓)

𝑺𝟐𝟐 = (𝟎. 𝟖𝟔𝟒, 𝟔𝟎) For (0.9504,90) refer Note #1

𝑺𝟑𝟐 = 𝟎. 𝟖𝟗𝟐𝟖, 𝟕𝟓 For (0.982,105) refer Note #1

𝐶𝑜𝑚𝑏𝑖𝑛𝑖𝑛𝑔: 𝑺𝟐 = 𝟎. 𝟕𝟐, 𝟒𝟓 , 𝟎. 𝟕𝟗𝟐, 𝟕𝟓 , 𝟎. 𝟖𝟔𝟒, 𝟔𝟎 , 𝟎. 𝟖𝟗𝟐𝟖, 𝟕𝟓

𝑺𝟐 = 𝟎. 𝟕𝟐, 𝟒𝟓 , 𝟎. 𝟖𝟔𝟒, 𝟔𝟎 , 𝟎. 𝟖𝟗𝟐𝟖, 𝟕𝟓

.9*.8 .99*.8

.9*.96 .99*.96

.9*.992 .99*.992

Note #2

m1=1 m1=1 m1=1 m2=1 m2=2 m2=3


# of devices in llel

A B C


1 0.9 m1=1 30 0.8 m2=1 15 0.5 m3=1 20

2 0.99 m1=2 60 0.96 m2=2 30 0.75 m3=2 40

3 - - 0.992 m2=3 45 0.875 m3=3 60

𝑺𝟏𝟑 =

𝑺𝟐𝟑 =

𝑺𝟑𝟑 =

𝐶𝑜𝑚𝑏𝑖𝑛𝑖𝑛𝑔: 𝑺𝟑 =

𝑺𝟐 = 𝟎. 𝟕𝟐, 𝟒𝟓 , 𝟎. 𝟖𝟔𝟒, 𝟔𝟎 , 𝟎. 𝟖𝟗𝟐𝟖, 𝟕𝟓m1=1 m1=1 m1=1 m2=1 m2=2 m2=3


m1=1 m2=1M3 =3

Best Reliability 0.648 with cost=100 where A -1 unit, B -1 unit, C- 2 units in ||el.

Assignment-4

1. Write multistage graph algorithm using backward approach.

2. Define transitive clossure of a directed graph. Find the transitive clossure matrix for the graph whose adjacency matrix is given.

3. Apply bottom up dynamic programming algorithm for the following instance of the knapsack problem. Knapsack capacity = 10.


Assignment-4

4. For the given graph obtain optimal cost tour using dynamic programming.

5. Apply Floyds algorithm to find the all pair shortest path for the graph given below.


Module 4: Dynamic Programming - TechJourney.intechjourney.in/docs/DAA/hn-daa-m4-slides.pdf · 2020....

Documents

Transcript of Module 4: Dynamic Programming - TechJourney.intechjourney.in/docs/DAA/hn-daa-m4-slides.pdf · 2020....