forked from UNN/2026-rff_mp
441 lines
14 KiB
Python
441 lines
14 KiB
Python
import time
|
||
import random
|
||
import csv
|
||
import os
|
||
from collections import deque
|
||
import heapq
|
||
import matplotlib.pyplot as plt
|
||
import numpy as np
|
||
|
||
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 is_passable(self):
|
||
return not self.is_wall
|
||
|
||
|
||
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_cell = None
|
||
self.exit_cell = None
|
||
|
||
def get_cell(self, x, y):
|
||
if 0 <= x < self.width and 0 <= y < self.height:
|
||
return self.grid[x][y]
|
||
return None
|
||
|
||
def get_neighbors(self, cell):
|
||
neighbors = []
|
||
for dx, dy in [(-1,0), (1,0), (0,-1), (0,1)]:
|
||
nx, ny = cell.x + dx, cell.y + dy
|
||
neighbor = self.get_cell(nx, ny)
|
||
if neighbor and neighbor.is_passable():
|
||
neighbors.append(neighbor)
|
||
return neighbors
|
||
|
||
|
||
class MazeBuilder:
|
||
def build_from_file(self, filename):
|
||
raise NotImplementedError
|
||
|
||
|
||
class TextFileMazeBuilder(MazeBuilder):
|
||
def build_from_file(self, filename):
|
||
with open(filename, 'r', encoding='utf-8') as f:
|
||
lines = f.readlines()
|
||
lines = [line.rstrip('\n') for line in lines if line.strip() != '']
|
||
if not lines:
|
||
raise ValueError("Файл пуст")
|
||
height = len(lines)
|
||
width = max(len(line) for line in lines)
|
||
maze = Maze(width, height)
|
||
for y, line in enumerate(lines):
|
||
for x, ch in enumerate(line):
|
||
if x >= width:
|
||
break
|
||
cell = maze.get_cell(x, y)
|
||
if ch == '#':
|
||
cell.is_wall = True
|
||
elif ch == 'S':
|
||
cell.is_start = True
|
||
maze.start_cell = cell
|
||
elif ch == 'E':
|
||
cell.is_exit = True
|
||
maze.exit_cell = cell
|
||
if maze.start_cell is None or maze.exit_cell is None:
|
||
raise ValueError("В лабиринте должны быть S и E")
|
||
return maze
|
||
|
||
|
||
class PathFindingStrategy:
|
||
def find_path(self, maze, start, exit):
|
||
raise NotImplementedError
|
||
|
||
|
||
class BFSStrategy(PathFindingStrategy):
|
||
def find_path(self, maze, start, exit):
|
||
if start == exit:
|
||
return [start]
|
||
queue = deque([start])
|
||
visited = {start}
|
||
parent = {start: None}
|
||
while queue:
|
||
current = queue.popleft()
|
||
if current == exit:
|
||
break
|
||
for neighbor in maze.get_neighbors(current):
|
||
if neighbor not in visited:
|
||
visited.add(neighbor)
|
||
parent[neighbor] = current
|
||
queue.append(neighbor)
|
||
if exit not in parent:
|
||
return []
|
||
path = []
|
||
step = exit
|
||
while step is not None:
|
||
path.append(step)
|
||
step = parent[step]
|
||
path.reverse()
|
||
return path
|
||
|
||
|
||
class DFSStrategy(PathFindingStrategy):
|
||
def find_path(self, maze, start, exit):
|
||
if start == exit:
|
||
return [start]
|
||
stack = [start]
|
||
visited = {start}
|
||
parent = {start: None}
|
||
while stack:
|
||
current = stack.pop()
|
||
if current == exit:
|
||
break
|
||
for neighbor in maze.get_neighbors(current):
|
||
if neighbor not in visited:
|
||
visited.add(neighbor)
|
||
parent[neighbor] = current
|
||
stack.append(neighbor)
|
||
if exit not in parent:
|
||
return []
|
||
path = []
|
||
step = exit
|
||
while step is not None:
|
||
path.append(step)
|
||
step = parent[step]
|
||
path.reverse()
|
||
return path
|
||
|
||
|
||
class AStarStrategy(PathFindingStrategy):
|
||
def heuristic(self, a, b):
|
||
return abs(a.x - b.x) + abs(a.y - b.y)
|
||
|
||
def find_path(self, maze, start, exit):
|
||
if start == exit:
|
||
return [start]
|
||
open_set = []
|
||
heapq.heappush(open_set, (0, id(start), start))
|
||
came_from = {}
|
||
g_score = {start: 0}
|
||
f_score = {start: self.heuristic(start, exit)}
|
||
while open_set:
|
||
_, _, current = heapq.heappop(open_set)
|
||
if current == exit:
|
||
path = []
|
||
step = current
|
||
while step is not None:
|
||
path.append(step)
|
||
step = came_from.get(step)
|
||
path.reverse()
|
||
return path
|
||
for neighbor in maze.get_neighbors(current):
|
||
tentative_g = g_score[current] + 1
|
||
if neighbor not in g_score or tentative_g < g_score[neighbor]:
|
||
came_from[neighbor] = current
|
||
g_score[neighbor] = tentative_g
|
||
f_score[neighbor] = tentative_g + self.heuristic(neighbor, exit)
|
||
heapq.heappush(open_set, (f_score[neighbor], id(neighbor), neighbor))
|
||
return []
|
||
|
||
|
||
class MazeSolver:
|
||
def __init__(self, maze, strategy=None):
|
||
self.maze = maze
|
||
self.strategy = strategy
|
||
self.observers = [] # для Observer
|
||
|
||
def set_strategy(self, strategy):
|
||
self.strategy = strategy
|
||
|
||
def attach(self, observer):
|
||
self.observers.append(observer)
|
||
|
||
def detach(self, observer):
|
||
self.observers.remove(observer)
|
||
|
||
def notify(self, event):
|
||
for obs in self.observers:
|
||
obs.update(event)
|
||
|
||
def solve(self):
|
||
if self.strategy is None:
|
||
raise ValueError("Стратегия не установлена")
|
||
start = self.maze.start_cell
|
||
exit_cell = self.maze.exit_cell
|
||
if start is None or exit_cell is None:
|
||
raise ValueError("Лабиринт не содержит старта или выхода")
|
||
self.notify("Поиск начат")
|
||
start_time = time.perf_counter()
|
||
path = self.strategy.find_path(self.maze, start, exit_cell)
|
||
end_time = time.perf_counter()
|
||
elapsed_ms = (end_time - start_time) * 1000
|
||
self.notify("Поиск завершён")
|
||
return path, elapsed_ms
|
||
|
||
|
||
class Observer:
|
||
def update(self, event):
|
||
raise NotImplementedError
|
||
|
||
|
||
class ConsoleView(Observer):
|
||
def __init__(self, maze):
|
||
self.maze = maze
|
||
|
||
def update(self, event):
|
||
if event == "Поиск начат":
|
||
print("=== Поиск начат ===")
|
||
elif event == "Поиск завершён":
|
||
print("=== Поиск завершён ===")
|
||
|
||
def render(self, path=None):
|
||
path_set = set(path) if path else set()
|
||
for y in range(self.maze.height):
|
||
row = ''
|
||
for x in range(self.maze.width):
|
||
cell = self.maze.get_cell(x, y)
|
||
if cell.is_wall:
|
||
row += '#'
|
||
elif cell.is_start:
|
||
row += 'S'
|
||
elif cell.is_exit:
|
||
row += 'E'
|
||
elif cell in path_set:
|
||
row += '*'
|
||
else:
|
||
row += ' '
|
||
print(row)
|
||
print()
|
||
|
||
|
||
class Command:
|
||
def execute(self):
|
||
raise NotImplementedError
|
||
|
||
def undo(self):
|
||
raise NotImplementedError
|
||
|
||
|
||
class MoveCommand(Command):
|
||
def __init__(self, player, dx, dy):
|
||
self.player = player
|
||
self.dx = dx
|
||
self.dy = dy
|
||
self.prev_x = player.x
|
||
self.prev_y = player.y
|
||
|
||
def execute(self):
|
||
new_x = self.player.x + self.dx
|
||
new_y = self.player.y + self.dy
|
||
maze = self.player.maze
|
||
cell = maze.get_cell(new_x, new_y)
|
||
if cell and cell.is_passable():
|
||
self.player.x = new_x
|
||
self.player.y = new_y
|
||
self.player.current_cell = cell
|
||
return True
|
||
return False
|
||
|
||
def undo(self):
|
||
self.player.x = self.prev_x
|
||
self.player.y = self.prev_y
|
||
self.player.current_cell = self.player.maze.get_cell(self.prev_x, self.prev_y)
|
||
|
||
|
||
class Player:
|
||
def __init__(self, maze, start_cell):
|
||
self.maze = maze
|
||
self.x = start_cell.x
|
||
self.y = start_cell.y
|
||
self.current_cell = start_cell
|
||
|
||
|
||
# EEEEEEEEEKSPERIMENTY
|
||
def generate_empty_maze(width, height):
|
||
maze = Maze(width, height)
|
||
start = maze.get_cell(0, 0)
|
||
exit_cell = maze.get_cell(width-1, height-1)
|
||
start.is_start = True
|
||
exit_cell.is_exit = True
|
||
maze.start_cell = start
|
||
maze.exit_cell = exit_cell
|
||
return maze
|
||
|
||
|
||
def generate_random_maze(width, height, wall_prob=0.3):
|
||
maze = Maze(width, height)
|
||
for x in range(width):
|
||
for y in range(height):
|
||
cell = maze.get_cell(x, y)
|
||
if random.random() < wall_prob:
|
||
cell.is_wall = True
|
||
start = maze.get_cell(0, 0)
|
||
exit_cell = maze.get_cell(width-1, height-1)
|
||
start.is_wall = False
|
||
start.is_start = True
|
||
exit_cell.is_wall = False
|
||
exit_cell.is_exit = True
|
||
maze.start_cell = start
|
||
maze.exit_cell = exit_cell
|
||
return maze
|
||
|
||
|
||
def generate_maze_with_dead_ends(width, height):
|
||
maze = Maze(width, height)
|
||
for x in range(width):
|
||
for y in range(height):
|
||
maze.get_cell(x, y).is_wall = True
|
||
x, y = 0, 0
|
||
while x < width and y < height:
|
||
cell = maze.get_cell(x, y)
|
||
cell.is_wall = False
|
||
if x == width-1 and y == height-1:
|
||
break
|
||
if y+1 < height and (x == width-1 or random.choice([True, False])):
|
||
y += 1
|
||
else:
|
||
x += 1
|
||
start = maze.get_cell(0, 0)
|
||
exit_cell = maze.get_cell(width-1, height-1)
|
||
start.is_start = True
|
||
exit_cell.is_exit = True
|
||
maze.start_cell = start
|
||
maze.exit_cell = exit_cell
|
||
return maze
|
||
|
||
|
||
def generate_maze_no_exit(width, height):
|
||
maze = generate_random_maze(width, height, 0.2)
|
||
exit_cell = maze.get_cell(width-1, height-1)
|
||
for dx, dy in [(-1,0), (1,0), (0,-1), (0,1)]:
|
||
nx, ny = exit_cell.x + dx, exit_cell.y + dy
|
||
neighbor = maze.get_cell(nx, ny)
|
||
if neighbor:
|
||
neighbor.is_wall = True
|
||
start = maze.get_cell(0, 0)
|
||
start.is_wall = False
|
||
start.is_start = True
|
||
maze.start_cell = start
|
||
maze.exit_cell = exit_cell
|
||
return maze
|
||
|
||
|
||
def run_experiment():
|
||
os.makedirs("results", exist_ok=True)
|
||
|
||
maze_generators = [
|
||
("empty_10x10", lambda: generate_empty_maze(10, 10)),
|
||
("empty_50x50", lambda: generate_empty_maze(50, 50)),
|
||
("empty_100x100", lambda: generate_empty_maze(100, 100)),
|
||
("random_10x10", lambda: generate_random_maze(10, 10, 0.3)),
|
||
("random_50x50", lambda: generate_random_maze(50, 50, 0.3)),
|
||
("random_100x100", lambda: generate_random_maze(100, 100, 0.3)),
|
||
("dead_ends_10x10", lambda: generate_maze_with_dead_ends(10, 10)),
|
||
("dead_ends_50x50", lambda: generate_maze_with_dead_ends(50, 50)),
|
||
("dead_ends_100x100", lambda: generate_maze_with_dead_ends(100, 100)),
|
||
("no_exit_10x10", lambda: generate_maze_no_exit(10, 10)),
|
||
("no_exit_50x50", lambda: generate_maze_no_exit(50, 50)),
|
||
]
|
||
|
||
strategies = [
|
||
("BFS", BFSStrategy()),
|
||
("DFS", DFSStrategy()),
|
||
("AStar", AStarStrategy())
|
||
]
|
||
|
||
repeats = 5
|
||
all_results = []
|
||
|
||
for maze_name, gen_func in maze_generators:
|
||
print(f"Тестирование лабиринта: {maze_name}")
|
||
maze = gen_func()
|
||
solver = MazeSolver(maze)
|
||
for strat_name, strat in strategies:
|
||
solver.set_strategy(strat)
|
||
total_time = 0
|
||
total_path_len = 0
|
||
path = []
|
||
for rep in range(repeats):
|
||
path, elapsed_ms = solver.solve()
|
||
total_time += elapsed_ms
|
||
total_path_len += len(path) if path else 0
|
||
avg_time = total_time / repeats
|
||
avg_len = total_path_len / repeats
|
||
all_results.append({
|
||
"Maze": maze_name,
|
||
"Strategy": strat_name,
|
||
"AvgTime_ms": avg_time,
|
||
"AvgPathLen": avg_len,
|
||
"PathFound": len(path) > 0 if path else False
|
||
})
|
||
print(f" {strat_name}: время {avg_time:.3f} мс, длина пути {avg_len:.1f}")
|
||
|
||
# Сохраняем CSV
|
||
csv_path = "results/experiment_results.csv"
|
||
with open(csv_path, 'w', newline='', encoding='utf-8') as f:
|
||
fieldnames = ["Maze", "Strategy", "AvgTime_ms", "AvgPathLen", "PathFound"]
|
||
writer = csv.DictWriter(f, fieldnames=fieldnames)
|
||
writer.writeheader()
|
||
writer.writerows(all_results)
|
||
print(f"Результаты сохранены в {csv_path}")
|
||
|
||
# Построение графика
|
||
maze_names = sorted(set(r["Maze"] for r in all_results))
|
||
strategy_names = ["BFS", "DFS", "AStar"]
|
||
data = {maze: {s: None for s in strategy_names} for maze in maze_names}
|
||
for r in all_results:
|
||
data[r["Maze"]][r["Strategy"]] = r["AvgTime_ms"]
|
||
|
||
fig, ax = plt.subplots(figsize=(14, 6))
|
||
x = np.arange(len(maze_names))
|
||
width = 0.25
|
||
colors = ['skyblue', 'lightgreen', 'salmon']
|
||
|
||
for i, strat in enumerate(strategy_names):
|
||
times = [data[maze][strat] if data[maze][strat] is not None else 0 for maze in maze_names]
|
||
ax.bar(x + i*width, times, width, label=strat, color=colors[i])
|
||
|
||
ax.set_xlabel('Лабиринт')
|
||
ax.set_ylabel('Среднее время (мс)')
|
||
ax.set_title('Сравнение стратегий поиска пути')
|
||
ax.set_xticks(x + width)
|
||
ax.set_xticklabels(maze_names, rotation=45, ha='right')
|
||
ax.legend()
|
||
|
||
plt.tight_layout()
|
||
plt.savefig("results/performance.png", dpi=150)
|
||
plt.show()
|
||
print("График сохранён в results/performance.png")
|
||
|
||
|
||
if __name__ == '__main__':
|
||
run_experiment()
|