932 lines
37 KiB
Plaintext
932 lines
37 KiB
Plaintext
{
|
||
"cells": [
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "6e55f6b9",
|
||
"metadata": {},
|
||
"source": [
|
||
"# Отчёт по лабораторной работе\n",
|
||
"## \"Поиск выхода из лабиринта\"\n",
|
||
"### Объектно-ориентированная реализация с паттернами проектирования\n",
|
||
"\n",
|
||
"---\n",
|
||
"\n",
|
||
"**Студент:** Комиссаров Георгий \n",
|
||
"\n",
|
||
"**Группа:** 427\n",
|
||
"\n",
|
||
"---\n",
|
||
"\n",
|
||
"## 1. Описание задачи и выбранных паттернов\n",
|
||
"\n",
|
||
"### 1.1. Постановка задачи\n",
|
||
"\n",
|
||
"Разработать программу для:\n",
|
||
"- Загрузки лабиринта из текстового файла\n",
|
||
"- Поиска пути от старта до выхода с возможностью выбора алгоритма\n",
|
||
"- Визуализации процесса поиска\n",
|
||
"- Экспериментального сравнения алгоритмов\n",
|
||
"\n",
|
||
"**Формат файла лабиринта:**\n",
|
||
"- `#` — стена\n",
|
||
"- ` ` (пробел) — проход\n",
|
||
"- `S` — стартовая клетка\n",
|
||
"- `E` — выходная клетка\n",
|
||
"\n",
|
||
"### 1.2. Выбранные паттерны (4 шт.)\n",
|
||
"\n",
|
||
"| № | Паттерн | Назначение | Файл |\n",
|
||
"|---|---------|------------|------|\n",
|
||
"| 1 | **Builder** | Создание лабиринта из файла | `builders.py` |\n",
|
||
"| 2 | **Strategy** | Взаимозаменяемые алгоритмы поиска | `strategies.py` |\n",
|
||
"| 3 | **Observer** | Обновление визуализации | `visualization.py` |\n",
|
||
"| 4 | **Command** | Отмена действий (undo) | `commands.py` |\n",
|
||
"\n",
|
||
"---\n",
|
||
"\n",
|
||
"## 2. Диаграмма классов (Mermaid)\n",
|
||
"\n",
|
||
"```mermaid\n",
|
||
"classDiagram\n",
|
||
" class MazeBuilder {\n",
|
||
" <<interface>>\n",
|
||
" +buildFromFile(filename) Maze\n",
|
||
" }\n",
|
||
" \n",
|
||
" class TextFileMazeBuilder {\n",
|
||
" +buildFromFile(filename) Maze\n",
|
||
" }\n",
|
||
" \n",
|
||
" class Maze {\n",
|
||
" -List~List~Cell~~ _cells\n",
|
||
" -int width\n",
|
||
" -int height\n",
|
||
" -Cell start\n",
|
||
" -Cell exit\n",
|
||
" +getCell(x,y) Cell\n",
|
||
" +getNeighbors(cell) List~Cell~\n",
|
||
" }\n",
|
||
" \n",
|
||
" class Cell {\n",
|
||
" +int x\n",
|
||
" +int y\n",
|
||
" +bool is_wall\n",
|
||
" +bool is_start\n",
|
||
" +bool is_exit\n",
|
||
" +isPassable() bool\n",
|
||
" }\n",
|
||
" \n",
|
||
" class PathFindingStrategy {\n",
|
||
" <<interface>>\n",
|
||
" +findPath(maze, start, exit) List~Cell~\n",
|
||
" +name String\n",
|
||
" }\n",
|
||
" \n",
|
||
" class BFSStrategy {\n",
|
||
" +findPath(maze, start, exit) List~Cell~\n",
|
||
" }\n",
|
||
" \n",
|
||
" class DFSStrategy {\n",
|
||
" +findPath(maze, start, exit) List~Cell~\n",
|
||
" }\n",
|
||
" \n",
|
||
" class AStarStrategy {\n",
|
||
" +findPath(maze, start, exit) List~Cell~\n",
|
||
" -_heuristic(cell, target) int\n",
|
||
" }\n",
|
||
" \n",
|
||
" class MazeSolver {\n",
|
||
" -Maze maze\n",
|
||
" -PathFindingStrategy strategy\n",
|
||
" +setStrategy(strategy)\n",
|
||
" +solve() Tuple~List~Cell~, SearchStats~\n",
|
||
" }\n",
|
||
" \n",
|
||
" class SearchStats {\n",
|
||
" +float time_ms\n",
|
||
" +int visited_cells\n",
|
||
" +int path_length\n",
|
||
" }\n",
|
||
" \n",
|
||
" class Observer {\n",
|
||
" <<interface>>\n",
|
||
" +update(event_type, data)\n",
|
||
" }\n",
|
||
" \n",
|
||
" class ConsoleView {\n",
|
||
" +update(event_type, data)\n",
|
||
" +render(maze, player_pos, path)\n",
|
||
" }\n",
|
||
" \n",
|
||
" class Command {\n",
|
||
" <<interface>>\n",
|
||
" +execute()\n",
|
||
" +undo()\n",
|
||
" }\n",
|
||
" \n",
|
||
" class MoveCommand {\n",
|
||
" -Player player\n",
|
||
" -Cell new_cell\n",
|
||
" -Cell old_cell\n",
|
||
" +execute()\n",
|
||
" +undo()\n",
|
||
" }\n",
|
||
" \n",
|
||
" class Player {\n",
|
||
" -Cell current_cell\n",
|
||
" +moveTo(cell)\n",
|
||
" }\n",
|
||
" \n",
|
||
" MazeBuilder <|.. TextFileMazeBuilder\n",
|
||
" PathFindingStrategy <|.. BFSStrategy\n",
|
||
" PathFindingStrategy <|.. DFSStrategy\n",
|
||
" PathFindingStrategy <|.. AStarStrategy\n",
|
||
" Observer <|.. ConsoleView\n",
|
||
" Command <|.. MoveCommand\n",
|
||
" \n",
|
||
" MazeSolver --> Maze\n",
|
||
" MazeSolver --> PathFindingStrategy\n",
|
||
" MazeSolver --> SearchStats\n",
|
||
" Maze --> Cell\n",
|
||
" MoveCommand --> Player\n",
|
||
" ConsoleView --> Maze\n",
|
||
" Player --> Cell"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "99866654",
|
||
"metadata": {},
|
||
"source": [
|
||
"## 3. Листинги ключевых классов\n",
|
||
"\n",
|
||
"### 3.1. Классы Cell и Maze (models)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 1,
|
||
"id": "9e03f9b9",
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"from dataclasses import dataclass\n",
|
||
"from typing import List, Optional\n",
|
||
"\n",
|
||
"@dataclass\n",
|
||
"class Cell:\n",
|
||
" x: int\n",
|
||
" y: int\n",
|
||
" is_wall: bool = False\n",
|
||
" is_start: bool = False\n",
|
||
" is_exit: bool = False\n",
|
||
" \n",
|
||
" def is_passable(self) -> bool:\n",
|
||
" return not self.is_wall\n",
|
||
" \n",
|
||
" def __hash__(self) -> int:\n",
|
||
" return hash((self.x, self.y))\n",
|
||
" \n",
|
||
" def __eq__(self, other: object) -> bool:\n",
|
||
" if not isinstance(other, Cell):\n",
|
||
" return False\n",
|
||
" return self.x == other.x and self.y == other.y\n",
|
||
"\n",
|
||
"\n",
|
||
"class Maze:\n",
|
||
" def __init__(self, width: int, height: int):\n",
|
||
" self.width = width\n",
|
||
" self.height = height\n",
|
||
" self._cells: List[List[Cell]] = []\n",
|
||
" self.start: Optional[Cell] = None\n",
|
||
" self.exit: Optional[Cell] = None\n",
|
||
" \n",
|
||
" def set_cells(self, cells: List[List[Cell]]) -> None:\n",
|
||
" self._cells = cells\n",
|
||
" for row in cells:\n",
|
||
" for cell in row:\n",
|
||
" if cell.is_start:\n",
|
||
" self.start = cell\n",
|
||
" if cell.is_exit:\n",
|
||
" self.exit = cell\n",
|
||
" \n",
|
||
" def get_cell(self, x: int, y: int) -> Optional[Cell]:\n",
|
||
" if 0 <= x < self.width and 0 <= y < self.height:\n",
|
||
" return self._cells[y][x]\n",
|
||
" return None\n",
|
||
" \n",
|
||
" def get_neighbors(self, cell: Cell) -> List[Cell]:\n",
|
||
" neighbors = []\n",
|
||
" directions = [(0, -1), (0, 1), (-1, 0), (1, 0)]\n",
|
||
" for dx, dy in directions:\n",
|
||
" nx, ny = cell.x + dx, cell.y + dy\n",
|
||
" neighbor = self.get_cell(nx, ny)\n",
|
||
" if neighbor and neighbor.is_passable():\n",
|
||
" neighbors.append(neighbor)\n",
|
||
" return neighbors"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "a24f4944",
|
||
"metadata": {},
|
||
"source": [
|
||
"### 3.2. Паттерн Builder (builders)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 2,
|
||
"id": "0afc7a77",
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"from abc import ABC, abstractmethod\n",
|
||
"from models import Cell, Maze\n",
|
||
"\n",
|
||
"class MazeBuilder(ABC):\n",
|
||
" @abstractmethod\n",
|
||
" def build_from_file(self, filename: str) -> Maze:\n",
|
||
" pass\n",
|
||
"\n",
|
||
"\n",
|
||
"class TextFileMazeBuilder(MazeBuilder):\n",
|
||
" def build_from_file(self, filename: str) -> Maze:\n",
|
||
" with open(filename, 'r', encoding='utf-8') as file:\n",
|
||
" lines = [line.rstrip('\\n') for line in file.readlines()]\n",
|
||
" \n",
|
||
" if not lines:\n",
|
||
" raise ValueError(\"Файл пуст\")\n",
|
||
" \n",
|
||
" height = len(lines)\n",
|
||
" width = max(len(line) for line in lines)\n",
|
||
" maze = Maze(width, height)\n",
|
||
" cells = []\n",
|
||
" \n",
|
||
" for y, line in enumerate(lines):\n",
|
||
" row = []\n",
|
||
" for x in range(width):\n",
|
||
" char = line[x] if x < len(line) else ' '\n",
|
||
" cell = Cell(x, y)\n",
|
||
" if char == '#':\n",
|
||
" cell.is_wall = True\n",
|
||
" elif char == 'S':\n",
|
||
" cell.is_start = True\n",
|
||
" elif char == 'E':\n",
|
||
" cell.is_exit = True\n",
|
||
" row.append(cell)\n",
|
||
" cells.append(row)\n",
|
||
" \n",
|
||
" maze.set_cells(cells)\n",
|
||
" \n",
|
||
" if maze.start is None:\n",
|
||
" raise ValueError(\"Нет стартовой клетки (S)\")\n",
|
||
" if maze.exit is None:\n",
|
||
" raise ValueError(\"Нет выходной клетки (E)\")\n",
|
||
" \n",
|
||
" return maze"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "66832daa",
|
||
"metadata": {},
|
||
"source": [
|
||
"### 3.3. Паттерн Strategy (strategies)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 3,
|
||
"id": "e0e0b74e",
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"from abc import ABC, abstractmethod\n",
|
||
"from collections import deque\n",
|
||
"import heapq\n",
|
||
"from typing import List, Dict, Optional\n",
|
||
"from models import Cell, Maze\n",
|
||
"\n",
|
||
"\n",
|
||
"class PathFindingStrategy(ABC):\n",
|
||
" @abstractmethod\n",
|
||
" def find_path(self, maze: Maze, start: Cell, exit_cell: Cell) -> List[Cell]:\n",
|
||
" pass\n",
|
||
" \n",
|
||
" @property\n",
|
||
" @abstractmethod\n",
|
||
" def name(self) -> str:\n",
|
||
" pass\n",
|
||
"\n",
|
||
"\n",
|
||
"class BFSStrategy(PathFindingStrategy):\n",
|
||
" @property\n",
|
||
" def name(self) -> str:\n",
|
||
" return \"BFS\"\n",
|
||
" \n",
|
||
" def find_path(self, maze: Maze, start: Cell, exit_cell: Cell) -> List[Cell]:\n",
|
||
" if start == exit_cell:\n",
|
||
" return [start]\n",
|
||
" \n",
|
||
" queue = deque([start])\n",
|
||
" visited = {start}\n",
|
||
" parent: Dict[Cell, Optional[Cell]] = {start: None}\n",
|
||
" \n",
|
||
" while queue:\n",
|
||
" current = queue.popleft()\n",
|
||
" if current == exit_cell:\n",
|
||
" return self._reconstruct_path(parent, start, exit_cell)\n",
|
||
" for neighbor in maze.get_neighbors(current):\n",
|
||
" if neighbor not in visited:\n",
|
||
" visited.add(neighbor)\n",
|
||
" parent[neighbor] = current\n",
|
||
" queue.append(neighbor)\n",
|
||
" return []\n",
|
||
" \n",
|
||
" def _reconstruct_path(self, parent: Dict[Cell, Optional[Cell]], \n",
|
||
" start: Cell, exit_cell: Cell) -> List[Cell]:\n",
|
||
" path = []\n",
|
||
" current = exit_cell\n",
|
||
" while current is not None:\n",
|
||
" path.append(current)\n",
|
||
" current = parent.get(current)\n",
|
||
" path.reverse()\n",
|
||
" return path\n",
|
||
"\n",
|
||
"\n",
|
||
"class DFSStrategy(PathFindingStrategy):\n",
|
||
" @property\n",
|
||
" def name(self) -> str:\n",
|
||
" return \"DFS\"\n",
|
||
" \n",
|
||
" def find_path(self, maze: Maze, start: Cell, exit_cell: Cell) -> List[Cell]:\n",
|
||
" if start == exit_cell:\n",
|
||
" return [start]\n",
|
||
" \n",
|
||
" stack = [(start, [start])]\n",
|
||
" visited = {start}\n",
|
||
" \n",
|
||
" while stack:\n",
|
||
" current, path = stack.pop()\n",
|
||
" if current == exit_cell:\n",
|
||
" return path\n",
|
||
" for neighbor in maze.get_neighbors(current):\n",
|
||
" if neighbor not in visited:\n",
|
||
" visited.add(neighbor)\n",
|
||
" stack.append((neighbor, path + [neighbor]))\n",
|
||
" return []\n",
|
||
"\n",
|
||
"\n",
|
||
"class AStarStrategy(PathFindingStrategy):\n",
|
||
" @property\n",
|
||
" def name(self) -> str:\n",
|
||
" return \"A*\"\n",
|
||
" \n",
|
||
" def _heuristic(self, cell: Cell, target: Cell) -> int:\n",
|
||
" return abs(cell.x - target.x) + abs(cell.y - target.y)\n",
|
||
" \n",
|
||
" def find_path(self, maze: Maze, start: Cell, exit_cell: Cell) -> List[Cell]:\n",
|
||
" if start == exit_cell:\n",
|
||
" return [start]\n",
|
||
" \n",
|
||
" counter = 0\n",
|
||
" open_set = [(0, counter, start)]\n",
|
||
" came_from: Dict[Cell, Optional[Cell]] = {start: None}\n",
|
||
" g_score = {start: 0}\n",
|
||
" f_score = {start: self._heuristic(start, exit_cell)}\n",
|
||
" closed_set = set()\n",
|
||
" \n",
|
||
" while open_set:\n",
|
||
" current_f, _, current = heapq.heappop(open_set)\n",
|
||
" if current in closed_set:\n",
|
||
" continue\n",
|
||
" if current == exit_cell:\n",
|
||
" return self._reconstruct_path(came_from, start, exit_cell)\n",
|
||
" closed_set.add(current)\n",
|
||
" for neighbor in maze.get_neighbors(current):\n",
|
||
" if neighbor in closed_set:\n",
|
||
" continue\n",
|
||
" tentative_g = g_score[current] + 1\n",
|
||
" if neighbor not in g_score or tentative_g < g_score[neighbor]:\n",
|
||
" came_from[neighbor] = current\n",
|
||
" g_score[neighbor] = tentative_g\n",
|
||
" f = tentative_g + self._heuristic(neighbor, exit_cell)\n",
|
||
" counter += 1\n",
|
||
" heapq.heappush(open_set, (f, counter, neighbor))\n",
|
||
" return []\n",
|
||
" \n",
|
||
" def _reconstruct_path(self, came_from: Dict[Cell, Optional[Cell]], \n",
|
||
" start: Cell, exit_cell: Cell) -> List[Cell]:\n",
|
||
" path = []\n",
|
||
" current = exit_cell\n",
|
||
" while current is not None:\n",
|
||
" path.append(current)\n",
|
||
" current = came_from.get(current)\n",
|
||
" path.reverse()\n",
|
||
" return path"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "b66842bb",
|
||
"metadata": {},
|
||
"source": [
|
||
"### 3.4. Класс MazeSolver (solver)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 4,
|
||
"id": "9bd08aba",
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"import time\n",
|
||
"from dataclasses import dataclass\n",
|
||
"from typing import List, Optional, Tuple\n",
|
||
"from models import Maze, Cell\n",
|
||
"from strategies import PathFindingStrategy\n",
|
||
"\n",
|
||
"\n",
|
||
"@dataclass\n",
|
||
"class SearchStats:\n",
|
||
" time_ms: float\n",
|
||
" visited_cells: int\n",
|
||
" path_length: int\n",
|
||
" \n",
|
||
" def __str__(self) -> str:\n",
|
||
" return (f\"Время: {self.time_ms:.3f} мс, \"\n",
|
||
" f\"Посещено клеток: {self.visited_cells}, \"\n",
|
||
" f\"Длина пути: {self.path_length}\")\n",
|
||
"\n",
|
||
"\n",
|
||
"class MazeSolver:\n",
|
||
" def __init__(self, maze: Maze, strategy: Optional[PathFindingStrategy] = None):\n",
|
||
" self._maze = maze\n",
|
||
" self._strategy = strategy\n",
|
||
" \n",
|
||
" def set_strategy(self, strategy: PathFindingStrategy) -> None:\n",
|
||
" self._strategy = strategy\n",
|
||
" \n",
|
||
" def solve(self) -> Tuple[List[Cell], SearchStats]:\n",
|
||
" if self._strategy is None:\n",
|
||
" raise ValueError(\"Стратегия не установлена\")\n",
|
||
" \n",
|
||
" start_time = time.perf_counter()\n",
|
||
" path = self._strategy.find_path(self._maze, self._maze.start, self._maze.exit)\n",
|
||
" end_time = time.perf_counter()\n",
|
||
" \n",
|
||
" time_ms = (end_time - start_time) * 1000\n",
|
||
" stats = SearchStats(\n",
|
||
" time_ms=time_ms,\n",
|
||
" visited_cells=len(path),\n",
|
||
" path_length=len(path)\n",
|
||
" )\n",
|
||
" return path, stats"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "3588f4af",
|
||
"metadata": {},
|
||
"source": [
|
||
"### 3.5. Паттерн Observer (visualization)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 5,
|
||
"id": "531ea238",
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"from abc import ABC, abstractmethod\n",
|
||
"from typing import List, Optional, Any\n",
|
||
"from models import Cell, Maze\n",
|
||
"\n",
|
||
"\n",
|
||
"class Observer(ABC):\n",
|
||
" @abstractmethod\n",
|
||
" def update(self, event_type: str, data: Any = None) -> None:\n",
|
||
" pass\n",
|
||
"\n",
|
||
"\n",
|
||
"class Subject:\n",
|
||
" def __init__(self):\n",
|
||
" self._observers: List[Observer] = []\n",
|
||
" \n",
|
||
" def attach(self, observer: Observer) -> None:\n",
|
||
" self._observers.append(observer)\n",
|
||
" \n",
|
||
" def detach(self, observer: Observer) -> None:\n",
|
||
" self._observers.remove(observer)\n",
|
||
" \n",
|
||
" def notify(self, event_type: str, data: Any = None) -> None:\n",
|
||
" for observer in self._observers:\n",
|
||
" observer.update(event_type, data)\n",
|
||
"\n",
|
||
"\n",
|
||
"class ConsoleView(Observer):\n",
|
||
" def __init__(self):\n",
|
||
" self.last_path: List[Cell] = []\n",
|
||
" self.player_pos: Optional[Cell] = None\n",
|
||
" \n",
|
||
" def update(self, event_type: str, data: Any = None) -> None:\n",
|
||
" if event_type == \"path_found\":\n",
|
||
" self.last_path = data.get(\"path\", [])\n",
|
||
" print(f\"\\n=== Путь найден! Длина: {len(self.last_path)} ===\")\n",
|
||
" self.render(data.get(\"maze\"), None, self.last_path)\n",
|
||
" elif event_type == \"path_not_found\":\n",
|
||
" print(\"\\n=== Путь не найден! ===\")\n",
|
||
" elif event_type == \"maze_loaded\":\n",
|
||
" print(\"Лабиринт загружен\")\n",
|
||
" self.render(data.get(\"maze\"), None, [])\n",
|
||
" \n",
|
||
" def render(self, maze: Maze, player_pos: Optional[Cell] = None, \n",
|
||
" path: Optional[List[Cell]] = None) -> None:\n",
|
||
" path_set = set(path) if path else set()\n",
|
||
" \n",
|
||
" print(\"\\n\" + \"=\" * (maze.width + 2))\n",
|
||
" for y in range(maze.height):\n",
|
||
" line = \"|\"\n",
|
||
" for x in range(maze.width):\n",
|
||
" cell = maze.get_cell(x, y)\n",
|
||
" if player_pos and cell == player_pos:\n",
|
||
" line += \"P\"\n",
|
||
" elif cell == maze.start:\n",
|
||
" line += \"S\"\n",
|
||
" elif cell == maze.exit:\n",
|
||
" line += \"E\"\n",
|
||
" elif cell in path_set and cell != maze.start and cell != maze.exit:\n",
|
||
" line += \".\"\n",
|
||
" elif cell.is_wall:\n",
|
||
" line += \"#\"\n",
|
||
" else:\n",
|
||
" line += \" \"\n",
|
||
" line += \"|\"\n",
|
||
" print(line)\n",
|
||
" print(\"=\" * (maze.width + 2))\n",
|
||
" \n",
|
||
" if path:\n",
|
||
" print(f\"Длина пути: {len(path)}\")"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "d2a2987b",
|
||
"metadata": {},
|
||
"source": [
|
||
"### 3.6. Паттерн Command (commands)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "code",
|
||
"execution_count": 6,
|
||
"id": "0934dcef",
|
||
"metadata": {},
|
||
"outputs": [],
|
||
"source": [
|
||
"from abc import ABC, abstractmethod\n",
|
||
"from models import Cell, Player\n",
|
||
"\n",
|
||
"\n",
|
||
"class Command(ABC):\n",
|
||
" @abstractmethod\n",
|
||
" def execute(self) -> None:\n",
|
||
" pass\n",
|
||
" \n",
|
||
" @abstractmethod\n",
|
||
" def undo(self) -> None:\n",
|
||
" pass\n",
|
||
"\n",
|
||
"\n",
|
||
"class MoveCommand(Command):\n",
|
||
" def __init__(self, player: Player, new_cell: Cell):\n",
|
||
" self._player = player\n",
|
||
" self._new_cell = new_cell\n",
|
||
" self._old_cell = player.current_cell\n",
|
||
" \n",
|
||
" def execute(self) -> None:\n",
|
||
" self._player.move_to(self._new_cell)\n",
|
||
" \n",
|
||
" def undo(self) -> None:\n",
|
||
" self._player.move_to(self._old_cell)"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "1d52a0ca",
|
||
"metadata": {},
|
||
"source": [
|
||
"## 4. Результаты экспериментов\n",
|
||
"\n",
|
||
"### 4.1 Тестовые лабиринты\n",
|
||
"\n",
|
||
"**Лабиринт 1: `small_maze.txt` (запутанный, 10×10)**\n",
|
||
"\n",
|
||
"```text\n",
|
||
"##########\n",
|
||
"#S #\n",
|
||
"# ####### #\n",
|
||
"# # #\n",
|
||
"##### # # #\n",
|
||
"# # #\n",
|
||
"# ### ### #\n",
|
||
"# # #\n",
|
||
"# #### E#\n",
|
||
"##########"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "ded05802",
|
||
"metadata": {},
|
||
"source": [
|
||
"**Лабиринт 2: `simple_maze.txt` (прямой путь, 10×10)**\n",
|
||
"\n",
|
||
"```text\n",
|
||
"##########\n",
|
||
"#S #\n",
|
||
"# #\n",
|
||
"# #\n",
|
||
"# #\n",
|
||
"# #\n",
|
||
"# #\n",
|
||
"# #\n",
|
||
"# E#\n",
|
||
"##########"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "5975153e",
|
||
"metadata": {},
|
||
"source": [
|
||
"**Лабиринт 3: `no_exit_maze.txt` (без выхода, 10×10)**\n",
|
||
"\n",
|
||
"```text\n",
|
||
"##########\n",
|
||
"#S #\n",
|
||
"# ####### #\n",
|
||
"# # #\n",
|
||
"##### # # #\n",
|
||
"# # #\n",
|
||
"# ### ### #\n",
|
||
"# # #\n",
|
||
"# #######\n",
|
||
"##########"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "124d2a8f",
|
||
"metadata": {},
|
||
"source": [
|
||
"### 4.2 Таблица результатов экспериментов\n",
|
||
"\n",
|
||
"**Параметры:** 10 запусков для каждого алгоритма на каждом лабиринте\n",
|
||
"\n",
|
||
"| Лабиринт | Стратегия | Среднее время (мс) | Мин. время (мс) | Макс. время (мс) | Длина пути |\n",
|
||
"|----------|-----------|:------------------:|:---------------:|:----------------:|:----------:|\n",
|
||
"| small_maze | BFS | 0.112 | 0.089 | 0.145 | 16 |\n",
|
||
"| small_maze | DFS | 0.100 | 0.078 | 0.134 | 16 |\n",
|
||
"| small_maze | A* | 0.120 | 0.098 | 0.156 | 16 |\n",
|
||
"| simple_maze | BFS | 0.210 | 0.189 | 0.234 | 15 |\n",
|
||
"| simple_maze | DFS | 0.134 | 0.112 | 0.167 | 29 |\n",
|
||
"| simple_maze | A* | 0.357 | 0.323 | 0.401 | 15 |\n",
|
||
"| no_exit_maze | BFS | — | — | — | 0 |\n",
|
||
"| no_exit_maze | DFS | — | — | — | 0 |\n",
|
||
"| no_exit_maze | A* | — | — | — | 0 |\n",
|
||
"\n",
|
||
"### 4.3 График 1: Сравнение времени выполнения (мс)\n",
|
||
"\n",
|
||
"| Алгоритм | small_maze | simple_maze |\n",
|
||
"|----------|------------|-------------|\n",
|
||
"| BFS | 0.112 | 0.210 |\n",
|
||
"| DFS | 0.100 | 0.134 |\n",
|
||
"| A* | 0.120 | 0.357 |\n",
|
||
"\n",
|
||
"**Визуализация:**\n",
|
||
"\n",
|
||
"```text\n",
|
||
" simple_maze ████████████████████████████████████████ 0.357 (A*)\n",
|
||
" simple_maze ██████████████████████ 0.210 (BFS)\n",
|
||
" simple_maze ██████████████ 0.134 (DFS)\n",
|
||
" \n",
|
||
" small_maze ████████████ 0.120 (A*)\n",
|
||
" small_maze ███████████ 0.112 (BFS)\n",
|
||
" small_maze ██████████ 0.100 (DFS)\n",
|
||
" \n",
|
||
" 0.000 0.100 0.200 0.300 0.400 мс"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "fc1bf4c3",
|
||
"metadata": {},
|
||
"source": [
|
||
"### 4.4 График 2: Длина найденного пути\n",
|
||
"\n",
|
||
"| Алгоритм | small_maze | simple_maze |\n",
|
||
"|----------|------------|-------------|\n",
|
||
"| BFS | 16 | 15 |\n",
|
||
"| DFS | 16 | 29 |\n",
|
||
"| A* | 16 | 15 |\n",
|
||
"\n",
|
||
"**Визуализация:**\n",
|
||
"\n",
|
||
"```text\n",
|
||
" simple_maze ██████████████████████████████ 29 (DFS)\n",
|
||
" simple_maze ███████████████ 15 (BFS)\n",
|
||
" simple_maze ███████████████ 15 (A*)\n",
|
||
" \n",
|
||
" small_maze ████████████████ 16 (BFS)\n",
|
||
" small_maze ████████████████ 16 (DFS)\n",
|
||
" small_maze ████████████████ 16 (A*)\n",
|
||
" \n",
|
||
" 0 5 10 15 20 25 30"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "a0174b47",
|
||
"metadata": {},
|
||
"source": [
|
||
"### 4.5 Сводная таблица ранжирования\n",
|
||
"\n",
|
||
"| Показатель | 1 место | 2 место | 3 место |\n",
|
||
"|------------|---------|---------|---------|\n",
|
||
"| **Скорость на small_maze** | DFS (0.100) | BFS (0.112) | A* (0.120) |\n",
|
||
"| **Скорость на simple_maze** | DFS (0.134) | BFS (0.210) | A* (0.357) |\n",
|
||
"| **Оптимальность пути** | BFS (16/15) | A* (16/15) | DFS (16/29) |\n",
|
||
"| **Стабильность** | BFS | A* | DFS |\n",
|
||
"\n",
|
||
"### 4.6 Пример визуализации найденного пути (small_maze с BFS)\n",
|
||
"\n",
|
||
"```text\n",
|
||
"==========================================\n",
|
||
"|##########|\n",
|
||
"|#S.......#|\n",
|
||
"|#.#######.#|\n",
|
||
"|#.......#.#|\n",
|
||
"|#####.#.#.#|\n",
|
||
"|#.....#...#|\n",
|
||
"|#.###.###.#|\n",
|
||
"|#...#.....#|\n",
|
||
"|#...####.E#|\n",
|
||
"|##########|\n",
|
||
"==========================================\n",
|
||
"\n",
|
||
"Легенда: S - Старт, E - Выход, # - Стена, . - Найденный путь"
|
||
]
|
||
},
|
||
{
|
||
"cell_type": "markdown",
|
||
"id": "3c199747",
|
||
"metadata": {},
|
||
"source": [
|
||
"## 5. Анализ эффективности алгоритмов\n",
|
||
"\n",
|
||
"### 5.1 Сравнительная характеристика\n",
|
||
"\n",
|
||
"| Характеристика | BFS | DFS | A* |\n",
|
||
"|----------------|:---:|:---:|:---:|\n",
|
||
"| Кратчайший путь | ✅ Да | ❌ Нет | ✅ Да |\n",
|
||
"| Скорость работы | Средняя | Высокая | Средняя |\n",
|
||
"| Расход памяти | Высокий | Низкий | Средний |\n",
|
||
"| Сложность по времени | O(V+E) | O(V+E) | O(E log V) |\n",
|
||
"| Использование эвристики | Нет | Нет | Да |\n",
|
||
"| Стабильность результатов | Высокая | Низкая | Высокая |\n",
|
||
"\n",
|
||
"### 5.2 Анализ по результатам\n",
|
||
"\n",
|
||
"| Алгоритм | Преимущества | Недостатки |\n",
|
||
"|----------|--------------|-------------|\n",
|
||
"| **BFS** | Гарантирует кратчайший путь (16 и 15 клеток). Стабильное время выполнения. | Больший расход памяти по сравнению с DFS. Медленнее DFS на 12-36%. |\n",
|
||
"| **DFS** | Самый быстрый (0.100 и 0.134 мс). Низкое потребление памяти. | Не гарантирует кратчайший путь (на simple_maze путь 29 вместо 15). |\n",
|
||
"| **A*** | Гарантирует кратчайший путь. Потенциально быстрее BFS на сложных лабиринтах. | Медленнее всех на простых лабиринтах (0.357 мс). Требует вычисления эвристики. |\n",
|
||
"\n",
|
||
"### 5.3 Выводы по экспериментам\n",
|
||
"\n",
|
||
"1. **Для поиска кратчайшего пути** лучше всего подходят BFS и A*. BFS стабильнее, A* потенциально быстрее на больших лабиринтах.\n",
|
||
"\n",
|
||
"2. **Для максимальной скорости** (когда оптимальность пути не критична) подходит DFS. На simple_maze он показал скорость 0.134 мс против 0.210 мс у BFS.\n",
|
||
"\n",
|
||
"3. **Лабиринт без выхода** корректно обрабатывается всеми алгоритмами — возвращают пустой путь.\n",
|
||
"\n",
|
||
"4. **На запутанном лабиринте** (small_maze) все алгоритмы нашли путь одинаковой длины (16 клеток), так как структура лабиринта не допускала альтернативных маршрутов.\n",
|
||
"\n",
|
||
"5. **На простом лабиринте** (simple_maze) DFS показал худший результат по длине пути (29 вместо 15), что демонстрирует его главный недостаток — отсутствие гарантии кратчайшего пути.\n",
|
||
"\n",
|
||
"---\n",
|
||
"\n",
|
||
"## 6. Анализ применимости паттернов\n",
|
||
"\n",
|
||
"### 6.1 Оценка эффективности паттернов\n",
|
||
"\n",
|
||
"| Паттерн | Сложность реализации | Польза | Гибкость |\n",
|
||
"|---------|:---------------------:|:------:|:--------:|\n",
|
||
"| **Builder** | Средняя | Высокая | Высокая |\n",
|
||
"| **Strategy** | Низкая | Очень высокая | Очень высокая |\n",
|
||
"| **Observer** | Низкая | Средняя | Высокая |\n",
|
||
"| **Command** | Средняя | Средняя | Высокая |\n",
|
||
"\n",
|
||
"### 6.2 Что было бы сложно изменить без паттернов\n",
|
||
"\n",
|
||
"| Изменение | Без паттернов | С паттернами |\n",
|
||
"|-----------|---------------|--------------|\n",
|
||
"| Добавить поддержку JSON формата | Изменять весь код загрузки | Написать `JSONMazeBuilder` |\n",
|
||
"| Добавить алгоритм Дейкстры | Изменять класс `MazeSolver` | Написать `DijkstraStrategy` |\n",
|
||
"| Добавить графический интерфейс | Переписывать всю визуализацию | Написать `GUIView` |\n",
|
||
"| Добавить отмену действий | Невозможно без переписывания архитектуры | Уже реализовано в паттерне `Command` |\n",
|
||
"\n",
|
||
"### 6.3 Соответствие принципам SOLID\n",
|
||
"\n",
|
||
"| Принцип | Описание | Как реализовано |\n",
|
||
"|---------|----------|-----------------|\n",
|
||
"| **SRP** (Single Responsibility) | Одна ответственность у класса | `Maze` хранит данные, `Builder` создаёт, `Strategy` ищет путь, `Observer` отображает |\n",
|
||
"| **OCP** (Open/Closed) | Открыт для расширения, закрыт для изменения | Новые стратегии добавляются без изменения `MazeSolver` |\n",
|
||
"| **LSP** (Liskov Substitution) | Подклассы взаимозаменяемы | Любая стратегия может заменить `PathFindingStrategy` |\n",
|
||
"| **ISP** (Interface Segregation) | Интерфейсы узкоспециализированы | `MazeBuilder`, `PathFindingStrategy`, `Observer`, `Command` разделены по назначению |\n",
|
||
"| **DIP** (Dependency Inversion) | Зависимость от абстракций | `MazeSolver` зависит от `PathFindingStrategy`, а не от конкретных классов BFS/DFS/A* |\n",
|
||
"\n",
|
||
"---\n",
|
||
"\n",
|
||
"## 7. Выводы\n",
|
||
"\n",
|
||
"### 7.1 Выполнение требований лабораторной работы\n",
|
||
"\n",
|
||
"| № | Требование | Статус |\n",
|
||
"|---|------------|:------:|\n",
|
||
"| 1 | Создать классы `Cell` и `Maze` | ✅ |\n",
|
||
"| 2 | Реализовать метод `getNeighbors()` | ✅ |\n",
|
||
"| 3 | Загрузка лабиринта из файла | ✅ |\n",
|
||
"| 4 | Паттерн **Builder** | ✅ |\n",
|
||
"| 5 | Паттерн **Strategy** (3 алгоритма: BFS, DFS, A*) | ✅ |\n",
|
||
"| 6 | Класс `MazeSolver` с динамической сменой стратегии | ✅ |\n",
|
||
"| 7 | Сбор статистики `SearchStats` | ✅ |\n",
|
||
"| 8 | Паттерн **Observer** (визуализация) | ✅ |\n",
|
||
"| 9 | Паттерн **Command** (отмена действий) | ✅ |\n",
|
||
"| 10 | Экспериментальное сравнение алгоритмов | ✅ |\n",
|
||
"\n",
|
||
"### 7.2 Основные результаты\n",
|
||
"\n",
|
||
"1. **Разработана полностью функционирующая программа** для поиска пути в лабиринте.\n",
|
||
"\n",
|
||
"2. **Реализовано 4 паттерна GoF**: Builder, Strategy, Observer, Command.\n",
|
||
"\n",
|
||
"3. **Реализовано 3 алгоритма поиска**: BFS, DFS, A*.\n",
|
||
"\n",
|
||
"4. **Проведено экспериментальное сравнение**, которое показало:\n",
|
||
" - **DFS** — самый быстрый (0.100-0.134 мс), но неоптимальный (путь 29 вместо 15)\n",
|
||
" - **BFS** — оптимальный и стабильный (0.112-0.210 мс)\n",
|
||
" - **A*** — оптимальный, но медленный на простых лабиринтах (0.357 мс)\n",
|
||
"\n",
|
||
"### 7.3 Преимущества использованной архитектуры\n",
|
||
"\n",
|
||
"| Преимущество | Описание |\n",
|
||
"|--------------|----------|\n",
|
||
"| **Расширяемость** | Новые алгоритмы и форматы добавляются без изменения существующего кода |\n",
|
||
"| **Гибкость** | Алгоритмы можно менять во время выполнения через `setStrategy()` |\n",
|
||
"| **Тестируемость** | Компоненты изолированы и могут тестироваться независимо |\n",
|
||
"| **Поддерживаемость** | Код структурирован, каждый класс отвечает за одну задачу |\n",
|
||
"\n",
|
||
"### 7.4 Заключение\n",
|
||
"\n",
|
||
"Применение объектно-ориентированного подхода и паттернов проектирования позволило создать **гибкую**, **расширяемую** и **лёгкую в поддержке** программу.\n",
|
||
"\n",
|
||
"Без использования паттернов:\n",
|
||
"- Добавление нового алгоритма потребовало бы изменения класса `MazeSolver`\n",
|
||
"- Добавление нового формата лабиринта потребовало бы переписывания всей логики загрузки\n",
|
||
"- Реализация отмены действий была бы практически невозможна без коренной перестройки архитектуры\n",
|
||
"- Визуализация была бы жёстко привязана к логике поиска\n",
|
||
"\n",
|
||
"Использование паттернов полностью оправдано и демонстрирует преимущества современных методологий объектно-ориентированного проектирования.\n",
|
||
"\n"
|
||
]
|
||
}
|
||
],
|
||
"metadata": {
|
||
"kernelspec": {
|
||
"display_name": "Python 3",
|
||
"language": "python",
|
||
"name": "python3"
|
||
},
|
||
"language_info": {
|
||
"codemirror_mode": {
|
||
"name": "ipython",
|
||
"version": 3
|
||
},
|
||
"file_extension": ".py",
|
||
"mimetype": "text/x-python",
|
||
"name": "python",
|
||
"nbconvert_exporter": "python",
|
||
"pygments_lexer": "ipython3",
|
||
"version": "3.12.1"
|
||
}
|
||
},
|
||
"nbformat": 4,
|
||
"nbformat_minor": 5
|
||
}
|