101 lines
2.9 KiB
Python
101 lines
2.9 KiB
Python
from abc import ABC, abstractmethod
|
|
from collections import deque
|
|
#Этап 1
|
|
class Cell:
|
|
def __init__(self, x, y, is_wall=False, is_start=False, is_exit=False):
|
|
self.x = x
|
|
self.y = y
|
|
self.is_wall = is_wall
|
|
self.is_start = is_start
|
|
self.is_exit = is_exit
|
|
|
|
def isPassable(self):
|
|
return not self.is_wall
|
|
|
|
class Maze:
|
|
def __init__(self, cells, width, height, start, exit):
|
|
self.width = width
|
|
self.height = height
|
|
self.cells =cells
|
|
self.start = start
|
|
self.exit = exit
|
|
|
|
def getCell(self, x, y):
|
|
if 0 <= x< self.width and 0 <=y< self.height:
|
|
return self.cells[y][x]
|
|
return None
|
|
|
|
def getNeighbors(self, cell: Cell):
|
|
neighbors = []
|
|
directions = [(0, -1), (0, 1), (-1, 0), (1, 0)]
|
|
|
|
for dir_x, dir_y in directions:
|
|
neigh_x = cell.x+dir_x
|
|
neigh_y = cell.y+dir_y
|
|
neighbor = self.getCell(neigh_x, neigh_y)
|
|
if neighbor and neighbor.isPassable():
|
|
neighbors.append(neighbor)
|
|
return neighbors
|
|
|
|
#Этап 2
|
|
class MazeBuilder(ABC):
|
|
@abstractmethod
|
|
def buildFromFile(self, filename):
|
|
pass
|
|
|
|
class TextFileMazeBuilder(MazeBuilder):
|
|
def buildFromFile(self, filename):
|
|
with open(filename, 'r') as f:
|
|
lines = [line.rstrip('\n') for line in f]
|
|
height = len(lines)
|
|
width = max(len(line) for line in lines)
|
|
|
|
grid=[]
|
|
start_cell=None
|
|
exit_cell=None
|
|
for y in range(height):
|
|
row=[]
|
|
for x in range(width):
|
|
char=lines[y][x]
|
|
|
|
is_wall = (char == '#')
|
|
is_start = (char == 'S')
|
|
is_exit = (char == 'E')
|
|
|
|
cell=Cell(x, y, is_wall, is_start, is_exit)
|
|
|
|
if is_start:
|
|
start_cell =cell
|
|
if is_exit:
|
|
exit_cell =cell
|
|
row.append(cell)
|
|
grid.append(row)
|
|
return Maze(grid, width, height, start_cell, exit_cell)
|
|
|
|
#Этап 3
|
|
class PathFindingStrategy(ABC):
|
|
@abstractmethod
|
|
def findPath(self,maze, start, exit):
|
|
pass
|
|
|
|
class BFS(PathFindingStrategy):
|
|
def findPath(self, maze, start, exit):
|
|
queue = deque([start])
|
|
travled_path={start: None}
|
|
while queue:
|
|
current = queue.popleft()
|
|
if current==exit:
|
|
path=[]
|
|
while current is not None:
|
|
path.append(current)
|
|
current = travled_path[current]
|
|
return path[::-1]
|
|
for neighbor in maze.getNeighbors(current):
|
|
if neighbor not in travled_path:
|
|
travled_path[neighbor] = current
|
|
queue.append(neighbor)
|
|
return []
|
|
|
|
class DFS(PathFindingStrategy):
|
|
def findPath(self, maze, start, exit):
|