156 lines
4.1 KiB
Python
156 lines
4.1 KiB
Python
from abc import ABC, abstractmethod
|
|
from collections import deque
|
|
import heapq
|
|
|
|
class PathFindingStrategy(ABC):
|
|
@abstractmethod
|
|
def findPath(self, maze, start, exit_cell):
|
|
pass
|
|
def restorePath(
|
|
self,
|
|
parent,
|
|
start,
|
|
exit_cell
|
|
):
|
|
path = []
|
|
current = exit_cell
|
|
while current != start:
|
|
path.append(current)
|
|
current = parent[current]
|
|
path.append(start)
|
|
path.reverse()
|
|
return path
|
|
class BFSStrategy(PathFindingStrategy):
|
|
def findPath(
|
|
self,
|
|
maze,
|
|
start,
|
|
exit_cell
|
|
):
|
|
queue = deque([start])
|
|
visited = {start}
|
|
parent = {}
|
|
while queue:
|
|
current = queue.popleft()
|
|
if current == exit_cell:
|
|
return (
|
|
self.restorePath(
|
|
parent,
|
|
start,
|
|
exit_cell),
|
|
len(visited)
|
|
)
|
|
for neighbor in maze.getNeighbors(current):
|
|
if neighbor not in visited:
|
|
visited.add(
|
|
neighbor
|
|
)
|
|
parent[
|
|
neighbor
|
|
] = current
|
|
queue.append(
|
|
neighbor
|
|
)
|
|
return [], len(visited)
|
|
|
|
class DFSStrategy(PathFindingStrategy):
|
|
def findPath(
|
|
self,
|
|
maze,
|
|
start,
|
|
exit_cell
|
|
):
|
|
stack = [start]
|
|
visited = {start}
|
|
parent = {}
|
|
while stack:
|
|
current = stack.pop()
|
|
if current == exit_cell:
|
|
return (self.restorePath
|
|
(
|
|
parent,
|
|
start,
|
|
exit_cell),
|
|
len(visited)
|
|
)
|
|
for neighbor in maze.getNeighbors(current):
|
|
if neighbor not in visited:
|
|
visited.add(
|
|
neighbor
|
|
)
|
|
parent[
|
|
neighbor
|
|
] = current
|
|
|
|
stack.append(
|
|
neighbor
|
|
)
|
|
return [], len(visited)
|
|
|
|
class AStarStrategy(PathFindingStrategy):
|
|
def heuristic(
|
|
self,
|
|
cell,
|
|
exit_cell
|
|
):
|
|
return (abs(cell.x - exit_cell.x) + abs(cell.y - exit_cell.y))
|
|
def findPath(
|
|
self,
|
|
maze,
|
|
start,
|
|
exit_cell
|
|
):
|
|
pq = []
|
|
heapq.heappush(
|
|
pq,
|
|
(
|
|
0,
|
|
id(start),
|
|
start
|
|
)
|
|
)
|
|
parent = {}
|
|
g_score = {
|
|
start: 0
|
|
}
|
|
visited = set()
|
|
while pq:
|
|
_, _, current = (
|
|
heapq.heappop(
|
|
pq
|
|
)
|
|
)
|
|
if current in visited:
|
|
continue
|
|
visited.add(
|
|
current
|
|
)
|
|
if current == exit_cell:
|
|
return (self.restorePath(
|
|
parent,
|
|
start,
|
|
exit_cell),
|
|
len(visited)
|
|
)
|
|
for neighbor in maze.getNeighbors(current):
|
|
new_cost = (
|
|
g_score[current]
|
|
+ 1
|
|
)
|
|
if (neighbor not in g_score or new_cost < g_score[neighbor] ):
|
|
g_score[neighbor
|
|
] = new_cost
|
|
parent[
|
|
neighbor
|
|
] = current
|
|
priority = (new_cost + self.heuristic(neighbor, exit_cell)
|
|
)
|
|
heapq.heappush(
|
|
pq,
|
|
(
|
|
priority,
|
|
id(neighbor),
|
|
neighbor
|
|
)
|
|
)
|
|
return [], len(visited) |