def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
# TODO
# Keep track of number of states explored
num_explored = 0
# Initialize frontier to just the starting position
start = Node(state=source, parent=None, action=None)
frontier = QueueFrontier()
frontier.add(start)
explored = set()
# Keep looping until solution found
while True:
# If nothing left in frontier, then no path
if frontier.empty():
raise Exception("no solution")
# Choose a node from the frontier
node = frontier.remove()
num_explored += 1
# If node is the goal, then we have a solution
if node.state == target:
answer = []
while node.parent is not None:
#action = movieid, state = personid
answer.append((node.action, node.state))
node = node.parent
answer.reverse()
return answer
#Mark node as explored
if node.state not in explored:
explored.add(node.state)
for action, state in neighbors_for_person(node.state):
if not frontier.contains_state(state) and state not in explored:
child = Node(state=state, parent=node, action=action)
#if you detect a goal node, no need to add it to the frontier, you can simply return the solution immediately.
if child.state == target:
answer = []
while child.parent is not None:
#action = movieid, state = personid
answer.append((child.action, child.state))
child = child.parent
answer.reverse()
return answer
frontier.add(child)
explored.add(child.state)
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
# keep track of number of states explored
num_explored = 0
# state is person id
# action is movie id
# initialize frontier to starting position
start = Node(state=source, parent=None, action=None)
frontier = QueueFrontier()
frontier.add(start)
# initialize empty explored set
explored = set()
# keep looping until solution found
while True:
# if nothing in the frontier at start of loop, no path
if frontier.empty():
return (None)
# choose a node from the frontier
node = frontier.remove()
num_explored += 1
# if node is the goal, we have a solution
# this should be the shortest path since we're using BFS
if node.state == target:
actions = []
states = []
while node.parent is not None:
actions.append(node.action)
states.append(node.state)
node = node.parent
actions.reverse()
states.reverse()
solution = []
for i in range(len(actions)):
solution.append((actions[i], states[i]))
return (solution)
explored.add(node.state)
for action, state in neighbors_for_person(node.state):
if not frontier.contains_state(state) and state not in explored:
child = Node(state=state, parent=node, action=action)
frontier.add(child)
# TODO
raise NotImplementedError
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
num_explored = 0
start = Node(state=start, parent=None, action=action)
frontier = QueueFrontier()
frontier.add(start)
explored = set()
# Loop until solution is found
while True:
if frontier.empty():
return None
node = frontier.remove()
explored.add(node.state)
solution = []
for movie_id, person_id in neighbors_for_person(node.state):
if not frontier.contains_state(person_id) and person_id not in explored:
child = Node(person_id, node, movie_id)
if child.state == target:
solution.append((movie_id, person_id))
while node.parent is not None:
solution.append((node.action, node.state))
nod = node.parent
solution.reverse()
return solution
frontier.add(child)
if node.state == goal:
actions = []
cells = []
while node.parent is not None:
actions.append(node.action)
cells.append(node.state)
node = node.parent
actions.reverse()
cells.reverse()
solution = (actions, cells)
return
explored.add(node.state)
for action, state in neighbors(node.state):
if not (frontier.contains_state(state) and state not in explored):
child = Node(state=state, parent=node, action=action)
frontier.add(child)
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
# Initialize front to the start position
start = Node(state=source, parent=None, action=None)
frontier = QueueFrontier()
frontier.add(start)
# Initialize an empty set
explored = set()
#loop
while True:
# If nothing left in frontier, then no path
if frontier.empty():
return None
# Choose a node from the frontier
node = frontier.remove()
num_explored += 1
# If node is the goal, then we have a solution
if node.state == target:
actions = []
cells = []
while node.parent is not None:
actions.append(node.action)
cells.append(node.state)
node = node.parent
actions.reverse()
cells.reverse()
solution = (actions, cells)
return
# Mark node as explored
explored.add(node.state)
# Add neighbors to frontier
for action, state in neighbors_for_person(node.state):
if state not in explored and not frontier.contains_state(action):
child = Node(state=state, parent=node, action=action)
if child.state == target:
action_path = []
node = child
while node.parent is not None:
action_path.append((node.action, node.state))
node = node.parent
action_path.reverse()
return action_path
frontier.add(child)
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
# Initialize frontier to just the starting position
start = Node(state=source, parent=None, action=None)
frontier = QueueFrontier()
frontier.add(start)
print('Target is ' + target)
print(start.parent)
# Keep looping until solution found
while True:
# If nothing left in frontier, then no path
if frontier.empty():
raise Exception("no solution")
# Initialize an empty explored set
explored = set()
# Choose a node from the frontier
node = frontier.remove()
# If node is the goal, then we have a solution
if node.state == target:
print('there')
solution = []
link = set()
while node.parent is not None:
solution.append(((node.action), (node.state)))
print(solution)
node = node.parent
print('no parent')
solution.reverse()
print(solution)
return solution
# Mark node as explored
explored.add(node.state)
print(neighbors_for_person(node.state))
for person in neighbors_for_person(node.state):
if not frontier.contains_state(
person[1]) and person[1] not in explored:
print('Here')
child = Node(state=person[1], parent=node, action=person[0])
print(child.parent)
frontier.add(child)
if person[1] == target:
break
# TODO
raise NotImplementedError
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
""" initialize frontier to start """
start = Node(state=source, parent=None, action=None)
frontier = QueueFrontier()
frontier.add(start)
# empty explored set
explored = set()
# Keep looping until solution found
while True:
# If nothing left in frontier, then no path
if frontier.empty():
return None
# Choose a node from the frontier
node = frontier.remove()
# If node is the goal, then we have a solution
if node.state == target:
solution = []
while node.parent is not None:
x = node.action
y = node.state
solution.append((x, y))
node = node.parent
solution.reverse()
return solution
# if not add it to explored
explored.add(node.state)
# check neighbours of the node
for mov, pop in neighbors_for_person(node.state):
#check if node is solution before putting it in a frontier
if pop == target:
node = Node(state=pop, parent=node, action=mov)
solution = []
while node.parent is not None:
x = node.action
y = node.state
solution.append((x, y))
node = node.parent
solution.reverse()
return solution
# else add node to the frontier
elif not frontier.contains_state(pop) and pop not in explored:
child = Node(state=pop, parent=node, action=mov)
frontier.add(child)
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
# TODO
start = Node(state=source, parent=None, action=None) # VA
frontier = QueueFrontier() # VA
frontier.add(start) # VA
explored = set() # VA -> MIRAR SI ES LOCAL A LA FUNCION
while True:
# If nothing left in frontier, then no path
if frontier.empty(): # VA
raise Exception("no solution")
# Choose a node from the frontier
node = frontier.remove() # VA
# If node is the goal, then we have a solution
"""
if node.state == target: # VA-> TARGET (VA TODO LO DEL IF)
actions = []
cells = []
while node.parent is not None:
actions.append(node.action)
cells.append(node.state)
node = node.parent
actions.reverse()
cells.reverse()
self.solution = (actions, cells)
return
"""
# Mark node as explored
# Add neighbors to frontier
# VA -> CON LA FUNCIÓN QUE TENEMOS
for movie_id, person_id in neighbors_for_person(node.state):
if not frontier.contains_state(
person_id) and person_id not in explored:
if person_id == target:
path = []
path.append((movie_id, person_id))
while node.parent is not None:
path.append((node.action, node.state))
node = node.parent
path.reverse()
return path
else:
child = Node(state=person_id, parent=node, action=movie_id)
frontier.add(child)
explored.add(person_id) # VA
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
Frontier = QueueFrontier()
exploredNodes = set()
# exploredStartNodes = set()
start = selectStart(source, target, exploredNodes, Frontier)
if start == None:
raise Exception("No solution")
# exploredStartNodes.add(start.state)
exploredNodes.add(start.state)
while True:
if Frontier.empty():
newStart = selectStart(source, target, exploredNodes, Frontier)
if newStart == None:
raise Exception("No Solution")
else:
Frontier.add(newStart)
# exploredStartNodes.add(newStart.state)
exploredNodes.add(newStart.state)
else:
node = Frontier.remove()
if node.state[1] == target:
cells = []
##Add the current node and its parents
cells.append(node.state)
while (node.parent is not None):
cells.append(node.parent.state)
node = node.parent
cells.reverse()
return cells
neighborsOfNodes = neighbors_for_person(node.state[1])
for neighbor in neighborsOfNodes:
if targetInNeighbors(neighborsOfNodes, target):
if neighbor[1] == target:
child = Node(state=neighbor, parent=node, action=None)
Frontier.add(child)
exploredNodes.add(child.state)
elif neighbor not in exploredNodes and not Frontier.contains_state(
neighbor):
child = Node(state=neighbor, parent=node, action=None)
Frontier.add(child)
exploredNodes.add(child.state)
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
#Initialize frontier to starting position
source = Node(state=source, parent=None, action=None)
frontier = QueueFrontier()
frontier.add(source)
#Explored Set
explored = set()
# TODO
#Solution Loop
while True:
if frontier.empty():
break
node = frontier.remove()
if node.state == target:
solution = []
while node.parent is not None:
segment = (node.action, node.state)
solution.append(segment)
node = node.parent
solution.reverse()
return solution
explored.add(node.state)
#add neighbors to frontier
neighbors = neighbors_for_person(node.state)
for costars in neighbors:
if costars[1] == target:
solution = []
finalnodes = Node(state=target, parent=node, action=costars[0])
while finalnodes.parent is not None:
segment = (finalnodes.action, finalnodes.state)
solution.append(segment)
finalnodes = finalnodes.parent
solution.reverse()
return solution
if not frontier.contains_state(
costars[1]) and costars[1] not in explored:
child = Node(state=costars[1], parent=node, action=costars[0])
frontier.add(child)
return None
raise NotImplementedError
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
node.state will be an actor, and node.action will be the movie taken to get from one actor to the next.
"""
# Initialize frontier to just the starting actor
start = Node(state=(source), parent=None, action=None)
frontier = QueueFrontier()
frontier.add(start)
# Initialize an empty explored set
explored = set()
while True:
# If nothing left in frontier, then no path
if frontier.empty():
raise Exception("No solution.")
# Choose a node from the frontier
node = frontier.remove()
#print (f'Node popped: {node.state}')
# check for target in film node.
explored.add(node.state)
# if node.state == target:
# solution = []
# while node.parent is not None:
# solution.append((node.action, node.state))
# node = node.parent
# solution.reverse()
# return solution
neighbors = []
for movie, actor in neighbors_for_person(node.state):
if actor not in neighbors:
neighbors.append(actor)
if target in neighbors:
solution = []
solution.append((movie, target))
while node.parent is not None:
solution.append((node.action, node.state))
node = node.parent
solution.reverse()
return solution
nodecounter = 0
for movie, actor in neighbors_for_person(node.state):
if not frontier.contains_state(actor) and actor not in explored:
child = Node(state=actor, parent=node, action=movie)
frontier.add(child)
nodecounter += 1
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
frontier = QueueFrontier()
explored = set() # person IDs already explored
initialnode = Node(source, None, None)
frontier.add(initialnode)
while not frontier.empty():
# Remove a node from the frontier (QUEUE)
currentnode = frontier.remove()
# Skip Node if already explored (personID)
if currentnode.state in explored:
continue
# Obtain the list of (movie, personid) that the source is in
setofneighbors = neighbors_for_person(currentnode.state)
for movieid, personid in setofneighbors:
# Create a Node for neighbor
checknode = Node(personid, currentnode, movieid)
# Check if person is the target
if target == checknode.state:
reversedSolution = []
tempnode = checknode
# Make sure we are not at the Initial Node where Parent = None
while tempnode.parent != None:
# print(f"Person {tempnode.state}, Movie{tempnode.action}")
# Add the current node to the Solution List
reversedSolution.append((tempnode.action, tempnode.state))
# Obtain the parent of the current node to backtrack to the beginning
tempnode = tempnode.parent
# Reverse the Solution to display path from Start to End
return reversedSolution[::-1]
# Add the node to the frontier to be analyzed later
else:
frontier.add(checknode)
# Add it after its been explored
explored.add(currentnode.state)
return None
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
# Keep track of number of states explored
num_explored = 0
# Initialize frontier to just the starting position
ageGap = find_age_gap(target, source)
start = Node(state=source,
parent=None,
action=None,
heuristic=ageGap,
cost=num_explored)
frontier = AFrontier()
frontier.add(start)
# Initialize an empty explored set
explored = set()
while True:
# Empty Frontier returns no solution
if frontier.empty():
raise Exception("No solution")
# Select a Node from the frontier
node = frontier.remove()
num_explored += 1
# check if node matches target and return solution
if node.state == target:
solution = solution_path(node)
return solution, num_explored
# Mark node as explored if it is not the goal
explored.add(node.state)
# Add neighbors to frontier
for action, state in neighbors_for_person(node.state):
# check if neighbor is the goal
if state == target:
solution = solution_path(node)
# Don't add node to frontier if we have already explored it or it is already in the frontier
if not frontier.contains_state(state) and state not in explored:
ageGap = find_age_gap(target, state)
child = Node(state=state,
parent=node,
action=action,
heuristic=ageGap,
cost=num_explored)
frontier.add(child)
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
# TODO
#actions = movies
#states = people_id
start = Node(state=source, parent=None, action=None)
#BFS search
frontier = QueueFrontier()
frontier.add(start)
# Initialize an empty explored set
explored = set()
# Keep looping until solution found
while True:
# If nothing left in frontier, then return none
if frontier.empty():
return None
# Choose a node from the frontier
node = frontier.remove()
# If node is the goal (target person), then we return a solution
if node.state == target:
movies = []
persons = []
while node.parent is not None:
movies.append(node.action)
persons.append(node.state)
node = node.parent
movies.reverse()
persons.reverse()
solution = []
for i in range(len(movies)):
solution.append((movies[i], persons[i]))
return solution
# Mark node as explored
explored.add(node.state)
# Add neighbors to frontier
for (movie_id, person_id) in neighbors_for_person(node.state):
if not frontier.contains_state(
person_id) and person_id not in explored:
child = Node(state=person_id, parent=node, action=movie_id)
frontier.add(child)
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
# TODO
# Initialize frontier to just the starting position
start = Node(state=source, parent=None, action=None)
frontier = QueueFrontier()
states_in_frontier = set()
frontier.add(start)
states_in_frontier.add(source)
# Initialize an empty explored set
explored = set()
# Keep looping until solution found
while True:
# If nothing left in frontier, then no path
if frontier.empty():
return None
# Choose a node from the frontier
node = frontier.remove()
states_in_frontier.remove(node.state)
# Mark node as explored
explored.add(node.state)
# Add neighbors to frontier
set1 = neighbors_for_person(node.state)
for action, state in set1:
if state not in explored and state not in states_in_frontier:
child = Node(state=state, parent=node, action=action)
# If node is the goal, then we have a solution
if node.state == target:
actions = []
cells = []
while node.parent is not None:
actions.append(node.action)
cells.append(node.state)
node = node.parent
actions.reverse()
cells.reverse()
# Form the list with (movie_id, person_id) pairs, as required
solution = []
length = len(actions)
for i in range(length):
solution.append((actions[i], cells[i]))
return solution
frontier.add(child)
states_in_frontier.add(child.state)
class UI:
def __init__(self):
self._root = Node()
def add_widget(self, obj):
self._root.add_child(obj)
@property
def root(self):
return self._root
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
"""Finds a solution to maze, if one exists."""
# Keep track of number of states explored
num_explored = 0
# Initialize frontier to just the starting position
start = Node(state=source, parent=None, action=None)
frontier = QueueFrontier()
frontier.add(start)
# Initialize an empty explored set
explored = set()
# Keep looping until solution found
while True:
# If nothing left in frontier, then no path
if frontier.empty():
raise Exception("no solution")
# Choose a node from the frontier
node = frontier.remove()
num_explored += 1
# If node is the goal, then we have a solution
if node.state == target:
actions = []
cells = []
path = []
while node.parent is not None:
path.append((node.action, node.state))
#actions.append(node.action)
#cells.append(node.state)
node = node.parent
#actions.reverse()
#cells.reverse()
path.reverse()
return path
# Mark node as explored
explored.add(node.state)
# Add neighbors to frontier
for action, state in neighbors_for_person(node.state):
if not frontier.contains_state(state) and state not in explored:
child = Node(state=state, parent=node, action=action)
frontier.add(child)
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
# Initialize frontier to just the source name
start = Node(state=source, parent=None, action=None)
frontier = QueueFrontier()
frontier.add(start)
# Initialize an empty explored set
explored = set()
# Keep looping until solution
while True:
# If nothing left in frontier, then no path
if frontier.empty():
raise Exception('No solution.')
# Choose node from the frontier
node = frontier.remove()
#print(people[node.state]['name'])
explored.add(node.state)
#print(explored)
# If node is the goal, then we have a solution
if node.state == target:
solution = []
while node.parent is not None:
path = (node.action, node.state)
solution.append(path)
node = node.parent
solution.reverse()
#print(solution)
return solution
# Add neighbors to the frontier
for action, state in neighbors_for_person(node.state):
if not frontier.contains_state(state) and state not in explored:
if state == target:
solution = []
node = Node(state=state, action=action, parent=node)
while node.parent is not None:
path = (node.action, node.state)
solution.append(path)
node = node.parent
solution.reverse()
#print(solution)
return solution
child = Node(state=state, action=action, parent=node)
frontier.add(child)
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
# A variable that keep track of number of states explored (OPTIONAL)
num_explored = 0
# Set the state in which the agent begins and the goal.
start = Node(state=source, parent=None, action=None)
goal = target
# Initialize a frontier that contains the initial state.
frontier = QueueFrontier()
frontier.add(start)
# Initialize an empty explored set
explored = set()
while True:
# Checks if the frontier is empty
if frontier.empty():
return None
# Add a node to the explored set.
node = frontier.remove()
explored.add(node.state)
# Add one each time a state is explored
num_explored += 1
# Expand node, add resulting nodes to the frontier
# if they aren't already in the frontier or the explored set.
# Also checks if a child node contains the goal state
for action, state in neighbors_for_person(node.state):
if not frontier.contains_state(state) and (state not in explored):
child = Node(state=state, parent=node, action=action)
if child.state == goal:
path = []
node = child
while node.parent is not None:
path.append((node.action, node.state))
node = node.parent
#Print the number of states explored (OPTIONAL)
print(f"States Explored: {num_explored}")
path.reverse()
return path
frontier.add(child)
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
num_explored = 0
# Keep track of number of states explored
start = Node(state=source, parent=None, action=None)
frontier = QueueFrontier()
frontier.add(start)
# Initialize an empty explored set
explored = set()
# Keep looping until you've checked all states
while True:
# Emma Watson
# Ezra Miller
# Michael Stuhlbarg
# If nothing left in frontier, then no path
if frontier.empty():
return None
# Choose a node from the frontier
node = frontier.remove()
num_explored += 1
# If node is the goal, then we have a solution
if node.state == target:
actions = []
cells = []
while node.parent is not None:
actions.append(node.action)
cells.append(node.state)
node = node.parent
actions.reverse()
cells.reverse()
return list(zip([int(i) for i in actions],
[int(i) for i in cells]))
# Mark node as explored
explored.add(node.state)
# Add neighbors to frontier
for action, state in neighbors_for_person(
node.state): # (movie_id, person_id)
if not frontier.contains_state(state) and state not in explored:
child = Node(state=state, parent=node, action=action)
frontier.add(child)
def find_connection(start_id, end_id):
'''
Finds and returns the connection between two actors
'''
# Keeps track of all ids which have been visited
visited = set()
visited.add(start_id)
# Gets all the stars who are in the same movie as the starting actor
neighbors = get_neighbors(start_id, visited)
queue = Queue()
paths = list()
# Checking all the neighbors of the start and adds them to the queue
for movie_id, star_id in neighbors:
if star_id == end_id:
return [(movie_id, star_id)]
if star_id not in visited:
# Stores each connection between actors
node = Node(start_id, movie_id, star_id)
queue.push(node)
paths.append([(movie_id, star_id)])
while not queue.isEmpty():
# Get the current node and add it to the visited set
current_node = queue.pop()
current_star_id = current_node.star_2_id
visited.add(current_star_id)
# Gets rhe current path
current_path = paths[0]
paths = paths[1:]
neighbors = get_neighbors(current_star_id, visited)
for movie_id, star_id in neighbors:
path = list(current_path)
if star_id not in visited:
# Adds a star's id to the queue if it has not been visited
node = Node(current_node.star_2_id, movie_id, star_id)
queue.push(node)
path.append((movie_id, star_id))
paths.append(path)
# Checks if connection has been found
if star_id == end_id:
return path
# No path
else:
return None
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
num_explored = 0
starting_node = Node(state=source, parent=None, action=None)
my_frontier = QueueFrontier() # frontier
my_frontier.add(starting_node) # initial state
explored_set = set() # empty explored set
done = False
while not done:
if my_frontier.empty():
raise Exception("no solution")
my_node = my_frontier.remove() # check if empty and removed node from frontier
num_explored += 1
if num_explored % 100 == 0:
print(f"Number Explored: {num_explored}")
if my_node.state[1] == target:
parents = []
while my_node.parent is not None:
parents.append(my_node.state)
my_node = my_node.parent
target = parents
return target
explored_set.add(my_node.state)
try:
if len(explored_set) == 1:
for x in neighbors_for_person(my_node.state):
if not my_frontier.contains_state(x) and x not in explored_set:
child = Node(state=x, parent=my_node, action=None)
my_frontier.add(child)
else:
for x in neighbors_for_person(my_node.state[1]):
if not my_frontier.contains_state(x) and x not in explored_set:
child = Node(state=x, parent=my_node, action=None)
my_frontier.add(child)
except KeyError:
pass
if my_frontier.empty():
done = True
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
# TODO
# Initialize path as a list
path = []
# Initialize a set that contains movie-person pairs which are explored
person_explored = set()
num_explored = 0
# Initialize the frontier to just the starting pair
start = Node(state=source, parent=None, action=None)
frontier = QueueFrontier()
frontier.add(start)
# Keep looping until solution found
while True:
# if nothing left in frontier, then no solution
if frontier.empty():
return None
# Choose a node from the frontier
node = frontier.remove()
num_explored += 1
# If node is the goal, then we have a solution
if node.state == target:
actions = []
people = []
while node.parent is not None:
actions.append(node.action)
people.append(node.state)
node = node.parent
actions.reverse()
people.reverse()
for i in range(len(actions)):
path.append((actions[i], people[i]))
return path
# Mark pair as explored
person_explored.add(node.state)
# Add neighbors to frontier
for movie, person in neighbors_for_person(node.state):
if not frontier.contains_state(person) and person not in person_explored:
child = Node(state=person, parent = node, action = movie)
frontier.add(child)
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
# create the start node+frontier, and insert the start node
start = Node(state=source, parent=None, action=None)
frontier = QueueFrontier()
frontier.add(start)
# list of explored actors
checkedActors = set()
while True:
# If queue is empty, we've checked all actors inserted, and found no connection :-(
if frontier.empty():
return None
# read a node from the queue
node = frontier.remove()
#print("working on =",people[node.state])
# add current actor id to processed actor list - not much sense re-processing the current node...
checkedActors.add(node.state)
# Find neighbors of current actor ID
neighbors = neighbors_for_person(node.state)
#print(people[node.state]["name"]+" has "+str(len(neighbors))+" actors who played with him/her")
# check the list of actors
for movieID, actorID in neighbors:
#print("actor "+people[actorID]["name"]+"("+actorID+") in movie "+movies[movieID]["title"])
# if we already processed this actor, skip to the next actor in the list
if actorID not in checkedActors:
# create a new node
child = Node(state=actorID, parent=node, action=movieID)
# did we reach the "destination" actor?
if child.state == target:
# create the path (movie id, actor id) - it's backwards (from the destination to the source)
path = []
node = child
while node.parent is not None:
path.append((node.action, node.state))
node = node.parent
# reverse the order
path.reverse()
return path
# not a the "destination" yet, add the node and move on
frontier.add(child)
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
# Keep track of number of states explored
num_explored = 0
# Initialize frontier to just the starting position (source)
start = Node(state=source, parent=None, action=None)
frontier = QueueFrontier()
frontier.add(start)
# Initialize an empty explored set
explored_set = set()
#Keep looping until solution found
while True:
#If nothing left in frontier, then no path
if frontier.empty():
raise Exception("No Solution")
# choose a node from the frontier
node = frontier.remove()
num_explored += 1
# Add neighbors to frontier
for action, state in neighbors_for_person(node.state):
if not frontier.contains_state(
state) and state not in explored_set:
# If this node is the target, then we have a solution
if node.state == target:
actions = []
cells = []
while node.parent is not None:
actions.append(node.action)
cells.append(node.state)
node = node.parent
actions.reverse()
cells.reverse()
zip_actionsAndCells = zip(actions, cells)
solution = []
for temp in zip_actionsAndCells:
solution.append(temp)
return solution
child = Node(state=state, parent=node, action=action)
frontier.add(child)
# Mark node as explored
explored_set.add(node.state)
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
# TODO
# Start with empty frontier and explored set
# Add frontier nodes
# If frontier is empty, no solution
# Remove node from frontier
# If node is goal, success
# Add node to explored
# If not in frontier or explore set, expand node
# If daughter node is not goal, add to frontier
explored = set()
frontier = QueueFrontier()
start = Node(state=source, parent=None, action=None)
frontier.add(start)
while True:
if frontier.empty():
return None
node = frontier.remove()
if node.state == target:
actions = []
states = []
while node.parent is not None:
actions.append(node.action)
states.append(node.state)
node = node.parent
actions.reverse()
states.reverse()
solution = list(zip(actions, states))
return solution
explored.add(node.state)
for action, state in neighbors_for_person(node.state):
if not frontier.contains_state(state) and state not in explored:
child = Node(state=state, parent=node, action=action)
frontier.add(child)
raise NotImplementedError
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
#Setup the frontier
Frontier = QueueFrontier()
InitialNode = Node(state=source, parent=None, action=None)
Frontier.add(InitialNode)
ExploredStates = []
#Check the node
while True:
#If it's empty, there's no solution
if Frontier.empty():
raise Exception("No solution")
#Remove one then consider it
nodeToCheck = Frontier.remove()
#Is it the goal state? then return
if nodeToCheck.state == target:
path = []
#(Movie ID to get there from previous, person id)
#loop and add the path to the array
while nodeToCheck.parent is not None:
path.append((nodeToCheck.action, nodeToCheck.state))
nodeToCheck = nodeToCheck.parent
#return it
path.reverse()
return path
else:
#else, add it to the explored states and get its neighbors to add them to the frontier
ExploredStates.append(nodeToCheck.state)
neighbors = neighbors_for_person(nodeToCheck.state)
for movie_id, person_id in neighbors:
if not Frontier.contains_state(
person_id) and person_id not in ExploredStates:
Frontier.add(
Node(state=person_id,
parent=nodeToCheck,
action=movie_id))
# TODO
raise NotImplementedError
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
'''
node should contain state: movie_i,
parent = movie_j ,
action: co-starring person id that lead from Movie i to movie j
# first, put all neighbours for source person into queue, check for goal before putting them in
# take the next state in queue, check goal, if not, find all neighbours in queue, repeat.
'''
# TODO
# Keep track of number of movies explored
num_explored = 0
# Initialize frontier to just the starting position
start = Node(state=source, parent=None, action=None)
frontier = QueueFrontier()
frontier.add(start)
# Initialize an empty explored set for person
explored = set()
# keeo looping until solution found
while True:
# if nothing left in the frontier, then no solution
if frontier.empty():
path = None
# choose a node from the frontier
node = frontier.remove()
num_explored += 1
#print(node.state)
# if node is the goal, then we have a solution
if node.state == target:
path = get_path(node)
return path
# Mark person as explored
explored.add(node.state)
# Add neighbors to frontier (check goal first)
for movie_id, person_id in neighbors_for_person(node.state):
if person_id == target:
child = Node(state=person_id, parent=node, action=movie_id)
path = get_path(child)
return path
elif not frontier.contains_state(
person_id) and person_id not in explored:
child = Node(state=person_id, parent=node, action=movie_id)
frontier.add(child)
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
"""
neighbours_for_x = neighbors_for_person(source)
frontier = QueueFrontier()
print("the source is: "+ source)
print("the target is: "+ target)
node_list = []
node_hist = []
movie_people_seen = []
action_start= 0
#adding nodes to the queue to loop over.
for every in neighbours_for_x:
current_node = Node(state=every, parent=("",source),action= action_start)
frontier.add(current_node)
#loop until we have found a link otherwise return none if the queue is empty.
while True:
if frontier.empty():
return None
#getting item from queue, adding the removed item to list of seen nodes.
node = frontier.remove()
node_hist.append((node.state[0],node.state[1],node.parent[0],node.parent[1]))
movie_people_seen.append((node.state[0],node.state[1]))
if node.state[1] == target:
print("link found")
node_list.append(node.state)
#creating the list of nodes we passed through from source to get to the target.
for every in node_hist:
if every[0] == node.parent[0] and every[1] == node.parent[1]:
node_list.append((every[0], every[1]))
node = Node(state=(every[0],every[1]), parent=(every[2],every[3]), action = action_start)
if every[3] == source:
break
#returning the list.
return node_list[::-1]
node_neighbours = neighbors_for_person(node.state[1])
#looping over neighbours if we didn't find a connection to the target yet.
for every in node_neighbours:
if every not in movie_people_seen:
#keeping track of the depth of our search.
action_new_number = node.action + 1
node_current = Node(state = every, parent= node.state, action= action_new_number)
frontier.add(node_current)
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
# note that 'action' here refers to movie_id
source_node = Node(state=source, parent=None, action=None)
frontier = QueueFrontier()
frontier.add(source_node)
# Initialize number of explored states and explored nodes set
states_explored = 0
nodes_explored = set()
while True:
# Stop if nothing to explore and thus no path found
if frontier.empty():
raise Exception("no solution")
# Picking shallowest node, using queue
node = frontier.remove()
states_explored += 1
# Check if node is goal and return if goal
if node.state == target:
path = []
print("1", node.state)
while node.parent is not None:
path.append((node.action, node.state))
node = node.parent
path.reverse()
return path
# Record node explored
nodes_explored.add(node.state)
for action, state in neighbors_for_person(node.state):
# checking node as they're added to frontier
if state == target:
path = []
path.append((action, state))
while node.parent is not None:
path.append((node.action, node.state))
node = node.parent
path.reverse()
return path
# add neighbors to frontier
elif not frontier.contains_state(
state) and state not in nodes_explored:
child = Node(state=state, parent=node, action=action)
frontier.add(child)
def shortest_path(source, target):
"""
Returns the shortest list of (movie_id, person_id) pairs
that connect the source to the target.
If no possible path, returns None.
"""
# Initialize frontier to just the starting position
start = Node(state=source, parent=None, action=None)
frontier = QueueFrontier()
frontier.add(start)
# Initialize an empty explored set
explored = set()
solution = []
# Keep track of number of states explored
num_explored = 0
# Keep looping until solution found
while True:
# If nothing left in frontier, then no path
if frontier.empty():
return None
# Choose a node from the frontier
node = frontier.remove()
num_explored += 1
# to prevent endless run
if num_explored > 200:
sys.exit("couldn't find quick solution")
# Mark node as explored
explored.add(node.state)
# Add neighbors to frontier
neighbors = neighbors_for_person(node.state)
for action, state in neighbors:
if not frontier.contains_state(state) and state not in explored:
# If node is the goal, then we have a solution
if state == target:
# Add current/last connection to the goal person
solution.append([action, state])
# Add all previous connections using parent nodes
while node.parent is not None:
solution.append([node.action, node.state])
node = node.parent
solution.reverse()
print(f"{num_explored} nodes were explored.")
return solution
child = Node(state=state, parent=node, action=action)
frontier.add(child)
