Recursion and

Recursive Backtracking

Computer Science E-119

Harvard Extension School
Fall 2012
David G. Sullivan, Ph.D.

Iteration
When we encounter a problem that requires repetition,
we often use iteration i.e., some type of loop.
Sample problem: printing the series of integers from
n1 to n2, where n1 <= n2.
example: printSeries(5, 10) should print the following:
5, 6, 7, 8, 9, 10

Here's an iterative solution to this problem:

public static void printSeries(int n1, int n2) {
for (int i = n1; i < n2; i++) {
System.out.print(i + ", ");
}
System.out.println(n2);
}

Recursion
An alternative approach to problems that require repetition
is to solve them using recursion.
A recursive method is a method that calls itself.
Applying this approach to the print-series problem gives:
public static void printSeries(int n1, int n2) {
if (n1 == n2) {
System.out.println(n2);
} else {
System.out.print(n1 + ", ");
printSeries(n1 + 1, n2);
}
}

Tracing a Recursive Method

public static void printSeries(int n1, int n2) {
if (n1 == n2) {
System.out.println(n2);
} else {
System.out.print(n1 + ", ");
printSeries(n1 + 1, n2);
}
}

What happens when we execute printSeries(5, 7)?

printSeries(5, 7):
System.out.print(5 + ", ");
printSeries(6, 7):
System.out.print(6 + ", ");
printSeries(7, 7):
System.out.print(7);
return
return
return

Recursive Problem-Solving
When we use recursion, we solve a problem by reducing it
to a simpler problem of the same kind.
We keep doing this until we reach a problem that is
simple enough to be solved directly.
This simplest problem is known as the base case.
public static void printSeries(int n1, int n2) {
if (n1 == n2) {
// base case
System.out.println(n2);
} else {
System.out.print(n1 + ", ");
printSeries(n1 + 1, n2);
}
}

The base case stops the recursion, because it doesn't

make another call to the method.

Recursive Problem-Solving (cont.)

If the base case hasn't been reached, we execute the
recursive case.
public static void printSeries(int n1, int n2) {
if (n1 == n2) {
// base case
System.out.println(n2);
} else {
// recursive case
System.out.print(n1 + ", ");
printSeries(n1 + 1, n2);
}
}

The recursive case:

reduces the overall problem to one or more simpler problems
of the same kind
makes recursive calls to solve the simpler problems

Structure of a Recursive Method

recursiveMethod(parameters) {
if (stopping condition) {
// handle the base case
} else {
// recursive case:
// possibly do something here
recursiveMethod(modified parameters);
// possibly do something here
}
}

There can be multiple base cases and recursive cases.

When we make the recursive call, we typically use parameters
that bring us closer to a base case.

Tracing a Recursive Method: Second Example

public static void mystery(int i) {
if (i <= 0) {
// base case
return;
}

// recursive case
System.out.println(i);
mystery(i 1);
System.out.println(i);
}

What happens when we execute mystery(2)?

Printing a File to the Console

Here's a method that prints a file using iteration:
public static void print(Scanner input) {
while (input.hasNextLine()) {
System.out.println(input.nextLine());
}
}

Here's a method that uses recursion to do the same thing:

public static void printRecursive(Scanner input) {
// base case
if (!input.hasNextLine()) {
return;
}
// recursive case
System.out.println(input.nextLine());
printRecursive(input); // print the rest
}

Printing a File in Reverse Order

What if we want to print the lines of a file in reverse order?
It's not easy to do this using iteration. Why not?
It's easy to do it using recursion!
How could we modify our previous method to make it
print the lines in reverse order?
public static void printRecursive(Scanner input) {
if (!input.hasNextLine()) {
// base case
return;
}
String line = input.nextLine();
System.out.println(line);
printRecursive(input); // print the rest
}

A Recursive Method That Returns a Value

Simple example: summing the integers from 1 to n
public static int sum(int n) {
if (n <= 0) {
return 0;
}
int total = n + sum(n 1);
return total;
}

Example of this approach to computing the sum:

sum(6) = 6 + sum(5)
= 6 + 5 + sum(4)

Tracing a Recursive Method

public static int sum(int n) {
if (n <= 0) {
return 0;
}
int total = n + sum(n 1);
return total;
}

What happens when we execute int x = sum(3);

from inside the main() method?
main() calls sum(3)
sum(3) calls sum(2)
sum(2) calls sum(1)
sum(1) calls sum(0)
sum(0) returns 0
sum(1) returns 1 + 0 or 1
sum(2) returns 2 + 1 or 3
sum(3) returns 3 + 3 or 6
main()

Tracing a Recursive Method on the Stack

public static int sum(int n) {
if (n <= 0) {
return 0;
}
int total = n + sum(n 1);
return total;
}
base case

Example: sum(3)

n
total

return 0

n
total

n
total

n
total

1
1

total = 1 + sum(0)
=1+ 0

return 1

n
total

n
total

n
total

n
total

n
total

n
total

n
total

n
total

n
total

n
total

2
3

n
total

return 3
n
total

time

Infinite Recursion
We have to ensure that a recursive method will eventually
reach a base case, regardless of the initial input.
Otherwise, we can get infinite recursion.
produces stack overflow there's no room for
more frames on the stack!
Example: here's a version of our sum() method that uses
a different test for the base case:
public static int sum(int n) {
if (n == 0) {
return 0;
}
int total = n + sum(n 1);
return total;
}

what values of n would cause infinite recursion?

3
6

Thinking Recursively
When solving a problem using recursion, ask yourself these
questions:
1. How can I break this problem down into one or more
smaller subproblems?
make recursive method calls to solve the subproblems

2. What are the base cases?

i.e., which subproblems are small enough to solve directly?

3. Do I need to combine the solutions to the subproblems?

If so, how should I do so?

Raising a Number to a Power

We want to write a recursive method to compute
xn = x*x*x**x
n of them

where x and n are both integers and n >= 0.

Examples:
210 = 2*2*2*2*2*2*2*2*2*2 = 1024
105 = 10*10*10*10*10 = 100000
Computing a power recursively: 210 = 2*29
= 2*(2 * 28)
=
Recursive definition:

xn = x * xn-1 when n > 0

x0 = 1

See ~cscie119/examples/recursion/Power.java

Power Method: First Try

public class Power {
public static int power1(int x, int n) {
if (n < 0)
throw new IllegalArgumentException(
n must be >= 0);
if (n == 0)
return 1;
else
return x * power1(x, n-1);
}
}
x5 n0
return 1

Example: power1(5,3)

x5 n3

x5 n1

x5 n1

x5 n1
return 5*1

x5 n2

x5 n2

x5 n2

x5 n2

x5 n3

x5 n3

x5 n3

x5 n3

x5 n2
return 5*5
x5 n3

x5 n3
return 5*25

time

Power Method: Second Try

Theres a better way to break these problems into subproblems.
For example: 210 = (2*2*2*2*2)*(2*2*2*2*2)
= (25) * (25) = (25)2
A more efficient recursive definition of xn (when n > 0):
xn = (xn/2)2 when n is even
xn = x * (xn/2)2 when n is odd (using integer division for n/2)
Let's write the corresponding method together:
public static int power2(int x, int n) {

Analyzing power2
How many method calls would it take to compute 21000 ?
power2(2, 1000)
power2(2, 500)
power2(2, 250)
power2(2, 125)
power2(2, 62)
power2(2, 31)
power2(2, 15)
power2(2, 7)
power2(2, 3)
power2(2, 1)
power2(2, 0)

Much more efficient than

power1() for large n.
It can be shown that
it takes approx. log2n
method calls.

An Inefficient Version of power2

What's wrong with the following version of power2()?
public static int power2Bad(int x, int n) {
// code to handle n < 0 goes here...
if (n == 0)
return 1;
if ((n % 2) == 0)
return power2(x, n/2) * power2(x, n/2);
else
return x * power2(x, n/2) * power2(x, n/2);
}

Processing a String Recursively

A string is a recursive data structure. It is either:
empty ("")
a single character, followed by a string
Thus, we can easily use recursion to process a string.
process one or two of the characters
make a recursive call to process the rest of the string
Example: print a string vertically, one character per line:
public static void printVertical(String str) {
if (str == null || str.equals("")) {
return;
}
System.out.println(str.charAt(0)); // first char
printVertical(str.substring(1));
// rest of string
}

Counting Occurrences of a Character in a String

Let's design a recursive method called numOccur().

numOccur(ch, str) should return the number of times that

the character ch appears in the string str

Thinking recursively:

Counting Occurrences of a Character in a String (cont.)

Put the method definition here:

Common Mistake
This version of the method does not work:
public static int numOccur(char ch, String str) {
if (str == null || str.equals("")) {
return 0;
}
int count = 0;
if (str.charAt(0) == ch) {
count++;
}
numOccur(ch, str.substring(1));
return count;
}

Another Faulty Approach

Some people make count "global" to fix the prior version:
public static int count = 0;
public static int numOccur(char ch, String str) {
if (str == null || str.equals("")) {
return 0;
}
if (str.charAt(0) == ch) {
count++;
}
numOccur(ch, str.substring(1));
return count;
}

Not recommended, and not allowed on the problem sets!

Problems with this approach?

Removing Vowels from a String

Let's design a recursive method called removeVowels().

removeVowels(str) should return a string in which all of the

vowels in the string str have been removed.

example:
removeVowels("recurse")

should return
"rcrs"

Thinking recursively:

Removing Vowels from a String (cont.)

Put the method definition here:

Recursive Backtracking: the n-Queens Problem

Find all possible ways of placing n queens on an n x n
chessboard so that no two queens occupy the same row,
column, or diagonal.
Sample solution
for n = 8:

Q
Q
Q
Q
Q
Q
Q
Q

This is a classic example of a problem that can be solved

using a technique called recursive backtracking.

Recursive Strategy for n-Queens

Consider one row at a time. Within the row, consider one
column at a time, looking for a safe column to place a queen.
If we find one, place the queen, and make a recursive call to
place a queen on the next row.
If we cant find one, backtrack by returning from the recursive
call, and try to find another safe column in the previous row.
Example for n = 4:
row 0: Q

col 0: safe

row 1:

Q
Q

col 0: same col

col 1: same diag

col 2: safe

4-Queens Example (cont.)

row 2:

col 0: same col

Q
Q

Q
Q

col 1: same diag col 2: same col/diag col 3: same diag

Weve run out of columns in row 2!

Backtrack to row 1 by returning from the recursive call.
pick up where we left off
we had already tried columns 0-2, so now we try column 3:
Q

Q
Q

we left off in col 2

try col 3: safe

Continue the recursion as before.

4-Queens Example (cont.)

row 2:

Q
Q

col 1: safe

col 0: same col

row 3:

Q
Q

Q
Q

Q
Q

Q
Q

col 0: same col/diag col 1: same col/diag col 2: same diag col 3: same col/diag

Backtrack to row 2:
Q

Q
Q

we left off in col 1 col 2: same diag

col 3: same col

Backtrack to row 1. No columns left, so backtrack to row 0!

4-Queens Example (cont.)

row 0:

row 1:

row 2:

Q
Q
Q

row 3:

Q
Q

Q
Q

Q
Q

Q
Q

A solution!

findSafeColumn() Method
public void findSafeColumn(int row) {
if (row == boardSize) { // base case: a solution!
solutionsFound++;
displayBoard();
if (solutionsFound >= solutionTarget)
System.exit(0);
return;
}
for (int col = 0; col < boardSize; col++) {
if (isSafe(row, col)) {
placeQueen(row, col);
// Move onto the next row.
findSafeColumn(row + 1);

Note: neither row++

nor ++row will work
here.

// If we get here, weve backtracked.

removeQueen(row, col);
}
}
}

(see ~cscie119/examples/recursion/Queens.java)

Tracing findSafeColumn()
public void findSafeColumn(int row) {
if (row == boardSize) {
// code to process a solution goes here...
}
for (int col = 0; col < BOARD_SIZE; col++) {
if (isSafe(row, col)) {
placeQueen(row, col);
findSafeColumn(row + 1);
removeQueen(row, col);
}
}
}
We can pick up
backtrack!
row: 2
col: 0,1,2,3

row: 0
col: 0

where we left off,

because the value
of col is stored in
the stack frame.

backtrack!
row: 3
col: 0,1,2,3

row: 2
col: 0,1

row: 2
col: 0,1

row: 1
col: 0,1,2

row: 1
col: 0,1,2

row: 1
col: 0,1,2

row: 1
col: 0,1,2,3

row: 1
col: 0,1,2,3

row: 1
col: 0,1,2,3

row: 0
col: 0

row: 0
col: 0

row: 0
col: 0

row: 0
col: 0

row: 0
col: 0

row: 0
col: 0

time

Template for Recursive Backtracking

void findSolutions(n, other params) {
if (found a solution) {
solutionsFound++;
displaySolution();
if (solutionsFound >= solutionTarget)
System.exit(0);
return;
}
for (val = first to last) {
if (isValid(val, n)) {
applyValue(val, n);
findSolutions(n + 1, other params);
removeValue(val, n);
}
}
}

Template for Finding a Single Solution

boolean findSolutions(n, other params) {
if (found a solution) {
displaySolution();
return true;
}
for (val = first to last) {
if (isValid(val, n)) {
applyValue(val, n);
if (findSolutions(n + 1, other params))

return true;
removeValue(val, n);
}
}

return false;
}

Data Structures for n-Queens

Three key operations:
isSafe(row, col): check to see if a position is safe
placeQueen(row, col)
removeQueen(row, col)

A two-dim. array of booleans would be sufficient:

public class Queens {
private boolean[][] queenOnSquare;

Advantage: easy to place or remove a queen:

public void placeQueen(int row, int col) {
queenOnSquare[row][col] = true;
}
public void removeQueen(int row, int col) {
queenOnSquare[row][col] = false;
}

Problem: isSafe() takes a lot of steps. What matters more?

Additional Data Structures for n-Queens

To facilitate isSafe(), add three arrays of booleans:
private boolean[] colEmpty;
private boolean[] upDiagEmpty;
private boolean[] downDiagEmpty;

An entry in one of these arrays is:

true if there are no queens in the column or diagonal
false otherwise

Numbering diagonals to get the indices into the arrays:

upDiag = row + col
downDiag =
(boardSize 1) + row col
0

Using the Additional Arrays

Placing and removing a queen now involve updating four
arrays instead of just one. For example:
public void placeQueen(int row, int col) {
queenOnSquare[row][col] = true;
colEmpty[col] = false;
upDiagEmpty[row + col] = false;
downDiagEmpty[(boardSize - 1) + row - col] = false;
}

However, checking if a square is safe is now more efficient:

public boolean isSafe(int row, int col) {
return (colEmpty[col]
&& upDiagEmpty[row + col]
&& downDiagEmpty[(boardSize - 1) + row - col]);
}

Recursive Backtracking II: Map Coloring

Using just four colors (e.g., red, orange, green, and blue), we
want color a map so that no two bordering states or countries
have the same color.
Sample map (numbers show alphabetical order in full list of
state names):

This is another example of a problem that can be solved using

recursive backtracking.

Applying the Template to Map Coloring

boolean findSolutions(n, other params) {
if (found a solution) {
displaySolution();
return true;
}
for (val = first to last) {
if (isValid(val, n)) {
applyValue(val, n);
if (findSolutions(n + 1, other params))
return true;
removeValue(val, n);
}
}
meaning in map coloring
template element
return false;
}

found a solution
val
isValid(val, n)
applyValue(val, n)
removeValue(val, n)

Map Coloring Example

consider the states in alphabetical order. colors = { red, yellow, green, blue }.

We color Colorado through

Utah without a problem.
Colorado:
Idaho:
Kansas:
Montana:
Nebraska:
North Dakota:
South Dakota:
Utah:

No color works for Wyoming,

so we backtrack

Map Coloring Example (cont.)

Now we can complete

the coloring:

Recursive Backtracking in General

Useful for constraint satisfaction problems that involve assigning
values to variables according to a set of constraints.
n-Queens:
variables = Queens position in each row
constraints = no two queens in same row, column, diagonal

map coloring
variables = each states color
constraints = no two bordering states with the same color

many others: factory scheduling, room scheduling, etc.

Backtracking reduces the # of possible value assignments that
we consider, because it never considers invalid assignments.
Using recursion allows us to easily handle an arbitrary
number of variables.
stores the state of each variable in a separate stack frame

Recursion vs. Iteration

Recursive methods can often be easily converted to a
non-recursive method that uses iteration.
This is especially true for methods in which:
there is only one recursive call
it comes at the end (tail) of the method
These are known as tail-recursive methods.
Example: an iterative sum() method.
public static int sum(n) {
// handle negative values of n here
int sum = 0;
for (int i = 1; i <= n; i++)
sum += i;
return sum;
}

Recursion vs. Iteration (cont.)

Once you're comfortable with using recursion, you'll find that
some algorithms are easier to implement using recursion.
We'll also see that some data structures lend themselves to
recursive algorithms.
Recursion is a bit more costly because of the overhead involved
in invoking a method.
Rule of thumb:
if it's easier to formulate a solution recursively, use recursion,
unless the cost of doing so is too high
otherwise, use iteration