def algorithm(matrix):
print("__________________________")
print("Which Algorithm you want to use ?\n")
print("For A* Print A")
print("For Best First Search Print G")
print("For BFS print B")
choose = input().upper()
if choose == "A":
os.system("clear")
print("You have choosen A* Algorithm")
start = Nodes(matrix, None, 0, 0, 'A', None)
a_start(start, Goal)
if choose == "G":
os.system("clear")
print("You have choosen Mighty! Best First Algorithm")
start = Nodes(matrix, None, 0, 0, 'G', None)
bestFirstSearch(start, Goal)
if choose == "B":
os.system("clear")
print("You have choosen bfs algorithm")
start = Nodes(matrix, None, 0, 0, 'B', None)
bfs(start, Goal)
print("Wait Please I'm trying ...")
def findWordLadder(startWord, endWord, wordGraph):
# 1. do graph traversal starting from node for startWord
startNode = wordGraph.getNode(startWord)
endNode = wordGraph.getNode(endWord)
bfs(wordGraph, startNode)
# 2. extract word ladder from the graph
return extractWordLadder(startNode, endNode)
def main():
state = State([[1, 2, 3], [0, 0, 0], [0, 0, 0]])
# state2 = State([[1,0,0],[0,2,3],[0,0,0]])
# state3 = State([[0,2,0],[0,0,3],[1,0,0]])
# state4 = State([[0,0,0],[1,2,3],[0,0,0]])
# state5 = State([[1,0,0],[0,2,0],[0,0,3]])
# state6 = State([[0,0,3],[1,2,0],[0,0,0]])
end_state = State([[0, 0, 0], [0, 0, 0], [1, 2, 3]])
trace = set()
trace2 = set()
trace3 = set()
bfs(state, end_state, trace)
def start_rech(self, label, label_1):
if (self.search_type == "dfs"):
dfs(self.values[0], self.values[1], label_1)
self.rech_sequance = trace
for j in trace:
i = 0
for x in self.labels:
if (j[i//3][i % 3] == "0"):
x["fg"] = "white"
else:
x["fg"] = "black"
x["text"] = j[i//3][i % 3]
i = i+1
if (estEtatFinal(j, self.values[1])):
label["text"] = "Success"
label["fg"] = "white"
else:
label["text"] = "Failure"
label["fg"] = "red"
#x = dfs(self.labels, self.values)
#self.rech_sequance = x.recherche(self.values[0], self.values[1])
elif (self.search_type == "bfs"):
x = bfs(self.labels, self.values)
self.rech_sequance = x.recherche(
self.values[0], self.values[1], label, label_1)
else:
x = a_star(self.labels, self.values)
self.rech_sequance = x.recherche(
self.values[0], self.values[1], label, label_1)
def main():
global start_vertex, goal_vertex, mouse_press, mouse_move
set_stroke_width(2)
# drawing the background
draw_image(img, 0, 0)
# drawing all the vertices and adjacent edges
for key in vertices_dictionary:
vertices_dictionary[key].draw_vertex(0, 0, 1)
vertices_dictionary[key].draw_adjacency_edges(0, 0, 1)
# check if start vertex and goal vertex do not hold 'None'
if start_vertex and goal_vertex:
# find a path between them
bfs_list = bfs(start_vertex, goal_vertex)
# draw the edges
i = 1
while i <= len(bfs_list) - 1:
j = i - 1
bfs_list[i].draw_edge(bfs_list[j], 1, 0, 0)
i += 1
def main(args):
# If both args.d and args.n are false, use BFS
# If args.n is true, use naive
# If args.d is true, use Dijkstra
# If args.b is true, use BFS
graph = pickle.load(open(args.data, 'rb'))
de_graph = add_dead_ends_to_graph(graph)
unit_weighted_graph = make_unit_weighted_graph(graph)
for source_k, source_v in graph.iteritems():
print source_k.encode('ascii', 'ignore')
for dest_k, dest_v in graph.iteritems():
if args.d:
# use Dijkstra's algorithm
sp = shortestPath(unit_weighted_graph,source_k,dest_k)
elif args.n:
# use naive algorithm
sp = find_shortest_path(graph,source_k,dest_k,[])
else:
# use BFS algorithm
sp = bfs(graph,source_k,dest_k)
if sp and len(sp) > 1:
print len(sp)-1, sp, ":", source_k.encode('ascii', 'ignore'), "->", dest_k.encode('ascii', 'ignore')
def compute(self, list): route = [] results = [] self.textbox.delete(0, tk.END) route.extend(bfs(list[0], list[1])) for i in range(1, len(list) - 1): results = bfs(list[i], list[i + 1]) route.extend(results[1:]) j = 0 self.clearButtons() label = dict((i, '') for i in route) for i in route: label[i] += str(j) + ' ' self.buttons[i[0]][i[1]].config(text = str(label[i])) j += 1 self.insertTextBox(str(route))
def startMoves(self): while len(self.points) > 1: steps = bfs(self.points[0], self.points[1]) start = steps[0] for cur in steps[1:]: delta = (cur[0]-start[0],cur[1]-start[1]) knightMoves(delta[0], delta[1]) start = cur del self.points[0]
def stressTestBfsLevel(self,count):
print "Started BFS with " + str(count)
start = time.clock()
node = self.rotations[count]
g = Graph(node.data,hungrarianCubeOperators())
path = bfs(g,hungarianCubePredicate)
self.assertFalse(path is None)
elapsed = (time.clock() - start)
print "Done BFS with " + str(count)+ " levels " +"on " + str(elapsed) +" seconds"
def compute_details(
self): #this function is of little importance to the user.
#This function finds all non trivial details. This may include shortest distance to all powers and the first moves to be made to reach them in shortest time
#This can also compute other details like the area of the current region in which the bike resides etc..
self.player1 = bfs()
self.player2 = bfs()
self.player1.compute(self.map, self.my_posn)
self.player2.compute(self.map, self.enemy_posn)
self.n = len(self.player1.traverser_posn)
for i in range(self.n):
self.my_traverser_posn.append(self.player1.traverser_posn[i])
self.my_traverser_move.append(self.player1.traverser_move[i])
self.my_traverser_distance.append(
self.player1.traverser_distance[i])
self.m = len(self.player1.nitro_posn)
for i in range(self.m):
self.my_nitro_posn.append(self.player1.nitro_posn[i])
self.my_nitro_move.append(self.player1.nitro_move[i])
self.my_nitro_distance.append(self.player1.nitro_distance[i])
self.p = len(self.player2.traverser_posn)
for i in range(self.p):
self.enemy_traverser_posn.append(self.player2.traverser_posn[i])
self.enemy_traverser_move.append(self.player2.traverser_move[i])
self.enemy_traverser_distance.append(
self.player2.traverser_distance[i])
self.q = len(self.player2.nitro_posn)
for i in range(self.q):
self.enemy_nitro_posn.append(self.player2.nitro_posn[i])
self.enemy_nitro_move.append(self.player2.nitro_move[i])
self.enemy_nitro_distance.append(self.player2.nitro_distance[i])
def findBFS(self, start_name):
g = load_graph()
start = g[start_name]
# Jasper: maybe change below line to make random?
pref = self.preferences[0][0]
end = g[str(pref)]
path = bfs(start, end)
return path
def test_oneStepHCube(self):
cube = HungarianCube()
node = Node(cube,None,[])
cube2 = rotateFrontLeft(node)[0].data
g = Graph(cube2,hungrarianCubeOperators())
path = bfs(g,hungarianCubePredicate)
self.assertEquals(len(path),2)
print path[0].data
print "-----"
print path[1].data
def test_stressTestBfs(self):
print "Stress Test BFS"
node = self.rotations[4]
g = Graph(node.data,hungrarianCubeOperators())
path = bfs(g,hungarianCubePredicate)
for x in path:
print x.data
print "------"
print "*&*&*&*&*&*&"
def findBFS(self, start_name):
g = load_graph()
start = g[start_name]
# Jasper: maybe change below line to make random?
pref = self.preferences[0][0]
end = g[str(pref)]
path = bfs(start, end)
return path
def compute_details(self): #this function is of little importance to the user.
#This function finds all non trivial details. This may include shortest distance to all powers and the first moves to be made to reach them in shortest time
#This can also compute other details like the area of the current region in which the bike resides etc..
self.player1 = bfs()
self.player2 = bfs()
self.player1.compute(self.map,self.my_posn)
self.player2.compute(self.map,self.enemy_posn)
self.n = len(self.player1.traverser_posn)
for i in range(self.n):
self.my_traverser_posn.append( self.player1.traverser_posn[i] )
self.my_traverser_move.append( self.player1.traverser_move[i] )
self.my_traverser_distance.append( self.player1.traverser_distance[i] )
self.m = len(self.player1.nitro_posn)
for i in range(self.m):
self.my_nitro_posn.append( self.player1.nitro_posn[i] )
self.my_nitro_move.append( self.player1.nitro_move[i] )
self.my_nitro_distance.append( self.player1.nitro_distance[i] )
self.p = len(self.player2.traverser_posn)
for i in range(self.p):
self.enemy_traverser_posn.append( self.player2.traverser_posn[i] )
self.enemy_traverser_move.append( self.player2.traverser_move[i] )
self.enemy_traverser_distance.append( self.player2.traverser_distance[i] )
self.q = len(self.player2.nitro_posn)
for i in range(self.q):
self.enemy_nitro_posn.append( self.player2.nitro_posn[i] )
self.enemy_nitro_move.append( self.player2.nitro_move[i] )
self.enemy_nitro_distance.append( self.player2.nitro_distance[i] )
def findLunchPath(self, start_name):
g = load_graph()
start = g[start_name]
# Jasper: maybe change below line to make random?
pref = self.preferences[0][0]
end = g[str(pref)]
path = bfs(start, end)
# TRIP DISTANCE in pixels
trip_dist = len(path)*39
return trip_dist
def findLunchPath(self, start_name):
g = load_graph()
start = g[start_name]
# Jasper: maybe change below line to make random?
pref = self.preferences[0][0]
end = g[str(pref)]
path = bfs(start, end)
# TRIP DISTANCE in pixels
trip_dist = len(path) * 39
return trip_dist
def strategy_two(maze, fire, start, goal, q):
fire_maze = np.copy(fire)
temp_maze = np.copy(fire)
dimension = maze.shape[0]
temp_start = start
curX = 0
curY = 0
while fire_maze[curX][curY] != 4: # goal
if fire_maze[curX][curY] == 7: # runner is at a cell that is on fire
return 'Died', fire_maze
# calculate the path from the current cell to the goal at every step
status, traversal_path, num_explored_nodes = bfs(
temp_maze, temp_start, goal)
if status == 'No Solution': # the BFS call resulted in no path from the start to the goal being possible
return 'No Path Possible', fire_maze
# move to the next cell on the path
if curX + 1 < dimension and (traversal_path[curX + 1][curY] == 6
or traversal_path[curX + 1][curY] == 4):
curX = curX + 1
elif curY + 1 < dimension and (traversal_path[curX][curY + 1] == 6
or traversal_path[curX][curY + 1] == 4):
curY = curY + 1
elif curX - 1 >= 0 and (traversal_path[curX - 1][curY] == 6
or traversal_path[curX - 1][curY] == 4):
curX = curX - 1
elif curY - 1 >= 0 and (traversal_path[curX][curY - 1] == 6
or traversal_path[curX][curY - 1] == 4):
curY = curY - 1
if fire_maze[curX][curY] == 4: # goal is reached
break
fire_maze[curX][curY] = 6
temp_start = (curX, curY)
# advance the fire one step after the runner takes a step
fire_maze = advance_fire_one_step(fire_maze, q)
temp_maze = reset_path(
fire_maze, dimension
) # allows BFS to let the runner go back up the current path if necessary
return 'Escaped', fire_maze
def difference_explored(dimension, density):
total_difference = 0
for i in range(0, 100):
maze_trial = generate_maze(dimension, density) # generate maze
status, maze_copy, num_explored_bfs = bfs(
maze_trial, (0, 0),
(dimension - 1,
dimension - 1)) # run bfs and get number of explored nodes
status, maze_copy, num_explored_astar = astar(
maze_trial, (0, 0),
(dimension - 1,
dimension - 1)) # run A* and get number of explored nodes
total_difference += (num_explored_bfs - num_explored_astar)
return (total_difference / 100)
def strategy_one(maze, fire, start, goal, q):
fire_maze = np.copy(fire)
status, traversal_path, num_explored_nodes = bfs(
fire_maze, start, goal
) # finds the shortest path from the start to the goal if one exists
if status == 'No Solution':
return 'No Path Possible', fire_maze
dimension = maze.shape[0]
curX = 0
curY = 0
while fire_maze[curX][
curY] != 7: # while the runner is not on a cell that is on fire
if fire_maze[curX][
curY] == 4: # the runner has reached the goal and escaped successfully
return 'Escaped', fire_maze
if fire_maze[curX][curY] != 3: # not the start
fire_maze[curX][curY] = 6
# calculate which cell is the next one on the path to the goal
if curX + 1 < dimension and (traversal_path[curX + 1][curY] == 6
or traversal_path[curX + 1][curY]
== 4) and fire_maze[curX + 1][curY] != 6:
curX = curX + 1
elif curX - 1 >= 0 and (traversal_path[curX - 1][curY] == 6
or traversal_path[curX - 1][curY]
== 4) and fire_maze[curX - 1][curY] != 6:
curX = curX - 1
elif curY + 1 < dimension and (traversal_path[curX][curY + 1] == 6
or traversal_path[curX][curY + 1] == 4
) and fire_maze[curX][curY + 1] != 6:
curY = curY + 1
elif curY - 1 >= 0 and (traversal_path[curX][curY - 1] == 6
or traversal_path[curX][curY - 1]
== 4) and fire_maze[curX][curY - 1] != 6:
curY = curY - 1
# after the runner has effectively moved to the above mentioned cell the fire must be advanced one step
fire_maze = advance_fire_one_step(fire_maze, q)
return 'Died', fire_maze
def goToLunch(self, start_name, window):
g = load_graph()
start = g[start_name]
pref = self.preferences[0][0]
end = g[str(pref)]
path = bfs(start, end)
# TRIP DISTANCE in pixels
trip_dist = len(path)*39
'''
prints shortest path in reverse
# print the shortest path to students preference
i = len(path) - 1
print "Path for student: " + str(self)
while (i >= 0):
print path[i]
i = i-1
'''
print " "
print "Simulating Student " + str(self.id) + "'s shortest path to " + str(pref.name) + " from " + "(" + str(start_name) + ")"
# important! index path BACKWARDS (shortest path is dict of BACKPOINTERS)
i = len(path) - 1
while (i > 0):
print path[i].name
if (i == 1):
is_final = True
else:
is_final = False
self.makeMove(path[i], path[i-1], is_final,window)
i = i-1
print "Student arrived at destination " + str(path[i].name)
def goToLunch(self, start_name, window):
g = load_graph()
start = g[start_name]
pref = self.preferences[0][0]
end = g[str(pref)]
path = bfs(start, end)
# TRIP DISTANCE in pixels
trip_dist = len(path) * 39
'''
prints shortest path in reverse
# print the shortest path to students preference
i = len(path) - 1
print "Path for student: " + str(self)
while (i >= 0):
print path[i]
i = i-1
'''
print " "
print "Simulating Student " + str(
self.id) + "'s shortest path to " + str(
pref.name) + " from " + "(" + str(start_name) + ")"
# important! index path BACKWARDS (shortest path is dict of BACKPOINTERS)
i = len(path) - 1
while (i > 0):
print path[i].name
if (i == 1):
is_final = True
else:
is_final = False
self.makeMove(path[i], path[i - 1], is_final, window)
i = i - 1
print "Student arrived at destination " + str(path[i].name)
def test_path_algorithms():
dimension = int(sys.argv[1])
density = float(sys.argv[2])
cmap = colors.ListedColormap(color_set)
norm = colors.BoundaryNorm(range_set, len(color_set))
plt.figure(figsize=(8, 8))
plt.axis('off')
maze = generate_maze(dimension, density) # generate maze
# run each algorithm on maze and time them
start_time = time.time()
status, astar_maze, num_explored_nodes = astar(
maze, (0, 0), (dimension - 1, dimension - 1))
end_time = time.time()
print(status)
print(end_time - start_time)
print(num_explored_nodes)
start_time = time.time()
status, bfs_maze, num_explored_nodes = bfs(maze, (0, 0),
(dimension - 1, dimension - 1))
end_time = time.time()
print(status)
print(end_time - start_time)
print(num_explored_nodes)
start_time = time.time()
status, dfs_maze = dfs(maze, (0, 0), (dimension - 1, dimension - 1))
end_time = time.time()
print(status)
print(end_time - start_time)
# plot each result and save as image
plt.imshow(astar_maze, cmap=cmap, norm=norm)
plt.savefig('astar_maze.jpg')
plt.imshow(bfs_maze, cmap=cmap, norm=norm)
plt.savefig('bfs_maze')
plt.imshow(dfs_maze, cmap=cmap, norm=norm)
plt.savefig('dfs_maze')
def test_twoStepsHCube(self):
cube = HungarianCube()
print "original"
node = Node(cube)
print node.data
print "*****"
node = rotateFrontLeft(node)[0]
print node.data
print "*****"
cube2 = rotateRightRight(node)[0].data
print cube2
print "*****"
g = Graph(cube2,hungrarianCubeOperators())
path = bfs(g,hungarianCubePredicate)
self.assertEquals(len(path),3)
print "Solution"
print path[0].data
print "-----"
print path[1].data
print "-----"
print path[2].data
print "-=-=-=-=-=-"
def run_algorithm(self, algo):
"""
Main algorithm function.
:param algo: String, choosen algorithm
:return: None
"""
#Breadth-first search algorithm
if algo == 'bfs':
cf, hbxt = bfs(self.start_tile, self.end_tile)
#Dijkstra's algorithm
elif algo == 'dijkstra':
cf, csf, hbxt = dijkstra(self.start_tile, self.end_tile)
self.cost = csf[self.end_tile]
#A* algorithm
elif algo == 'a_star':
cf, csf, hbxt = a_star(self.start_tile, self.end_tile)
self.cost = csf[self.end_tile]
self.draw_paths(cf, hbxt, algo)
from bfs import *
from dfs import *
from ids import *
# Code from this exercise all made by @skdGT
print("---- BFS -----")
node, tree = bfs(State1((0, 0), (0, 0), "Start"), goal=2)
print("- Tree -")
tree.print_tree()
if node is not None:
path = find_path(node)
print("- Solution -")
print_path(path)
else:
print("- No Solution -")
print('\n\n\n\n\n\n')
print("---- DFS -----")
node, tree = dfs(State1((0, 0), (0, 0), "Start"), max_depth=10)
print("- Tree -")
tree.print_tree()
if node is not None:
path = find_path(node)
print("- Solution -")
print_path(path)
else:
print("- No Solution -")
print('\n\n\n\n\n\n')
print("---- IDDFS -----")
from bfs import *
from dfs import *
from greedy import *
from astar import *
from ac3 import *
from backtracking import *
from sudoku import *
if __name__ == '__main__':
# Lendo argumentos:
filename = sys.argv[1]
algorithm = sys.argv[2]
if algorithm == "bfs":
for board in read_board(filename):
print(bfs(board))
elif algorithm == "dfs":
for board in read_board(filename):
print(dfs(board))
elif algorithm == "greedy":
for board in read_board(filename):
print(greedy(board, h1))
elif algorithm == "astar":
for board in read_board(filename):
print(astar(board, g, h1))
elif algorithm == "ac3":
for board in read_board(filename):
csp = CSP(board)
print(AC3(csp, csp.queue()))
elif algorithm == "backtracking":
for board in read_board(filename):
from bfs import *
from maze import *
import sys
if __name__ == '__main__':
m = Maze(20, 10)
print(m)
MazeNode.quiet_mode = False
nodes = m.get_node_list()
g = Graph()
for i in nodes:
# add each maze nodes edges to graph
if i.u: g.add_edge(i.u, i.u.d)
if i.d: g.add_edge(i.d, i.d.u)
if i.l: g.add_edge(i.l, i.l.r)
if i.r: g.add_edge(i.r, i.r.l)
pprint(g)
source_node = m.get(0, 0)
bfs_result = bfs(g, source_node)
pprint(bfs_result)
print(m)
def findWordLadder(startWord, endWord, wordGraph):
bfs(wordGraph, wordGraph.getNode(startWord))
wl = extractWordLadder(wordGraph.getNode(startWord), wordGraph.getNode(endWord))
return wl
import argparse
from bfs import *
from Algorithm_A import *
if __name__ == "__main__":
parser = argparse.ArgumentParser(prog='main.py')
parser.add_argument('--a',
help='insertion sort algorithm',
dest='a',
action="store_true")
parser.add_argument('--bfs',
help='Bubble sort algorithm',
dest='bfs',
action="store_true")
parser.add_argument('--start',
help='start point',
type=int,
nargs="+",
dest='start')
parser.add_argument('--end',
help='start point',
type=int,
nargs="+",
dest='end')
args = parser.parse_args()
print(args)
if args.a:
a(args.start, args.end)
if args.bfs:
bfs(args.start, args.end)
pygame.init()
win = pygame.display.set_mode((width, height))
icon = pygame.image.load('icon.png')
pygame.display.set_icon(icon)
pygame.display.set_caption('Maze')
win.fill(white)
pygame.display.update()
# Рисуем лабиринт
new_maze()
kruskal()
# Выход
a[n + 2][m + 1] = a[n + 3][m + 1] = 0
# Максимальный путь
max_i, max_j = max_cell(bfs())
a[max_i][max_j] = 5
update() # <<<---
# Рисуем кнопки + Получаем список всех кнопок
bs = draw_buttons()
# Рисуем игроков
for i in range(players):
draw_player(0, 0, i)
while not end:
pygame.time.delay(75)
for event in pygame.event.get():
if event.type == pygame.QUIT:
exitonclick()
elif( option == 2):
numNodes= [0]
print( "Room is:")
for i in range(size):
print( initState[0][i])
print("Position of vacuum cleaner is " + str( initState[1][0]) + ',' + str(initState[1][1]))
startTime = time.process_time()
bfs( initState, path1, size, numNodes)
totalTime = time.process_time() - startTime
nodeSize = len(path1) + ( size*size ) + 2
totalCost = int((percentage * size * size)/100) + 2*len(path1)
print( "totalCost is " + str(totalCost))
print( "Number of nodes created are " + str(numNodes))
print( "Time taken " + str(totalTime))
print("Node size is " + str(nodeSize))
print( "Path is:")
print(path1)
elif( option ==3):
numNodes=[0]
from DirtGenerator import dirtGenerator
from dfs import *
from bfs import *
#initState = dirtGenerator(10)
initState = ([[0 for i in range(10)] for j in range(10)], [0,0])
initState[1][1] = 1
initState[1][0] = 1
initState[0][1][3] =1
for i in range(10):
print (initState[0][i])
print("position is " + str( initState[1][0]) + ',' + str(initState[1][1]))
path = []
bfs( initState, path)
print(path)
from bfs import * from graph import * from vertex import * g = Graph() g.addVertex(4) g.addVertex(7) g.addVertex(55) g.addVertex(12) g.addVertex(54) g.addEdge(4,7, "A") g.addEdge(7,55 , "B") g.addEdge(55,12, "C") g.addEdge(12,54, "D") g.addEdge(7,4, "A") g.addEdge(55,7, "B") g.addEdge(12,55, "C") g.addEdge(54,12, "D") bfs(g, 4)
def test_simpleHungarianCube(self):
cube = HungarianCube()
g = Graph(cube,hungrarianCubeOperators())
path = bfs(g,hungarianCubePredicate)
self.assertEquals(map(lambda x: x.data, path),[cube])
def wordLadders(wordsFile="words5.text"):
# 1. read the words file
# 2. build a graph based on the words file
# 3. user interaction loop:
# - request user to enter either two words (start and end word)
# or one word (start word) or 'q' (to quit)
# - check that the give word or words are in the dictionary
# - execute breadth first search from the start word's node
# (Note: you need to slightly modify the original bfs in bfs.py
# to set and update distance and parent properties of Nodes. This also
# requires modification of the Node class in basicgraph.py to add
# those properties.)
# - if an end word was given, extract word ladder from
# start to that endword
# - if an end word was not given, find the node in the graph
# with the largest distance value and extract the ladder between
# the start node and that node.
# - print appropriate information - the extracted ladder and its length
# code for 1. and 2. above goes here
graph, nodes, edges = buildWordGraph(wordsFile)
# code for 3. goes inside the while loop below
print("Created word graph with " + str(nodes) + " nodes and " +
str(edges) + " edges")
userInput = input(
"Enter start and end words OR start word OR 'q' to quit: ")
words = userInput.split()
while (words[0] != 'q'):
wordsLen = len(words)
counter = 0
for x in words:
for node in graph.nodes:
if (node.getName() == "['" + str(x) + "']"):
counter = counter + 1
if (wordsLen == counter):
bfs(graph, graph.getNode("['" + words[0] + "']"))
if (wordsLen == 1):
maximumNum = 0
for node in graph.nodes:
if node.getDist() >= maximumNum:
maximumNode = node
maximumNum = node.getDist()
lad, dist = extractWordLadder(
graph.getNode(maximumNode.getName()))
print(maximumNode.getName() + " is maximally distant (" +
str(dist) + " steps) from " + words[0])
print(lad)
if (wordsLen == 2):
lad, dist = extractWordLadder(
graph.getNode("['" + words[1] + "']"))
print("Shortest ladder from " + words[0] + " to " + words[1] +
" is length " + str(dist) + ":")
print(lad)
else:
print("Word/Words are not in dictionary")
userInput = input(
"Enter start and end words OR start word OR 'q' to quit: ")
words = userInput.split()
def test_path_found1(self):
path = ['s', 'e', 'r', 'f', 'g']
self.assertEqual(bfs('s', 'g', self.g1), path)
from sys import argv #import all the objects in initGraph, not just import initGraph from initGraph import * #from bfs import * from bfs import * from dfs import * from astar import * from datetime import datetime startTime = datetime.now() # the arguments from user inputs. script, city1, city2, routingopt, algoopt= argv #print G.node[city1] #print G.node[city2] # 'is' is to test if the two object is exactly the same, # while == is for the testing of the value of stings themselves. if algoopt == 'bfs': bfs(city1,city2,routingopt) elif algoopt == 'dfs': dfs(city1,city2,routingopt) elif algoopt == 'astar': astar(city1,city2,routingopt) else: print 'Only bfs, dfs, and astar are supported!' #print algoopt print 'Run time: %s'%(str(datetime.now() - startTime)) print '=================================================================='
from bfs import *
from dfs import *
from ids import *
# Code from this exercise all made by @skdGT
print("---- BFS -----")
node, tree = bfs(State2((3, 3, 1), (3, 3, 1), "Start"))
print("- Tree -")
tree.print_tree()
if node is not None:
path = find_path(node)
print("- Solution -")
print_path(path)
else:
print("- No Solution -")
print('\n\n\n\n\n\n')
print("---- DFS -----")
node, tree = dfs(State2((3, 3, 1), (3, 3, 1), "Start"))
print("- Tree -")
tree.print_tree()
if node is not None:
path = find_path(node)
print("- Solution -")
print_path(path)
else:
print("- No Solution -")
from bfs import *
# create dummy graph & driver test
my_graph = Graph()
my_graph.add_directed_edge('r', 's')
my_graph.add_directed_edge('t', 'u')
my_graph.add_directed_edge('w', 'x')
my_graph.add_directed_edge('x', 'y')
my_graph.add_directed_edge('r', 'v')
my_graph.add_directed_edge('s', 'w')
my_graph.add_directed_edge('t', 'x')
my_graph.add_directed_edge('u', 'y')
my_graph.add_directed_edge('t', 'w')
my_graph.add_directed_edge('u', 'x')
bfs_result = bfs(my_graph,'s')
print ("List of parents")
print(bfs_result[0])
print ("")
print ("List of distance from " + 's')
print(bfs_result[1])
print ("")
shortest_path(my_graph, 's', 'y')
def fs_tree(workflow_lines):
""" gives the fs tree as view in workflow begin """
w_lines_by_id = dict([(w_line._id, w_line) for w_line in workflow_lines])
def path_graph(dirs):
""" ["/a/b/c", "/a/b", "/a"] -> {"/a":"/a/b", "/a/b":"/a/b/c"} """
def pairwise(iterable):#this code is duplicated elsewhere
a, b = tee(iterable)
next(b, None)
return izip(a, b)
_graph = {}
if len(dirs) == 1:
_graph[dirs[0]] = None
else:
for (parent, child) in pairwise(reversed(dirs)):
_graph[parent] = child
return _graph
def clean_call(line_id):
w_line = w_lines_by_id[line_id]
return w_line.clean_call
parents_to_children = {}
created_paths = set()
the_graph = graph(workflow_lines)
#FIMXE this code does not add fake root to orphan nodes. so, bfs does not work properly.
#so, it is a hack to add the fake root
num_nodes = len(workflow_lines)
orphan_nodes = set(range(1, num_nodes + 1))#at the begin we think everyone is a orphan
for father, children in the_graph.iteritems():
for child in children:
if child in orphan_nodes:
orphan_nodes.remove(child)
#adding fake root
fake_root_id = 0
the_graph[fake_root_id] = []
for orphan in orphan_nodes:
the_graph[fake_root_id].append(orphan)
#NOTE: there is a corner case when handling open calls wiht O_CREAT flags, it's
#possible to know if the a proper creation or a ordinary open because posix
#allows one to call open with O_CREAT to a already created file. So, instead of
#complicate things other methods (accessed_and_created), we are going to evaluate
#open calls separately.
#files we are sure were open using O_CREAT but were created before
false_positive_ocreat = set()
#files we cannot answer if they were created before open(O_CREAT)
undefined_ocreat = set()
#files we are trying to check if they were created before or not
opentocreat_candidates = set()
for node_and_child in bfs(the_graph, 0):
child_id = int(node_and_child[1])
if (child_id == 0):
continue#argg
node_clean_call = clean_call(child_id)
if node_clean_call.call == "read" or \
node_clean_call.call == "llseek":
fullpath = node_clean_call.fullpath()
if fullpath in opentocreat_candidates:
#a path that receives a read or llseek beyond
#its position 0 before any write call should
#have been created before.
if long(node_clean_call.rvalue) > 0:
false_positive_ocreat.add(fullpath)
opentocreat_candidates.remove(fullpath)
elif node_clean_call.call == "write":
fullpath = node_clean_call.fullpath()
if fullpath in opentocreat_candidates:
#so, a file opened using O_CREAT flag receives a write
#we cannot decide if it is a false positive
opentocreat_candidates.remove(fullpath)
undefined_ocreat.add(fullpath)
elif node_clean_call.call == "open":
fullpath = node_clean_call.fullpath()
if open_to_create(node_clean_call) and \
not (fullpath in false_positive_ocreat) and \
not (fullpath in undefined_ocreat):
opentocreat_candidates.add(fullpath)
#It's possible to think directories are files, because they can be opened
#or llseeked for example. So, we collected things we know are directories
#during bfs walk, and do a check against the things we think are files but are not
known_dirs = set()
for node_and_child in bfs(the_graph, 0):
child_id = int(node_and_child[1])
if (child_id == 0):
continue#argg
node_clean_call = clean_call(child_id)
ac_dirs, ac_files, c_dirs, c_files = accessed_and_created(node_clean_call)
if (node_clean_call.call == "open") and open_to_create(node_clean_call):
if node_clean_call.fullpath() in false_positive_ocreat:
try:
if node_clean_call.fullpath() in c_files:
c_files.remove(node_clean_call.fullpath())
except ValueError:
sys.stderr.write(node_clean_call.fullpath())
sys.exit(1)
ac_files.append(node_clean_call.fullpath())
for _dir in ac_dirs:
known_dirs.add(_dir)
for _dir in c_dirs:
known_dirs.add(_dir)
for c_dir in c_dirs:
created_paths.add(c_dir)
for c_file in c_files:
created_paths.add(c_file)
for parent_dir, child_dir in path_graph(ac_dirs).iteritems():
if not parent_dir in created_paths:
if not (parent_dir, "d") in parents_to_children:
parents_to_children[(parent_dir, "d")] = set()
if child_dir:
if not child_dir in created_paths:
parents_to_children[(parent_dir, "d")].add((child_dir, "d"))
for a_file in ac_files:
if not a_file in created_paths:
parent = parent_path(a_file)
if not (parent, "d") in parents_to_children:
parents_to_children[(parent, "d")] = set()
parents_to_children[(parent, "d")].add((a_file, "f"))
#accessed_and_created method is not reliable, for example
#it is possible to directories be opened and closed, also llseeked
#for this reason, ac_files can return directories, to get over it
#we make a second pass to see if an acessed file was also identified as
#directory, if so, we change its type
#TODO is the conversely possible ? think a file is a directory
to_change_type = []
for parent, children in parents_to_children.iteritems():
for path, _type in children:
if _type is "f":
if path in known_dirs:
to_change_type.append((parent, (path, _type)))
for parent, child in to_change_type:
parents_to_children[parent].remove(child)
parents_to_children[parent].add((child[0], "d"))
return parents_to_children
def kevinbaconnumber(actor):
actors = open("actors.txt","r")
movies = open("movies.txt","r")
movieactors = open("movieactors.txt","r")
actordic = {}
actorlist = []
for aline in actors:
actorlist = aline.split("|")
editactor = actorlist[1].replace("\n","")
actordic[int(actorlist[0])] = editactor
actors = open("actors.txt","r")
revactordic = {}
revactorlist = []
for aline in actors:
revactorlist = aline.split("|")
editactorrev = revactorlist[1].replace("\n","")
revactordic[editactorrev] = int(revactorlist[0])
moviedic = {}
movielist = []
for aline in movies:
movielist = aline.split("|")
editmovie = movielist[1].replace("\n","")
moviedic[int(movielist[0])] = editmovie
madic = {}
malist = []
for aline in movieactors:
malist = aline.split("|")
editma = malist[1].replace("\n","")
if int(malist[0]) in madic:
madic[int(malist[0])].append(int(editma))
else:
madic[int(malist[0])] = []
madic[int(malist[0])].append(int(editma))
kbg = Graph()
actors = open("actors.txt","r")
actorlist = []
for aline in actors:
actorlist = aline.split("|")
kbg.addVertex(int(actorlist[0]))
movies= open("movieactors.txt","r")
movielist = []
for aline in movies:
movielist = aline.split("|")
movienum = int(movielist[0])
edges = madic[movienum]
while len(edges) >= 1:
for i in range(len(edges)-1):
kbg.addEdge(edges[0],edges[i+1],movienum)
kbg.addEdge(edges[i+1],edges[0],movienum)
edges.pop(0)
bfs(kbg,63)
if actor in revactordic:
if kbg.getVertex(revactordic[actor]).getDistance() > 2000:
print("This actor is not related to Kevin Bacon")
else:
vert = kbg.getVertex(revactordic[actor])
print("Kevin Bacon Number:",vert.getDistance())
actornum = revactordic[actor]
while actornum != 63:
nextactor = kbg.getVertex(actornum).getPred()
commonmovie = kbg.getVertex(actornum).getCost(nextactor)
print(actordic[actornum],"was in",moviedic[commonmovie],"which also starred")
actornum = nextactor.getId()
print("Kevin Bacon")
else:
print("This actor is not in our database (check spelling)")
def test_path_target_not_found1(self):
path = []
self.assertEqual(bfs('s', 'z', self.g1), None)
from mst import *
from sp import *
# BFS
s = 8
edges = [(0, 1, None),
(0, 2, None),
(2, 3, None),
(3, 4, None),
(3, 5, None),
(4, 5, None),
(4, 6, None),
(5, 7, None),
(6, 7, None)]
g = Graph(0, s, edges)
assert(bfs(g, 0) == [0, 1, 2, 3, 4, 5, 6 ,7])
# DFS
assert(dfs(g, 0) == [0, 1, 2, 3, 4, 5, 7, 6])
# Topological Sort
s = 9
edges = [(0, 1, None),
(0, 4, None),
(1, 2, None),
(1, 4, None),
(2, 7, None),
(3, 4, None),
(5, 2, None),
(5, 6, None),
(6, 7, None)]
def test_path_infinite_loop(self):
path = ['s', 'd', 'e', 'g']
self.assertEqual(bfs('s', 'g', self.g2), path)
def wordLadders(wordsFile):
global wordGraph # this is useful for debugging - you can "look" at wordGraph
# in the Python shell to determine if it's correct
# 1. read the words file and build a graph based on the words file
wordGraph = buildWordGraph(wordsFile)
print("Created word graph with {} nodes and {} edges".format(
len(wordGraph.nodes),
sum(len(adjList)
for adjList in wordGraph.adjacencyLists.values()) // 2))
# - check that the give word or words are in the dictionary
# - execute breadth first search from the start word's node
# (Note: you need to slightly modify the original bfs in bfs.py
# to set and update distance and parent properties of Nodes. This also
# requires modification of the Node class in basicgraph.py to add
# those properties.)
# - if an end word was given, extract word ladder from
# start to that endword
# - if an end word was not given, find the node in the graph
# with the largest distance value and extract the ladder between
# the start node and that node.
# - print appropriate information - the extracted ladder and its length
# 2. user interaction loop:
userInput = input(
"Enter start and end words OR start word OR 'q' to quit: ")
words = userInput.split()
while (words[0] != 'q'):
# make sure word or words are in the wordsFile (and thus now in graph)
startNode = wordGraph.getNode(words[0])
if (startNode is None):
print(
"The start word is not in the dictionary. Please try again.")
elif (len(words) == 2) and (wordGraph.getNode(words[1]) is None):
print("The end word is not in the dictionary. Please try again.")
elif (len(words) == 2) and (words[0] == words[1]):
print(
"The start and end words must be different. Please try again.")
else:
# Execute bread-first search from the startNode. This
# should set distance properties of all words reachable from start
# word, and also set "parent" properties appropriately.
bfs(wordGraph, startNode)
# If only one word was given, look through all nodes in the graph
# to find one with max distance property. That word is the one with
# the maximal "shortest distance" from start word.
if (len(words) == 1):
maxDistance = -1
for node in wordGraph.nodes:
dist = node.getDistance()
if dist is not None and dist >= maxDistance:
endNode = node
maxDistance = node.getDistance()
print("{} is maximally distant ({} steps) from {}:".format(
endNode.getName(), maxDistance, words[0]))
# If two words were given, execute extractWordLadder from node for
# second word, yielding a list of words representing the shortest
# path between start and end words.
else:
endNode = wordGraph.getNode(words[1])
if endNode.getParent() == None:
print("There is no word ladder from ", startNode.getName(),
" to ", endNode.getName())
else:
print("Shortest ladder from {} to {} is length {}:".format(
words[0], words[1], endNode.distance))
ladder = extractWordLadder(endNode)
for word in ladder:
print(word, end=" ")
print()
# Finally, ask for new start/end or start words or 'q'
userInput = input(
"Enter start and end words OR start word OR 'q' to quit: ")
words = userInput.split()
from eight import state
from bfs import *
from timeit import Timer
initial = state(None, [8,1,3,2,4,5,state.space,7,6], 0)
goal = state(None, [1,2,3,8,state.space,4,7,6,5])
print(initial)
f = lambda: bfs(initial, goal)
res = f()
print('has decision :', res[0])
print('open states :', res[2])
print('closed states :', res[3])
print('result path :')
for m in res[1]:
print(m)
t = Timer(f)
print("Time = ", t.timeit(number=100))
from init_database import *
from database_functions import *
from bfs import *
if __name__ == '__main__':
#create_info_table()
#create_links_table()
print('\n'.join(bfs('Minecraft', 'Gamecube')))
for row in con:
i = row[0]
j = row[1]
d = row[2]
distance_matrix[i][j] = d
distance_matrix[j][i] = d
#get a adjacency list
networklist = [[] for i in range(n)]
for row in con:
i = row[0]
j = row[1]
d = row[2]
networklist[i].append(j)
networklist[j].append(i)
bfs_test = bfs(networklist,2)
dfs_test = dfs(networklist,2)
print('Verticed for bfs: ',bfs_test)
print('Vertices for dfs: ',dfs_test)
#Results:
#Verticed for bfs: [2, 1, 5, 3, 0, 4, 7, 6]
#Vertices for dfs: [2, 3, 7, 6, 4, 0, 5, 1]
def test_bfs(self):
g = Graph('a',[op2])
path = bfs(g,goal_predicate1)
self.assertFalse(path is None)
self.assertTrue(['a', 'c', 'd'] == map(lambda x: x.data, path) or \
['a', 'b', 'd'] == map(lambda x: x.data, path))
