Fall Lecture 13 Thursday, October 11

Size: px

Start display at page:

Download "Fall Lecture 13 Thursday, October 11"

Clemence Todd
5 years ago
Views:

1 Fall 2018 Lecture 13 Thursday, October 11

2 n queens One s favorite ipod app

3 n queens Queens attack on row, column, or diagonal Task: put n queens safely on an n-by-n board

4 British Museum algorithm Definition: A general approach that finds a solution by checking all possibilities one by one. Not a practical technique when the number of possibilities is enormous.

5 before we start Number of ways to put 8 queens on board 64! 58! 8! 4,000,000,000

6 before we start Number of ways to put 8 queens on board 4,000,000,000 Number of ways using different columns 8! 40,000

7 before we start Number of ways to put 8 queens on board 4,000,000,000 Number of ways using different columns 40,000 Number of safe ways 92

8 before we start Number of ways to put 8 queens on board 4,000,000,000 Number of ways using different columns 40,000 Number of safe ways 92 How many solutions do we want? 1

9 a fast algorithm? PRICELESS ML Card there are some things money can t buy; for everything else there s ML

10 backtracking Many search algorithms backtrack from a dead end, to an earlier choice point, in order to explore further alternatives Easy to implement with a failure continuation

11 classic n-queens Try placing a queen in each row Check for attacks by queens in previous rows If SAFE, start on next row. If UNSAFE and reached end of row, BACKTRACK

12 col 1 col 2 col 3 col 4 row 4 starting 4-by-4 algorithm row 3 no queens yet row 2 trying row 1, col 1 row 1? SAFE

13 col 1 col 2 col 3 col 4 row 4 row 3 row 2? trying row 2, col 1 row 1? queen at (1,1) SAFE

14 col 1 col 2 col 3 col 4 row 4 row 3 row 2 row 1, col 1 UNSAFE row 1 queen at (1,1) SAFE

15 row 4 row 3 row 2 row 2, col 1 UNSAFE row 1? col 1 col 2 col 3 col 4 queen at (1,1) SAFE

16 col 1 col 2 col 3 col 4 row 4 row 3 row 2 row 2, col 3 SAFE row 1? queen at (1,1) SAFE

17 trying row 3, col 1 queens at (1,1), (2,3) SAFE

18 trying row 3, col 1 queens at (1,1), (2,3) SAFE

19 trying row 3, col 1 queens at (1,1), (2,3) SAFE

20 trying row 3, col 2 queens at (1,1), (2,3) SAFE

21 trying row 3, col 2 queens at (1,1), (2,3) SAFE

22 trying row 3, col 2 queens at (1,1), (2,3) SAFE

23 trying row 3, col 3 queens at (1,1), (2,3) SAFE

24 trying row 3, col 3 queens at (1,1), (2,3) SAFE

25 trying row 3, col 3 queens at (1,1), (2,3) SAFE

26 trying row 3, col 4 queens at (1,1), (2,3) SAFE

27 trying row 3, col 4 queens at (1,1), (2,3) SAFE

28 trying row 3, col 4 queens at (1,1), (2,3) SAFE

29 with queens at (1,1), (2,3) trying row 3, col 4 there s no safe place in row 3 queens at (1,1), (2,3) SAFE

30 with queens at (1,1), (2,3) trying row 3, col 4 there s no safe place in row 3 so backtrack queens at (1,1), (2,3) SAFE

31 ? backtrack to

32 ? backtrack to

33 backtrack to? queens at (1,1), (2,4)

34 backtrack to? queens at (1,1), (2,4) SAFE

35 backtrack to? trying row 3, col 1 queens at (1,1), (2,4) SAFE

36 backtrack to? trying row 3, col 1 queens at (1,1), (2,4) SAFE

39 safe so far, but what next?

40 at end of algorithm queens at (1,3), (2,1), (3,4), (4,2) safe!

41 algorithm ideas Start with no queens on the board At each stage we have a partial solution Try to extend partial solution with a queen in the next row If not possible, backtrack and adjust the partial solution

42 board type row = int type col = int type pos = row * col type sol = pos list

threat threat : pos * pos -> bool fun threat((x,y), (i,j)) = (x=i) orelse (y=j) orelse 1 2 3

43 threat threat : pos * pos -> bool fun threat((x,y), (i,j)) = (x=i) orelse (y=j) orelse (x+y = i+j) orelse (x-y = i-j) threat(p, q) = true iff p attacks q

44 conflict conflict : pos * pos list -> bool fun conflict (p, nil) = false conflict (p, q::qs) = threat(p, q) orelse conflict(p, qs) conflict (p, [q1,...,qk]) = false if threat(p, qi) = false for each i conflict (p, [q1,...,qk]) = true if threat(p, qi) = true for some i q2 q4 q1 q5 q

45 safe safe : pos list -> bool fun safe [ ] = true safe (q::qs) = if conflict(q, qs) then false else safe(qs) safe [q1,...,qk] = true iff for all i j, qi and qj are on different rows, columns and diagonals

46 solutions qs is a partial solution for rows 1 through i if safe qs & map (fn (x, y) => x) qs = [i,..., 1] & map (fn (x, y) => y) qs is a subset of {1,,n} A full solution to the n-queens problem is a partial solution for rows 1 through n

47 failure continuations Many search algorithms can be solved elegantly using partial solutions and failure continuations The continuation says what to do if we reach a dead end There s no need to propagate a partial solution (it was a dead end!) So a failure continuation will be a function with a dummy argument ( ) : unit

48 answers type ans = sol option SOME qs NONE means found the solution qs means no solution exists continuations type cont = unit -> ans

49 strategy A recursive function that maintains a partial solution and tries to extend it by adding a queen in the next row Its arguments should indicate the board size the current partial solution the next row the columns still to be tried, in the next row what to do if we reach a dead end

50 try try : int * row * col list * sol -> (unit -> sol option) -> sol option try(n, i, A, qs) fc REQUIRES: 1 i n and A is a sublist of [1,...,n] & qs is a partial solution for rows 1 through i-1 ENSURES: EITHER try (n, i, A, qs) fc = SOME(qs ) where qs is a full solution extending qs with a queen in row i at a column in A OR try (n, i, A, qs) fc = fc( ) & there is no solution extending qs with a queen in row i at a column in A

51 try try : int * row * col list * sol -> (unit -> sol option) -> sol option try(n, i, A, qs) fc REQUIRES: 1 i n and A is a sublist of [1,...,n] & qs is a partial solution for rows 1 through i-1 ENSURES: (1) try (n, i, A, qs) fc = SOME(qs ) where qs is a full solution extending qs with a queen in row i at a column in A, if there is one (2) try (n, i, A, qs) fc = fc( ) otherwise (if there s no such solution)

52 try(n, i, A, qs) fc columns to be tried for row i partial solution on rows 1...i-1 If A = [ ], there is no solution extending qs, so fail If A = j::b, either (i,j) is attacked by qs, so try columns from B for row i or it s safe to extend qs with (i,j); if i=n, (i,j)::qs is a full solution; otherwise, look for a solution extending (i,j)::qs in row i+1, and if this fails, backtrack to try columns from B for row i.

53 try(n, i, A, qs) fc columns to be tried for row i partial solution on rows 1...i-1 If A = [ ], there is no solution extending qs, so fail fc( ) conflict((i,j), qs)=true If A = j::b, try(n, i, B, qs) fc either (i,j) is attacked by qs, so try columns from B for row i or it s safe to extend qs with (i,j); if i=n, (i,j)::qs is a full solution; otherwise, look for a solution extending (i,j)::qs in row i+1, and if this fails, backtrack to try columns from B for row i. conflict((i,j), qs)=false try(n, i+1, [1,...,n], (i,j)::qs) (fn ( ) => try(n, i, B, qs) fc)

54 try fun try (n, i, A, qs) fc = case A of [ ] => fc( ) j::b => if conflict((i, j), qs) then try (n, i, B, qs) fc else if i = n then SOME( (i, j)::qs ) else try(n, i+1, upto 1 n, (i, j)::qs) (fn ( ) => try (n, i, B, qs) fc)

55 queens queens : int -> sol option REQUIRES: n > 0 ENSURES: (1) queens n = SOME qs where qs is an n-queens solution, if there is one; (2) queens n = NONE otherwise

56 queens queens : int -> sol option REQUIRES: n > 0 ENSURES: EITHER queens n = SOME qs where qs is an n-queens solution; OR queens n = NONE & there is no n-queens solution.

57 queens Look for solution extending [ ] with a queen in row 1 fun queens n = try (n, 1, upto 1 n, nil) (fn ( ) => NONE) Pessimistic failure continuation

58 results queens 3 = NONE queens 4 = SOME [(4,3),(3,1),(2,4),(1,2)] queens 5 = SOME [(5,4),(4,2),(3,5),(2,3),(1,1)] queens 8 = SOME [(8,4),(7,2),(6,7),(5,3),(4,6),(3,8),(2,5),(1,1)] queens 20 = SOME [(20,11),(19,6),(18,14),(17,7),(16,10),...]

59 queens 4 = SOME [(4,3),(3,1),(2,4),(1,2)]

60 8-queens Q Q Q Q Q Q Q Q

61 correctness? For all total fc, and all (n, i, A, qs) such that 1 i n, A is a sublist of [1,...,n] & qs is a partial solution on rows 1 through i-1, EITHER try (n, i, A, qs) fc = SOME(qs ) where qs is a full solution extending qs with a queen in row i at a column in A OR try (n, i, A, qs) fc = fc( ) & there is no full solution extending qs with a queen in row i at a column in A.

62 proof idea Assuming REQUIRES property, in each recursive call either the row index i stays the same and the length of the column list A decreases, or the row index i increases The row index is always between 1 and n So (n - i, length A) decreases lexicographically (x1, y1) > (x2, y2) if x1>x2 or (x1=x2 and y1 > y2) Use induction on (n-i, length A)

63 direct-style A function of type t 1 -> t 2 can be applied to an argument of type t 1, and returns a value of type t 2. A direct-style function evaluates its argument, returns a result.

64 continuation-style A continuation-style function of type t1 -> (t2 -> a) -> a can be applied to an argument of type t1 and a continuation of type t2 -> a, where a is a type of answers. Instead of returning, it passes a value to its continuation, to get an answer.

65 continuation? A function that represents the rest of a computation or what to do next Expects to be called with a value ( the result so far ) and computes a final value (an answer )

66 direct cps Every direct-style function definition can be turned into a cps function definition a purely syntactic transformation The cps version makes control flow and intermediate values explicit The cps version is also tail recursive

67 factorial (* fact : int -> int *) fun fact n = if n=0 then 1 else n * fact(n-1) direct style not tail recursive (* fact : int -> (int -> a) -> a *) fun fact n k = continuation style if n=0 then k 1 else fact (n-1)(fn x => k(n * x)) tail recursive

68 examples fact 3 (fn x => x) = 6 fact 3 Int.toString = 6 fact 3 (fn y -> fact y Int.toString) =?

69 specs fact : int -> int REQUIRES n 0 ENSURES fact(n) = n! fact : int -> (int -> a) -> a REQUIRES n 0 ENSURES fact n k = k(n!)

70 proof Let ans be a type, and let P(n) be: For all k : int -> ans, fact n k = k(fact n) Prove n 0. P(n) Use induction on n fact 3 (fn m => m+1) = 7

71 polymorphic The cps factorial has a polymorphic type int -> (int -> a) -> a Why? Because it does the same thing no matter what the continuation is (passes a value to the continuation) (and that value doesn t dependent on the continuation) (and the cps factorial doesn t care what the continuation does)

72 cps When applied, a cps function calls its continuation at most once Passes the same value, regardless of the continuation Has the same control flow as direct-style fun fact n = if n=0 then 1 else n * fact(n-1) fun fact n k = if n=0 then k 1 else fact (n-1)(fn x => k(n*x))

73 not cps fun fact n k = if n=0 then k 1 else n * fact (n-1) k fact : int -> (int -> int) -> int fact 3 (fn m => m+1) = 12 according to spec, should evaluate to 7

74 not cps fun fact n k = if n=0 then 1 else fact (n-1) (fn x => k(x*n)) fact : int -> (int -> int) -> int fact 3 (fn m => m+1) = 1 according to spec, should evaluate to 7

75 counting a tree count : int tree -> int count : int tree -> (int -> a) -> a fun count Empty = 0 count (Node(A,x,B)) = count A + x + count B fun count Empty k = k 0 count (Node(A, x, B)) k = count A (fn m => count B (fn n => k(m+x+n))

76 not cps fun count Empty k = k 0 count (Node(A, x, B)) k = count A k + x + count B k Why not? What s its type? What goes wrong?

77 tail recursion A recursive function definition is tail recursive if each recursive call is in tail position, the last thing the function does before returning. fun fact n = if n=0 then 1 else n * fact(n-1) fun factacc(n, a) = if n=0 then a else factacc(n-1, n*a) fun fact n k = if n=0 then k 1 else fact (n-1) (fn x => k(n * x))

78 tail call elimination Tail calls can be implemented in a space-efficient manner. When a function is called, the argument values get pushed onto a stack, with a return address for the value returned by the call. For tail calls, we can re-use the same stack frame for arguments and leave the return address unchanged: the result of the tail call needs to get returned to the original call site. Execution of factacc(3, 1) call factacc (3, 1) call factacc (2, 3) call factacc (1, 6) call factacc (0, 6) return 6 return 6 return 6 return 6 With tail call elimination call factacc (3, 1) replace args with (2, 3) replace args with (1, 6) replace args with (0, 6) return 6

Australian researchers develop typeface they say can boost memory, that could help students cramming for exams.

Font of all knowledge? Australian researchers develop typeface they say can boost memory, that could help students cramming for exams. About 400 university students took part in a study that found a small