843 lines
30 KiB
Python
843 lines
30 KiB
Python
|
"""
|
|||
|
|
Лабораторная работа: Применение паттернов проектирования
|
|||
|
|
Этапы 1-6: Модель лабиринта, Builder, Strategy, MazeSolver, Observer/Command, эксперименты
|
|||
|
|
"""
|
|||
|
|
|
|||
|
|
import time
|
|||
|
|
import csv
|
|||
|
|
import random
|
|||
|
|
from collections import deque
|
|||
|
|
from typing import List, Tuple, Dict, Set, Optional
|
|||
|
|
import heapq
|
|||
|
|
from dataclasses import dataclass
|
|||
|
|
from abc import ABC, abstractmethod
|
|||
|
|
|
|||
|
|
# ============================================================
|
|||
|
|
# Этап 1. Модель лабиринта
|
|||
|
|
# ============================================================
|
|||
|
|
class Cell:
|
|||
|
|
"""Клетка лабиринта."""
|
|||
|
|
def __init__(self, x: int, y: int, is_wall: bool = False, weight: int = 1):
|
|||
|
|
self.x = x
|
|||
|
|
self.y = y
|
|||
|
|
self.is_wall = is_wall
|
|||
|
|
self.is_start = False
|
|||
|
|
self.is_exit = False
|
|||
|
|
self.weight = weight # для взвешенных лабиринтов
|
|||
|
|
|
|||
|
|
def is_passable(self) -> bool:
|
|||
|
|
return not self.is_wall
|
|||
|
|
|
|||
|
|
def __eq__(self, other):
|
|||
|
|
return isinstance(other, Cell) and self.x == other.x and self.y == other.y
|
|||
|
|
|
|||
|
|
def __hash__(self):
|
|||
|
|
return hash((self.x, self.y))
|
|||
|
|
|
|||
|
|
def __repr__(self):
|
|||
|
|
return f"Cell({self.x},{self.y})"
|
|||
|
|
|
|||
|
|
|
|||
|
|
class Maze:
|
|||
|
|
"""Лабиринт, содержащий сетку клеток."""
|
|||
|
|
def __init__(self, width: int, height: int):
|
|||
|
|
self.width = width
|
|||
|
|
self.height = height
|
|||
|
|
self.cells = [[Cell(x, y) for x in range(width)] for y in range(height)]
|
|||
|
|
self.start_cell = None
|
|||
|
|
self.exit_cell = None
|
|||
|
|
|
|||
|
|
def get_cell(self, x: int, y: int) -> Cell:
|
|||
|
|
if 0 <= x < self.width and 0 <= y < self.height:
|
|||
|
|
return self.cells[y][x]
|
|||
|
|
raise IndexError("Координаты вне границ лабиринта")
|
|||
|
|
|
|||
|
|
def get_neighbors(self, cell: Cell) -> List[Cell]:
|
|||
|
|
"""Возвращает список соседних проходимых клеток (вверх, вниз, влево, вправо)."""
|
|||
|
|
neighbors = []
|
|||
|
|
for dx, dy in [(0, -1), (0, 1), (-1, 0), (1, 0)]:
|
|||
|
|
nx, ny = cell.x + dx, cell.y + dy
|
|||
|
|
if 0 <= nx < self.width and 0 <= ny < self.height:
|
|||
|
|
n = self.cells[ny][nx]
|
|||
|
|
if n.is_passable():
|
|||
|
|
neighbors.append(n)
|
|||
|
|
return neighbors
|
|||
|
|
|
|||
|
|
def set_start(self, x: int, y: int):
|
|||
|
|
cell = self.get_cell(x, y)
|
|||
|
|
cell.is_start = True
|
|||
|
|
self.start_cell = cell
|
|||
|
|
|
|||
|
|
def set_exit(self, x: int, y: int):
|
|||
|
|
cell = self.get_cell(x, y)
|
|||
|
|
cell.is_exit = True
|
|||
|
|
self.exit_cell = cell
|
|||
|
|
|
|||
|
|
def copy(self):
|
|||
|
|
"""Создаёт глубокую копию лабиринта (для взвешенных вариантов)."""
|
|||
|
|
new_maze = Maze(self.width, self.height)
|
|||
|
|
for y in range(self.height):
|
|||
|
|
for x in range(self.width):
|
|||
|
|
orig = self.cells[y][x]
|
|||
|
|
new_maze.cells[y][x] = Cell(x, y, orig.is_wall, orig.weight)
|
|||
|
|
if orig.is_start:
|
|||
|
|
new_maze.set_start(x, y)
|
|||
|
|
if orig.is_exit:
|
|||
|
|
new_maze.set_exit(x, y)
|
|||
|
|
return new_maze
|
|||
|
|
|
|||
|
|
|
|||
|
|
# ============================================================
|
|||
|
|
# Этап 2. Builder для загрузки из текстового файла
|
|||
|
|
# ============================================================
|
|||
|
|
class MazeBuilder(ABC):
|
|||
|
|
@abstractmethod
|
|||
|
|
def build_from_file(self, filename: str) -> Maze:
|
|||
|
|
pass
|
|||
|
|
|
|||
|
|
|
|||
|
|
class TextFileMazeBuilder(MazeBuilder):
|
|||
|
|
"""Строитель лабиринта из текстового файла."""
|
|||
|
|
def build_from_file(self, filename: str) -> Maze:
|
|||
|
|
with open(filename, 'r', encoding='utf-8') as f:
|
|||
|
|
lines = [line.rstrip('\n') for line in f]
|
|||
|
|
|
|||
|
|
if not lines:
|
|||
|
|
raise ValueError("Файл пуст")
|
|||
|
|
|
|||
|
|
height = len(lines)
|
|||
|
|
width = max(len(line) for line in lines)
|
|||
|
|
|
|||
|
|
grid = []
|
|||
|
|
for y, line in enumerate(lines):
|
|||
|
|
row = []
|
|||
|
|
for x in range(width):
|
|||
|
|
ch = line[x] if x < len(line) else ' '
|
|||
|
|
row.append(ch)
|
|||
|
|
grid.append(row)
|
|||
|
|
|
|||
|
|
maze = Maze(width, height)
|
|||
|
|
start_found = exit_found = False
|
|||
|
|
|
|||
|
|
for y in range(height):
|
|||
|
|
for x in range(width):
|
|||
|
|
ch = grid[y][x]
|
|||
|
|
cell = maze.get_cell(x, y)
|
|||
|
|
|
|||
|
|
if ch == '#':
|
|||
|
|
cell.is_wall = True
|
|||
|
|
elif ch == 'S':
|
|||
|
|
if start_found:
|
|||
|
|
raise ValueError("Обнаружено несколько стартовых клеток 'S'")
|
|||
|
|
cell.is_start = True
|
|||
|
|
maze.start_cell = cell
|
|||
|
|
start_found = True
|
|||
|
|
elif ch == 'E':
|
|||
|
|
if exit_found:
|
|||
|
|
raise ValueError("Обнаружено несколько выходных клеток 'E'")
|
|||
|
|
cell.is_exit = True
|
|||
|
|
maze.exit_cell = cell
|
|||
|
|
exit_found = True
|
|||
|
|
elif ch != ' ':
|
|||
|
|
raise ValueError(f"Недопустимый символ '{ch}' в позиции ({x},{y})")
|
|||
|
|
|
|||
|
|
if not start_found:
|
|||
|
|
raise ValueError("Отсутствует стартовая клетка 'S'")
|
|||
|
|
if not exit_found:
|
|||
|
|
raise ValueError("Отсутствует выходная клетка 'E'")
|
|||
|
|
|
|||
|
|
return maze
|
|||
|
|
|
|||
|
|
|
|||
|
|
# ============================================================
|
|||
|
|
# Этап 3. Стратегии поиска пути (возвращают путь и число посещённых)
|
|||
|
|
# ============================================================
|
|||
|
|
class PathFindingStrategy(ABC):
|
|||
|
|
@abstractmethod
|
|||
|
|
def find_path(self, maze: Maze, start: Cell, exit_cell: Cell) -> Tuple[List[Cell], int]:
|
|||
|
|
"""Возвращает (путь, количество посещённых клеток)."""
|
|||
|
|
pass
|
|||
|
|
|
|||
|
|
|
|||
|
|
class BFSStrategy(PathFindingStrategy):
|
|||
|
|
"""Поиск в ширину – гарантирует кратчайший путь."""
|
|||
|
|
def find_path(self, maze: Maze, start: Cell, exit_cell: Cell) -> Tuple[List[Cell], int]:
|
|||
|
|
if start == exit_cell:
|
|||
|
|
return [start], 1
|
|||
|
|
|
|||
|
|
queue = deque([start])
|
|||
|
|
visited = {start}
|
|||
|
|
parent = {start: None}
|
|||
|
|
visited_count = 1
|
|||
|
|
|
|||
|
|
while queue:
|
|||
|
|
cur = queue.popleft()
|
|||
|
|
if cur == exit_cell:
|
|||
|
|
path = []
|
|||
|
|
while cur is not None:
|
|||
|
|
path.append(cur)
|
|||
|
|
cur = parent[cur]
|
|||
|
|
path.reverse()
|
|||
|
|
return path, visited_count
|
|||
|
|
|
|||
|
|
for nb in maze.get_neighbors(cur):
|
|||
|
|
if nb not in visited:
|
|||
|
|
visited.add(nb)
|
|||
|
|
visited_count += 1
|
|||
|
|
parent[nb] = cur
|
|||
|
|
queue.append(nb)
|
|||
|
|
|
|||
|
|
return [], visited_count
|
|||
|
|
|
|||
|
|
|
|||
|
|
class DFSStrategy(PathFindingStrategy):
|
|||
|
|
"""Поиск в глубину – быстрый, но не гарантирует кратчайший путь."""
|
|||
|
|
def find_path(self, maze: Maze, start: Cell, exit_cell: Cell) -> Tuple[List[Cell], int]:
|
|||
|
|
if start == exit_cell:
|
|||
|
|
return [start], 1
|
|||
|
|
|
|||
|
|
stack = [(start, [start])]
|
|||
|
|
visited = set()
|
|||
|
|
visited_count = 0
|
|||
|
|
|
|||
|
|
while stack:
|
|||
|
|
cur, path = stack.pop()
|
|||
|
|
if cur in visited:
|
|||
|
|
continue
|
|||
|
|
visited.add(cur)
|
|||
|
|
visited_count += 1
|
|||
|
|
|
|||
|
|
if cur == exit_cell:
|
|||
|
|
return path, visited_count
|
|||
|
|
|
|||
|
|
for nb in maze.get_neighbors(cur):
|
|||
|
|
if nb not in visited:
|
|||
|
|
stack.append((nb, path + [nb]))
|
|||
|
|
|
|||
|
|
return [], visited_count
|
|||
|
|
|
|||
|
|
|
|||
|
|
class AStarStrategy(PathFindingStrategy):
|
|||
|
|
"""А* с эвристикой Манхэттенского расстояния."""
|
|||
|
|
def _heuristic(self, a: Cell, b: Cell) -> float:
|
|||
|
|
return abs(a.x - b.x) + abs(a.y - b.y)
|
|||
|
|
|
|||
|
|
def find_path(self, maze: Maze, start: Cell, exit_cell: Cell) -> Tuple[List[Cell], int]:
|
|||
|
|
if start == exit_cell:
|
|||
|
|
return [start], 1
|
|||
|
|
|
|||
|
|
open_set = []
|
|||
|
|
counter = 0
|
|||
|
|
heapq.heappush(open_set, (0, counter, start))
|
|||
|
|
g_score = {start: 0}
|
|||
|
|
f_score = {start: self._heuristic(start, exit_cell)}
|
|||
|
|
parent = {start: None}
|
|||
|
|
visited_count = 1
|
|||
|
|
|
|||
|
|
while open_set:
|
|||
|
|
_, _, cur = heapq.heappop(open_set)
|
|||
|
|
if cur == exit_cell:
|
|||
|
|
path = []
|
|||
|
|
while cur is not None:
|
|||
|
|
path.append(cur)
|
|||
|
|
cur = parent[cur]
|
|||
|
|
path.reverse()
|
|||
|
|
return path, visited_count
|
|||
|
|
|
|||
|
|
for nb in maze.get_neighbors(cur):
|
|||
|
|
move_cost = nb.weight
|
|||
|
|
tentative = g_score[cur] + move_cost
|
|||
|
|
if nb not in g_score or tentative < g_score[nb]:
|
|||
|
|
parent[nb] = cur
|
|||
|
|
g_score[nb] = tentative
|
|||
|
|
f_score[nb] = tentative + self._heuristic(nb, exit_cell)
|
|||
|
|
counter += 1
|
|||
|
|
heapq.heappush(open_set, (f_score[nb], counter, nb))
|
|||
|
|
visited_count += 1
|
|||
|
|
|
|||
|
|
return [], visited_count
|
|||
|
|
|
|||
|
|
|
|||
|
|
class DijkstraStrategy(PathFindingStrategy):
|
|||
|
|
"""Алгоритм Дейкстры для взвешенных графов."""
|
|||
|
|
def find_path(self, maze: Maze, start: Cell, exit_cell: Cell) -> Tuple[List[Cell], int]:
|
|||
|
|
if start == exit_cell:
|
|||
|
|
return [start], 1
|
|||
|
|
|
|||
|
|
pq = []
|
|||
|
|
counter = 0
|
|||
|
|
heapq.heappush(pq, (0, counter, start))
|
|||
|
|
dist = {start: 0}
|
|||
|
|
parent = {start: None}
|
|||
|
|
visited_count = 1
|
|||
|
|
|
|||
|
|
while pq:
|
|||
|
|
cur_dist, _, cur = heapq.heappop(pq)
|
|||
|
|
if cur_dist > dist.get(cur, float('inf')):
|
|||
|
|
continue
|
|||
|
|
|
|||
|
|
if cur == exit_cell:
|
|||
|
|
path = []
|
|||
|
|
while cur is not None:
|
|||
|
|
path.append(cur)
|
|||
|
|
cur = parent[cur]
|
|||
|
|
path.reverse()
|
|||
|
|
return path, visited_count
|
|||
|
|
|
|||
|
|
for nb in maze.get_neighbors(cur):
|
|||
|
|
new_dist = cur_dist + nb.weight
|
|||
|
|
if new_dist < dist.get(nb, float('inf')):
|
|||
|
|
dist[nb] = new_dist
|
|||
|
|
parent[nb] = cur
|
|||
|
|
counter += 1
|
|||
|
|
heapq.heappush(pq, (new_dist, counter, nb))
|
|||
|
|
visited_count += 1
|
|||
|
|
|
|||
|
|
return [], visited_count
|
|||
|
|
|
|||
|
|
|
|||
|
|
# ============================================================
|
|||
|
|
# Этап 4. MazeSolver (оркестратор)
|
|||
|
|
# ============================================================
|
|||
|
|
@dataclass
|
|||
|
|
class SearchStats:
|
|||
|
|
path_length: int
|
|||
|
|
visited_cells: int
|
|||
|
|
time_ms: float
|
|||
|
|
|
|||
|
|
|
|||
|
|
class MazeSolver:
|
|||
|
|
"""Оркестратор: управляет лабиринтом и стратегией поиска."""
|
|||
|
|
def __init__(self, maze: Maze, strategy: PathFindingStrategy):
|
|||
|
|
self.maze = maze
|
|||
|
|
self.strategy = strategy
|
|||
|
|
|
|||
|
|
def set_strategy(self, strategy: PathFindingStrategy):
|
|||
|
|
self.strategy = strategy
|
|||
|
|
|
|||
|
|
def solve(self) -> SearchStats:
|
|||
|
|
start_time = time.perf_counter()
|
|||
|
|
path, visited = self.strategy.find_path(self.maze, self.maze.start_cell, self.maze.exit_cell)
|
|||
|
|
end_time = time.perf_counter()
|
|||
|
|
return SearchStats(len(path), visited, (end_time - start_time) * 1000.0)
|
|||
|
|
|
|||
|
|
|
|||
|
|
# ============================================================
|
|||
|
|
# Этап 5. Observer и Command (визуализация и пошаговое управление)
|
|||
|
|
# ============================================================
|
|||
|
|
class Observer(ABC):
|
|||
|
|
@abstractmethod
|
|||
|
|
def update(self, event: str, data: dict = None):
|
|||
|
|
pass
|
|||
|
|
|
|||
|
|
|
|||
|
|
class ConsoleView(Observer):
|
|||
|
|
"""Отображает лабиринт, позицию игрока и найденный путь."""
|
|||
|
|
def __init__(self):
|
|||
|
|
self.last_maze = None
|
|||
|
|
self.last_player_pos = None
|
|||
|
|
self.last_path = None
|
|||
|
|
|
|||
|
|
def update(self, event: str, data: dict = None):
|
|||
|
|
if event == "maze_loaded":
|
|||
|
|
self.last_maze = data["maze"]
|
|||
|
|
self.render()
|
|||
|
|
elif event == "player_moved":
|
|||
|
|
self.last_maze = data["maze"]
|
|||
|
|
self.last_player_pos = data["player_pos"]
|
|||
|
|
self.render()
|
|||
|
|
elif event == "path_found":
|
|||
|
|
self.last_path = data["path"]
|
|||
|
|
self.render()
|
|||
|
|
elif event == "clear_path":
|
|||
|
|
self.last_path = None
|
|||
|
|
self.render()
|
|||
|
|
|
|||
|
|
def render(self):
|
|||
|
|
if self.last_maze is None:
|
|||
|
|
print("Нет лабиринта для отображения")
|
|||
|
|
return
|
|||
|
|
|
|||
|
|
maze = self.last_maze
|
|||
|
|
player = self.last_player_pos
|
|||
|
|
path_set = set(self.last_path) if self.last_path else set()
|
|||
|
|
|
|||
|
|
for y in range(maze.height):
|
|||
|
|
row = []
|
|||
|
|
for x in range(maze.width):
|
|||
|
|
cell = maze.get_cell(x, y)
|
|||
|
|
if player and cell == player:
|
|||
|
|
row.append('@')
|
|||
|
|
elif cell == maze.start_cell:
|
|||
|
|
row.append('S')
|
|||
|
|
elif cell == maze.exit_cell:
|
|||
|
|
row.append('E')
|
|||
|
|
elif cell in path_set and cell.is_passable():
|
|||
|
|
row.append('*')
|
|||
|
|
elif cell.is_wall:
|
|||
|
|
row.append('#')
|
|||
|
|
else:
|
|||
|
|
row.append(' ')
|
|||
|
|
print(''.join(row))
|
|||
|
|
print()
|
|||
|
|
|
|||
|
|
|
|||
|
|
class Player:
|
|||
|
|
"""Игрок, перемещающийся по лабиринту."""
|
|||
|
|
def __init__(self, start_cell: Cell):
|
|||
|
|
self.position = start_cell
|
|||
|
|
|
|||
|
|
def move_to(self, new_cell: Cell):
|
|||
|
|
self.position = new_cell
|
|||
|
|
|
|||
|
|
|
|||
|
|
class Command(ABC):
|
|||
|
|
@abstractmethod
|
|||
|
|
def execute(self) -> bool:
|
|||
|
|
pass
|
|||
|
|
|
|||
|
|
@abstractmethod
|
|||
|
|
def undo(self):
|
|||
|
|
pass
|
|||
|
|
|
|||
|
|
|
|||
|
|
class MoveCommand(Command):
|
|||
|
|
"""Команда перемещения игрока."""
|
|||
|
|
def __init__(self, player: Player, maze: Maze, direction: str):
|
|||
|
|
self.player = player
|
|||
|
|
self.maze = maze
|
|||
|
|
self.direction = direction
|
|||
|
|
self.prev_position = player.position
|
|||
|
|
self.new_position = None
|
|||
|
|
|
|||
|
|
def execute(self) -> bool:
|
|||
|
|
dx, dy = 0, 0
|
|||
|
|
if self.direction == 'W':
|
|||
|
|
dy = -1
|
|||
|
|
elif self.direction == 'S':
|
|||
|
|
dy = 1
|
|||
|
|
elif self.direction == 'A':
|
|||
|
|
dx = -1
|
|||
|
|
elif self.direction == 'D':
|
|||
|
|
dx = 1
|
|||
|
|
else:
|
|||
|
|
return False
|
|||
|
|
|
|||
|
|
nx = self.player.position.x + dx
|
|||
|
|
ny = self.player.position.y + dy
|
|||
|
|
try:
|
|||
|
|
target = self.maze.get_cell(nx, ny)
|
|||
|
|
if target.is_passable():
|
|||
|
|
self.new_position = target
|
|||
|
|
self.player.move_to(target)
|
|||
|
|
return True
|
|||
|
|
except IndexError:
|
|||
|
|
pass
|
|||
|
|
return False
|
|||
|
|
|
|||
|
|
def undo(self):
|
|||
|
|
if self.prev_position:
|
|||
|
|
self.player.move_to(self.prev_position)
|
|||
|
|
|
|||
|
|
|
|||
|
|
class GameController:
|
|||
|
|
"""Управляет игрой, наблюдателями и командами."""
|
|||
|
|
def __init__(self, maze: Maze):
|
|||
|
|
self.maze = maze
|
|||
|
|
self.player = Player(maze.start_cell)
|
|||
|
|
self.observers = []
|
|||
|
|
self.command_stack = []
|
|||
|
|
|
|||
|
|
def attach(self, observer: Observer):
|
|||
|
|
self.observers.append(observer)
|
|||
|
|
|
|||
|
|
def detach(self, observer: Observer):
|
|||
|
|
self.observers.remove(observer)
|
|||
|
|
|
|||
|
|
def notify(self, event: str, data: dict = None):
|
|||
|
|
for obs in self.observers:
|
|||
|
|
obs.update(event, data or {})
|
|||
|
|
|
|||
|
|
def load_maze(self, maze: Maze):
|
|||
|
|
self.maze = maze
|
|||
|
|
self.player = Player(maze.start_cell)
|
|||
|
|
self.notify("maze_loaded", {"maze": maze})
|
|||
|
|
|
|||
|
|
def find_path(self, strategy: PathFindingStrategy) -> List[Cell]:
|
|||
|
|
solver = MazeSolver(self.maze, strategy)
|
|||
|
|
stats = solver.solve()
|
|||
|
|
print(f"Длина пути: {stats.path_length}, посещено: {stats.visited_cells}, время: {stats.time_ms:.3f} мс")
|
|||
|
|
path, _ = strategy.find_path(self.maze, self.maze.start_cell, self.maze.exit_cell)
|
|||
|
|
self.notify("path_found", {"path": path})
|
|||
|
|
return path
|
|||
|
|
|
|||
|
|
def clear_path(self):
|
|||
|
|
self.notify("clear_path", {})
|
|||
|
|
|
|||
|
|
def execute_command(self, cmd: Command):
|
|||
|
|
if cmd.execute():
|
|||
|
|
self.command_stack.append(cmd)
|
|||
|
|
self.notify("player_moved", {"maze": self.maze, "player_pos": self.player.position})
|
|||
|
|
|
|||
|
|
def undo(self):
|
|||
|
|
if self.command_stack:
|
|||
|
|
cmd = self.command_stack.pop()
|
|||
|
|
cmd.undo()
|
|||
|
|
self.notify("player_moved", {"maze": self.maze, "player_pos": self.player.position})
|
|||
|
|
|
|||
|
|
|
|||
|
|
# ============================================================
|
|||
|
|
# Этап 6. Генераторы тестовых лабиринтов
|
|||
|
|
# ============================================================
|
|||
|
|
def generate_simple_maze(width: int, height: int) -> Maze:
|
|||
|
|
"""Маленький лабиринт с простым путём."""
|
|||
|
|
maze = Maze(width, height)
|
|||
|
|
for y in range(height):
|
|||
|
|
for x in range(width):
|
|||
|
|
maze.cells[y][x].is_wall = True
|
|||
|
|
|
|||
|
|
x, y = 0, 0
|
|||
|
|
path = [(x, y)]
|
|||
|
|
while x < width - 1 or y < height - 1:
|
|||
|
|
if x < width - 1 and (y == height - 1 or random.random() < 0.5):
|
|||
|
|
x += 1
|
|||
|
|
else:
|
|||
|
|
if y < height - 1:
|
|||
|
|
y += 1
|
|||
|
|
path.append((x, y))
|
|||
|
|
|
|||
|
|
for px, py in path:
|
|||
|
|
maze.cells[py][px].is_wall = False
|
|||
|
|
|
|||
|
|
maze.set_start(0, 0)
|
|||
|
|
maze.set_exit(width - 1, height - 1)
|
|||
|
|
return maze
|
|||
|
|
|
|||
|
|
|
|||
|
|
def generate_with_dead_ends(width: int, height: int) -> Maze:
|
|||
|
|
"""Средний лабиринт с гарантированным путём и множеством тупиков."""
|
|||
|
|
maze = Maze(width, height)
|
|||
|
|
for y in range(height):
|
|||
|
|
for x in range(width):
|
|||
|
|
maze.cells[y][x].is_wall = True
|
|||
|
|
|
|||
|
|
x, y = 0, 0
|
|||
|
|
main_path = []
|
|||
|
|
while x < width - 1 or y < height - 1:
|
|||
|
|
main_path.append((x, y))
|
|||
|
|
if x < width - 1 and (y == height - 1 or random.random() < 0.6):
|
|||
|
|
x += 1
|
|||
|
|
else:
|
|||
|
|
if y < height - 1:
|
|||
|
|
y += 1
|
|||
|
|
else:
|
|||
|
|
x += 1
|
|||
|
|
main_path.append((width - 1, height - 1))
|
|||
|
|
|
|||
|
|
for px, py in main_path:
|
|||
|
|
maze.cells[py][px].is_wall = False
|
|||
|
|
|
|||
|
|
num_dead_ends = int(width * height * 0.08)
|
|||
|
|
for _ in range(num_dead_ends):
|
|||
|
|
base_x, base_y = random.choice(main_path)
|
|||
|
|
directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
|
|||
|
|
random.shuffle(directions)
|
|||
|
|
for dx, dy in directions:
|
|||
|
|
nx, ny = base_x + dx, base_y + dy
|
|||
|
|
if 0 <= nx < width and 0 <= ny < height and maze.cells[ny][nx].is_wall:
|
|||
|
|
length = random.randint(2, 4)
|
|||
|
|
for step in range(length):
|
|||
|
|
if 0 <= nx < width and 0 <= ny < height and maze.cells[ny][nx].is_wall:
|
|||
|
|
maze.cells[ny][nx].is_wall = False
|
|||
|
|
nx += dx
|
|||
|
|
ny += dy
|
|||
|
|
else:
|
|||
|
|
break
|
|||
|
|
break
|
|||
|
|
|
|||
|
|
maze.set_start(0, 0)
|
|||
|
|
maze.set_exit(width - 1, height - 1)
|
|||
|
|
return maze
|
|||
|
|
|
|||
|
|
|
|||
|
|
def generate_complex_maze(width: int, height: int) -> Maze:
|
|||
|
|
"""Большой лабиринт с гарантированным путём и высокой запутанностью."""
|
|||
|
|
maze = Maze(width, height)
|
|||
|
|
for y in range(height):
|
|||
|
|
for x in range(width):
|
|||
|
|
maze.cells[y][x].is_wall = True
|
|||
|
|
|
|||
|
|
x, y = 0, 0
|
|||
|
|
main_path = []
|
|||
|
|
while x < width - 1 or y < height - 1:
|
|||
|
|
main_path.append((x, y))
|
|||
|
|
if x < width - 1 and (y == height - 1 or random.random() < 0.7):
|
|||
|
|
x += 1
|
|||
|
|
else:
|
|||
|
|
if y < height - 1:
|
|||
|
|
y += 1
|
|||
|
|
else:
|
|||
|
|
x += 1
|
|||
|
|
main_path.append((width - 1, height - 1))
|
|||
|
|
|
|||
|
|
for px, py in main_path:
|
|||
|
|
maze.cells[py][px].is_wall = False
|
|||
|
|
|
|||
|
|
num_branches = int(width * height * 0.12)
|
|||
|
|
for _ in range(num_branches):
|
|||
|
|
base_x, base_y = random.choice(main_path)
|
|||
|
|
directions = [(1, 0), (-1, 0), (0, 1), (0, -1)]
|
|||
|
|
random.shuffle(directions)
|
|||
|
|
for dx, dy in directions:
|
|||
|
|
nx, ny = base_x + dx, base_y + dy
|
|||
|
|
if 0 <= nx < width and 0 <= ny < height and maze.cells[ny][nx].is_wall:
|
|||
|
|
length = random.randint(1, 5)
|
|||
|
|
branch = []
|
|||
|
|
for step in range(length):
|
|||
|
|
if 0 <= nx < width and 0 <= ny < height and maze.cells[ny][nx].is_wall:
|
|||
|
|
maze.cells[ny][nx].is_wall = False
|
|||
|
|
branch.append((nx, ny))
|
|||
|
|
nx += dx
|
|||
|
|
ny += dy
|
|||
|
|
else:
|
|||
|
|
break
|
|||
|
|
if random.random() < 0.3 and len(branch) >= 2:
|
|||
|
|
bx, by = branch[-1]
|
|||
|
|
for ddx, ddy in [(1, 0), (-1, 0), (0, 1), (0, -1)]:
|
|||
|
|
nnx, nny = bx + ddx, by + ddy
|
|||
|
|
if (0 <= nnx < width and 0 <= nny < height and
|
|||
|
|
maze.cells[nny][nnx].is_wall and random.random() < 0.5):
|
|||
|
|
maze.cells[nny][nnx].is_wall = False
|
|||
|
|
break
|
|||
|
|
|
|||
|
|
maze.set_start(0, 0)
|
|||
|
|
maze.set_exit(width - 1, height - 1)
|
|||
|
|
return maze
|
|||
|
|
|
|||
|
|
|
|||
|
|
def generate_empty_maze(width: int, height: int) -> Maze:
|
|||
|
|
"""Пустой лабиринт без стен."""
|
|||
|
|
maze = Maze(width, height)
|
|||
|
|
for y in range(height):
|
|||
|
|
for x in range(width):
|
|||
|
|
maze.cells[y][x].is_wall = False
|
|||
|
|
maze.set_start(0, 0)
|
|||
|
|
maze.set_exit(width - 1, height - 1)
|
|||
|
|
return maze
|
|||
|
|
|
|||
|
|
|
|||
|
|
def generate_no_exit_maze(width: int, height: int) -> Maze:
|
|||
|
|
"""Лабиринт без выхода (выход окружён стенами)."""
|
|||
|
|
maze = generate_empty_maze(width, height)
|
|||
|
|
ex, ey = width - 1, height - 1
|
|||
|
|
for dx, dy in [(0, 0), (0, -1), (0, 1), (-1, 0), (1, 0), (-1, -1), (-1, 1), (1, -1), (1, 1)]:
|
|||
|
|
nx, ny = ex + dx, ey + dy
|
|||
|
|
if 0 <= nx < width and 0 <= ny < height:
|
|||
|
|
if not (nx == 0 and ny == 0):
|
|||
|
|
maze.cells[ny][nx].is_wall = True
|
|||
|
|
maze.cells[ey][ex].is_wall = False
|
|||
|
|
maze.set_exit(ex, ey)
|
|||
|
|
return maze
|
|||
|
|
|
|||
|
|
|
|||
|
|
# ============================================================
|
|||
|
|
# Экспериментальная часть
|
|||
|
|
# ============================================================
|
|||
|
|
def run_experiment(maze: Maze, strategies: List[Tuple[str, PathFindingStrategy]], runs: int = 5) -> List[dict]:
|
|||
|
|
"""Запускает эксперимент на одном лабиринте и возвращает усреднённые результаты."""
|
|||
|
|
results = []
|
|||
|
|
for name, strategy in strategies:
|
|||
|
|
times = []
|
|||
|
|
visited_counts = []
|
|||
|
|
path_lengths = []
|
|||
|
|
for _ in range(runs):
|
|||
|
|
solver = MazeSolver(maze, strategy)
|
|||
|
|
stats = solver.solve()
|
|||
|
|
times.append(stats.time_ms)
|
|||
|
|
visited_counts.append(stats.visited_cells)
|
|||
|
|
path_lengths.append(stats.path_length)
|
|||
|
|
|
|||
|
|
avg_time = sum(times) / runs
|
|||
|
|
variance = sum((t - avg_time) ** 2 for t in times) / runs
|
|||
|
|
std_time = variance ** 0.5
|
|||
|
|
|
|||
|
|
results.append({
|
|||
|
|
'maze_type': '',
|
|||
|
|
'strategy': name,
|
|||
|
|
'avg_time_ms': avg_time,
|
|||
|
|
'std_time_ms': std_time,
|
|||
|
|
'avg_visited': sum(visited_counts) / runs,
|
|||
|
|
'avg_path_len': sum(path_lengths) / runs,
|
|||
|
|
'path_found': all(l > 0 for l in path_lengths)
|
|||
|
|
})
|
|||
|
|
return results
|
|||
|
|
|
|||
|
|
|
|||
|
|
def save_results_to_csv(results: List[dict], filename: str):
|
|||
|
|
"""Сохраняет результаты в CSV с разделителем ';' для совместимости с Excel."""
|
|||
|
|
if not results:
|
|||
|
|
return
|
|||
|
|
with open(filename, 'w', newline='', encoding='utf-8-sig') as f:
|
|||
|
|
writer = csv.DictWriter(f, fieldnames=results[0].keys(), delimiter=';')
|
|||
|
|
writer.writeheader()
|
|||
|
|
for row in results:
|
|||
|
|
row_copy = {}
|
|||
|
|
for k, v in row.items():
|
|||
|
|
if isinstance(v, float):
|
|||
|
|
row_copy[k] = f"{v:.6f}".replace(',', '.')
|
|||
|
|
else:
|
|||
|
|
row_copy[k] = v
|
|||
|
|
writer.writerow(row_copy)
|
|||
|
|
|
|||
|
|
|
|||
|
|
# ============================================================
|
|||
|
|
# Взвешенные лабиринты (опциональное задание)
|
|||
|
|
# ============================================================
|
|||
|
|
def assign_weights_random(maze: Maze, weights: List[Tuple[float, int]]) -> Maze:
|
|||
|
|
"""Присваивает веса клеткам согласно вероятностям."""
|
|||
|
|
for y in range(maze.height):
|
|||
|
|
for x in range(maze.width):
|
|||
|
|
if not maze.cells[y][x].is_wall:
|
|||
|
|
r = random.random()
|
|||
|
|
cum = 0
|
|||
|
|
for prob, w in weights:
|
|||
|
|
cum += prob
|
|||
|
|
if r < cum:
|
|||
|
|
maze.cells[y][x].weight = w
|
|||
|
|
break
|
|||
|
|
return maze
|
|||
|
|
|
|||
|
|
|
|||
|
|
def weighted_experiment():
|
|||
|
|
"""Дополнительный эксперимент со взвешенными клетками."""
|
|||
|
|
print("\n=== ВЗВЕШЕННЫЕ ЛАБИРИНТЫ (опциональное задание) ===")
|
|||
|
|
maze = generate_with_dead_ends(30, 30)
|
|||
|
|
assign_weights_random(maze, [(0.8, 1), (0.15, 3), (0.05, 2)])
|
|||
|
|
|
|||
|
|
strategies = [
|
|||
|
|
("A* (манхэттен)", AStarStrategy()),
|
|||
|
|
("Dijkstra", DijkstraStrategy())
|
|||
|
|
]
|
|||
|
|
|
|||
|
|
print("Лабиринт 30x30 со взвешенными клетками (болото 3, песок 2, асфальт 1)")
|
|||
|
|
results = run_experiment(maze, strategies, runs=10)
|
|||
|
|
|
|||
|
|
for r in results:
|
|||
|
|
print(f"{r['strategy']:15} | Время: {r['avg_time_ms']:.2f} мс | "
|
|||
|
|
f"Посещено: {r['avg_visited']:.0f} | Длина пути: {r['avg_path_len']:.0f}")
|
|||
|
|
|
|||
|
|
# Сравнение с BFS
|
|||
|
|
bfs = BFSStrategy()
|
|||
|
|
path_bfs, _ = bfs.find_path(maze, maze.start_cell, maze.exit_cell)
|
|||
|
|
if path_bfs:
|
|||
|
|
cost_bfs = sum(cell.weight for cell in path_bfs)
|
|||
|
|
print(f"BFS нашёл путь длиной {len(path_bfs)} клеток, стоимость = {cost_bfs}")
|
|||
|
|
|
|||
|
|
path_dijkstra, _ = DijkstraStrategy().find_path(maze, maze.start_cell, maze.exit_cell)
|
|||
|
|
if path_dijkstra:
|
|||
|
|
cost_dijkstra = sum(cell.weight for cell in path_dijkstra)
|
|||
|
|
print(f"Dijkstra нашёл путь длиной {len(path_dijkstra)} клеток, стоимость = {cost_dijkstra}")
|
|||
|
|
|
|||
|
|
path_astar, _ = AStarStrategy().find_path(maze, maze.start_cell, maze.exit_cell)
|
|||
|
|
if path_astar:
|
|||
|
|
cost_astar = sum(cell.weight for cell in path_astar)
|
|||
|
|
print(f"A* нашёл путь длиной {len(path_astar)} клеток, стоимость = {cost_astar}")
|
|||
|
|
|
|||
|
|
|
|||
|
|
# ============================================================
|
|||
|
|
# Демонстрация работы Observer и Command (по желанию)
|
|||
|
|
# ============================================================
|
|||
|
|
def demo_observer_command():
|
|||
|
|
"""Демонстрирует паттерны Observer и Command."""
|
|||
|
|
print("\n=== ДЕМОНСТРАЦИЯ OBSERVER И COMMAND ===")
|
|||
|
|
maze = generate_simple_maze(10, 10)
|
|||
|
|
|
|||
|
|
controller = GameController(maze)
|
|||
|
|
view = ConsoleView()
|
|||
|
|
controller.attach(view)
|
|||
|
|
|
|||
|
|
print("Лабиринт загружен:")
|
|||
|
|
controller.load_maze(maze)
|
|||
|
|
|
|||
|
|
print("Поиск пути с помощью BFS:")
|
|||
|
|
controller.find_path(BFSStrategy())
|
|||
|
|
|
|||
|
|
input("Нажмите Enter для пошагового управления...")
|
|||
|
|
|
|||
|
|
controller.clear_path()
|
|||
|
|
print("\nУправление: W/A/S/D - движение, Z - отмена, Q - выход")
|
|||
|
|
while True:
|
|||
|
|
cmd = input("> ").upper().strip()
|
|||
|
|
if cmd == 'Q':
|
|||
|
|
break
|
|||
|
|
elif cmd == 'Z':
|
|||
|
|
controller.undo()
|
|||
|
|
elif cmd in ('W', 'A', 'S', 'D'):
|
|||
|
|
move_cmd = MoveCommand(controller.player, controller.maze, cmd)
|
|||
|
|
controller.execute_command(move_cmd)
|
|||
|
|
else:
|
|||
|
|
print("Неизвестная команда")
|
|||
|
|
|
|||
|
|
|
|||
|
|
# ============================================================
|
|||
|
|
# Основной эксперимент
|
|||
|
|
# ============================================================
|
|||
|
|
def main():
|
|||
|
|
"""Основной эксперимент: сравнение стратегий на различных лабиринтах."""
|
|||
|
|
print("=== ЗАПУСК ЭКСПЕРИМЕНТОВ ===")
|
|||
|
|
|
|||
|
|
strategies = [
|
|||
|
|
("BFS", BFSStrategy()),
|
|||
|
|
("DFS", DFSStrategy()),
|
|||
|
|
("A*", AStarStrategy()),
|
|||
|
|
("Dijkstra", DijkstraStrategy())
|
|||
|
|
]
|
|||
|
|
|
|||
|
|
# Генерация тестовых лабиринтов
|
|||
|
|
maze_definitions = {
|
|||
|
|
"small_10x10_simple": generate_simple_maze(10, 10),
|
|||
|
|
"medium_50x50_deadends": generate_with_dead_ends(50, 50),
|
|||
|
|
"large_100x100_complex": generate_complex_maze(100, 100),
|
|||
|
|
"empty_50x50": generate_empty_maze(50, 50),
|
|||
|
|
"no_exit_50x50": generate_no_exit_maze(50, 50)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
all_results = []
|
|||
|
|
|
|||
|
|
for maze_name, maze in maze_definitions.items():
|
|||
|
|
print(f"\nЗапуск на лабиринте: {maze_name} ({maze.width}x{maze.height})")
|
|||
|
|
results = run_experiment(maze, strategies, runs=5)
|
|||
|
|
|
|||
|
|
for r in results:
|
|||
|
|
r['maze_type'] = maze_name
|
|||
|
|
all_results.append(r)
|
|||
|
|
|
|||
|
|
# Вывод промежуточных результатов
|
|||
|
|
for r in results:
|
|||
|
|
print(f" {r['strategy']:8} | Время: {r['avg_time_ms']:7.2f}±{r['std_time_ms']:.2f} мс | "
|
|||
|
|
f"Посещено: {r['avg_visited']:7.0f} | Длина пути: {r['avg_path_len']:5.0f}")
|
|||
|
|
|
|||
|
|
# Сохранение результатов
|
|||
|
|
save_results_to_csv(all_results, "experiment_results.csv")
|
|||
|
|
print("\nРезультаты сохранены в experiment_results.csv")
|
|||
|
|
|
|||
|
|
# Вывод сводной таблицы
|
|||
|
|
print("\n" + "=" * 100)
|
|||
|
|
print("СВОДНАЯ ТАБЛИЦА РЕЗУЛЬТАТОВ")
|
|||
|
|
print("=" * 100)
|
|||
|
|
print(f"{'Лабиринт':<25} | {'Стратегия':<10} | {'Время (мс)':<15} | {'Посещено':<10} | {'Длина пути':<10}")
|
|||
|
|
print("-" * 100)
|
|||
|
|
for r in all_results:
|
|||
|
|
print(f"{r['maze_type']:<25} | {r['strategy']:<10} | {r['avg_time_ms']:>8.2f} ± {r['std_time_ms']:<5.2f} | "
|
|||
|
|
f"{r['avg_visited']:>8.0f} | {r['avg_path_len']:>8.0f}")
|
|||
|
|
|
|||
|
|
|
|||
|
|
# ============================================================
|
|||
|
|
# Запуск
|
|||
|
|
# ============================================================
|
|||
|
|
if __name__ == "__main__":
|
|||
|
|
main()
|
|||
|
|
|
|||
|
|
# Раскомментируйте для демонстрации:
|
|||
|
|
# demo_observer_command()
|
|||
|
|
# weighted_experiment()
|