Download presentation

Presentation is loading. Please wait.

Published byScarlett Perry Modified about 1 year ago

1

2
1Copyright © Gyora Benedek, 2003

3
2 Solving Lights Out with BFS by Dr. Gyora Benedek

4
3Copyright © Gyora Benedek, 2003 The Lights Out game Lights Out™ is a hand-held puzzle game by Tiger Electronics.

5
4Copyright © Gyora Benedek, 2003 Basic definitions Lights Out consists of a 5 by 5 grid of buttons which also have lights in them. By pressing a button, its light and those of the (non-diagonally) adjacent buttons will change. Given a pattern of lights, you have to switch them all off by pressing the correct buttons. Try to do it in as few moves as possible.Demo

6
5Copyright © Gyora Benedek, 2003 Example 1a BeforeAfter

7
6Copyright © Gyora Benedek, 2003 Example 1b AfterBefore

8
7Copyright © Gyora Benedek, 2003 Example 2a AfterBefore

9
8Copyright © Gyora Benedek, 2003 Example 2b

10
9Copyright © Gyora Benedek, 2003 Example 2c

11
10Copyright © Gyora Benedek, 2003 Example 2d

12
11Copyright © Gyora Benedek, 2003 Example 2e

13
12Copyright © Gyora Benedek, 2003 Example 2f

14
13Copyright © Gyora Benedek, 2003 Example 2g - end

15
14Copyright © Gyora Benedek, 2003 Notes Notation: Let lit=1; unlit=0; There are 2^25 positions – only 2^23 have solutions. Repeating same move = undo. Moves order does not matter. Can be solved with Linear Algebra (beyond our scope).

16
15Copyright © Gyora Benedek, 2003 Many Variants Different board sizes Different neighborhood definitions 3 or more colors Restrictions on moves Links to Solutions, Tricks, Research papers, Algorithms, etc http://www.geocities.com/jaapsch/puzzles/lights.htm#desc http://qcunix1.qc.edu/~lteitelm/algs/lo_links.html

17
16Copyright © Gyora Benedek, 2003 Lit Only variant You may only press lit buttons.demo

18
17Copyright © Gyora Benedek, 2003 Example 3a

19
18Copyright © Gyora Benedek, 2003 Example 3b

20
19Copyright © Gyora Benedek, 2003 Example 3c

21
20Copyright © Gyora Benedek, 2003 Example 3d - end

22
21Copyright © Gyora Benedek, 2003 Example 4a

23
22Copyright © Gyora Benedek, 2003 Example 4b

24
23Copyright © Gyora Benedek, 2003 Example 4c

25
24Copyright © Gyora Benedek, 2003 Example 4c

26
25Copyright © Gyora Benedek, 2003 Example 4d

27
26Copyright © Gyora Benedek, 2003 Example 4e

28
27Copyright © Gyora Benedek, 2003 Example 4f

29
28Copyright © Gyora Benedek, 2003 Example 4g

30
29Copyright © Gyora Benedek, 2003 Example 4h

31
30Copyright © Gyora Benedek, 2003 Example 4i

32
31Copyright © Gyora Benedek, 2003 Example 4j

33
32Copyright © Gyora Benedek, 2003 Example 4k

34
33Copyright © Gyora Benedek, 2003 Example 4l - end

35
34Copyright © Gyora Benedek, 2003 Lit Only variant You may only press lit buttons. Moves’ order does matter. The set of “Lit Only solvable puzzles” is obviously a subset of “solvable puzzles”. Can be proved that all solvable puzzles are Lit Only solvable. Lit Only solution may be longer.

36
35Copyright © Gyora Benedek, 2003 How to solve Lit Only? We want to be able to compute an optimal solution to a given puzzle efficiently. We can make a lengthy preparation step and use a lot of memory. Preparation puts all positions in a dictionary: key= position (25 bits) value= solution length (8 bits) GetSolLen(pos) returns solution length for pos.

37
36Copyright © Gyora Benedek, 2003 Background The Lit Only game corresponds to a directed graph G where each vertex is a position and the moves are the edges. We set one vertex (all 0 position) as the target T and are interested in the distance of each vertex from T. Vertices (positions) from which there is no path to T are unsolvable.

38
37Copyright © Gyora Benedek, 2003 Background (2) Usually a graph is given explicitly. Here the edges are implicit, but given a vertex we can find all the out edges and also all the in edges.

39
38Copyright © Gyora Benedek, 2003 How to solve a position void Solve(tPos Pos){ int NewL, L = GetSolLen(Pos); tPos NewPos; if (L==NoSolution) {print “No Solution”; return;} while (L>0){ for all valid moves let NewPos be result of move if ((NewL=GetSolLen(NewPos))

40
39Copyright © Gyora Benedek, 2003 Notes on Solve Moves are printed from left to right. Assuming that GetSolLen( ) returns correct values, L will decrease exactly by 1 in each iteration of the while loop. Time complexity O(nMoves · SolutionLen) here nMoves=25 so we get O(SolutionLen)

41
40Copyright © Gyora Benedek, 2003 Preparation To fill the dictionary we start from the target T (all 0) and go backwards. We use BFS (Breadth First Search) on G with its edges reversed.

42
41Copyright © Gyora Benedek, 2003 BFS Queue Open; Dictionary Closed; int L; tPos P1, P2; Open.Enqueue({T,0});// If many sources Closed.Insert(T, 0);// loop to enqueue all While (not Open.IsEmpty( )){ {P1,L} = Open.Dequeue( ); For each edge (P1,P2) if (not Closed.Find(P2)){ Open.Enqueue({P2,L+1}); Closed.Insert(P2,L+1);}

43
42Copyright © Gyora Benedek, 2003 BFS demo 0 Open T AB CD E F T,0 @While P1=? L=?

44
43Copyright © Gyora Benedek, 2003 BFS demo 0 Open T AB CD E F empty @For P1=T L=0

45
44Copyright © Gyora Benedek, 2003 BFS demo 0 11 Open T AB CD E F A,1 B,1 @While P1=T L=0

46
45Copyright © Gyora Benedek, 2003 BFS demo 0 11 Open T AB CD E F B,1 @For P1=A L=1

47
46Copyright © Gyora Benedek, 2003 BFS demo 0 11 22 Open T AB CD E F B,1 C,2 D,2 @While P1=A L=1

48
47Copyright © Gyora Benedek, 2003 BFS demo 0 11 22 Open T AB CD E F C,2 D,2 @For P1=B L=1

49
48Copyright © Gyora Benedek, 2003 BFS demo 0 11 222 Open T AB CD E F D,2 E,2 @For P1=C L=2 Note that T and D did not change; they were closed already

50
49Copyright © Gyora Benedek, 2003 BFS demo 0 11 222 3 Open T AB CD E F E,2 F,3 @For P1=D L=2

51
50Copyright © Gyora Benedek, 2003 BFS demo 0 11 222 3 Open T AB CD E F F,3 @For P1=E L=2 No edges to D.

52
51Copyright © Gyora Benedek, 2003 BFS demo 0 11 222 3 Open T AB CD E F empty @For P1=F L=3 T and F already closed.

53
52Copyright © Gyora Benedek, 2003 BFS correctness When a vertex {v, L} is added to Closed, L is the shortest distance from one of the sources to v. There is no need to modify them anymore. At any time in the Open queue there are vertexes with L and L+1 only, so that those with L are before those with L+1.

54
53Copyright © Gyora Benedek, 2003 BFS Complexity Each node enters Closed at most once. Each edge is traveled at most once. Time complexity = O(m) Where m is the number of edges in the relevant connected component; assuming O(1) for each operation on the dictionary.

55
54Copyright © Gyora Benedek, 2003 BFS for Lit Only Given a position P1 we need to find all edges (P2,P1) in G. To get a P2 press an unlit button in P1. To find all positions from which P1 can be reached, press all unlit buttons in P1 (starting from P1 each time).Demo

56
55Copyright © Gyora Benedek, 2003 Example 5: step back from T

57
56Copyright © Gyora Benedek, 2003 Example 5 Now we are 1 step away from T

58
57Copyright © Gyora Benedek, 2003 Example 5 This is also 1 step away from T…

59
58Copyright © Gyora Benedek, 2003 Example 5 There are 25 different positions 1 step away from T.

60
59Copyright © Gyora Benedek, 2003 Example 6: step back… The only possibility

61
60Copyright © Gyora Benedek, 2003 Example 6: step back… The only position from which we can reach the above position.

62
61Copyright © Gyora Benedek, 2003 Implementing Closed A Hash table? Actually there are 2^25 =32M positions. An array of 2^25 Bytes with Pos as index will do. Init: For all i do Closed[i]=255; Max distance must be < 255.

63
62Copyright © Gyora Benedek, 2003 Implementing Open Option1: a queue containing pos (25 bits) and L (8 bits). This may be very large (~ 4*2^23 ). Option2: no queue. Run on Closed and look for each pos with L. When done L++. The order in which positions are handled may be different, the result the same. Takes long time when few positions per L.

64
63Copyright © Gyora Benedek, 2003 Implementing Open (2) Option3: Combine the two options. Implement a queue in a relatively short array. Use this queue as in Option1. If this array is full revert to Option2. Limited memory overhead, saves time when queue is not full.

65
64Copyright © Gyora Benedek, 2003 Time Complexity Option1: O(nPositions + nMoves·nSolvablePositions) = O(n+m) =c · (2^25+25·2^23) Option2: O(nPositions · MaxSolutionLen + nMoves · nSolvablePositions)

66
65Copyright © Gyora Benedek, 2003 Optimizations It so happens that all solvable positions are uniquely defined by the 1 st 23 bits. Closed can be 2^23 = 8MBytes ‘only’. By using board symmetry this can be reduced to ~ 1/8; slightly more than 1MBytes.

67
66Copyright © Gyora Benedek, 2003 Problems High Memory & Time complexity! Not practical for larger boards (6x6). A few years ago even 5x5 was not practical.

68
67Copyright © Gyora Benedek, 2003

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google