1. CSC 205 – Java Programming II
Lecture 23
March 4, 2002

2. Backtracking
Backtracking is the strategy of trying to reach a goal by a sequence of chosen positions with re-tracing in reverse order of position that cannot lead to the goal.
a sequence of chosen positions
next positions in a predefined order
retracing in reverse order

3. Illustration P13 P4 P12 P7 P3 P11 P6 P5 P2 Pi P10 P9 P8 P1 Position P0
  P14 (GOAL)
P P4
P P P3
P P P P2
P P P P1 P0
1st
Attempt
2nd
Attempt
retracing Pi
Position
retracing
(ORIG.)

4. Marking Visited Positions
When a position is visited, it is marked as (potentially) being on a path to the goal
code 9
If we discover otherwise, the marking must be undone, so that position will never again be visited.
code 2

5. A Standard Solution A general-purpose BackTrack class is available
User needs to supply
An Application class
A Position class
to define an application-specific position
An Iterator class
to enumerate next position from the current position

6. The Application Interface
import java.util.*;
public interface Application {
// Postcondition: true has been returned if pos could be on a //path to a goal position. Otherwise, false has been returned.
public boolean valid (Position pos);   
// Postcondition: the position specified by pos has been //marked as being on a path to a goal position.
public void record (Position pos);
// Postcondition: true has been returned if pos is a goal //position. Otherwise, false has been returned.
public boolean done (Position pos);

7. The Application Interface
// Postcondition: the position specified by pos has been //marked as not being on a path to a goal position.
public void undo (Position pos);
// Postcondition: a string representation of this Application has //been returned.
public String toString();
// Postcondition: an iterator over the positions directly //accessible from pos has been returned.
public Iterator iterator (Position pos);
} // interface Application

8. The BackTrack Class import java.util.*; public class BackTrack {
public class BackTrack {
Application app;
// Postcondition: this BackTrack has been initialized from app.
public BackTrack (Application app) {
this.app = app;
} // constructor
// Postcondition: a solution going through pos has been attempted.
public boolean tryToSolve (Position pos) {
… …
} // method tryToSolve
} // class BackTrack

9. The tryToSolve Method boolean success = false;
Iterator itr = app.iterator (pos);
while (!success && itr.hasNext()) {
pos = (Position)itr.next();
if (app.valid (pos)) {
app.record (pos);
if (app.done (pos))
success = true;
else {
success = tryToSolve (pos);
if (!success)
app.undo (pos);
} // not done
} // a valid position
} // while
return success;

10. Possible Moves Possible moves from pos in tryToSolve:
Success, if one of those moves is a goal position
Hopeful, if one of those moves is valid but not a goal position. Recursive call!
Failure, if none of those moves is on a path to goal

11. Important
When a return is made, the pre-call value of pos is restored.
So the previously visited positions are available, to be printed as part of the path to the goal, to be undone, ...

12. An A-Maze-ing Application
start
finish
Maze notation
0: corridor
1: wall
Iterator choices:
north, east, south, west
(in that order)

13. The Position Class public class Position { protected int row, column;
public Position () {
row = 0; column = 0;
} // constructor
public Position (int row, int column) {
this.row = row; this.column = 0;
public int row () { return row; }
public int column () { return column ; } }

14. The Maze Class public class Maze implements Application {
protected final byte WALL = 0;
protected final byte CORRIDOR = 1;
protected final byte PATH = 9;
protected final byte TRIED = 2;
protected Position finish;
protected byte[ ][ ] grid;
public boolean valid (Position pos) {
if (pos.row() >= 0 && pos.row() < grid.length &&
pos.column() >= 0 && pos.column() < grid [0].length && grid [pos.row()][pos.column()] == CORRIDOR)
return true;
return false;
} // method valid

15. The Maze Class public void record (Position pos) {
grid [pos.row()][pos.column()] = PATH;
} // method record
public boolean done (Position pos) {
return pos.row() == finish.row()
&& pos.column() == finish.column();
} // method done
private class MazeIterator implements Iterator {
… …
} // class MazeIterator
} // class Maze

16. The MazeIterator Class
private class MazeIterator implements Iterator {
int row, column,
int count = 0;
public MazeIterator (Position pos) {
row = pos.row();
column = pos.column();
} // constructor
public boolean hasNext() {
return count < 4;
} // method hasNext

17. The MazeIterator Class
// Precondition: 0 <= count <= 3.
// Postcondition: the choice for the next Position has been //returned.
public Object next() {
  Position nextPosition = new Position();
switch (count++) {
  case 0: nextPosition = new Position (row-1, column); break; // NORTH
case 1: nextPosition = new Position (row, column+1); break; // EAST
case 2: nextPosition = new Position (row+1, column);
break; // SOUTH
case 3: nextPosition = new Position (row, column-1);
} // switch;
return nextPosition;
} // method next
} // class MazeIterator

18. An Example
0-north X
3-west
1-east X X
2-south

19. Try Another Case
start
finish
Maze notation
0: corridor
1: wall
Iterator choices:
north, south, east, west
(in that order)