1. Recursion as a Problem-Solving Technique
Chapter 5

2. Chapter 5 -- Recursion as a Problem-Solving Technique
Chapter 2 presented the basic concepts of recursion.
This chapter introduces you to two new concepts, backtracking and formal grammars.
Backtracking is a problem-solving technique that involves guesses at a solution.
Formal grammars enable you to define, for example, syntactically correct algebraic expressions.
This chapter concludes with a discussion of the close relationship between recursion and mathematical induction.
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

3. Chapter 5 -- Recursion as a Problem-Solving Technique
Backtracking
This section considers an organized way to make successive guesses at a solution.
If a particular guess leads to a dead end, you back up to that guess and replace it with a different guess.
You can combine recursion and backtracking to solve the following problem
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

4. Chapter 5 -- Recursion as a Problem-Solving Technique
The Eight Queens Problem
Given:
a chessboard (8x8 grid)
Problem:
Place 8 queens on the board in a non attacking fashion.
Remember: a Queen can attack in her row, column, or along her diagonal.
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

5. Chapter 5 -- Recursion as a Problem-Solving Technique
One strategy is to guess at a solution.
However there are 4,426,165,368 ways to arrange 8 queens on a chessboard.
I think you might get tired trying all of these!
A simple observation can eliminate many arrangements:
No queen can reside on a row or column that contains another queen,
Or each row and column can contain exactly one queen.
This leaves 8! Arrangements to evaluate (8!=40,320)
Let’s try something else
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

6. Chapter 5 -- Recursion as a Problem-Solving Technique
Let’s provide some organization for the guessing strategy
Place 1 Queen per column
(beginning with the first square of column 1)
Next you consider column 2,
you eliminate its first square (because column 1 has a Queen on row 1)
you eliminate its second square (because of a diagonal attack)
you finally place the queen on the third square
Now consider column 3
………
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

7. Chapter 5 -- Recursion as a Problem-Solving Technique
After placing 5 Queens you end up at this configuration:
And you are stuck
So, what should you do?
You can’t place a queen in column 6, so back up to column 5 and go to the next possible solution.
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

8. Chapter 5 -- Recursion as a Problem-Solving Technique
The next possible location in Column 5 is the last row.
When you consider column 6, there are still no solutions available, so you back up… 5 has no more options, so you back up to column 4.
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

9. Chapter 5 -- Recursion as a Problem-Solving Technique
So, let’s write the code for
bool placeQueens(int currColumn)
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

10. Chapter 5 -- Recursion as a Problem-Solving Technique
bool placeQueens(int currColumn) {
if (currColumn > BOARD_SIZE)
return true;
else{
bool queenPlaced = false;
int row = 1;
while (!queenPlaced && ( row < BOARD_SIZE){
if (isUnderAttack(row,currColumn)
row++;
setQueen(row,currColumn)
queenPlaced=placeQueens(currColumn+1)
if(!queenPlaced){
removeQueen(row,currColumn);
row++ }
return queenPlaced;
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

11. Chapter 5 -- Recursion as a Problem-Solving Technique
Here is one solution
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

12. Chapter 5 -- Recursion as a Problem-Solving Technique
Defining Languages
What is a language?
A language is nothing more than a set of strings of symbols.
C++Programs = {strings w: w is a syntactically correct C++ program}
Note: all programs a re strings, BUT not all strings are programs.
Now we need to discuss the rules for forming the strings in a language
This is a Grammar.
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

13. Chapter 5 -- Recursion as a Problem-Solving Technique
The Basics of Grammars
A grammar uses several special symbols
x | y means x or y
xy means x followed by y
<word> means any instance of word that definition defines.
Example: C++Ids
C++Ids = {w: w is a legal C++ Identifier}
So, what makes a legal identifier?
A letter, followed by 0 or more letters or digits.
Remember that _ is a letter.
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

14. Chapter 5 -- Recursion as a Problem-Solving Technique
Example: C++Ids (cont)
There are many ways to represent this. One is a Syntax Diagram
A syntax Diagram is easy for people to use, but a grammar is a better starting point if you want to write a function that will recognize an identifier
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

15. Chapter 5 -- Recursion as a Problem-Solving Technique
Example: C++Ids (cont)
A grammar for the language C++Ids is
<identifier> = <letter> | <identifier> <letter> | <identifier><digit>
<letter> = a|b|...|z|A|B|...|Z|_
<digit> = 0|1|...|9
This definition reads as follows:
An identifier is a letter, or an identifier followed by a letter, or an identifier followed by a digit.
Note that this grammar is recursive, as are many grammars.
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

16. Chapter 5 -- Recursion as a Problem-Solving Technique
So, now we need to write code to recognize strings in this language.
bool isId(string w)
This function is recursive,
so what is the base case.
How is the recursive call done?
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

17. Chapter 5 -- Recursion as a Problem-Solving Technique
Here is a trace of this function for the string A2B
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

18. Chapter 5 -- Recursion as a Problem-Solving Technique
Two Simple Languages
Now we want to consider two more simple examples of languages, their grammars, and the resulting recognition algorithms
The first one is Palindromes
First, what is a palindrome?
Palindromes = {w : w reads the same left to right as right to left}
Specifically, w is a palindrome if and only if:
The first and last characters of w are the same AND
w minus its first and last characters is a palindrome
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

19. Chapter 5 -- Recursion as a Problem-Solving Technique
Palindromes (cont)
So the grammar is....
<pal> = empty_string | <ch> | a<pal>a | b<pal>b | ... | Z<pal>Z
<ch> = a|b|...|z|A|B|...|Z
Now, we need to write the code:
bool isPal(string w)
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

20. Chapter 5 -- Recursion as a Problem-Solving Technique
The second example is strings of the form AnBn
This is the set of strings of n consecutive A’s followed by n consecutive B’s
This grammar is actually very similar to the grammar for palindromes.
You strip away both the first and last characters and check to see that the first is an A and the last is a B
<legal-word> = empty_string | A<legal-word>B
Now we need to write the code:
bool isAnBn(string w)
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

21. Chapter 5 -- Recursion as a Problem-Solving Technique
Algebraic Expressions
One of the tasks a compiler must perform is to recognize and evaluate algebraic expressions
Consider the following:
y = x+z*(w/k+z*(7*6));
First: is the RHS a syntactically legal algebraic expression?
If so, the compiler must then indicate how to compute the expressions value.
There are several common definitions for “syntactically legal”
some definitions require an expression to be fully parenthesized: ((a*b)*c)
This section presents 3 different languages for algebraic expressions.
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

22. Chapter 5 -- Recursion as a Problem-Solving Technique
Infix, Prefix, and postfix notation
Definitions:
Infix: operator appears between its operands
3 + 2
We need associativity rules (precedence) and the use of parentheses to avoid ambiguity: a + b * c
ten there is a / b * c
Prefix: operator precedes its operands
+ 3 2
Postfix: operator follows its operands
3 2 +
We will come back to more Infix discussions later (Chapter 6)
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

23. Chapter 5 -- Recursion as a Problem-Solving Technique
Prefix expressions
A grammar that defines the language of all prefix expressions is:
<prefix> = <identifier> | <operator><prefix><prefix>
<operator> = + | - | * | /
<identifier> = a | b | ... | z
Now you can write a recursive algorithm that recognizes whether a string is a prefix expression
What is the base case?
What is the recursive call?
bool isPre( string w)
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

24. Chapter 5 -- Recursion as a Problem-Solving Technique
Postfix expressions
A grammar that defines the language of all postfix expressions is:
<postfix> = <identifier> | <postfix><postfix><operator>
<operator> = + | - | * | /
<identifier> = a | b | ... | z
Now you can write a recursive algorithm that converts from postfix to prefix.
What is the base case?
What is the recursive call?
string convertPost2Pre(string w)
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

25. The Relationship between Recursion and Mathematical Induction
A very strong relationship exists between recursion and mathematical induction.
Given the similarities, it should not be surprising that induction is often employed to prove properties about recursive algorithms
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

26. Chapter 5 -- Recursion as a Problem-Solving Technique
The Correctness of the Recursive Factorial Function
The proof is by induction on n
Basis
show the property is true for n=0
fact(0)= 1;
Inductive Hypothesis
assume that the property is true for an arbitrary k
Inductive Conclusion
show it is true for n=k+1
fact(k+1) = (k+1) * fact(k)
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

27. Chapter 5 -- Recursion as a Problem-Solving Technique
The Cost of Towers of Hanoi
If you begin with N disks, how many moves does it take?
When N = 1 this is easy move
When N > 1 the number is not so apparent
Moves(N) = Moves(N-1) + Moves(1) + Moves(N-1)
Moves(N) = 2*Moves(N-1) + Moves(1)
This is a recurrence relationship.
You can compute a closed form algebraic formula for this, but the techniques are not relevant to this course (they are covered in CS 465-Algorithms)
The solution is moves(N)=2N-1
The proof of this is by induction on N
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

28. Chapter 5 -- Recursion as a Problem-Solving Technique
Basis
show true for N=1, here 21-2=1
Inductive hypothesis
assume it is true for N=K
Inductive conclusion
show that it is true for N=K+1
moves(k+1) = 2*moves(k)+1
= 2*(2k-1)+1
= 2k+1-1
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique

29. Chapter 5 -- Recursion as a Problem-Solving Technique
CS 308
Chapter 5 -- Recursion as a Problem-Solving Technique