429 lines
13 KiB
Python
429 lines
13 KiB
Python
|
from abc import ABC, abstractmethod
|
|||
|
|
from collections import deque
|
|||
|
|
import heapq
|
|||
|
|
import time
|
|||
|
|
import csv
|
|||
|
|
import random
|
|||
|
|
import os
|
|||
|
|
|
|||
|
|
BASE = os.path.dirname(os.path.abspath(__file__))
|
|||
|
|
|
|||
|
|
|
|||
|
|
class Cell:
|
|||
|
|
def __init__(self, x, y):
|
|||
|
|
self.x = x
|
|||
|
|
self.y = y
|
|||
|
|
self.isWall = False
|
|||
|
|
self.isStart = False
|
|||
|
|
self.isExit = False
|
|||
|
|
|
|||
|
|
def isPassable(self):
|
|||
|
|
return not self.isWall
|
|||
|
|
|
|||
|
|
def __eq__(self, other):
|
|||
|
|
if other is None:
|
|||
|
|
return False
|
|||
|
|
return self.x == other.x and self.y == other.y
|
|||
|
|
|
|||
|
|
def __hash__(self):
|
|||
|
|
return hash((self.x, self.y))
|
|||
|
|
|
|||
|
|
def __lt__(self, other):
|
|||
|
|
return (self.x, self.y) < (other.x, other.y)
|
|||
|
|
|
|||
|
|
|
|||
|
|
class Maze:
|
|||
|
|
def __init__(self, width, height):
|
|||
|
|
self.width = width
|
|||
|
|
self.height = height
|
|||
|
|
self.grid = [[Cell(x, y) for y in range(height)] for x in range(width)]
|
|||
|
|
self.start = None
|
|||
|
|
self.exit = None
|
|||
|
|
|
|||
|
|
def getCell(self, x, y):
|
|||
|
|
if 0 <= x < self.width and 0 <= y < self.height:
|
|||
|
|
return self.grid[x][y]
|
|||
|
|
return None
|
|||
|
|
|
|||
|
|
def getNeighbors(self, cell):
|
|||
|
|
neighbors = []
|
|||
|
|
for dx, dy in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
|
|||
|
|
n = self.getCell(cell.x + dx, cell.y + dy)
|
|||
|
|
if n and n.isPassable():
|
|||
|
|
neighbors.append(n)
|
|||
|
|
return neighbors
|
|||
|
|
|
|||
|
|
|
|||
|
|
class MazeBuilder(ABC):
|
|||
|
|
@abstractmethod
|
|||
|
|
def buildFromFile(self, filename):
|
|||
|
|
pass
|
|||
|
|
|
|||
|
|
|
|||
|
|
class TextFileMazeBuilder(MazeBuilder):
|
|||
|
|
def buildFromFile(self, filename):
|
|||
|
|
with open(filename, "r", encoding="utf-8") as f:
|
|||
|
|
lines = [line.rstrip("\n\r") for line in f.readlines()]
|
|||
|
|
|
|||
|
|
height = len(lines)
|
|||
|
|
width = len(lines[0]) if height > 0 else 0
|
|||
|
|
|
|||
|
|
for line in lines:
|
|||
|
|
if len(line) != width:
|
|||
|
|
raise ValueError("все строки должны быть одной длины")
|
|||
|
|
|
|||
|
|
maze = Maze(width, height)
|
|||
|
|
|
|||
|
|
for y in range(height):
|
|||
|
|
for x in range(width):
|
|||
|
|
ch = lines[y][x]
|
|||
|
|
cell = maze.getCell(x, y)
|
|||
|
|
if ch == "#":
|
|||
|
|
cell.isWall = True
|
|||
|
|
elif ch == " ":
|
|||
|
|
cell.isWall = False
|
|||
|
|
elif ch == "S":
|
|||
|
|
cell.isWall = False
|
|||
|
|
cell.isStart = True
|
|||
|
|
maze.start = cell
|
|||
|
|
elif ch == "E":
|
|||
|
|
cell.isWall = False
|
|||
|
|
cell.isExit = True
|
|||
|
|
maze.exit = cell
|
|||
|
|
else:
|
|||
|
|
raise ValueError(f"неизвестный символ: {ch}")
|
|||
|
|
|
|||
|
|
if maze.start is None:
|
|||
|
|
raise ValueError("нет старта (S)")
|
|||
|
|
if maze.exit is None:
|
|||
|
|
raise ValueError("нет выхода (E)")
|
|||
|
|
|
|||
|
|
return maze
|
|||
|
|
|
|||
|
|
|
|||
|
|
class PathFindingStrategy(ABC):
|
|||
|
|
@abstractmethod
|
|||
|
|
def findPath(self, maze, start, exit_cell):
|
|||
|
|
pass
|
|||
|
|
|
|||
|
|
def _reconstruct(self, parent, exit_cell):
|
|||
|
|
path = []
|
|||
|
|
curr = exit_cell
|
|||
|
|
while curr is not None:
|
|||
|
|
path.append(curr)
|
|||
|
|
curr = parent.get(curr)
|
|||
|
|
path.reverse()
|
|||
|
|
return path
|
|||
|
|
|
|||
|
|
|
|||
|
|
class BFSStrategy(PathFindingStrategy):
|
|||
|
|
def findPath(self, maze, start, exit_cell):
|
|||
|
|
if exit_cell is None:
|
|||
|
|
return []
|
|||
|
|
queue = deque([start])
|
|||
|
|
visited = {start}
|
|||
|
|
parent = {start: None}
|
|||
|
|
|
|||
|
|
while queue:
|
|||
|
|
curr = queue.popleft()
|
|||
|
|
if curr == exit_cell:
|
|||
|
|
return self._reconstruct(parent, exit_cell)
|
|||
|
|
for n in maze.getNeighbors(curr):
|
|||
|
|
if n not in visited:
|
|||
|
|
visited.add(n)
|
|||
|
|
parent[n] = curr
|
|||
|
|
queue.append(n)
|
|||
|
|
return []
|
|||
|
|
|
|||
|
|
|
|||
|
|
class DFSStrategy(PathFindingStrategy):
|
|||
|
|
def findPath(self, maze, start, exit_cell):
|
|||
|
|
if exit_cell is None:
|
|||
|
|
return []
|
|||
|
|
stack = [start]
|
|||
|
|
visited = {start}
|
|||
|
|
parent = {start: None}
|
|||
|
|
|
|||
|
|
while stack:
|
|||
|
|
curr = stack.pop()
|
|||
|
|
if curr == exit_cell:
|
|||
|
|
return self._reconstruct(parent, exit_cell)
|
|||
|
|
for n in maze.getNeighbors(curr):
|
|||
|
|
if n not in visited:
|
|||
|
|
visited.add(n)
|
|||
|
|
parent[n] = curr
|
|||
|
|
stack.append(n)
|
|||
|
|
return []
|
|||
|
|
|
|||
|
|
|
|||
|
|
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):
|
|||
|
|
if exit_cell is None:
|
|||
|
|
return []
|
|||
|
|
open_set = []
|
|||
|
|
heapq.heappush(open_set, (0, start))
|
|||
|
|
parent = {start: None}
|
|||
|
|
g_score = {start: 0}
|
|||
|
|
|
|||
|
|
while open_set:
|
|||
|
|
curr = heapq.heappop(open_set)[1]
|
|||
|
|
if curr == exit_cell:
|
|||
|
|
return self._reconstruct(parent, exit_cell)
|
|||
|
|
|
|||
|
|
for n in maze.getNeighbors(curr):
|
|||
|
|
new_g = g_score[curr] + 1
|
|||
|
|
if n not in g_score or new_g < g_score[n]:
|
|||
|
|
g_score[n] = new_g
|
|||
|
|
parent[n] = curr
|
|||
|
|
f = new_g + self._heuristic(n, exit_cell)
|
|||
|
|
heapq.heappush(open_set, (f, n))
|
|||
|
|
return []
|
|||
|
|
|
|||
|
|
|
|||
|
|
class SearchStats:
|
|||
|
|
def __init__(self, time_ms, visited, path_len):
|
|||
|
|
self.time_ms = time_ms
|
|||
|
|
self.visited_cells = visited
|
|||
|
|
self.path_length = path_len
|
|||
|
|
|
|||
|
|
|
|||
|
|
class MazeSolver:
|
|||
|
|
def __init__(self, maze):
|
|||
|
|
self.maze = maze
|
|||
|
|
self.strategy = None
|
|||
|
|
self.observers = []
|
|||
|
|
|
|||
|
|
def setStrategy(self, strategy):
|
|||
|
|
self.strategy = strategy
|
|||
|
|
|
|||
|
|
def attach(self, observer):
|
|||
|
|
self.observers.append(observer)
|
|||
|
|
|
|||
|
|
def notify(self, event):
|
|||
|
|
for obs in self.observers:
|
|||
|
|
obs.update(event)
|
|||
|
|
|
|||
|
|
def solve(self):
|
|||
|
|
if self.strategy is None:
|
|||
|
|
raise ValueError("стратегия не выбрана")
|
|||
|
|
|
|||
|
|
start_time = time.perf_counter()
|
|||
|
|
path = self.strategy.findPath(self.maze, self.maze.start, self.maze.exit)
|
|||
|
|
elapsed_ms = (time.perf_counter() - start_time) * 1000
|
|||
|
|
|
|||
|
|
stats = SearchStats(elapsed_ms, len(path), len(path))
|
|||
|
|
self.notify({"type": "path_found", "maze": self.maze, "path": path, "stats": stats})
|
|||
|
|
return path, stats
|
|||
|
|
|
|||
|
|
|
|||
|
|
class Observer(ABC):
|
|||
|
|
@abstractmethod
|
|||
|
|
def update(self, event):
|
|||
|
|
pass
|
|||
|
|
|
|||
|
|
|
|||
|
|
class ConsoleView(Observer):
|
|||
|
|
def update(self, event):
|
|||
|
|
if event["type"] == "path_found":
|
|||
|
|
stats = event["stats"]
|
|||
|
|
print(f"длина пути {stats.path_length}, время {stats.time_ms:.2f} мс")
|
|||
|
|
|
|||
|
|
|
|||
|
|
def save_maze(maze, filename):
|
|||
|
|
path = os.path.join(BASE, filename)
|
|||
|
|
with open(path, "w", encoding="utf-8") as f:
|
|||
|
|
for y in range(maze.height):
|
|||
|
|
line = ""
|
|||
|
|
for x in range(maze.width):
|
|||
|
|
cell = maze.getCell(x, y)
|
|||
|
|
if cell == maze.start:
|
|||
|
|
line += "S"
|
|||
|
|
elif cell == maze.exit:
|
|||
|
|
line += "E"
|
|||
|
|
elif cell.isWall:
|
|||
|
|
line += "#"
|
|||
|
|
else:
|
|||
|
|
line += " "
|
|||
|
|
f.write(line + "\n")
|
|||
|
|
|
|||
|
|
|
|||
|
|
def generate_with_walls(w, h, prob=0.3):
|
|||
|
|
maze = Maze(w, h)
|
|||
|
|
for x in range(w):
|
|||
|
|
for y in range(h):
|
|||
|
|
if random.random() < prob:
|
|||
|
|
maze.getCell(x, y).isWall = True
|
|||
|
|
maze.getCell(0, 0).isWall = False
|
|||
|
|
maze.getCell(w - 1, h - 1).isWall = False
|
|||
|
|
for x in range(w):
|
|||
|
|
maze.getCell(x, 0).isWall = False
|
|||
|
|
for y in range(h):
|
|||
|
|
maze.getCell(w - 1, y).isWall = False
|
|||
|
|
maze.getCell(0, 0).isStart = True
|
|||
|
|
maze.start = maze.getCell(0, 0)
|
|||
|
|
maze.getCell(w - 1, h - 1).isExit = True
|
|||
|
|
maze.exit = maze.getCell(w - 1, h - 1)
|
|||
|
|
return maze
|
|||
|
|
|
|||
|
|
|
|||
|
|
def generate_empty(w, h):
|
|||
|
|
maze = Maze(w, h)
|
|||
|
|
for x in range(w):
|
|||
|
|
for y in range(h):
|
|||
|
|
maze.getCell(x, y).isWall = False
|
|||
|
|
maze.getCell(0, 0).isStart = True
|
|||
|
|
maze.start = maze.getCell(0, 0)
|
|||
|
|
maze.getCell(w - 1, h - 1).isExit = True
|
|||
|
|
maze.exit = maze.getCell(w - 1, h - 1)
|
|||
|
|
return maze
|
|||
|
|
|
|||
|
|
|
|||
|
|
def generate_no_exit(w, h):
|
|||
|
|
maze = generate_with_walls(w, h, 0.3)
|
|||
|
|
exit_cell = maze.getCell(w - 1, h - 1)
|
|||
|
|
exit_cell.isWall = True
|
|||
|
|
exit_cell.isExit = False
|
|||
|
|
maze.exit = None
|
|||
|
|
return maze
|
|||
|
|
|
|||
|
|
|
|||
|
|
def run_experiment(maze, strategy_class, maze_name, repeats=5):
|
|||
|
|
times = []
|
|||
|
|
path_lens = []
|
|||
|
|
|
|||
|
|
for _ in range(repeats):
|
|||
|
|
solver = MazeSolver(maze)
|
|||
|
|
solver.setStrategy(strategy_class())
|
|||
|
|
path, stats = solver.solve()
|
|||
|
|
times.append(stats.time_ms)
|
|||
|
|
path_lens.append(len(path))
|
|||
|
|
|
|||
|
|
raw = strategy_class.__name__
|
|||
|
|
strat_name = "A" if raw == "AStarStrategy" else raw.replace("Strategy", "")
|
|||
|
|
return {
|
|||
|
|
"лабиринт": maze_name,
|
|||
|
|
"стратегия": strat_name,
|
|||
|
|
"время_ср": sum(times) / repeats,
|
|||
|
|
"длина_пути_ср": sum(path_lens) / repeats,
|
|||
|
|
"путь_найден": any(l > 0 for l in path_lens),
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
|
|||
|
|
def main():
|
|||
|
|
mazes = []
|
|||
|
|
|
|||
|
|
small = generate_with_walls(10, 10, 0.2)
|
|||
|
|
save_maze(small, "maze_small.txt")
|
|||
|
|
mazes.append(("маленький 10x10", small))
|
|||
|
|
|
|||
|
|
medium = generate_with_walls(50, 50, 0.3)
|
|||
|
|
save_maze(medium, "maze_medium.txt")
|
|||
|
|
mazes.append(("средний 50x50", medium))
|
|||
|
|
|
|||
|
|
large = generate_with_walls(100, 100, 0.3)
|
|||
|
|
save_maze(large, "maze_large.txt")
|
|||
|
|
mazes.append(("большой 100x100", large))
|
|||
|
|
|
|||
|
|
empty = generate_empty(50, 50)
|
|||
|
|
save_maze(empty, "maze_empty.txt")
|
|||
|
|
mazes.append(("пустой 50x50", empty))
|
|||
|
|
|
|||
|
|
no_exit = generate_no_exit(20, 20)
|
|||
|
|
save_maze(no_exit, "maze_no_exit.txt")
|
|||
|
|
mazes.append(("без выхода 20x20", no_exit))
|
|||
|
|
|
|||
|
|
strategies = [BFSStrategy, DFSStrategy, AStarStrategy]
|
|||
|
|
results = []
|
|||
|
|
|
|||
|
|
for maze_name, maze in mazes:
|
|||
|
|
print(maze_name)
|
|||
|
|
for strat in strategies:
|
|||
|
|
res = run_experiment(maze, strat, maze_name)
|
|||
|
|
results.append(res)
|
|||
|
|
print(f" {strat.__name__}: {res['время_ср']:.2f} мс")
|
|||
|
|
|
|||
|
|
csv_path = os.path.join(BASE, "resultslab.csv")
|
|||
|
|
with open(csv_path, "w", newline="", encoding="utf-8-sig") as f:
|
|||
|
|
writer = csv.DictWriter(
|
|||
|
|
f,
|
|||
|
|
fieldnames=["лабиринт", "стратегия", "время_ср", "длина_пути_ср", "путь_найден"],
|
|||
|
|
delimiter=";",
|
|||
|
|
)
|
|||
|
|
writer.writeheader()
|
|||
|
|
for row in results:
|
|||
|
|
row_ru = row.copy()
|
|||
|
|
row_ru["путь_найден"] = "да" if row["путь_найден"] else "нет"
|
|||
|
|
writer.writerow(row_ru)
|
|||
|
|
|
|||
|
|
try:
|
|||
|
|
import matplotlib.pyplot as plt
|
|||
|
|
|
|||
|
|
plt.rcParams["font.sans-serif"] = ["Segoe UI", "Arial", "Tahoma", "DejaVu Sans"]
|
|||
|
|
plt.rcParams["axes.unicode_minus"] = False
|
|||
|
|
|
|||
|
|
labyrinths = []
|
|||
|
|
for r in results:
|
|||
|
|
if r["лабиринт"] not in labyrinths:
|
|||
|
|
labyrinths.append(r["лабиринт"])
|
|||
|
|
|
|||
|
|
fig, axes = plt.subplots(1, len(labyrinths), figsize=(4 * len(labyrinths), 4))
|
|||
|
|
if len(labyrinths) == 1:
|
|||
|
|
axes = [axes]
|
|||
|
|
|
|||
|
|
for idx, lab in enumerate(labyrinths):
|
|||
|
|
times = []
|
|||
|
|
for s in ["BFS", "DFS", "A"]:
|
|||
|
|
for r in results:
|
|||
|
|
if r["лабиринт"] == lab and r["стратегия"] == s:
|
|||
|
|
times.append(r["время_ср"])
|
|||
|
|
break
|
|||
|
|
axes[idx].bar(["BFS", "DFS", "A"], times, color=["#1a5632", "#0e5fb4", "#e67e22"])
|
|||
|
|
axes[idx].set_title(lab)
|
|||
|
|
axes[idx].set_ylabel("мс")
|
|||
|
|
|
|||
|
|
plt.tight_layout()
|
|||
|
|
plt.savefig(os.path.join(BASE, "maze_time_comparison.png"))
|
|||
|
|
plt.close()
|
|||
|
|
except ImportError:
|
|||
|
|
pass
|
|||
|
|
|
|||
|
|
report_path = os.path.join(os.path.dirname(BASE), "report.md")
|
|||
|
|
with open(report_path, "w", encoding="utf-8-sig") as f:
|
|||
|
|
f.write("# Отчёт: поиск пути в лабиринте\n\n")
|
|||
|
|
f.write("Паттерны: Builder, Strategy, Observer\n\n")
|
|||
|
|
f.write("```mermaid\nclassDiagram\n")
|
|||
|
|
f.write("class MazeBuilder\nclass TextFileMazeBuilder\n")
|
|||
|
|
f.write("class PathFindingStrategy\nclass BFSStrategy\n")
|
|||
|
|
f.write("class DFSStrategy\nclass AStarStrategy\n")
|
|||
|
|
f.write("class MazeSolver\nclass Observer\nclass ConsoleView\n")
|
|||
|
|
f.write("MazeBuilder <|-- TextFileMazeBuilder\n")
|
|||
|
|
f.write("PathFindingStrategy <|-- BFSStrategy\n")
|
|||
|
|
f.write("PathFindingStrategy <|-- DFSStrategy\n")
|
|||
|
|
f.write("PathFindingStrategy <|-- AStarStrategy\n")
|
|||
|
|
f.write("Observer <|-- ConsoleView\n")
|
|||
|
|
f.write("MazeSolver --> PathFindingStrategy\n")
|
|||
|
|
f.write("```\n\n")
|
|||
|
|
f.write("| Лабиринт | Стратегия | Время (мс) | Длина пути | Найден |\n")
|
|||
|
|
f.write("| --- | --- | --- | --- | --- |\n")
|
|||
|
|
for r in results:
|
|||
|
|
found = "да" if r["путь_найден"] else "нет"
|
|||
|
|
f.write(
|
|||
|
|
f"| {r['лабиринт']} | {r['стратегия']} | {r['время_ср']:.2f} | "
|
|||
|
|
f"{r['длина_пути_ср']:.0f} | {found} |\n"
|
|||
|
|
)
|
|||
|
|
f.write("\n\n\n")
|
|||
|
|
f.write("## Выводы\n\n")
|
|||
|
|
f.write("- BFS и A* находят кратчайший путь.\n")
|
|||
|
|
f.write("- DFS путь может быть длиннее.\n")
|
|||
|
|
f.write("- На пустом лабиринте алгоритмы работают быстрее всего.\n")
|
|||
|
|
f.write("- Без выхода все стратегии возвращают пустой путь.\n")
|
|||
|
|
|
|||
|
|
print("Готово:", report_path)
|
|||
|
|
|
|||
|
|
|
|||
|
|
if __name__ == "__main__":
|
|||
|
|
main()
|