def a_star( start ):
frontier = Queue.PriorityQueue() # Create a Queue to perform BFS on the world
frontier.put( (0, start) )
previous = {}
cost = {}
previous[tuple(start)] = (None,'')
cost[tuple(start)] = 0
neighbors = {'L':start, 'S':start, 'R':start, 'U':start, 'D':start}
while frontier.empty() == False:
current = frontier.get() # Remove next state from the Queue
current_state = current[1]
if problem23_1.is_goal(current_state):
break
neighbors['L'] = go_left(current_state)
neighbors['R'] = go_right(current_state)
neighbors['D'] = go_down(current_state)
neighbors['U'] = go_up(current_state)
neighbors['S'] = suck(current_state)
insertion_order = ('L', 'U', 'R', 'D', 'S')
for action in insertion_order:
new_cost = cost[current_state] + 1
if neighbors[action] not in cost or new_cost < cost[neighbors[action]]:
cost[neighbors[action]] = new_cost
priority = new_cost + heuristic( neighbors[action] )
frontier.put( (priority, neighbors[action]) )
previous[neighbors[action]] = (current_state, action)
"""
Once a graph of states has been traversed by the BFS algorithm
We can then print out the pathway from teh start state to
the goal by tracing a path along the dictionary named previous
"""
path = []
while current_state != start:
path.append(previous[current_state][1])
current_state = previous[current_state][0]
path.reverse()
return ''.join(tuple(path))
def breadth_first( start ):
#vacuum_location = start[-1]
#start_state = start[:-1]
#print start
#print type(start) is list
"""
We first create a frontier queue for the expansion of the search
and will start by enqueing the start state, which is noted by the
tuple start = ( int room1, int room2, vacuum_location )
"""
frontier = Queue.Queue() # Create a Queue to perform BFS on the world
frontier.put(start)
"""
We then create a dictionary noted previous so that we may trace our
way back to the start from any of the expanded nodes.
The first node placed in will be noted by the tuple start and will have
None as its value of previous. All other subsequent entries will be
in the format.... previous[state_tuple] = (previous_tuple, action taken)
"""
previous = {}
previous[tuple(start)] = (None,'')
"""
We then begin the bulk of the BFS algorithm and will create a
tuple for every state that is adjacent to the currently visited
node/state. These adjacent nodes will be called chlidren[L/R/S]
in the code and will create a unique tuple to be enqueued
"""
adjacency_list = {'L':start, 'S':start, 'R':start, 'U':start, 'D':start}
while( frontier.empty() == False ):
"""
each element of the queue will be a tuple containing the
rows as lists that will make up the vacuum world grid
"""
current = frontier.get() # Remove next state from the Queue
if problem23_1.is_goal(current):
break
adjacency_list['L'] = go_left(current)
adjacency_list['R'] = go_right(current)
adjacency_list['D'] = go_down(current)
adjacency_list['U'] = go_up(current)
adjacency_list['S'] = suck(current)
insertion_order = ('L', 'U', 'R', 'D', 'S')
for action in insertion_order:
if adjacency_list[action] not in previous:
frontier.put(adjacency_list[action])
previous[adjacency_list[action]] = (current, action)
"""
Once a graph of states has been traversed by the BFS algorithm
We can then print out the pathway from teh start state to
the goal by tracing a path along the dictionary named previous
"""
path = []
while current != start:
path.append(previous[current][1])
current = previous[current][0]
path.reverse()
return ''.join(tuple(path))
def depth_limited( start, max_depth ):
"""
We first create a frontier queue for the expansion of the search
and will start by enqueing the start state, which is noted by the
tuple start = ( int room1, int room2, vacuum_location )
"""
frontier = [] # Create a Queue to perform BFS on the world
frontier.append( (start, 0) )
"""
We then create a dictionary noted previous so that we may trace our
way back to the start from any of the expanded nodes.
The first node placed in will be noted by the tuple start and will have
None as its value of previous. All other subsequent entries will be
in the format.... previous[state_tuple] = (previous_tuple, action taken)
"""
previous = {}
previous[tuple(start)] = (None,'')
# visited = {}
# visited[tuple(start)] = True
"""
We then begin the bulk of the BFS algorithm and will create a
tuple for every state that is adjacent to the currently visited
node/state. These adjacent nodes will be called chlidren[L/R/S]
in the code and will create a unique tuple to be enqueued
"""
adjacency_list = {'L':start, 'S':start, 'R':start, 'U':start, 'D':start}
while( len(frontier) > 0 ):
"""
each element of the queue will be a tuple containing the
rows as lists that will make up the vacuum world grid
"""
current = frontier.pop() # Remove next state from the Queue
#visited[tuple(current)] = True
"""
if we reached the goal, we terminate the traversal early
"""
if problem23_1.is_goal(current[0]):
break
adjacency_list['L'] = go_left(current[0])
adjacency_list['R'] = go_right(current[0])
adjacency_list['D'] = go_down(current[0])
adjacency_list['U'] = go_up(current[0])
adjacency_list['S'] = suck(current[0])
insertion_order = ('S', 'D', 'R', 'U', 'L')
for action in insertion_order:
if adjacency_list[action] not in previous and current[1] < max_depth:
frontier.append( (adjacency_list[action], current[1] + 1) )
previous[adjacency_list[action]] = (current[0], action)
"""
Once a graph of states has been traversed by the BFS algorithm
We can then print out the pathway from teh start state to
the goal by tracing a path along the dictionary named previous
"""
#print current
output= []
pathfinder = current[0] # Assigne goal state to pathfinder
while pathfinder != start: # Trace path until the start
output.append(previous[pathfinder][1]) # trace previous
pathfinder = previous[pathfinder][0]
output.reverse()
if problem23_1.is_goal( current[0] ):
return ''.join(tuple(output))
else:
return None