Dynamic Programming Example 1 Fibonacci Numbers b Computing

Dynamic Programming

Example 1: Fibonacci Numbers b Computing the nth Fibonacci number recursively: • • F(n) = F(n-1) + F(n-2) F(0) = 0 F(1) = 1 Top-down approach – Time complexity? int Fib(int n) { if (n <= 1) return 1; else return Fib(n - 1) + Fib(n - 2); } F(n) F(n-1) F(n-2) + + n levels F(n-2) F(n-3) + F(n-4)

Example 1: Fibonacci Numbers • Computing the nth Fibonacci number using a bottom-up approach: • • b F(0) = 0 F(1) = 1 F(2) = 1+0 = 1 … F(n-2) = F(n-1) + F(n-2) Complexity: • Time – O(n) • Space – O(n)

Example 1: Fibonacci Numbers b b The bottom-up approach is only O(n). Why is the top-down so inefficient? • Re-computes many sub-problems. – How many times is F(n-5) computed? F(n) F(n-1) F(n-2) + + n levels F(n-2) F(n-3) + F(n-4)

Example 1: Fibonacci Numbers Fib(5) + Fib(4) + Fib(3) + Fib(2) + Fib(1) Fib(0) Fib(3) + Fib(2) + Fib(1) Fib(0)

Dynamic Programming b Dynamic Programming is an algorithm design technique for optimization problems: often minimizing or maximizing. b Like divide and conquer, DP solves problems by combining solutions to sub-problems. b Unlike divide and conquer, sub-problems are not independent. • Sub-problems overlap (share sub-problems) • Dynamic Programming = meta-technique (not a particular algorithm) • Programming = “tableau method’’, not writing a code

Dynamic Programming • In Dynamic Programming we usually reduce time by increasing the amount of space • We solve the problem by solving sub-problems of increasing size and saving each optimal solution in a table. • Time is saved since each sub-problem is solved only once. • • Main idea: - set up a recurrence relating a solution to a larger instance to solutions of some smaller instances - solve smaller instances once - record solutions in a table - extract solution to the initial instance from that table A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 7

Dynamic Programming is a general algorithm design technique for solving problems defined by recurrences with overlapping sub-problems • “Programming” here means “tableau method” • Main idea: - set up a recurrence relating a solution to a larger instance to solutions of some smaller instances - solve smaller instances once - record solutions in a table - extract solution to the initial instance from that table A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 8

Example 2: Coin-row problem There is a row of n coins whose values are some positive integers c₁, c₂, . . . , cn, not necessarily distinct. The goal is to pick up the maximum amount of money subject to the constraint that no two coins adjacent in the initial row can be picked up. E. g. : 5, 1, 2, 10, 6, 2. What is the best selection? Answer: {c 1, c 4, c 6} = {5, 10, 2} A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 9

DP solution to the coin-row problem Let F(n) be the maximum amount that can be picked up from the row of n coins. To derive a recurrence for F(n), we partition all the allowed coin selections into two groups: those without last coin – the max amount is ? those with the last coin -- the max amount is ? Thus we have the following recurrence F(n) = max{cn + F(n-2), F(n-1)} for n > 1, F(0) = 0, F(1)=c₁ A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 10

DP solution to the coin-row problem (cont. ) F(n) = max{cn + F(n-2), F(n-1)} for n > 1, F(0) = 0, F(1)=c₁ index coins F( ) 0 1 2 3 4 5 6 -- 5 1 2 10 6 2 5 A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 11

DP solution to the coin-row problem (cont. ) F(n) = max{cn + F(n-2), F(n-1)} for n > 1, F(0) = 0, F(1)=c₁ index coins F( ) 0 1 2 3 4 5 6 -- 5 1 2 10 6 2 5 5 F(2) = max{c 2 + F(0), F(1)} = max{1 + 0, 5} = 5 A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 12

DP solution to the coin-row problem (cont. ) F(n) = max{cn + F(n-2), F(n-1)} for n > 1, F(0) = 0, F(1)=c₁ index coins F( ) 0 1 2 3 4 5 6 -- 5 1 2 10 6 2 5 5 7 F(3) = max{c 3 + F(1), F(2)} = max{2 + 5, 5} = 7 A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 13

DP solution to the coin-row problem (cont. ) F(n) = max{cn + F(n-2), F(n-1)} for n > 1, F(0) = 0, F(1)=c₁ index coins F( ) 0 1 2 3 4 5 6 -- 5 1 2 10 6 2 5 5 7 15 F(4) = max{c 4 + F(2), F(3)} = max{10 + 5, 7} = 15 A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 14

DP solution to the coin-row problem (cont. ) F(n) = max{cn + F(n-2), F(n-1)} for n > 1, F(0) = 0, F(1)=c₁ index coins F( ) 0 1 2 3 4 5 6 -- 5 1 2 10 6 2 5 5 7 15 15 F(5) = max{c 5 + F(3), F(4)} = max{6 + 7, 15} = 15 A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 15

DP solution to the coin-row problem (cont. ) F(n) = max{cn + F(n-2), F(n-1)} for n > 1, F(0) = 0, F(1)=c₁ index coins F( ) 0 1 2 3 4 5 6 -- 5 1 2 10 6 2 5 5 7 15 15 17 F(6) = max{c 6 + F(4), F(5)} = max{2 + 15, 15} = 17 A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 16

DP solution to the coin-row problem (cont. ) F(n) = max{cn + F(n-2), F(n-1)} for n > 1, F(0) = 0, F(1)=c₁ index coins F( ) 0 1 2 3 4 5 6 -- 5 1 2 10 6 2 5 5 7 15 15 17 Max amount: 17 Coins of optimal solution: {c 1, c 4, c 6} Time efficiency: O(n) Space efficiency: O(n) Note: All smaller instances were solved. A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 17

Example: Longest Common Subsequence b Longest common subsequence (LCS) problem: • Given two sequences X = <x 1 x 2 … xm> and Y = <y 1 y 2 … yn>, find the longest subsequence which occurs in both • Ex: X = {A B C B D A B }, Y = {B D C A B A} • What’s the LCS? X= AB Y= C BDAB BDCAB A • Brute-force algorithm: For every subsequence of X, check if it’s a subsequence of Y – How many subsequences of X are there? – What will be the running time of the brute-force algorithm?

LCS Algorithm b Brute-force algorithm: 2 m subsequences of X to check against n elements of Y: O(n 2 m) b We can do better: for now, let’s only worry about the problem of finding the length of LCS b Notice LCS problem has overlapped subporblems • Subproblems: LCS of pairs of prefixes of X and Y

LCS Algorithm b b First we’ll find the length of LCS. Later we’ll modify the algorithm to find LCS itself. Define Xi, Yj to be the prefixes of X and Y of length i and j respectively (i ≤ m; j ≤ n) • Xi = <x 1 x 2 … xi>; Yj = <y 1 y 2 … yj> b b Define c[i, j] to be the length of LCS of Xi and Yj Then the length of LCS of X and Y will be c[m, n] X= AB C BDAB Y= BDCAB A

LCS recursive solution b We start with i = j = 0 (empty substrings of X and Y) b Since X 0 and Y 0 are empty strings, their LCS is always empty (i. e. , c[0, 0] = 0) b LCS of empty string and any other string is empty, so for every i and j: c[0, j] = c[i, 0] = 0

LCS recursive solution b When we calculate c[i, j], we consider two cases: b First case: x[i]=y[j]: one more symbol in strings X and Y matches, so the length of LCS Xi and Yj equals to the length of LCS of smaller strings Xi-1 and Yi-1 , plus 1

LCS recursive solution b Second case: x[i] != y[j] b As symbols don’t match, our solution is not improved, and the length of LCS(Xi , Yj) is the same as before (i. e. , maximum of LCS(Xi, Yj-1) and LCS(Xi-1, Yj) Why not just take the length of LCS(Xi-1, Yj-1) ?

LCS Length Algorithm LCS-Length(X, Y) 1. m = length(X) // get the # of symbols in X 2. n = length(Y) // get the # of symbols in Y 3. for i = 1 to m c[i, 0] = 0 // special case: Y 0 4. for j = 1 to n c[0, j] = 0 // special case: X 0 5. for i = 1 to m // for all Xi 6. for j = 1 to n // for all Yj 7. if ( Xi == Yj ) 8. c[i, j] = c[i-1, j-1] + 1 9. else c[i, j] = max( c[i-1, j], c[i, j-1] ) 10. return c

LCS Example We’ll see how LCS algorithm works on the following example: b X = ABCB b Y = BDCAB What is the Longest Common Subsequence of X and Y? LCS(X, Y) = BCB X=AB C B Y= BDCAB

LCS Example (0) j i 0 Xi 1 A 2 B 3 C 4 B 0 Yj 1 B 2 D X = ABCB; m = |X| = 4 Y = BDCAB; n = |Y| = 5 Allocate array c[4, 5] 3 C 4 A 5 B ABCB BDCAB

LCS Example (1) j 0 Yj 1 B 2 D 3 C 4 A 5 B 0 Xi 0 0 0 1 A 0 2 B 0 3 C 0 4 B 0 i for i = 1 to m for j = 1 to n c[i, 0] = 0 c[0, j] = 0 ABCB BDCAB

LCS Example (2) j 0 Yj 1 B 2 D 3 C 4 A 5 B 0 Xi 0 0 0 1 A 0 0 2 B 0 3 C 0 4 B 0 i ABCB BDCAB if ( Xi == Yj ) c[i, j] = c[i-1, j-1] + 1 else c[i, j] = max( c[i-1, j], c[i, j-1] )

LCS Example (3) j 0 Yj 1 B 2 D 3 C 4 A 5 B 0 Xi 0 0 0 1 A 0 0 2 B 0 3 C 0 4 B 0 i ABCB BDCAB if ( Xi == Yj ) c[i, j] = c[i-1, j-1] + 1 else c[i, j] = max( c[i-1, j], c[i, j-1] )

LCS Example (4) j 0 Yj 1 B 2 D 3 C 4 A 5 B 0 Xi 0 0 0 1 A 0 0 1 2 B 0 3 C 0 4 B 0 i ABCB BDCAB if ( Xi == Yj ) c[i, j] = c[i-1, j-1] + 1 else c[i, j] = max( c[i-1, j], c[i, j-1] )

LCS Example (5) j 0 Yj 1 B 2 D 3 C 4 A 5 B 0 Xi 0 0 0 1 A 0 0 1 1 2 B 0 3 C 0 4 B 0 i ABCB BDCAB if ( Xi == Yj ) c[i, j] = c[i-1, j-1] + 1 else c[i, j] = max( c[i-1, j], c[i, j-1] )

LCS Example (6) j 0 Yj 1 B 2 D 3 C 4 A 5 B 0 Xi 0 0 0 1 A 0 0 1 1 2 B 0 1 3 C 0 4 B 0 i ABCB BDCAB if ( Xi == Yj ) c[i, j] = c[i-1, j-1] + 1 else c[i, j] = max( c[i-1, j], c[i, j-1] )

LCS Example (7) j 0 Yj 1 B 2 D 3 C 4 A 5 B 0 Xi 0 0 0 1 A 0 0 1 1 2 B 0 1 1 3 C 0 4 B 0 i ABCB BDCAB if ( Xi == Yj ) c[i, j] = c[i-1, j-1] + 1 else c[i, j] = max( c[i-1, j], c[i, j-1] )

LCS Example (8) j 0 Yj 1 B 2 D 3 C 4 A 5 B 0 Xi 0 0 0 1 A 0 0 1 1 2 B 0 1 1 2 3 C 0 4 B 0 i ABCB BDCAB if ( Xi == Yj ) c[i, j] = c[i-1, j-1] + 1 else c[i, j] = max( c[i-1, j], c[i, j-1] )

LCS Example (10) j 0 Yj 1 B 2 D 3 C 4 A 5 B 0 Xi 0 0 0 1 A 0 0 1 1 2 B 0 1 1 2 3 C 0 1 1 4 B 0 i ABCB BDCAB if ( Xi == Yj ) c[i, j] = c[i-1, j-1] + 1 else c[i, j] = max( c[i-1, j], c[i, j-1] )

LCS Example (11) j 0 Yj 1 B 2 D 3 C 4 A 5 B 0 Xi 0 0 0 1 A 0 0 1 1 2 B 0 1 1 2 3 C 0 1 1 2 4 B 0 i ABCB BDCAB if ( Xi == Yj ) c[i, j] = c[i-1, j-1] + 1 else c[i, j] = max( c[i-1, j], c[i, j-1] )

LCS Example (12) j 0 Yj 1 B 2 D 3 C 4 A 5 B 0 Xi 0 0 0 1 A 0 0 1 1 2 B 0 1 1 2 3 C 0 1 1 2 2 2 4 B 0 i ABCB BDCAB if ( Xi == Yj ) c[i, j] = c[i-1, j-1] + 1 else c[i, j] = max( c[i-1, j], c[i, j-1] )

LCS Example (13) j 0 Yj 1 B 2 D 3 C 4 A 5 B 0 Xi 0 0 0 1 A 0 0 1 1 2 B 0 1 1 2 3 C 0 1 1 2 2 2 4 B 0 1 i ABCB BDCAB if ( Xi == Yj ) c[i, j] = c[i-1, j-1] + 1 else c[i, j] = max( c[i-1, j], c[i, j-1] )

LCS Example (14) j 0 Yj 1 B 2 D 3 C 4 A 5 B 0 Xi 0 0 0 1 A 0 0 1 1 2 B 0 1 1 2 3 C 0 1 1 2 2 2 4 B 0 1 1 2 2 i ABCB BDCAB if ( Xi == Yj ) c[i, j] = c[i-1, j-1] + 1 else c[i, j] = max( c[i-1, j], c[i, j-1] )

LCS Example (15) j 0 Yj 1 B 2 D 3 C 4 A 5 B 0 Xi 0 0 0 1 A 0 0 1 1 2 B 0 1 1 2 3 C 0 1 1 2 2 2 4 B 0 1 1 2 2 3 i ABCB BDCAB if ( Xi == Yj ) c[i, j] = c[i-1, j-1] + 1 else c[i, j] = max( c[i-1, j], c[i, j-1] )

LCS Algorithm Running Time b b LCS algorithm calculates the values of each entry of the array c[m, n] So what is the running time? O(mn) since each c[i, j] is calculated in constant time, and there are mn elements in the array

How to find actual LCS b b So far, we have just found the length of LCS, but not LCS itself. We want to modify this algorithm to make it output Longest Common Subsequence of X and Y Each c[i, j] depends on c[i-1, j] and c[i, j-1] or c[i-1, j-1] For each c[i, j] we can say how it was acquired: 2 2 2 3 For example, here c[i, j] = c[i-1, j-1] +1 = 2+1=3

Finding LCS j 0 Yj 1 B 2 D 3 C 4 A 5 B 0 Xi 0 0 0 1 A 0 0 1 1 2 B 0 1 1 2 3 C 0 1 1 2 2 2 4 B 0 1 1 2 2 3 i ABCB BDCAB

How to find actual LCS - continued b n n n Remember that So we can start from c[m, n] and go backwards Whenever c[i, j] = c[i-1, j-1]+1, remember x[i] (because x[i] is a part of LCS) When i=0 or j=0 (i. e. , we reached the beginning), output remembered letters in reverse order

Finding LCS (2) j 0 Yj 1 B 2 D 3 C 4 A 5 B 0 Xi 0 0 0 1 A 0 0 1 1 2 B 0 1 1 2 3 C 0 1 1 2 2 2 4 B 0 1 1 2 2 3 i LCS (reversed order): LCS (straight order): B C B

Properties of a problem that can be solved with dynamic programming b Simple Sub-problems • We should be able to break the original problem to smaller sub -problems that have the same structure b Optimal Substructure of the problems • The solution to the problem must be a composition of subproblem solutions b Sub-problem Overlap • Optimal sub-problems to unrelated problems can contain subproblems in common

Example 3: Change-making Problem Give change for amount n using the minimum number of coins of denominations d 1 < d 2 < … < dm. Example: n = 6, coin denominations 1, 3, and 4 A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 47

DP solution to the change-making problem Let F(n) be the minimum number of coins whose value add up to n add one coin of domination dj to the amount n – dj Thus we have the following recurrence F(n) = min{F(n - dj)} + 1 for n > 0, F(0) = 0 A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 48

DP solution to the change-making problem F(n) = min{F(n - dj)} + 1 for n > 0, F(0) = 0 n F( ) 0 0 1 2 3 4 5 6 F(0) = 0 A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 49

DP solution to the change-making problem F(n) = min{F(n - dj)} + 1 for n > 0, F(0) = 0 n F( ) 0 0 1 1 2 3 4 5 6 F(1) = min{F[1 - 1]} + 1 =0+1=1 A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 50

DP solution to the change-making problem F(n) = min{F(n - dj)} + 1 for n > 0, F(0) = 0 n F( ) 0 0 1 1 2 2 3 4 5 6 F(2) = min{F[2 - 1]} + 1 =1+1=2 A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 51

DP solution to the change-making problem F(n) = min{F(n - dj)} + 1 for n > 0, F(0) = 0 n F( ) 0 0 1 1 2 2 3 1 4 5 6 F(3) = min{F[3 - 1], F[3 - 3]} + 1 = min{2, 0} + 1 = 1 A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 52

DP solution to the change-making problem F(n) = min{F(n - dj)} + 1 for n > 0, F(0) = 0 n F( ) 0 0 1 1 2 2 3 1 4 1 5 6 F(4) = min{F[4 - 1], F[4 - 3], F[4 - 4]} + 1 = min{1, 1, 0} + 1 = 1 A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 53

DP solution to the change-making problem F(n) = min{F(n - dj)} + 1 for n > 0, F(0) = 0 n F( ) 0 0 1 1 2 2 3 1 4 1 5 2 6 F(5) = min{F[5 - 1], F[5 - 3], F[5 - 4]} + 1 = min{1, 2, 1} + 1 = 2 A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 54

DP solution to the change-making problem F(n) = min{F(n - dj)} + 1 for n > 0, F(0) = 0 n F( ) 0 0 1 1 2 2 3 1 4 1 5 2 6 2 F(6) = min{F[6 - 1], F[6 - 3], F[6 - 4]} + 1 = min{2, 1, 2} + 1 = 2 A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 55

DP solution to the change-making problem F(n) = min{F(n - dj)} + 1 for n > 0, F(0) = 0 n F( ) 0 0 1 1 2 2 3 1 4 1 5 2 6 2 Min coin #: 2 Coins of optimal solution: two 3’s Time efficiency: O(nm) Space efficiency: O(n) Note: All smaller instances were solved. A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 56

Example 4: Coin-collecting by robot Several coins are placed in cells of an n×m board. A robot, located in the upper left cell of the board, needs to collect as many of the coins as possible and bring them to the bottom right cell. On each step, the robot can move either one cell to the right or one cell down from its current location. A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 57

Solution to the coin-collecting problem Let F(i, j) be the largest number of coins the robot can collect and bring to cell (i, j) in the ith row and jth column. The largest number of coins that can be brought to cell (i, j): from the left neighbor ? from the neighbor above? The recurrence: F(i, j) = max{F(i-1, j), F(i, j-1)} + cij for 1 ≤ i ≤ n, 1 ≤ j ≤ m where cij = 1 if there is a coin in cell (i, j), and cij = 0 otherwise F(0, j) = 0 for 1 ≤ j ≤ m and F(i, 0) = 0 for 1 ≤ i ≤ n. A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 58

Solution to the coin-collecting problem (cont. ) F(i, j) = max{F(i-1, j), F(i, j-1)} + cij for 1 ≤ i ≤ n, 1 ≤ j ≤ m where cij = 1 if there is a coin in cell (i, j), and cij = 0 otherwise F(0, j) = 0 for 1 ≤ j ≤ m and F(i, 0) = 0 for 1 ≤ i ≤ n. A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 59

Solution to the coin-collecting problem (cont. ) F(i, j) = max{F(i-1, j), F(i, j-1)} + cij for 1 ≤ i ≤ n, 1 ≤ j ≤ m where cij = 1 if there is a coin in cell (i, j), and cij = 0 otherwise F(0, j) = 0 for 1 ≤ j ≤ m and F(i, 0) = 0 for 1 ≤ i ≤ n. A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 60

0 -1 Knapsack problem b Given a knapsack with maximum capacity W, and a set S consisting of n items b Each item i has some weight wi and benefit value bi (all wi , bi and W are integer values) b Problem: How to pack the knapsack to achieve maximum total value of packed items?

0 -1 Knapsack problem Weight Items This is a knapsack Max weight: W = 20 Benefit value wi bi 2 4 3 5 5 8 3 4 9 10

0 -1 Knapsack problem b Problem, in other words, is to find n The problem is called a “ 0 -1” problem, because each item must be entirely accepted or rejected. n Just another version of this problem is the “Fractional Knapsack Problem”, where we can take fractions of items.

0 -1 Knapsack problem: brute-force approach Let’s first solve this problem with a straightforward algorithm b Since there are n items, there are 2 n possible combinations of items. b We go through all combinations and find the one with the most total value and with total weight less or equal to W b Running time will be O(2 n)

0 -1 Knapsack problem: brute-force approach b b b Can we do better? Yes, with an algorithm based on dynamic programming We need to carefully identify the sub-problems Let’s try this: If items are labeled 1. . n, then a sub-problem would be to find an optimal solution for Sk = {items labeled 1, 2, . . k}, where k ≤ n

Defining a Subproblem If items are labeled 1. . n, then a sub-problem would be to find an optimal solution for Sk = {items labeled 1, 2, . . k} b This is a valid sub-problem definition. The question is: can we describe the final solution (Sn ) in terms of sub-problems (Sk)? b Unfortunately, we can’t do that. Explanation follows…. b

Defining a Subproblem w 1 =2 w 2=4 b 1 =3 b 2 =5 w 3 =5 b 3 =8 Max weight: W = 20 For S 4: Total weight: 14; total benefit: 20 w 1 =2 w 2=4 b 1 =3 b 2 =5 w 3 =5 b 3 =8 Weight Benefit w 4 =3 b 4 =4 wi bi 1 2 3 2 4 5 3 5 8 4 3 4 5 9 10 Item # S 4 Optimal Solution w 5 =9 b 5 =10 Optimal Solution: Total weight: 20 total benefit: 26 ? Solution for S 4 is not part of the solution for the problem!!!

Defining a Subproblem (continued) b b As we have seen, the solution for S 4 is not part of the solution for the problem So our definition of a sub-problem is flawed and we need another one! Let’s add another parameter: w, which will represent the remaining weight of the knapsack The sub-problem then will be to compute B[k, w]: maximum value in a knapsack with k item and remaining weight w

Recursive Formula for subproblems n Recursive formula for subproblems: It means, that the best subset of Sk that has total weight w is one of the two: 1) the best subset of Sk-1 that has total weight w, or 2) the best subset of Sk-1 that has total weight w-wk plus the value of item k b

Recursive Formula b b b The best subset of Sk that has the total weight w, either contains item k or not. First case: wk>w. Item k can’t be part of the solution, since if it was, the total weight would be > w, which is unacceptable Second case: wk <=w. Then the item k can be in the solution, and we choose the case with greater value

0 -1 Knapsack Algorithm for w = 0 to W B[0, w] = 0 for i = 0 to n B[i, 0] = 0 for w = 0 to W if wi <= w // item i can be part of the solution if bi + B[i-1, w-wi] > B[i-1, w] B[i, w] = bi + B[i-1, w- wi] else B[i, w] = B[i-1, w] // wi > w

Running time What is the running time of this algorithm? O(n*W) Remember that the brute-force algorithm takes O(2 n)

Example (1) Let’s run our algorithm on the following data: n = 4 (# of elements) W = 5 (max weight) Elements (weight, benefit): (2, 3), (3, 4), (4, 5), (5, 6)

Example (2) i W 0 1 2 3 4 5 0 1 2 3 0 0 0 for w = 0 to W B[0, w] = 0 4

Example (3) i W 0 1 2 3 4 5 0 1 2 3 4 0 0 0 0 0 for i = 0 to n B[i, 0] = 0

Example (4) i W 0 1 2 3 4 5 0 1 2 3 4 0 0 0 i=1 bi=3 wi=2 w=1 w-wi =-1 if wi <= w // item i can be part of the solution if bi + B[i-1, w-wi] > B[i-1, w] B[i, w] = bi + B[i-1, w- wi] else B[i, w] = B[i-1, w] // wi > w Items: 1: (2, 3) 2: (3, 4) 3: (4, 5) 4: (5, 6)

Example (5) i W 0 1 2 3 4 5 0 1 2 3 4 0 0 0 0 3 0 0 0 i=1 bi=3 wi=2 w-wi =0 if wi <= w // item i can be part of the solution if bi + B[i-1, w-wi] > B[i-1, w] B[i, w] = bi + B[i-1, w- wi] else B[i, w] = B[i-1, w] // wi > w Items: 1: (2, 3) 2: (3, 4) 3: (4, 5) 4: (5, 6)

Example (6) i W 0 1 2 3 4 5 0 1 2 3 4 0 0 0 0 3 3 0 0 0 i=1 bi=3 wi=2 w=3 w-wi=1 if wi <= w // item i can be part of the solution if bi + B[i-1, w-wi] > B[i-1, w] B[i, w] = bi + B[i-1, w- wi] else B[i, w] = B[i-1, w] // wi > w Items: 1: (2, 3) 2: (3, 4) 3: (4, 5) 4: (5, 6)

Example (7) i W 0 1 2 3 4 5 0 1 2 3 4 0 0 0 0 3 3 3 0 0 0 i=1 bi=3 wi=2 w=4 w-wi=2 if wi <= w // item i can be part of the solution if bi + B[i-1, w-wi] > B[i-1, w] B[i, w] = bi + B[i-1, w- wi] else B[i, w] = B[i-1, w] // wi > w Items: 1: (2, 3) 2: (3, 4) 3: (4, 5) 4: (5, 6)

Example (8) i W 0 1 2 3 4 5 0 1 2 3 4 0 0 0 0 3 3 0 0 0 i=1 bi=3 wi=2 w=5 w-wi=2 if wi <= w // item i can be part of the solution if bi + B[i-1, w-wi] > B[i-1, w] B[i, w] = bi + B[i-1, w- wi] else B[i, w] = B[i-1, w] // wi > w Items: 1: (2, 3) 2: (3, 4) 3: (4, 5) 4: (5, 6)

Example (9) i W 0 1 2 3 4 5 0 1 2 3 4 0 0 0 0 3 3 0 0 i=2 bi=4 wi=3 w=1 w-wi=-2 if wi <= w // item i can be part of the solution if bi + B[i-1, w-wi] > B[i-1, w] B[i, w] = bi + B[i-1, w- wi] else B[i, w] = B[i-1, w] // wi > w Items: 1: (2, 3) 2: (3, 4) 3: (4, 5) 4: (5, 6)

Example (10) i W 0 1 2 3 4 5 0 1 2 3 4 0 0 0 0 3 3 0 0 i=2 bi=4 wi=3 w=2 w-wi=-1 if wi <= w // item i can be part of the solution if bi + B[i-1, w-wi] > B[i-1, w] B[i, w] = bi + B[i-1, w- wi] else B[i, w] = B[i-1, w] // wi > w Items: 1: (2, 3) 2: (3, 4) 3: (4, 5) 4: (5, 6)

Example (11) i W 0 1 2 3 4 5 0 1 2 3 4 0 0 0 0 3 3 0 0 3 4 0 0 i=2 bi=4 wi=3 w-wi=0 if wi <= w // item i can be part of the solution if bi + B[i-1, w-wi] > B[i-1, w] B[i, w] = bi + B[i-1, w- wi] else B[i, w] = B[i-1, w] // wi > w Items: 1: (2, 3) 2: (3, 4) 3: (4, 5) 4: (5, 6)

Example (12) i W 0 1 2 3 4 5 0 1 2 3 4 0 0 0 0 3 3 0 0 3 4 4 0 0 i=2 bi=4 wi=3 w=4 w-wi=1 if wi <= w // item i can be part of the solution if bi + B[i-1, w-wi] > B[i-1, w] B[i, w] = bi + B[i-1, w- wi] else B[i, w] = B[i-1, w] // wi > w Items: 1: (2, 3) 2: (3, 4) 3: (4, 5) 4: (5, 6)

Example (13) i W 0 1 2 3 4 5 0 1 2 3 4 0 0 0 0 3 3 0 0 3 4 4 7 0 0 i=2 bi=4 wi=3 w=5 w-wi=2 if wi <= w // item i can be part of the solution if bi + B[i-1, w-wi] > B[i-1, w] B[i, w] = bi + B[i-1, w- wi] else B[i, w] = B[i-1, w] // wi > w Items: 1: (2, 3) 2: (3, 4) 3: (4, 5) 4: (5, 6)

Example (14) i W 0 1 2 3 4 5 0 1 2 3 4 0 0 0 0 3 3 0 0 3 4 4 7 0 0 3 4 0 i=3 bi=5 wi=4 w=1. . 3 if wi <= w // item i can be part of the solution if bi + B[i-1, w-wi] > B[i-1, w] B[i, w] = bi + B[i-1, w- wi] else B[i, w] = B[i-1, w] // wi > w Items: 1: (2, 3) 2: (3, 4) 3: (4, 5) 4: (5, 6)

Example (15) i W 0 1 2 3 4 5 0 1 2 3 4 0 0 0 0 3 3 0 0 3 4 4 7 0 0 3 4 5 0 i=3 bi=5 wi=4 w- wi=0 if wi <= w // item i can be part of the solution if bi + B[i-1, w-wi] > B[i-1, w] B[i, w] = bi + B[i-1, w- wi] else B[i, w] = B[i-1, w] // wi > w Items: 1: (2, 3) 2: (3, 4) 3: (4, 5) 4: (5, 6)

Example (15) i W 0 1 2 3 4 5 0 1 2 3 4 0 0 0 0 3 3 0 0 3 4 4 7 0 0 3 4 5 7 0 i=3 bi=5 wi=4 w=5 w- wi=1 if wi <= w // item i can be part of the solution if bi + B[i-1, w-wi] > B[i-1, w] B[i, w] = bi + B[i-1, w- wi] else B[i, w] = B[i-1, w] // wi > w Items: 1: (2, 3) 2: (3, 4) 3: (4, 5) 4: (5, 6)

Example (16) i W 0 1 2 3 4 5 0 1 2 3 4 0 0 0 0 3 3 0 0 3 4 4 7 0 0 3 4 5 i=3 bi=5 wi=4 w=1. . 4 if wi <= w // item i can be part of the solution if bi + B[i-1, w-wi] > B[i-1, w] B[i, w] = bi + B[i-1, w- wi] else B[i, w] = B[i-1, w] // wi > w Items: 1: (2, 3) 2: (3, 4) 3: (4, 5) 4: (5, 6)

Example (17) i W 0 1 2 3 4 5 0 1 2 3 4 0 0 0 0 3 3 0 0 3 4 4 7 0 0 3 4 5 7 i=3 bi=5 wi=4 w=5 if wi <= w // item i can be part of the solution if bi + B[i-1, w-wi] > B[i-1, w] B[i, w] = bi + B[i-1, w- wi] else B[i, w] = B[i-1, w] // wi > w Items: 1: (2, 3) 2: (3, 4) 3: (4, 5) 4: (5, 6) The greedy approach is not giving us the optimal value.

Comments b This algorithm only finds the max possible value that can be carried in the knapsack b To know the items that make this maximum value, an addition to this algorithm is necessary b Please see LCS algorithm from the previous lecture for the example how to extract this data from the table we built

Find Items i W 0 1 2 3 4 5 0 1 2 3 4 0 0 0 0 3 3 0 0 3 4 4 7 0 0 3 4 5 7 Item (reversed order): i = 2, i = 1 Item (straight order): i=1, i = 2

Optimal Binary Search Trees b Example: What is an optimal BST for keys A, B, C, and D with search probabilities 0. 1, 0. 2, 0. 4, and 0. 3, respectively? b Average number of comparison: a) 0. 1 * 1 + 0. 2 * 2 + 0. 4 * 3 + 0. 3 * 4 = 2. 9 b) 0. 1 * 2 + 0. 2 * 1 + 0. 4 * 2 + 0. 3 * 3 = 2. 1 c) 0. 1 *3 + 0. 2 * 2 + 0. 4 * 1 + 0. 3 * 2 = 1. 7 b b b A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 93

Optimal Binary Search Trees Problem: Given n keys a 1 < …< an and probabilities p 1 ≤ … ≤ pn searching for them, find a BST with a minimum average number of comparisons in successful search. Since total number of BSTs with n nodes is given by the nth Catalan number C(2 n, n)/(n+1), which grows exponentially, brute force is hopeless. A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 94

DP for Optimal BST Problem Let C[i, j] be minimum average number of comparisons made in T[i, j], optimal BST for keys ai < …< aj , where 1 ≤ i ≤ j ≤ n. Consider optimal BST among all BSTs with some ak (i ≤ k ≤ j ) as their root; T[i, j] is the best among them. C[i, j] = min {pk · 1 + i≤k≤j k-1 ∑ ps (level as in T[i, k-1] +1) + s=i j ∑ ps (level as in T[k+1, j] +1)} s =k+1 A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 95

DP for Optimal BST Problem (cont. ) After simplifications, we obtain the recurrence for C[i, j]: j C[i, j] = min {C[i, k-1] + C[k+1, j]} + ∑ ps for 1 ≤ i ≤ j ≤ n i≤k≤j C[i, i] = pi for 1 ≤ i ≤ j ≤ n s=i A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 96

Example: key A B C D probability 0. 1 0. 2 0. 4 0. 3 The tables below are filled diagonal by diagonal: the left one is filled using the recurrence j C[i, j] = min {C[i, k-1] + C[k+1, j]} + ∑ ps , C[i, i] = pi ; i≤k≤j The initial tables look like this: s=i

Example: key A B C D probability 0. 1 0. 2 0. 4 0. 3 j C[i, j] = min {C[i, k-1] + C[k+1, j]} + ∑ ps , C[i, i] = pi ; i≤k≤j s=i j 0 1 2 1 0 . 1 ? 1 0 . 2 2 i 2 3 4 5 0 3 4 j 3 . 4 0 i . 3 4 0 5 0 1 2 1 ? 3 4 2 3 4 optimal BST

Example: key A B C D probability 0. 1 0. 2 0. 4 0. 3 j C[i, j] = min {C[i, k-1] + C[k+1, j]} + ∑ ps , C[i, i] = pi ; i≤k≤j s=i j 0 1 2 1 0 . 1 . 4 0 . 2 ? 2 0 . 4 3 i 2 3 4 5 3 4 i j 1 0 . 3 4 0 5 0 1 2 2 3 4 ? 3 4 optimal BST

Example: key A B C D probability 0. 1 0. 2 0. 4 0. 3 j i≤k≤j s=i j 0 1 2 1 0 . 1 . 4 0 . 2 . 8 2 0 . 4 ? 3 0 . 3 4 0 5 i 2 3 4 5 3 4 i j 1 0 1 2 2 3 4 3 3 ? 4 optimal BST

Example: key A B C D probability 0. 1 0. 2 0. 4 0. 3 j i≤k≤j s=i j 0 1 2 3 1 0 . 1 . 4 ? 1 0 . 2 . 8 2 0 . 4 1. 0 3 0 . 3 4 0 5 i 2 3 4 5 4 i j 0 1 2 3 1 2 ? 2 3 3 4 optimal BST

Example: key A B C D probability 0. 1 0. 2 0. 4 0. 3 j i≤k≤j s=i j 0 1 2 3 1 0 . 1 . 4 1. 1 1 0 . 2 . 8 ? 2 0 . 4 1. 0 3 0 . 3 4 0 5 i 2 3 4 5 4 i j 0 1 2 3 4 1 2 3 ? 3 3 4 optimal BST

Example: key A B C D probability 0. 1 0. 2 0. 4 0. 3 j i≤k≤j s=i j 0 1 2 3 1 0 . 1 . 4 1. 1 ? 1 0 . 2 . 8 1. 4 2 0 . 4 1. 0 3 0 . 3 4 0 5 i 2 3 4 5 4 i j 0 1 2 3 4 1 2 3 ? 2 3 3 4 optimal BST

Example: key A B C D probability 0. 1 0. 2 0. 4 0. 3 j i≤k≤j s=i j 0 1 2 3 1 0 . 1 . 4 1. 1 1. 7 1 0 . 2 . 8 1. 4 2 0 . 4 1. 0 3 0 . 3 4 0 5 i 2 3 4 5 4 i j 0 1 2 3 4 1 2 3 3 3 3 4 optimal BST

Example: key A B C D probability 0. 1 0. 2 0. 4 0. 3 The tables below are filled diagonal by diagonal: the left one is filled using the recurrence j C[i, j] = min {C[i, k-1] + C[k+1, j]} + ∑ ps , C[i, i] = pi ; i≤k≤j s=i main table root table j 0 1 2 3 1 0 . 1 . 4 1. 1 1. 7 1 0 . 2 . 8 1. 4 2 0 . 4 1. 0 3 0 . 3 4 0 5 i 2 3 4 5 4 i j 0 1 2 3 4 1 2 3 3 3 3 4 C B D A optimal BST

DP for Optimal BST Problem (cont. ) j C[i, j] = min {C[i, k-1] + C[k+1, j]} + ∑ ps for 1 ≤ i ≤ j ≤ n i≤k≤j C[i, i] = pi for 1 ≤ i ≤ j ≤ n s=i A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 106

Optimal Binary Search Trees A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 107

Analysis DP for Optimal BST Problem Time efficiency: Θ(n 3) Space efficiency: Θ(n 2) A. Levitin “Introduction to the Design & Analysis of Algorithms, ” 3 rd ed. , Ch. 8 © 2012 Pearson Education, Inc. Upper Saddle River, NJ. All Rights Reserved. 108