170 likes | 308 Views
CS100J Lecture 18. Previous Lecture Programming concepts 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.
E N D
CS100J Lecture 18 • Previous Lecture • Programming concepts • 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. Lecture 18
X X X X Kn X X X X Knight’s Tour • 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. Lecture 18
1 22 3 18 25 30 13 16 4 19 24 29 14 17 34 31 23 2 21 26 35 32 15 12 20 5 56 49 28 41 36 33 57 50 27 42 61 54 11 40 6 43 60 55 48 39 64 37 51 58 45 8 53 62 47 10 44 7 52 59 46 9 38 63 Possible Solution Lecture 18
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. */ finalstatic int N = 8; static int [][] B = new int [N][N]; /* Unvisited squares are Blank. */ staticfinal int Blank = 0; /* Board subscripts range from lo to hi. */ staticfinal int lo = 0; staticfinal int hi = 7; /* UNDEFINED, an illegal coordinate. */ staticfinal int UNDEFINED = -1; } Lecture 18
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(); } Lecture 18
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; } Lecture 18
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. */ } Lecture 18
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. Lecture 18
1 22 3 18 25 30 13 16 4 19 24 29 14 17 34 31 23 2 21 26 35 32 15 12 20 5 0 49 28 41 36 33 0 0 27 42 0 0 11 40 6 43 0 0 48 39 0 37 0 0 45 8 0 0 47 10 44 7 0 0 46 9 38 0 Sample Intermediate State while ( ________________________) { } Lecture 18
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”). */ . . . } Lecture 18
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. */ . . . } } Lecture 18
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; Lecture 18
2 1 3 0 Kn 4 7 5 6 Neighbors // 0 1 2 3 4 5 6 7 int deltaR[] = {-1, -2, -2, -1, 1, 2, 2, 1}; int deltaC[] = { 2, 1, -1, -2, -2, -1, 1, 2}; Lecture 18
Boundary Conditions • where X can be any non-zero value • Must revise Initialize method to fill in border. (Exercise) 0 1 2 3 4 5 6 7 8 9 10 11 0 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 Lecture 18
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. */ finalstatic int deltaR[] = {-1,-2,-2,-1, 1, 2,2,1}; finalstatic int deltaC[] = {2 , 1,-1,-2,-2,-1,1,2}; Lecture 18
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; Lecture 18
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; } Lecture 18