CS100J Lecture 19

1. CS100J Lecture 19 • Previous 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. • This Lecture • Representation Rules of Thumb. • Transform problems to simpler equivalent problems • Maintain duplicate representations if helpful • Choose representations that limit search spaces • Find representations that yield uniform algorithms. Lecture 19

2. Think // Print the sum of the integers from 1 through n. System.out.println(______________________________); • Don’t use brute force just because the computer is a brute. Lecture 19

3. Ricocheting Bullet • A 1-by-1 box has an opening of width d. Shoot a gun into the box at angle . How far does the bullet travel? • Transform problems to simpler equivalent problems. 1 foot 1 foot d  Lecture 19

4. Ricocheting Bullet, continued • Transform problems to simpler equivalent problems. Lecture 19

5. Ricocheting Bullet, continued • Transform problems to simpler equivalent problems. y 8 6 4 2 x Lecture 19

6. Ricocheting Bullet, continued /* == the x corresponding to y and th. */ static double x( double y, double th ) { return (y / Math.tan( th )) ; } /* == the smallest even y > 0 for which the fractional part of the corresponding x is not larger than d.*/ static double min_y( double d, double th ) { int y = 2; while ( (x(y,th) - Math.floor(x(y,th))) > d ) y = y + 2; return y; } /* == x^2 */ static double sqr( double x ) { return x * x; } /* == distance traveled by bullet. */ static double distance( double d, double th ) { double y = min_y(d, th ); return Math.sqrt( sqr( x(y,th) ) + sqr(y) ); } Lecture 19

7. B 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 3 4 5 6 7 8 9 BB Tic Tac Toe • Maintain duplicate representations if helpful MovesX sumX Lecture 19

8. Magic Square Lecture 19

9. B 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 R Eight Queens • Choose representations that limit the search space Lecture 19

10. Eight Queens, continued /* Solve the Eight Queens problem. */ static void main(String args[])) { /* R[c] is row of queen in column c, for 0 <= c <= 7. */ int [] R = { 0, 1, 2, 3, 4, 5, 6, 7 }; /* Consider each permutation of R until one is found that represents a solution, or loop forever. */ while ( same_diagonal(R) ) next_permutation(R); /* Output solution R. */ ... } Lecture 19

11. B 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 Eight Queens, continued 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 Positive diagonal index is row+column Lecture 19

12. B 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 Eight Queens, continued 14 13 12 11 10 9 8 0 1 2 3 4 5 6 7 Negative diagonal index is column-row+7 Lecture 19

13. Eight Queens, continued // == 1 if R has two queens on same diagonal, else 0 static boolean same_diagonal( int [] R ) { boolean [] PosDiag = new boolean[15]; boolean [] NegDiag = new boolean[15]; // Set PosDiag and NegDiag to all false. for (int i = 0; i<=14; i++) { PosDiag[i] = false; NegDiag[i] = false; } // Set same to true if R has 2 queens on same diag. boolean same = false; int c = 0; // column index while ( c <= 7 && !same ) { if ( PosDiag[ R[c] + c ] || NegDiag[ c - R[c] + 7 ] ) same = true; else { PosDiag[ R[c] + c ] = true; NegDiag[ c - R[c] + 7 ] = true; c++; } } return same; } Lecture 19

14. Checkers • Find representations that yield uniform algorithms B 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 28 29 30 31 24 25 26 27 20 21 22 23 16 17 18 19 12 13 14 15 8 9 10 11 4 5 6 7 0 1 2 3 Lecture 19

15. Checkers, continued B 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 31 32 33 34 35 27 28 29 30 22 23 24 25 26 18 19 20 21 13 14 15 16 17 9 10 11 12 4 5 6 7 8 0 1 2 3 Lecture 19

16. 0 35 free 0 0 0 0 0 0 1 1 0 1 0 0 0 . . . 0 0 0 0 0 1 1 1 1 1 1 0 0 0 0 0 0 0 0 . . . 1 1 1 1 1 1 0 0 0 0 0 0 0 . . . red 0 0 0 0 0 0 1 1 0 1 0 0 0 . . . moves Checkers, continued B 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 red shifted right 5 Lecture 19