1. CS100J Lecture 18 Previous Lecture Programming concepts This Lecture
Two-dimensional arrays
Java Constructs
Constructors for two-dimensional arrays
Initializers for arrays
final
Reading
Lewis & Loftus Section 6.3
Savitch, Section 6.5
This Lecture
Two dimensional arrays.
Reasonable size problem (a past assignment).
Stepwise refinement.
Use of comments as high-level specifications:
as high-level commands,
as representation invariants.
Incremental development and testing.
Use of sentinels.
Static declarations.
Local declarations, scope, and the reuse of names.
Heuristic algorithms.
CS 100
Lecture 18

2. Knight’s Tour X Kn Chess is played on an 8-by-8 board.
A knight can move 2 in one direction (horizontal or vertical) and 1 in the other direction (vertical or horizontal). For example, Kn can move to each square marked X.
Problem. Write a program that tries to find a "knight's tour", e.g., starting in the upper left corner, the knight visits each of the 64 squares exactly once. Kn X
CS 100
Lecture 18

3. Possible Solution
CS 100
Lecture 18

4. Representation
Rule of Thumb. Avoid using literal constants in the code; define and use symbolic constants.
Static class declarations visible to all methods.
class Knight {
/* Chess board B is N-by-N int array, for N == 8. */
final static int N = 8;
static int [][] B = new int [N][N];
/* Unvisited squares are Blank. */
static final int Blank = 0;
/* Board subscripts range from lo to hi. */
static final int lo = 0;
static final int hi = 7;
/* UNDEFINED, an illegal coordinate. */
static final int UNDEFINED = -1; }
CS 100
Lecture 18

5. Main /* Try to find a Knight's Tour. */
static void main(String args[]) {
/* Set B to all Blank. */
Initialize();
/* Set B to arrangement of the integers 1,2,3,... representing consecutive positions of the knight during the tour. Squares that the knight cannot reach remain Blank. */
Solve();
/* Print B in an 8-by-8 grid. */
Display(); }
CS 100
Lecture 18

6. Initialize /* Set B to all Blank. */ static void Initialize() {
for (int r = lo; r <= hi; r++)
for (int c = lo; c <= hi; c++)
B[r][c] = Blank; }
CS 100
Lecture 18

7. Solve
/* Set B to arrangement of the integers 1,2,3,... representing consecutive positions of the knight during the tour. Squares that the knight cannot reach remain Blank. */
static void Solve() {
/* This procedure "stub" permits us to test the main program, Initialize, and Display routines. */ }
CS 100
Lecture 18

8. Display /* Print B in an 8-by-8 grid. */ static void Display() {
for (int r = lo; r <= hi; r++) {
for (int c = lo; c <= hi; c++)
System.out.print(B[r][c] + ” ”);
System.out.println(); }
Rule of Thumb. Develop your program using small procedures. Test it incrementally.
CS 100
Lecture 18

9. Sample Intermediate State
while ( ________________________) { }
CS 100
Lecture 18

10. Pattern /* Start at the beginning */ . . .
while ( /* not past the end */ ) {
/* Process the current “place” */
/* Go on to the next place (or to “past the end”). */ }
CS 100
Lecture 18

11. Solve { /* Initial configuration. */ int move = 0; // moves so far.
int r = lo; // current row of Kn.
int c = lo; // current column of Kn.
while (r != UNDEFINED) {
/* Visit <r,c>. */
move++;
B[r][c] = move;
/* Let <r,c> be coordinates of an unvisited "neighbor" of current <r,c>, or <UNDEFINED,UNDEFINED> if current square has no unvisited neighbors. */
. . . }
CS 100
Lecture 18

12. Choosing a Neighbor to Visit
/* Let <r,c> be coordinates of an unvisited "neighbor" of current <r,c>, or <UNDEFINED,UNDEFINED> if current square has no unvisited neighbors. */
int unvisitedR = UNDEFINED;
int unvisitedC = UNDEFINED;
for (int k = 0; k < 8; k++) {
int Nrow = _____________________________;
int Ncol = _____________________________;
if ( B[Nrow][Ncol] == Blank ){
unvisitedR = Nrow;
unvisitedC = Ncol; }
r = unvisitedR;
c = unvisitedC;
CS 100
Lecture 18

13. Neighbors //
int deltaR[] = {-1, -2, -2, -1, 1, 2, 2, 1};
int deltaC[] = { 2, 1, -1, -2, -2, -1, 1, 2}; Kn 1 7 2 3 4 5 6
CS 100
Lecture 18

14. Boundary Conditions x x x x x x x x x x x x x x x x x x x x x x x x
where X can be any non-zero value
Must revise Initialize method to fill in border. (Exercise) 1 2 3 4 5 6 7 8 9 10 11
x x x x x x x x x x x x
x x x x x x x x x x x x
x x
x x
x x
x x
x x
x x
x x
x x
x x
x x
x x
x x
x x
x x
x x
x x
x x x x x x x x x x x x
x x x x x x x x x x x x
CS 100
Lecture 18

15. Representation Revisited
Static class declarations visible to all methods.
/* Chess board B is N-by-N int array, for N == 12. */
final int N = 12;
int [][] B = new int [N][N];
/* Unvisited squares are Blank. */
final int Blank = 0;
/* Board subscripts range from lo to hi. */
final int lo = 2;
final int hi = 9;
/* UNDEFINED, an illegal coordinate. */
final int UNDEFINED = -1;
/* <deltaR[k],deltaC[k]> is <row,col> offset to neighbor k. */
final static int deltaR[] =
{-1,-2,-2,-1, 1, 2,2,1};
final static int deltaC[] =
{2 , 1,-1,-2,-2,-1,1,2};
CS 100
Lecture 18

16. Improvement Using Heuristic
Go where the options are running out, i.e., go to the unvisited neighbor with the fewest unvisited neighbors.
/* Let <r,c> be coordinates of an unvisited "neighbor" of current <r,c>, or <UNDEFINED,UNDEFINED> if current square has no unvisited neighbors. */
int fewest = 9; // min unvisited neighbors
int neighborR = UNDEFINED;
int neighborC = UNDEFINED;
for (int k = 0; k < 8; k++) {
int Nrow = r + deltaR[k];
int Ncol = c + deltaC[k];
if ( B[Nrow][Ncol] == Blank ){
int n = unvisited(Nrow, Ncol);
if (n < fewest ) {
neighborR = Nrow; neighborC = Ncol;
fewest = n; }
r = neighborR;
c = neighborC;
CS 100
Lecture 18

17. Unvisited
/* == the number of neighbors of square <r,c> that are unvisited. */
static int unvisited(int r, int c) {
int count = 0; // # unvisited neighs.
for (int k = 0; k < 8; k++) {
int Nrow = r + deltaR[k];
int Ncol = c + deltaC[k];
if ( B[Nrow][Ncol] == Blank ) count++; }
return count;
CS 100
Lecture 18