Practical Exam. Recursion and Friends

Transcription

1 Practical Exam Recursion and Friends

2 Treasure Hunt Recursion 2

3 Treasure Hunt On a rectangular grid, you enter from one side and exit from the other There are differing amounts of treasure on each grid cell You can only go up straight or diagonally Find the path from entrance to exit with the largest amount of treasure Exit Entrance

4 Intuition Let s assume we got to this cell and you have accumulated a total so far We have three ways to choose from, up, right diagonal or left diagonal We should choose the cell whose path from there has the highest treasure value How to calculate the value of the path from there? Recursive problem

5 findmax int findmax (grid, total, row, col) { // Base case // Recursive step }

6 Base Case When you reach the end of the map, there are no more cells to go to If you start from row 0, then you should end at row n-1 Simply return the total value you have calculated so far Exit (n-1) Entrance (0)

7 Recursive Step You are either at the left cell, middle cell, or right cell For left and right cell, you can only choose from 2 cells For middle cell, you can choose from

8 Recursive Steps if Left Cell, then totalupvalue = findmax (grid, total + upvalue, row+1, col) totalrightvalue = findmax (grid, total + rightvalue, row+1, col+1) return max (totalupvalue, totalrightvalue) if Middle Cell, then totalleftvalue = findmax (grid, total + leftvalue, row+1, col-1) totalupvalue = findmax (grid, total + upvalue, row+1, col) totalrightvalue = findmax (grid, total + rightvalue, row+1, col+1) return max (totalleftvalue, totalupvalue, totalrightvalue) if Right Cell, then totalleftvalue = findmax (grid, total + leftvalue, row+1, col-1) totalupvalue = findmax (grid, total + upvalue, row+1, col) return max (totalleftvalue, totalupvalue)

9 Notes How to do max of three values: max (a, b, c)? Math.max only takes in two values, not three Trick: Math.max (a, Math.max (b, c))

10 Questions? Treasure Hunt 10

11 Garden Speed Demon 11

12 Garden Given an R by C grid of cells Some cells contain mines, denoted by o Others have nothing, denoted by. (fullstop) Find all squares within that plot that have no mines

13 Intuition Find all squares: simplistically, just check all possible squares in the plot of land Sounds easy? It is Take-Home Lab 1 standard For every cell [O(n 2 )], construct squares of increasing order [O(n)]. For each cell in each square [O(n 2 )] check if it contains a mine [O(1)] Time complexity: O(n 2 ) * O(n) * O(n 2 ) * O(1) = O(n 5 ) 90% secured!

14 O(n 5 ) Find All Squares

15 Observation When we check a bigger square, some part of the bigger square is already checked previously Can you identify which parts are already checked? If you can, then you only need to check the unchecked parts! This saves us some time! 2 x 2 square 3 x 3 square The unchecked parts

16 Improvement from O(n 5 ) There are at most R + C 1 unchecked cells for each larger square (Why? Think about it ) This means a larger square can be checked in O(n) For every cell [O(n 2 )], construct squares of increasing order [O(n)]. For each unchecked cell in the larger square [O(n)] check if it contains a mine [O(1)] Time complexity: O(n 2 ) * O(n) * O(n) * O(1) = O(n 4 ) 100% secured! Can go home already!

17 Visualisation

18 Visualisation

19 Visualisation

20 Visualisation

21 Visualisation

22 Visualisation

23 Visualisation

24 Visualisation

25 Visualisation

26 Further Observation Looks like there s still duplicate checking going on We need to get rid of the duplicates to be even faster than O(n 4 ) Right now each square checking is linear or O(n) time Can we determine the number of mines in a square in O(1) time?

27 Further Insight We can count the number of mines in each subarray from [0,0] to the cell [x,y] This is called a prefix sum array, assuming each mine has the value of 1 (empty cells = 0) MINE MINE MINE

28 Inclusion-Exclusion Principle The entire array, from [0,0] to [2,3], has 3 mines (yellow numbers are where the mines are) We are only interested in the square [1,2] to [2,3]

29 Inclusion-Exclusion Principle The top row has one mine We don t need it, so subtract it from the total 3 1 = 2 mines left in the bottom of the array

30 Inclusion-Exclusion Principle The left columns also have a total of one mine Since we don t need these columns, remove them 2 1 = 1 mine left in the square

31 Inclusion-Exclusion Principle But that s not right. We are supposed to have 2 mines, not 1 mine. What happened? We subtracted the mine count at [0,1] twice!

32 Inclusion-Exclusion Principle So just add back the mine count at [0,1] to make up for the accidental double subtraction = 2 mines in the square, correct!

33 Inclusion-Exclusion Principle Hence from the prefix sum array p[], to find the number of mines in a square from [i,j] to [x,y], Num of mines = p[x][y] p[i-1][y] p[x][j-1] + p[i-1][j-1] O(1) calculation! In this case: [i,j] = [1,2] [x,y] = [2,3]

34 Inclusion-Exclusion Principle Number of mines = p[2][3] p[0][3] p[2][1] + p[0][1] = = MINE MINE MINE

35 Building the Prefix Sum Array Initialise the int array as mine = 1, blank = 0 [O(n 2 )] First perform a row-wise cumulative sum [O(n 2 )] Then perform a column-wise cumulative sum [O(n 2 )] Time complexity = O(n 2 ) + O(n 2 ) + O(n 2 ) = O(n 2 )

36 Improving on O(n 4 ) Build the prefix sum array [O(n 2 )] For every cell [O(n 2 )], construct squares of increasing order [O(n)] For each square, check if it contains mines [O(1)] Time complexity: O(n 2 ) + O(n 2 ) * O(n) * O(1) = O(n 2 ) + O(n 3 ) = O(n 3 ) 110% secured! Really can go home already!

37 Super Observation At the same starting point, smaller squares always have less mines (or equal) than the larger squares Hence for a certain starting point, the number of mines corresponding to square size is as follows: Sq. Size k-2 k-1 k Mines Observe that it is an ordered list of mine counts and each count can be produced in O(1) time

38 Super Observation From this ordered list, we just need to find the last square size that has 0 mines Simply look through from 0 to k size and pick the last zero-mine count However, we will have to build the entire list, which is O(n) runtime No benefit, since it will remain O(n 2 ) * O(n) = O(n 3 ) Sq. Size k-2 k-1 k Mines

39 Binary Search However, we don t have to look at every square size Since the list is ordered, we can do a binary search to find the first non-zero element [O(log n)] Start from the middle of the possible square sizes, then search the appropriate direction Down if count > 0, Up if count == 0 Stop if count == 0 and (size+1) s count == 1 Sq. Size k-2 k-1 k Mines

40 Improving on O(n 3 ) Build the prefix sum array [O(n 2 )] For every cell [O(n 2 )], find the last zero-count square size with binary search [O(log n)] Time complexity: O(n 2 ) + O(n 2 ) * O(log n) = O(n 2 ) + O(n 2 log n) = O(n 2 log n) 110% as well

41 CS2010 Insight Slides by Alvian Prasetya for CS1020 PE S Here, we stop checking squares starting from (0, 0) because larger squares will always have bomb at (1, 1). Or this But then, we Or this don t need to check this

42 Improving on O(n 2 log n) Possible? Yes, answer is on IVLE forum, O(n 2 ) runtime Utilises dynamic programming (DP), also known as the bottom-up approach to recursive problems Not in module syllabus, so I will not elaborate more Ask on the forum thread if you are interested to find out about the solution!

43 Questions? Garden 43