# Baixo
next = lb.get_bottom(labyrinth, cur, prev) # [cur[0] + 1, cur[1]]
if next != None:
queue.append(next)
prev[next[0]][next[1]] = cur
# Esquerda
next = lb.get_left(labyrinth, cur, prev) # [cur[0], cur[1] - 1]
if next != None:
queue.append(next)
prev[next[0]][next[1]] = cur
# Cima
next = lb.get_top(labyrinth, cur, prev) # [cur[0] - 1, cur[1]]
if next != None:
queue.append(next)
prev[next[0]][next[1]] = cur
# Gera o caminho a partir da matriz de predecessores
path = lb.prev_to_path(prev, start, end)
# Retorna um objeto com os resultados
if found:
return lb.Result(path, found_time - begin_time)
return lb.Result(None, None)
if __name__ == '__main__':
# Chama a execução padrão do algoritmo
lb.execute_algorithm(bfs)
if next_dist < cur_dist:
best = next
cur_dist = next_dist
# "Sobe para a colina mais alta", se best for igual a None é porque o algoritmo
# chegou em um melhor local, como não estamos usando backtracking ele deve parar
if best != None:
# Marca o antecessor do proximo elemento como sendo o atual
prev[best[0]][best[1]] = [cur[0], cur[1]]
cur = best
else:
# Marca o tempo que o algoritmo finalizou
found_time = time.time()
break
# Gera o caminho a partir da matriz de predecessores
# Nota-se que passamos cur ao invés de end para a função,
# Isso é feito para podermos checar o melhor local encontrado
# pelo algoritmo, já que muitas vezes ele não é capaz de achar
# o melhor global
path = lb.prev_to_path(prev, start, cur)
# Retorna um objeto com os resultados
return lb.Result(path, found_time - begin_time)
if __name__ == '__main__':
# Chama a execução padrão do algoritmo
lb.execute_algorithm(hill_climbing)
next = lb.get_bottom(labyrinth, cur, prev) # [cur[0] + 1, cur[1]]
if next != None:
stack.append(next)
prev[next[0]][next[1]] = cur
# Esquerda
next = lb.get_left(labyrinth, cur, prev) # [cur[0], cur[1] - 1]
if next != None:
stack.append(next)
prev[next[0]][next[1]] = cur
# Cima
next = lb.get_top(labyrinth, cur, prev) # [cur[0] - 1, cur[1]]
if next != None:
stack.append(next)
prev[next[0]][next[1]] = cur
# Gera o caminho a partir da matriz de predecessores
path = lb.prev_to_path(prev, start, end)
# Retorna um objeto com os resultados
if found:
return lb.Result(path, found_time - begin_time)
return lb.Result(None, None)
if __name__ == '__main__':
# Chama a execução padrão do algoritmo
lb.execute_algorithm(dfs)
# Baixo
next = lb.get_bottom(labyrinth, cur, prev) # [cur[0] + 1, cur[1]]
if next != None:
p_queue.append(next)
prev[next[0]][next[1]] = cur
# Esquerda
next = lb.get_left(labyrinth, cur, prev) # [cur[0], cur[1] - 1]
if next != None and prev[next[0]][next[1]] == [-1, -1]:
p_queue.append(next)
prev[next[0]][next[1]] = cur
# Cima
next = lb.get_top(labyrinth, cur, prev) # [cur[0] - 1, cur[1]]
if next != None and prev[next[0]][next[1]] == [-1, -1]:
p_queue.append(next)
prev[next[0]][next[1]] = cur
# Gera o caminho a partir da matriz de predecessores
path = lb.prev_to_path(prev, start, end)
# Retorna um objeto com os resultados
if found:
return lb.Result(path, found_time - begin_time)
return lb.Result(None, None)
if __name__ == '__main__':
# Chama a execução padrão do algoritmo
lb.execute_algorithm(best_first_search)
prev_dist[next[0]][next[1]] = dist + 1
# Esquerda
next = lb.get_left(labyrinth, cur, prev) # [cur[0], cur[1] - 1, distância]
if next != None:
next = [next[0], next[1], dist + 1]
p_queue.append(next)
prev[next[0]][next[1]] = [cur[0], cur[1]]
prev_dist[next[0]][next[1]] = dist + 1
# Cima
next = lb.get_top(labyrinth, cur, prev) # [cur[0] - 1, cur[1], distância]
if next != None:
next = [next[0], next[1], dist + 1]
p_queue.append(next)
prev[next[0]][next[1]] = [cur[0], cur[1]]
prev_dist[next[0]][next[1]] = dist + 1
# Gera o caminho a partir da matriz de predecessores
path = lb.prev_to_path(prev, start, end)
# Retorna um objeto com os resultados
if found:
return lb.Result(path, found_time - begin_time)
return lb.Result(None, None)
if __name__ == '__main__':
# Chama a execução padrão do algoritmo
lb.execute_algorithm(a_star)