Efficiency and Recursion. We determine the efficiency of an algorithm by seeing by how much the algorithm s runtime varies with the problem size.

Transcription

1 Efficiency and Recursion Key Idea: We determine the efficiency of an algorithm by seeing by how much the algorithm s runtime varies with the problem size. public static boolean hasduplicates(int[] a) { for (int i = 0; i < a.length; i++) { if (indexof(a, a[i], i+1) >= 0) { return true; return false; Does the runtime for this method depend on the length of array? How many times do we call indexof? What is the time for each call to indexof? If we double the length of the array, then we will call indexof as many times, AND each call to indexof takes as long. hasduplicates will take times as long. Looping over a problem of size n, where each time through the loop depends on the size of the problem is called a quadratic algorithm. Quadratic algorithms are slow, and can be used only on moderate size problems.

2 // Returns a^n, that is a to the power n (linear algorithm) public static double power(double a, int n) { if (n == 0) return 1.0; else return power(a, n-1) * a; Solving a problem of size n by solving a problem one smaller each time results in n recursive calls, each taking constant time. Can we do better? What is 3^8? 3^8 = 3^4 * 3^4. What is 3^9? 3^9 = 3^4 * 3^4 * 3 What if we divide the problem into 2 equal size problems and use the solutions to those problems to solve the original problem? // Returns a^n, that is a to the power n using Divide and // Conquer (linear algorithm) public static double powerdandc(double a, int n) { if (n == 0) return 1.0; else if (n %2 == 0) { return powerdandc(a, n/2) * powerdandc(a,n/2); else { return powerdandc(a, n/2) * powerdandc(a,n/2) * a; How many recursive calls do we make? Every time we double n, we double the number of recursive calls, since we repeat the call tree twice. For example, consider the call tree below (which ignores calls to pow(0)). It has 15 calls to pow. If n = 16 then we would have the call to pow(16) and two calls to the call trees headed by pow(8). There would be = 31 calls. That is, when we double n we double the number of calls to pow. The number of recursive calls is proportional to the size of the problem (that is, linear). pow(8) / \ pow(4) pow(4) / \ / \ pow(2) pow(2) pow(2) pow(2) / \ / \ / \ / \ p(1)p(1)p(1)p(1)p(1)p(1)p(1)p(1)

3 How many times can we divide a problem size in half (n is power of two)? log n times. (Recall, if n = 2^k, then log (base 2) of n is k. That is, 2^(log n) = n.) Dividing a problem of size n in half each time, and solving each half separately results in a call tree that has n recursive calls and is log(n) deep. We call this approach Divide and conquer. Ignoring the time to run the recursive calls, the time in the method is constant. The total number of recursive calls is linear. So, overall, the powerdandc is proportional to the size of the problem. We say it is a linear time algorithm. 3^8 = 3^4 * 3^4 Do we need to computed 3^4 twice? No, save the result in a variable. // Returns a^n, that is a to the power n using Divide and // Conquer (fast logarithmic time) public static double fastpower(double a, int n) { if (n == 0) return 1.0; double halfpower = fastpower(a, n/2); if (n % 2 == 0) { return halfpower * halfpower; else { return halfpower * halfpower * a; Dividing a problem size in half each recursive call, results in a logarithmic number of recursive calls. For example, n = 32 = 2^5 makes the following 6 recursive calls. pow(32) -> pow(16) -> pow(8) -> pow(4) -> pow(2) -> pow(1) -> pow(2). If we double n = 64 = 2^6, fastpower will make only 7 recursive calls, just one more recursive call. Notice, we get exponential speedup by removing one of the recursive calls in powerdandc! It prunes the call tree aggressively; it removes all but the leftmost branches. We say fastpower is a logarithmic time algorithm. Logarithmic time algorithms are fast. Every time you double the size of the problem the runtime goes up by only a constant! The runtime grows very slowly with size of the problem.

4 2-D Arrays (arrays of arrays) boolean[][] tree; tree = new boolean[3][4]; // 3 rows and 4 columns (filled with false) tree[1][3] = true; tree is an array of length 3 where each element is an array of length 4. What is the value of tree[1][3]? true; What is the value of tree[1]? the array {false, false false, true What is the number of rows? tree.length What is the number of columns? tree[0].length

5 ForestFire Problem: Given a grid of trees and empty spaces and one tree on fire, all trees that are contiguous to it: Above, Left, Below, Right Base Case: Walked off the grid or not a tree Recursive Case: Burn the current tree Then recursively the 4 neighboring trees private static boolean ongrid(int[][] forest, int row, int col) { return row >= 0 && col >= 0 && row < forest.length && col < forest[0].length; private static int (int[][] forest, int row, int col) { if (!ongrid(forest, row, col) forest[row][col]!= TREE) { return 0; else { forest[row][col] = BURNING; int above = (forest, row - 1, col); //above int left = (forest, row, col - 1); //left int right = (forest, row, col + 1); //right int below = (forest, row + 1, col); //Below return above + left + right + below + 1;

6 For example, suppose the tree on fire is at 0,0 and the wind is blowing so that only trees Above, to the Right, and Below of a ing tree will. Suppose T T T = tree 1 T T 2 T T T Going Above is our first move, which puts us at (0, 0). From there we can move three ways: (-1, 0) (0, 1) off no ing First we try Above, but (-1, 0) is off the grid. From here you have to go back to last move (0, 0) and see if there is another move, in this case by going Right. But this move (0, 1) has no tree. So we try the last move Below, which leads us back to the already ing tree. None of these three ways from (0, 0) leads to a new t tree, so we can't continue from here. So we back up again to the and try another way.

7 T T T = tree 1 T T 2 T T T (-1, 0) (0, 1) (0, 1) (1, 2) (2, 1) off no ing no no Back at the ing tree when we go Right we find a tree to. Next we expand the moves at (1, 1), and try Above (no tree), Right (no tree), and finally Below, where we reach a tree to at (2, 1).

8 T T T = tree 1 T T 2 T T T (-1, 0) (0, 1) (0, 1) (1, 2) (2, 1) off no ing no no (1, 1) (2, 2) (3, 1) ing off (1, 2) (2, 3) (3, 2) no off off When we the tree at (2,1), we "drill down" to the next tree to. One tree at (1, 1) is already ing, but the tree at (2,2) can. Again we go down to see if any adjacent tree can. Only after we have exhausted all moves, do we go back to the ing tree and try the last move. The full set of moves is below.

9 T T T = tree 1 T T 2 T T T (-1, 0) (0, 1) (0, 1) (1, 2) (2, 1) (2, 1) (3, 0) off no ing no no ing ing off (1, 1) (2, 2) (3, 1) ing off (1, 2) (2, 3) (3, 2) no off off