CPSC 490 Problem Solving in Computer Science

Transcription

1 CPSC 490 Problem Solving in Computer Science Lecture 6: Recovering Solutions from DP, Bitmask DP, Matrix Exponentiation David Zheng and Daniel Du Based on CPSC490 slides from /01/23

2 Announcements Presentations Presentation choices due Monday, January 29th Presentation dates are February 13th, 15th

3 Revisiting Knapsack You have n items, each with weight w i and value v i You can carry maximum weight W Maximize total value you can carry, taking at most one of each item. Value (v) Weight (w) If W = 9 then maximum total value = 11 Now what if we wanted to know which items we need to take to attain the maximum value? What if we wanted to minimize the number of items we took as well?

4 Backtracking in Knapsack Idea: Store how we got to the state. Value (v) Weight (w) Use an array to store the index of the last thing you took. To minimize the number of items, store also the minimum number of items you took to reach the state and update with the item you took to minimize the number of items taken.

5 Remember This Problem? How many ways are there to tile a 2 n grid with 2 1 tiles? Constraint: n 1, 000, 000 Solution: f (0) = f (1) = 1, f (n) = f (n 1) + f (n 2)

6 Problem 1 A Harder Problem How many ways are there to tile a 3 n grid with 2 1 tiles? Constraint: n 1, 000, 000 Notice that f (n) = number of ways to fill 3 n grid does not work.

7 A New Kind of DP State f (n) = number of ways to fill 3 n grid does NOT work because after filling a single column, the right most column may not be full! We need more information: configuration of the right most column! Represent right most column by a bitmask: 1 = filled, 0 = not filled.

8 Review of Bitmask and Bit Operations A bitmask represents a set: i-th bit is 1 if the i-th element is in set. In most programming languages, you have bitwise operations on integers: ^, ~, <<, >>, &, What bitwise operations correspond to these set operations? Union of two sets x and y: x y Intersection: x & y Symmetric difference: x ^ y A singleton set i: (1 << i) Checking if i x: x & (1<<i) The element in x with the smallest label: x & (-x) More bit-twiddling hacks:

9 Problem 1 Solution DP State: f (k, C) = number of ways to fill the first k columns such that column k + 1 has configuration equal to bitmask C

10 Problem 1 Solution DP State: f (k, C) = number of ways to fill the first k columns such that column k + 1 has configuration equal to bitmask C Base case: f (0, 000) = 1, f (0, z) = 0 for z 0

11 Problem 1 Solution DP State: f (k, C) = number of ways to fill the first k columns such that column k + 1 has configuration equal to bitmask C Base case: f (0, 000) = 1, f (0, z) = 0 for z 0 Recurrence: try to fill last unfilled column don t double count!

12 Problem 1 Solution DP State: f (k, C) = number of ways to fill the first k columns such that column k + 1 has configuration equal to bitmask C Base case: f (0, 000) = 1, f (0, z) = 0 for z 0 Recurrence: try to fill last unfilled column don t double count! f (k, 000) = f (k 2, 000) + f (k 1, 001) + f (k 1, 100) f (k, 001) = f (k 1, 000) + f (k 1, 110) f (k, 100) = f (k 1, 000) + f (k 1, 011) f (k, 110) = f (k 1, 001) f (k, 011) = f (k 1, 100)

13 Problem 1 Solution DP State: f (k, C) = number of ways to fill the first k columns such that column k + 1 has configuration equal to bitmask C Base case: f (0, 000) = 1, f (0, z) = 0 for z 0 Recurrence: try to fill last unfilled column don t double count! f (k, 000) = f (k 2, 000) + f (k 1, 001) + f (k 1, 100) f (k, 001) = f (k 1, 000) + f (k 1, 110) f (k, 100) = f (k 1, 000) + f (k 1, 011) f (k, 110) = f (k 1, 001) f (k, 011) = f (k 1, 100) Answer: f (n, 000)

14 Problem 1 Solution DP State: f (k, C) = number of ways to fill the first k columns such that column k + 1 has configuration equal to bitmask C Base case: f (0, 000) = 1, f (0, z) = 0 for z 0 Recurrence: try to fill last unfilled column don t double count! f (k, 000) = f (k 2, 000) + f (k 1, 001) + f (k 1, 100) f (k, 001) = f (k 1, 000) + f (k 1, 110) f (k, 100) = f (k 1, 000) + f (k 1, 011) f (k, 110) = f (k 1, 001) f (k, 011) = f (k 1, 100) Answer: f (n, 000) Time Complexity: O(n)

15 Problem 2 An Even Harder Problem How many ways are there to tile a 4 n grid with 2 1 tiles? Constraint: n 1, 000, 000 What about 5 n, 6 n,..., or in general k n?

16 Problem 2 An Even Harder Problem How many ways are there to tile a 4 n grid with 2 1 tiles? Constraint: n 1, 000, 000 What about 5 n, 6 n,..., or in general k n? Solution: find the recurrence with O(2 2k ) BFS!

17 Problem 3 Even Harder! How many ways are there to tile a k n grid with 2 1 tiles? Constraints: 2 k 10, 0 n 10 18

18 Skipping Recurrence Steps Quickly Consider the case of k = 2, i.e. f n = f n 1 + f n 2

19 Skipping Recurrence Steps Quickly Consider the case of k = 2, i.e. f n = f n 1 + f n 2 Expand the term f n 1 we get 2-step recurrence f n = f n 2 + f n 3 + f n 2 = 2f n 2 + f n 3

20 Skipping Recurrence Steps Quickly Consider the case of k = 2, i.e. f n = f n 1 + f n 2 Expand the term f n 1 we get 2-step recurrence f n = f n 2 + f n 3 + f n 2 = 2f n 2 + f n 3 Now use the above two formulas, we get 4-step recurrence f n = 4f n 4 + 2f n 5 + f n 4 + f n 5 = 5f n 4 + 3f n 5

21 Skipping Recurrence Steps Quickly Consider the case of k = 2, i.e. f n = f n 1 + f n 2 Expand the term f n 1 we get 2-step recurrence f n = f n 2 + f n 3 + f n 2 = 2f n 2 + f n 3 Now use the above two formulas, we get 4-step recurrence f n = 4f n 4 + 2f n 5 + f n 4 + f n 5 = 5f n 4 + 3f n 5 Do this again, we get 8-step recurrence f n = 34f n f n 9

22 Skipping Recurrence Steps Quickly Consider the case of k = 2, i.e. f n = f n 1 + f n 2 Expand the term f n 1 we get 2-step recurrence f n = f n 2 + f n 3 + f n 2 = 2f n 2 + f n 3 Now use the above two formulas, we get 4-step recurrence f n = 4f n 4 + 2f n 5 + f n 4 + f n 5 = 5f n 4 + 3f n 5 Do this again, we get 8-step recurrence f n = 34f n f n 9 This seems tedious can we automate this procedure efficiently?

23 Matrix Multiplication Why did it work? The recurrence was linear! For k = 2 [ ] [ ] [ ] 0 1 fn 2 fn 1 = 1 1 f n 1 f n In other words, [ ] n 1 [ ] [ ] 0 1 f0 fn 1 = 1 1 f 1 f n

24 Matrix Multiplication k = 3 is a bit more complicated f n 2, f n 1, f n 1, f n 1,4 = f n 1, f n 1,5 f n 1,0 f n,0 f n,1 f n,4 f n,6 f n,5

25 Fast Matrix Exponentiation All we need now is a way to get M n quickly in O(log n) time!

26 Fast Matrix Exponentiation All we need now is a way to get M n quickly in O(log n) time! If we know M, then we can square it to get M 2, but squaring that again gives M 4, and then M 8, and so on...

27 Fast Matrix Exponentiation All we need now is a way to get M n quickly in O(log n) time! If we know M, then we can square it to get M 2, but squaring that again gives M 4, and then M 8, and so on... We can compute M 2k with O(k) matrix multiplications

28 Fast Matrix Exponentiation All we need now is a way to get M n quickly in O(log n) time! If we know M, then we can square it to get M 2, but squaring that again gives M 4, and then M 8, and so on... We can compute M 2k with O(k) matrix multiplications Matrix multiplication is associative, so we can break up the exponent into sum of powers of two by using its base-2 representation: M 30 = M = M 16 M 8 M 4 M 2

29 Fast Matrix Exponentiation All we need now is a way to get M n quickly in O(log n) time! If we know M, then we can square it to get M 2, but squaring that again gives M 4, and then M 8, and so on... We can compute M 2k with O(k) matrix multiplications Matrix multiplication is associative, so we can break up the exponent into sum of powers of two by using its base-2 representation: M 30 = M = M 16 M 8 M 4 M 2 compute M 2k for 0 k log n, and then multiply the appropriate ones together in a total of O(log n) multiplications!

30 Fast Matrix Exponentiation All we need now is a way to get M n quickly in O(log n) time! If we know M, then we can square it to get M 2, but squaring that again gives M 4, and then M 8, and so on... We can compute M 2k with O(k) matrix multiplications Matrix multiplication is associative, so we can break up the exponent into sum of powers of two by using its base-2 representation: M 30 = M = M 16 M 8 M 4 M 2 compute M 2k for 0 k log n, and then multiply the appropriate ones together in a total of O(log n) multiplications! alternatively, we can use divide and conquer to also get O(log n).

31 Fast Matrix Exponentiation 1 FAST _ POW (M, n): 2 initialize A = Identity matrix 3 for k from 0 to log _2( n): 4 if n AND 2^ k!= 0: 5 A = A * M 6 M = M * M 7 return A 1 FAST _ POW _ REC (M, n): 2 if n ==0: 3 return Identity matrix 4 A = FAST _ POW _ REC (M, n /2) 5 A = A * A 6 if n is odd : 7 A = A * M 8 return A

32 Next Class Strings!