def depth_first_search(mapa, inicio, fim):
aberto = []
fechado = []
no_inicio = No.No(inicio, None)
no_objetivo = No.No(fim, None)
aberto.append(no_inicio)
while len(aberto) > 0:
no_atual = aberto.pop(-1)
fechado.append(no_atual)
if no_atual == no_objetivo:
path = []
while no_atual != no_inicio:
path.append(no_atual.posicao)
no_atual = no_atual.pai
return path[::-1]
(x, y) = no_atual.posicao
vizinhos = [(x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1)]
for proximo in vizinhos:
valor_mapa = mapa.get(proximo)
if ((valor_mapa == '#') or (valor_mapa == '&')
or (valor_mapa == ' ')):
continue
vizinhos = No.No(proximo, no_atual)
if (vizinhos in fechado):
continue
if (vizinhos not in aberto):
aberto.append(vizinhos)
return None
def best_first_search(mapa, inicio, fim):
aberto = []
fechado = []
no_inicio = No.No(inicio, None)
objetivo = No.No(fim, None)
aberto.append(no_inicio)
while len(aberto) > 0:
aberto.sort()
no_atual = aberto.pop(0)
fechado.append(no_atual)
if no_atual == objetivo:
path = []
while no_atual != no_inicio:
path.append(no_atual.posicao)
no_atual = no_atual.pai
return path[::-1]
(x, y) = no_atual.posicao
vizinhos = [(x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1)]
for proximo in vizinhos:
valor = mapa.get(proximo)
if (valor == '#'):
continue
if (valor == '&'):
continue
if (valor == ' '):
continue
vizinho = No.No(proximo, no_atual)
if (vizinho in fechado):
continue
vizinho.g = abs(vizinho.posicao[0] -
no_inicio.posicao[0]) + abs(vizinho.posicao[1] -
no_inicio.posicao[1])
vizinho.h = abs(vizinho.posicao[0] -
objetivo.posicao[0]) + abs(vizinho.posicao[1] -
objetivo.posicao[1])
vizinho.f = vizinho.h
for no in aberto:
if (vizinho == no and vizinho.f > no.f):
continue
aberto.append(vizinho)
return None
def simulated_annealing(mapa, inicio, fim, T0=1000, N=15, alpha=0.999, k=1):
inicio_no = No.No(inicio, None)
objetivo_no = No.No(fim, None)
path = []
no_atual = inicio_no
(x, y) = no_atual.posicao
(goal_x, goal_y) = objetivo_no.posicao
path.append(no_atual.posicao)
while T0 > 2:
for j in range(N):
rand_amp = np.random.rand()
choose_x_y = np.random.rand()
step_x = 0
step_y = 0
if choose_x_y >= 0.5:
step_x = k * (1 if rand_amp < 0.5 else -1)
else:
step_y = -k * (1 if rand_amp < 0.5 else -1)
x_temporary = x + step_x
y_temporary = y + step_y
obj_mov_possible = (x_temporary - goal_x) ** 2 + (y_temporary - goal_y) ** 2
obj_val_current = (x_temporary - x) ** 2 + (y_temporary - y) ** 2
rand_factor = np.random.rand()
probality_eq = 1 / (np.exp((obj_mov_possible - obj_val_current) / T0))
content = mapa.get((x_temporary, y_temporary))
if ((content == '#') or (content == '&') or (content == ' ')):
continue
if (obj_mov_possible <= obj_val_current) | (rand_factor <= probality_eq):
no_atual = No.No((x, y), (x_temporary, y_temporary))
x = x_temporary
y = y_temporary
path.append(no_atual.posicao)
else:
if (obj_mov_possible <= obj_val_current) | (rand_factor <= probality_eq):
no_atual = No.No((x, y), (x_temporary, y_temporary))
x = x_temporary
y = y_temporary
path.append(no_atual.posicao)
else:
x = x
y = y
if no_atual == objetivo_no:
return path[::-1]
T0 = alpha * T0
return None
def depth_first_search(mapa, inicio, fim):
# Criar listas para nós abertos e nós fechados
aberto = []
fechado = []
# Crie um nó representando o inicio e o objetivo
no_inicio = No.No(inicio, None)
no_objetivo = No.No(fim, None)
# Adiciona nó inicial
aberto.append(no_inicio)
# Repetir até que a lista aberta esteja vazia
while len(aberto) > 0:
# Obtenha o último nó (LIFO)
no_atual = aberto.pop(-1)
# Adicione o nó atual à lista fechada
fechado.append(no_atual)
# Verifique se atingimos a meta, retorne o caminho
if no_atual == no_objetivo:
path = []
while no_atual != no_inicio:
path.append(no_atual.posicao)
no_atual = no_atual.pai
# Retornar caminho invertido
return path[::-1]
# Pega a posição atual do nó
(x, y) = no_atual.posicao
# Pega os vizinhos
vizinhos = [(x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1)]
# Loop nos vizinhos
for proximo in vizinhos:
# Pega valor do mapa
valor_mapa = mapa.get(proximo)
# Verifique se é uma parede, fantasma ou obstáculo
if ((valor_mapa == '#') or (valor_mapa == '&')
or (valor_mapa == ' ')):
continue
# Crie o nó vizinho
vizinhos = No.No(proximo, no_atual)
# Checa se o vizinho está em fechado
if (vizinhos in fechado):
continue
# Adicione o nó se não estiver aberto
if (vizinhos not in aberto):
aberto.append(vizinhos)
# Retorne vazio, não há caminho
return None
def breadth_first_search(mapa, inicio, fim):
# Criar listas para nós abertos e nós fechados
aberto = []
fechado = []
# Crie um nó representando o inicio e o objetivo
inicio_node = No.No(inicio, None)
objetivo = No.No(fim, None)
# Adiciona nó inicial
aberto.append(inicio_node)
# Repetir até que a lista aberta esteja vazia
while len(aberto) > 0:
# Pegue o primeiro nó (FIFO)
no_atual = aberto.pop(0)
# Adicione o nó atual à lista fechada
fechado.append(no_atual)
# Verifique se atingimos a meta, retorne o caminho
if no_atual == objetivo:
caminho = []
while no_atual != inicio_node:
caminho.append(no_atual.posicao)
no_atual = no_atual.pai
# Retornar caminho invertido
return caminho[::-1]
# Pega a posição atual do nó
(x, y) = no_atual.posicao
# Pega os vizinhos
vizinhos = [(x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1)]
# Loop nos vizinhos
for proximo in vizinhos:
# Pega valor do mapa
valor = mapa.get(proximo)
# Verifique se é uma parede, fantasma ou obstáculo
if (valor == '#') or (valor == '&') or (valor == ' '):
continue
# Crie o nó vizinho
vizinho = No.No(proximo, no_atual)
# Checa se o vizinho está em fechado
if (vizinho in fechado):
continue
# Adicione o nó se não estiver aberto
if (vizinho not in aberto):
aberto.append(vizinho)
return None
def aestrela(mapa, inicio, fim):
aberto = []
fechado = []
inicio_no = No.No(inicio, None)
objetivo_no = No.No(fim, None)
aberto.append(inicio_no)
while len(aberto) > 0:
aberto.sort()
no_atual = aberto.pop(0)
fechado.append(no_atual)
if no_atual == objetivo_no:
path = []
while no_atual != inicio_no:
path.append(no_atual.posicao)
no_atual = no_atual.pai
return path[::-1]
(x, y) = no_atual.posicao
vizinhos = [(x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1)]
for prox in vizinhos:
mapa_valor = mapa.get(prox)
if ((mapa_valor == '#') or (mapa_valor == '&')):
continue
vizinho = No.No(prox, no_atual)
if (vizinho in fechado):
continue
vizinho.g = abs(vizinho.posicao[0] -
inicio_no.posicao[0]) + abs(vizinho.posicao[1] -
inicio_no.posicao[1])
vizinho.h = abs(vizinho.posicao[0] - objetivo_no.posicao[0]) + abs(
vizinho.posicao[1] - objetivo_no.posicao[1])
vizinho.f = vizinho.g + vizinho.h
for no in aberto:
if (vizinho == no and vizinho.f > no.f):
continue
aberto.append(vizinho)
return None
def breadth_first_search(mapa, inicio, fim):
aberto = []
fechado = []
inicio_node = No.No(inicio, None)
objetivo = No.No(fim, None)
aberto.append(inicio_node)
while len(aberto) > 0:
no_atual = aberto.pop(0)
fechado.append(no_atual)
if no_atual == objetivo:
caminho = []
while no_atual != inicio_node:
caminho.append(no_atual.posicao)
no_atual = no_atual.pai
return caminho[::-1]
(x, y) = no_atual.posicao
vizinhos = [(x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1)]
for proximo in vizinhos:
valor = mapa.get(proximo)
if (valor == '#') or (valor == '&') or (valor == ' '):
continue
vizinho = No.No(proximo, no_atual)
if (vizinho in fechado):
continue
if (vizinho not in aberto):
aberto.append(vizinho)
return None
def aestrela(mapa, inicio, fim, heuristica):
# Criar listas para nós abertos e nós fechados
aberto = []
fechado = []
# Crie um nó representando o inicio e o objetivo
inicio_no = No.No(inicio, None)
objetivo_no = No.No(fim, None)
# Adiciona nó inicial
aberto.append(inicio_no)
# Repetir até que a lista aberta esteja vazia
while len(aberto) > 0:
# Ordene a lista aberta para obter o nó com o menor custo primeiro
aberto.sort()
# Obtenha o nó com o menor custo
no_atual = aberto.pop(0)
# Adicione o nó atual à lista fechada
fechado.append(no_atual)
# Verifique se atingimos a meta, retorne o caminho
if no_atual == objetivo_no:
path = []
while no_atual != inicio_no:
path.append(no_atual.posicao)
no_atual = no_atual.pai
# Retornar caminho invertido
return path[::-1]
# Pega a posição atual do nó
(x, y) = no_atual.posicao
# Pega os vizinhos
vizinhos = [(x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1)]
# Loop nos vizinhos
for prox in vizinhos:
# Pega valor do mapa
mapa_valor = mapa.get(prox)
# Verifique se é uma parede, fantasma ou obstáculo
if ((mapa_valor == '#') or (mapa_valor == '&')
or (mapa_valor == ' ')):
continue
# Crie o nó vizinho
vizinho = No.No(prox, no_atual)
if (vizinho in fechado):
continue
# Gera heurísticas
if (heuristica == 1):
# Distância de Manhattan
vizinho.g = h.distancia_manhattan(vizinho.posicao[0],
inicio_no.posicao[0],
vizinho.posicao[1],
inicio_no.posicao[1])
vizinho.h = h.distancia_manhattan(vizinho.posicao[0],
objetivo_no.posicao[0],
vizinho.posicao[1],
objetivo_no.posicao[1])
else:
# Distância de Euclides
vizinho.g = h.euclidiano(vizinho.posicao[0],
inicio_no.posicao[0],
vizinho.posicao[1],
inicio_no.posicao[1])
vizinho.h = h.euclidiano(vizinho.posicao[0],
objetivo_no.posicao[0],
vizinho.posicao[1],
objetivo_no.posicao[1])
vizinho.f = vizinho.g + vizinho.h # Custo total é o somatório do inicio mais a heurística
# Verifique se o vizinho deve ser adicionado à lista aberta
for no in aberto:
if (vizinho == no and vizinho.f > no.f):
continue
aberto.append(vizinho)
# Retorne vazio, não há caminho
return None