-
Read R&N Ch.1. How would you define AI and why? What is its place in
the context of Computer Science?
-
R&N Exercise 1.9 + 1.10
-
R&N Exercise 2.4
-
Uninformed Search: Consider the following graph where nodes are
states, arcs are operators labeled with costs, A is the initial
state, and G is the goal state:
In this exercise, you will give the order in which nodes are goal-tested
according to different search strategies employing different ways of avoiding
repeated states. List the order of node goal-testing until the goal G
is tested or 18 nodes have been listed. Ties in node ordering are broken
alphabetically by state label. The ways in which repeated states are avoided
are as follows:
-
"Generate all": Repeated states are not avoided; all nodes are generated.
-
"No self-loop": Do not return to the state you just came from.
-
"No cycles": Do not create paths with cycles in them.
-
"No repeats": Do not generate any state that was ever generated before.
Strategy
|
Generate all
|
No self-loop
|
No cycles
|
No repeats
|
Breadth-First
|
|
|
|
|
Uniform Cost
|
|
|
|
|
Depth-First
|
|
|
|
|
Depth-Limited
(limit=1)
|
|
|
|
|
Iterative Deepening
|
|
|
|
|
-
TripleCross Challenge #1 [Collaboration in pairs is permitted.]
Program depth-first search for TripleCross. There are two separable parts
to this project. The first task is to code a TripleCross search state
class. (See David Barr's
TripleCross page.) The second task is to code DFS. To aid
you in this programming adventure, please take advantage of code of a similar
nature which can be found in folders Queue and search
in the class code repository. There, you will
find not only an implementation of breadth-first search for the tile-puzzle,
but also abstract classes
State, Operator, and Searcher
which should be extended for your own implementations. (The Queue
class need not be used.) Use a state search limit such that your
code will terminate within 10 seconds. Then experiment to see how
scrambled the puzzle can be to reliably find a solution. For instance,
what percentage of the time will it find a solution 10, 15, or 20 random
moves from the start state? It's up to you decide what means to use
to avoid infinite loops. For instance, you could decided to add a
an option to limit depth (thus creating depth-limited search) or go a bit
further and implement iterative deepening (probably the most practical
option). Alternatively, you could implement one of the repeated-state
avoidance methods above with varying memory costs. Or you could do
a combination of each Submit code as directed on the
class homepage, and submit a brief (< 1 page) description of your design
and experimentation. Most importantly, have fun with it! (Note:
If you enjoy this puzzle, a simpler version is available from Binary Arts
as "Port to Port", available at Amazon, etc.)
