1 / 16

Chapter 5: Recursion as a Problem-Solving Technique

Chapter 5: Recursion as a Problem-Solving Technique. Backtracking. Recursive Grammars. Matrix Operations. Mathematical Induction. Recurrence Relations. CS 240. 19. Recursion can be a very effective technique for solving what would otherwise be extremely elaborate problems.

curry
Download Presentation

Chapter 5: Recursion as a Problem-Solving Technique

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Chapter 5: Recursion as a Problem-Solving Technique Backtracking Recursive Grammars Matrix Operations Mathematical Induction Recurrence Relations CS 240 19

  2. Recursion can be a very effective technique for solving what would otherwise be extremely elaborate problems. Sample recursive applications include: • Backtracking algorithms. • Programming language definition. • Matrix operations. In addition, a solid understanding of recursion is helpful in analyzing the time complexity of algorithms. Recursion-related analysis techniques include: • Mathematical induction. • Recurrence relations. CS 240 20

  3. Recursive Backtracking Example: Flood Fill Algorithm Boundary pixel Seed pixel LRUD-visited pixel Starting with a “seed” pixel that’s inside a polygonal region, recursively visit the four adjacent pixels, coloring any that haven’t been colored, and that aren’t on the polygon’s boundary. Reaching the boundary is the recursion’s termination condition. void floodfill(int x, inty) { if (!filled(x,y)) { color(x,y); floodfill(x-1,y); // Left floodfill(x+1,y); // Right floodfill(x,y-1); // Up floodfill(x,y+1); // Down } } CS 240 21

  4. Recursive Grammar Example: A Calculator Grammar Languages (e.g., programming languages) are often defined by their grammars, sets of recursive rules which provide syntax. Using this grammar, the following is a syntactically correct calculator program: pi = 3.1416; rad = 2.5; ht = 10; area = pi * rad * rad; surfacearea = 2 * (area + pi * rad * ht); END program: END expr_list END expr_list: expression ; expression ; expr_list expression: term + expression term – expression term term: primary / term primary * term primary primary: NUMBER NAME NAME = expression - primary ( expression ) • Recursive grammars are also prominent in more sophisticated languages, making the following language features possible: • nested loops, conditionals, function calls • cascaded operators (<<, >>, =, etc.) • multiple cases in a switch statement CS 240 22

  5. Recursive Matrix Operation Example: Determinants                          Many matrix operations may be defined recursively, with combinations of submatrix operations used to implement the large matrix operation. Note that a matrix’s determinant is used to determine, among other things, whether the matrix is invertible. CS 240 23

  6. Recursive Determinant Program Example //////////////////////////////////////////// // Class definition file: Matrix.h// // The matrix class has two data members: // // a square array of integer values (all // // between 0 and 9), and an integer indi- // // cating the array size. Its member // // functions include constructors, func- // // tions to set and access specific array // // elements, a function to access a sub- // // array, a recursive determinant func- // // tion, and an output operator. // //////////////////////////////////////////// #ifndefMATRIX_H #include <fstream> using namespace std; typedefintelementType; constintMAX_GRID_SIZE = 7; class matrix { public: // Class constructors matrix() {size = 0;} matrix(constmatrix &m); matrix(intsz); // Member functions intgetSize() const { return size; } void setElement(inti, intj, elementType item); elementTypegetElement(int i, intj) { return table[i][j]; } elementType determinant(); friend ostream& operator << (ostream &os, constmatrix &m); protected: // Data members elementType table[MAX_GRID_SIZE] [MAX_GRID_SIZE]; intsize; // Member function matrix minor(int i, intj); }; #define MATRIX_H #endif CS 240 24

  7. //////////////////////////////////////////// // Class implementation file: Matrix.cpp // // The implementation of the copy and // // initializing constructors, the setEle- // // ment, determinant, and minor member // // functions, and the output operator. // //////////////////////////////////////////// #include<stdlib.h> #include <assert.h> #include <fstream> #include <iomanip> #include <math.h> #include "Matrix.h" using namespace std; // Copy constructor: Copies existing mat.// matrix::matrix(const matrix &m) { size = m.size; for (int row = 0; row < m.size; row++) for (int col = 0; col < m.size; col++) table[row][col] = m.table[row][col]; } // Initializing constructor: Sets *this // // up as a sz x sz matrix of zeros. // matrix::matrix(intsz) { size = sz; for (int row = 0; row < sz; row++) for (int col = 0; col < sz; col++) table[row][col] = 0; } // SetElement Member Function: Sets the // // (i,j) element of the matrix to item. // void matrix::setElement(int i, intj, elementType e) { assert ((0<=i) && (i<size) && (0<=j) && (j<size)); table[i][j] = e; } // Determinant Member Function: Calculates // // & returns the determinant of the matrix. // elementType matrix::determinant() { elementType value = 0; if (size == 1) return table[0][0]; for (int col = 0; col < size; col++) { value += (elementType)pow(-1, 0+col) * table[0][col] * minor(0, col).determinant(); } return value; } Notice how the size×size matrix is being evaluated recursively by using the top row to expand into size (size-1)×(size-1) submatrices. CS 240 25

  8. // Minor Member Function: If *this is // // an nXn matrix, then this returns // // the (n-1)X(n-1) matrix that is // // *this w/row i & column j removed. // matrix matrix::minor(int i, intj) { intsubrow, subcol; assert (size > 1); matrix submat(size-1); subrow = 0; for (int row = 0; row < size; row++) { subcol = 0; if (row != i) { for (int col = 0; col < size; col++) if (col != j) { submat.setElement(subrow, subcol, table[row][col]); subcol++; } subrow++; } } return submat; } // Output Operator: Outputs matrix // // as a grid of size rows with // // size columns in each row. // ostream& operator << (ostream &os, constmatrix &m) { for (int row = 0; row < m.getSize(); row++) { for (int col = 0; col < m.getSize(); col++) os << setw(4) << m.table[row][col]; os << endl; } return os; } CS 240 26

  9. matrix grid(gridSize); for (int row=0; row<gridSize; row++) for (int col=0; col<gridSize; col++) grid.setElement(row, col, generateRandomNumber(0,9)); cout << endl << "MATRIX:" << endl << grid << endl << endl; cout << "DETERMINANT: " << grid.determinant() << endl << endl; } // The generateRandomNumber function // // randomly generates an integer in the // // range between the parameterized low- // // erBound & upperBound values (inclu- // // sive). The first time it is called, // // it seeds the rand() random number // // generation function. // intgenerateRandomNumber(intlowerBound, intupperBound) { static boolfirstTime = true; time_trandomNumberSeed; if (firstTime) { time(&randomNumberSeed); srand(randomNumberSeed); firstTime = false; } return (lowerBound + int((upperBound - lowerBound) * (float(rand()) / RAND_MAX))); } //////////////////////////////////////////////////// // Program file: matrixDriver.cpp // // This program tests the matrix class by // // creating a random matrix of a user-specified // // size, outputting it, & taking its determinant. // //////////////////////////////////////////////////// #include <iostream> #include <iomanip> #include <ctime> #include "Matrix.h" using namespace std; intgenerateRandomNumber(intlowerBound, intupperBound); // The main function randomly generates & outputs // // a square matrix,, & determines its determinant.// void main() { intgridSize; cout << "SPECIFY THE MATRIX SIZE (a positive " << "integer less than " << MAX_GRID_SIZE+1 << "): "; cin >> gridSize; while ((gridSize<1) || (gridSize>MAX_GRID_SIZE)) { cout << "SORRY, ONLY VALUES BETWEEN 1 AND " << MAX_GRID_SIZE << " ARE ACCEPTED>\n "; cout << "SPECIFY THE MATRIX SIZE (a positive " << "integer less than " << MAX_GRID_SIZE+1 << "): "; cin >> gridSize; } CS 240 27

  10. CS 240 28

  11. A mathematical “cousin” to recursion is the concept of induction. When you want to prove that something is true for all integer values, beginning at a specific value n0, perform the following steps: Step One: Prove The Base Case Formally demonstrate that it’s true for that smallest value, n0. Step Two: Assume For Some General Case Assume that the it’s been proven true for all values through k, where k is at least n0. Step Three: Prove For The Next Case Use the assumption that it’s been proven true for smaller cases to prove that it’s also true for k+1. CS 240 29

  12. i=1,1i = 1 = ½(1)(1+1) Induction Example i=1,2i = 1+2 = 3 = ½(2)(2+1) Theorem A: i = 1,n i = ½n(n + 1) for all n  1. i=1,3i = 1+2+3 = 6 = ½(3)(3+1) Proof (by induction): • Step One (Prove for the base case): For n = 1,  i = 1,1 i = 1 = ½(1)(1 + 1). i=1,4i = 1+2+3+4 = 10 = ½(4)(4+1) • Step Two (Assume for some general case): Assume for n = k:  i = 1,k i = ½k(k + 1). i=1,5i = 1+2+3+4+5 = 15 = ½(5)(5+1) • Step Three (Prove for the next case): Prove for n = k + 1: •  i = 1,k+1 i = (k + 1) +  i = 1,k i • = (k + 1) + ½k(k + 1) • (by the assumption for case k) • = ½(2)(k + 1) + ½k(k + 1) • = ½(k + 1)(k + 2) • = ½(k + 1)((k + 1) + 1). i=1,6i = 1+2+3+4+5+6 = 21 = ½(6)(6+1) i=1,7i = 1+2+3+4+5+6+7 = 28 = ½(7)(7+1) CS 240 30

  13. Why Does Induction Work? To prove that  i = 1,n i = ½n(n + 1) for all n  1, we started by proving that it was true for n = 1. Once we accomplished that, we assumed that it was true for some arbitrary value k and then proved that that made it true for the next value: k + 1. In essence, this last proof causes the truth of the theorem to “cascade” through all remaining values. Proof that if it’s true for n = k, then it’s also true for n = k + 1 TRUE FOR n = 1: 1 = ½(1)(2) TRUE FOR n = 2: 1 + 2 = ½(2)(3) TRUE FOR n = 3: 1+2+3 = ½(3)(4) TRUE FOR n = 4: 1+2+3 +4 = ½(4)(5) TRUE FOR n = 5 : 1+2+3 +4+5 = ½(5)(6) Letting k = 1 Letting k = 2 Letting k = 3 Letting k = 4 And so on... CS 240 31

  14. What’s Wrong With This Induction? Theorem Z:For any group of n people, all n have the same height. Proof (by induction): • Step One (Prove for the base case): For n = 1, the group consists of a single person, so the entire group obviously has the same height. • Step Two (Assume for some general case): Assume for n = k: Any group of k people have the same height. • Step Three (Prove for the next case): Prove for n = k + 1: Given a group of k + 1 people, remove one person. The resulting group of k people must, by the inductive hypothesis, have the same height. Reinsert the person that was removed and then remove a different person. The resulting group of k people must also have the same height. Thus, all k + 1 people must have the same height! CS 240 32

  15. One of the bridges between recursion and induction is the recurrence relation, which can be used to determine the execution time of a recursive function. Using mathematical induction, we can prove that: T(k) = 7(2k)-5for all k 0 • Step One (Prove for the base case): For n = 0, we already know that T(0) = 2, and 7(20)-5 also evaluates to 2. intpowerOf2(constint &n) { if (n == 0) return 1; return powerOf2(n-1) + powerOf2(n-1); } • Step Two (Assume for some general case): Assume for n = k: T(k) = 7(2k)-5. Assuming that the execution time for arithmetic operations, condition checking, and returning are all the same, let’s also assume that there is a function T(n) such that it takes T(k) time to execute powerOf2(k). • Step Three (Prove for the next case): We need to prove it for n = k + 1: We know that T(k+1) = 5 + 2T(k), and we’re assuming that T(k) = 7(2k)-5, so we can conclude that T(k+1) = 5 + 2(7(2k)-5) = 7(2k+1)-5, which is what we wanted. Examination of the code above allows us to conclude the following two facts: T(0) = 2 T(k) = 5 + 2T(k-1) for all k > 0 CS 240 33

  16. 1 Let’s try the same approach on this alternate form of the function. 2 4 intpowerOf2(constint &n) { if (n == 0) return 1; return 2*powerOf2(n-1); } 8 16 32 Using the same assumptions as before, we get the following recurrence relation: 64 128 T(0) = 2 T(k) = 4 + T(k-1) for all k > 0 256 512 1024 This time, however, mathematical induction tells us that: 2048 4096 T(k) = 4k+2for all k 0 8192 16384 32768 CS 240 34

More Related