1 / 17

CS100J Lecture 18

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.

sgardner
Télécharger la présentation

CS100J Lecture 18

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. 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

  2. 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

  3. 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

  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. */ 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

  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(); } 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; } 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. */ } 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. Lecture 18

  9. 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

  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”). */ . . . } 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. */ . . . } } 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; Lecture 18

  13. 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

  14. 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

  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. */ finalstatic int deltaR[] = {-1,-2,-2,-1, 1, 2,2,1}; finalstatic int deltaC[] = {2 , 1,-1,-2,-2,-1,1,2}; 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; 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; } Lecture 18

More Related