def connected_components(X):
"""Find all connected nonzero components in a 3d array X
Returns a list of lists of indices of connected components
"""
visited = np.zeros_like(X, dtype="bool")
components = []
current_component = set()
def _fn(p):
if X[p]:
current_component.add(p)
return True
for i in range(visited.shape[0]):
for j in range(visited.shape[1]):
for k in range(visited.shape[2]):
if visited[i, j, k]:
continue
visited[i, j, k] = True
if not X[i, j, k]:
continue
# found a new component
pos = (i, j, k)
visited |= depth_first_search(X, pos, _fn, util.diag_adjacent)
components.append(list(current_component))
current_component.clear()
return components
def connected_components(X, unique_idm=False):
"""Find all connected nonzero components in a array X.
X is either rank 3 (volume) or rank 4 (volume-idm)
If unique_idm == True, different block types are different
components
Returns a list of lists of indices of connected components
"""
visited = np.zeros((X.shape[0], X.shape[1], X.shape[2]), dtype="bool")
components = []
current_component = set()
diag_adj = util.build_safe_diag_adjacent(
[0, X.shape[0], 0, X.shape[1], 0, X.shape[2]])
if len(X.shape) == 3:
X = np.expand_dims(X, axis=3)
def is_air(X, i, j, k):
return X[i, j, k, 0] == 0
if not unique_idm:
def _build_fn(X, current_component, idm):
def _fn(p):
if X[p[0], p[1], p[2], 0]:
current_component.add(p)
return True
return _fn
else:
def _build_fn(X, current_component, idm):
def _fn(p):
if tuple(X[p]) == idm:
current_component.add(p)
return True
return _fn
for i in range(visited.shape[0]):
for j in range(visited.shape[1]):
for k in range(visited.shape[2]):
if visited[i, j, k]:
continue
visited[i, j, k] = True
if is_air(X, i, j, k):
continue
# found a new component
pos = (i, j, k)
_fn = _build_fn(X, current_component, tuple(X[i, j, k, :]))
visited |= depth_first_search(X.shape[:3], pos, _fn, diag_adj)
components.append(list(current_component))
current_component.clear()
return components
def accessible_interesting_blocks(blocks, pos):
"""Return a boolean mask of blocks that are accessible-interesting from pos.
A block b is accessible-interesting if it is
1. interesting, AND
2. there exists a path from pos to b through only passable or interesting blocks
"""
passable = np.isin(blocks, PASSABLE_BLOCKS)
interesting = np.isin(blocks, BORING_BLOCKS, invert=True)
passable_or_interesting = passable | interesting
X = np.zeros_like(passable)
def _fn(p):
if passable_or_interesting[p]:
X[p] = True
return True
return False
depth_first_search(blocks, pos, _fn)
return X & interesting
def main():
print('Water Jugs: ')
print(
' Tuples are in this format --> [<Node (litersOfWaterInPot1, litersOfWaterInPot2, litersOfWaterInPot3)>]'
)
goalState = (2, 2, 3)
problem = Problem2(goalState)
goal = depth_first_search(problem)
print("\nPath = ", goal.path(), "\n\nPath cost = ", goal.path_cost)
#print(" Steps = " + str(goal.path()), "\n Cost = " + str(goal.path_cost))
print()
def main():
print('Family Dilema: ')
print(
' Tuples are in this format --> [<Node (isPoliceAcross, isThiefAcross, isMomAcross, isDadAcross, numberOfSonsAcross, numberOfGirlsAcross, isBoatAcross)>]'
)
goalState = (1, 1, 1, 1, 2, 2, 1)
problem = Problem1(goalState)
goal = depth_first_search(problem)
print("\nPath = ", goal.path(), "\n\nPath cost = ", goal.path_cost)
#print(" Steps = " + str(goal.path()), "\n Cost = " + str(goal.path_cost))
print()
def get_component_of(x, incidents, n):
"""Returns the set of connected verticies associated to a particular vertex X from a
dictionary of INCIDENTS for a graph of order N."""
closed = set()
for i in range(n):
if i+1 in closed:
continue
problem = GraphSearchProblem(x, i+1, graph_path_goal_test, incidents)
result = depth_first_search(problem)
if result == -1:
continue
closed = closed.union(result[2])
return closed
def main():
print('River Crossing: ')
print(
' Tuples are in this format --> [<Node (leftThief, leftMom, leftDad, leftSons, leftDaughters, leftPolice, rightThief, rightMom, rightDad, rightSons, rightDaughters, rightPolice boatSide)>]'
)
goalState = (0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 1, 1)
problem = Problem1(goalState)
goal = depth_first_search(problem)
print("\nPath = ", goal.path(), "\n\nPath cost = ", goal.path_cost)
#print(" Steps = " + str(goal.path()), "\n Cost = " + str(goal.path_cost))
print()
def main():
#Runs the Cannibals and Missionary problem, will provide a solution to getting all missionaries
#and all cannibals to the other side, without missionaries ever being outnumbered by cannibals
#on either side.
print('Missionaries/Cannibals Problem: ')
print(
' Tuples are in this format --> [<Node (leftMissionaries, rightMissionaries, leftCannibals, rightCannibals, boatSide)>]'
)
goalState = (3, 0, 3, 0, 0)
problem = MCP(goalState)
goal = depth_first_search(problem)
print("\nPath = ", goal.path(), "\n\nPath cost = ", goal.path_cost)
#print(" Steps = " + str(goal.path()), "\n Cost = " + str(goal.path_cost))
print()
def test_depth_first_search(self):
print("Starting depth first search test")
print("---------------------------------------------")
puzzle = EightPuzzleState([1, 0, 2, 3, 4, 5, 6, 7, 8])
problem = PuzzleSearchProblem(puzzle)
path, step = search.depth_first_search(problem)
print("Test DFS on:")
print(puzzle)
self.print_result("DFS", step, problem.get_costs(path), path)
curr = puzzle
for a in path:
curr = curr.next_state(a)
self.assertTrue(curr.is_goal(), "The final state is not goal test")
print("=============================================")
def BuscaProfundidade(self):
table = self.get_table()
print(table)
initial_state = StateNode(Game8(table), None, None, 0, 0)
start = int(round(time.time() * 1000))
path = depth_first_search(initial_state)
end = int(round(time.time() * 1000))
for state in path:
self.depth_label['text'] = 'Profundidade: ' + str(state.depth)
b = state.game.get_b_position()
state.game.table[b[0]][b[1]] = ''
self.set_table(state.game.table)
state.game.show_table()
time.sleep(1)
self.generated_nodes_label['text'] = 'Nós gerados: ' + str(
s.generated_nodes)
self.execution_time['text'] = 'Tempo de execução (ms): ' + str(end -
start)
def test_depth_first_search(self):
print("Starting depth first search test")
print("---------------------------------------------")
with TimeoutAlarm(
30,
error_message=
"Depth First Search cannot find the solution within 30s"):
puzzle = EightPuzzleState([1, 0, 2, 3, 4, 5, 6, 7, 8])
problem = PuzzleSearchProblem(puzzle)
path, step = search.depth_first_search(problem)
print("Test DFS on:")
print(puzzle)
self.print_result("DFS", step, problem.get_costs(path), path)
curr = puzzle
for a in path:
curr = curr.next_state(a)
self.assertTrue(curr.is_goal(), "The final state is not goal test")
print("=============================================")
print()
print('=' * 50)
print('=' * 50)
print("Q1: FIVE QUEENS")
print('=' * 50)
print('=' * 50)
fq = NQueensProblem(5)
print()
print('-' * 50)
print("DEPTH-FIRST-TREE-SEARCH")
print('-' * 50)
dfts = depth_first_search(fq, search_type=uninformed_tree_search)
print("Solution", dfts.solution())
print()
print('=' * 50)
print('=' * 50)
print("Q2-5: TRAVEL")
print('=' * 50)
print('=' * 50)
city_map = CityMap()
city_map.add_road('F', 'S', 5)
city_map.add_one_way_road('S', 'A', 2)
city_map.add_road('S', 'C', 6)
from trees import Node
from search import (depth_first_search, breadth_first_search,
recursion_tree_traverse)
# Setup Tree
root = Node(0)
root.left = Node(1)
root.right = Node(2)
root.left.left = Node(3)
root.left.right = Node(4)
root.right.left = Node(5)
root.right.right = Node(6)
print('Depth First Search')
depth_first_search(root)
print('=' * 25)
print('Breadth First Search')
breadth_first_search(root)
print('Recursion Tree Traversal')
recursion_tree_traverse(root)
print
print '=' * 50
print '=' * 50
print "N QUEENS PROBLEM"
print '=' * 50
print '=' * 50
nq = NQueensProblem(8)
print
print '-' * 24 + '1' + '-' * 25
print "Running DEPTH-FIRST-TREE-SEARCH"
print '-' * 50
dfts = depth_first_search(nq, search_type=uninformed_tree_search)
print "Solution", dfts.solution()
print
print '-' * 24 + '2' + '-' * 25
print "Running BREADTH-FIRST-TREE-SEARCH"
print '-' * 50
bfts = breadth_first_search(nq, search_type=uninformed_tree_search)
print "Solution", bfts.solution()
print
print '=' * 50
puzzle = EightPuzzleState(list(range(9)))
for i in range(moves):
puzzle = puzzle.next_state(random.sample(puzzle.legal_moves(), 1)[0])
return puzzle
if __name__ == '__main__':
# puzzle = createRandomEightPuzzle(30)
puzzle = EightPuzzleState([3, 0, 5, 6, 2, 4, 7, 8, 1])
print('A random puzzle:')
print(puzzle)
problem = PuzzleSearchProblem(puzzle)
#path, step = search.uniform_cost_search(problem)
#path, step = search.breadth_first_search(problem)
path, step = search.depth_first_search(problem)
#path, step = search.uniform_cost_search(problem)
#path, step = search.a_start_search(problem)
print(('BFS found a path of %d moves: %s by %d steps cost %d' %
(len(path), str(path), step, problem.get_costs(path))))
curr = puzzle
i = 1
for a in path:
curr = curr.next_state(a)
print(('After %d move%s: %s' % (i, ("", "s")[i > 1], a)))
print(curr)
input("Press return for the next state...") # wait for key stroke
i += 1
import search
import token
fplay = token.playz()
# gives the choose function the start and goal and capacity and the flag
fplay.choose({'x': 5, 'y': 3, 'z': 0}, {'x': 4, 'y': 0, 'z': 4}, [5,3,8], 1)
print("Start position =>", fplay.start(),"\n", "Goal position =>", fplay.goaldiff)
# gives the token to the search
list = search.depth_first_search(fplay, fplay.start(), "")
# to print the steps
for node in list:
x = node["x"]
y = node["y"]
z = node["z"]
print(x, y, z)
print("\n \n")
fplay = token.playz()
fplay.choose({'x': 7, 'y': 0, 'z': 0,}, {'x': 2, 'y': 2, 'z': 3}, [7,4,3], 1)
print("Start position =>", fplay.start(),"\n", "Goal position =>", fplay.goaldiff)
list = search.depth_first_search(fplay, fplay.start(), "")
for node in list:
x = node["x"]
y = node["y"]
z = node["z"]
print(x, y, z)
print("\n \n")
import search
from graph import Graph
if __name__ == "__main__":
# Setting graph we initiated to search class...
graph = Graph()
search.graph = graph
search.depth_first_search()
search.breath_first_search()
search.iterative_deepening_search()
search.uniform_cost_search()
search.greedy_best_first_search()
search.a_star_search()
