285 lines
10 KiB
Python
285 lines
10 KiB
Python
import csv
|
||
import time
|
||
import os
|
||
import random
|
||
from collections import deque
|
||
import heapq
|
||
import matplotlib.pyplot as plt
|
||
import pandas as pd
|
||
|
||
class Cell:
|
||
def __init__(self, x, y):
|
||
self.x = x
|
||
self.y = y
|
||
self.is_wall = False
|
||
self.is_start = False
|
||
self.is_exit = False
|
||
|
||
def isPassable(self):
|
||
return not self.is_wall
|
||
|
||
class Maze:
|
||
def __init__(self, width, height):
|
||
self.width = width
|
||
self.height = height
|
||
self.cells = []
|
||
self.start = None
|
||
self.exit = None
|
||
|
||
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):
|
||
neighbors = []
|
||
for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
|
||
neighbor = self.getCell(cell.x + dx, cell.y + dy)
|
||
if neighbor and neighbor.isPassable():
|
||
neighbors.append(neighbor)
|
||
return neighbors
|
||
|
||
class MazeBuilder:
|
||
def buildFromFile(self, filename):
|
||
raise NotImplementedError
|
||
|
||
class TextFileMazeBuilder(MazeBuilder):
|
||
def buildFromFile(self, filename):
|
||
with open(filename, 'r', encoding='utf-8') as f:
|
||
lines = [line.rstrip('\n') for line in f.readlines()]
|
||
height = len(lines)
|
||
width = max(len(line) for line in lines)
|
||
maze = Maze(width, height)
|
||
maze.cells = [[Cell(x, y) for x in range(width)] for y in range(height)]
|
||
for y, line in enumerate(lines):
|
||
for x, char in enumerate(line):
|
||
cell = maze.cells[y][x]
|
||
if char == '#':
|
||
cell.is_wall = True
|
||
elif char == 'S':
|
||
cell.is_start = True
|
||
maze.start = cell
|
||
elif char == 'E':
|
||
cell.is_exit = True
|
||
maze.exit = cell
|
||
if maze.start is None or maze.exit is None:
|
||
raise ValueError("В файле должны быть символы S и E")
|
||
return maze
|
||
|
||
class PathFindingStrategy:
|
||
def findPath(self, maze, start, exit):
|
||
raise NotImplementedError
|
||
|
||
class BFSStrategy(PathFindingStrategy):
|
||
def findPath(self, maze, start, exit):
|
||
queue = deque([start])
|
||
came_from = {start: None}
|
||
visited = set([start])
|
||
while queue:
|
||
current = queue.popleft()
|
||
if current == exit:
|
||
break
|
||
for neighbor in maze.getNeighbors(current):
|
||
if neighbor not in visited:
|
||
visited.add(neighbor)
|
||
queue.append(neighbor)
|
||
came_from[neighbor] = current
|
||
path = self._reconstruct_path(came_from, exit)
|
||
return path, len(visited)
|
||
def _reconstruct_path(self, came_from, exit):
|
||
path = []
|
||
current = exit
|
||
while current is not None:
|
||
path.append(current)
|
||
current = came_from.get(current)
|
||
path.reverse()
|
||
return path if path and path[0] == came_from.get(exit) or path[0] == exit else []
|
||
|
||
class DFSStrategy(PathFindingStrategy):
|
||
def findPath(self, maze, start, exit):
|
||
stack = [start]
|
||
came_from = {start: None}
|
||
visited = set([start])
|
||
while stack:
|
||
current = stack.pop()
|
||
if current == exit:
|
||
break
|
||
for neighbor in maze.getNeighbors(current):
|
||
if neighbor not in visited:
|
||
visited.add(neighbor)
|
||
stack.append(neighbor)
|
||
came_from[neighbor] = current
|
||
path = self._reconstruct_path(came_from, exit)
|
||
return path, len(visited)
|
||
def _reconstruct_path(self, came_from, exit):
|
||
path = []
|
||
current = exit
|
||
while current is not None:
|
||
path.append(current)
|
||
current = came_from.get(current)
|
||
path.reverse()
|
||
return path
|
||
|
||
class AStarStrategy(PathFindingStrategy):
|
||
def heuristic(self, a, b):
|
||
return abs(a.x - b.x) + abs(a.y - b.y)
|
||
def findPath(self, maze, start, exit):
|
||
open_set = []
|
||
counter = 0
|
||
heapq.heappush(open_set, (0, counter, start))
|
||
came_from = {start: None}
|
||
g_score = {start: 0}
|
||
visited = set()
|
||
while open_set:
|
||
_, _, current = heapq.heappop(open_set)
|
||
if current in visited:
|
||
continue
|
||
visited.add(current)
|
||
if current == exit:
|
||
break
|
||
for neighbor in maze.getNeighbors(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 = tentative_g + self.heuristic(neighbor, exit)
|
||
counter += 1
|
||
heapq.heappush(open_set, (f_score, counter, neighbor))
|
||
path = self._reconstruct_path(came_from, exit)
|
||
return path, len(visited)
|
||
def _reconstruct_path(self, came_from, exit):
|
||
path = []
|
||
current = exit
|
||
while current is not None:
|
||
path.append(current)
|
||
current = came_from.get(current)
|
||
path.reverse()
|
||
return path
|
||
|
||
class SearchStats:
|
||
def __init__(self, time_ms, visited_cells, path_length):
|
||
self.time_ms = time_ms
|
||
self.visited_cells = visited_cells
|
||
self.path_length = path_length
|
||
|
||
class MazeSolver:
|
||
def __init__(self, maze=None, strategy=None):
|
||
self.maze = maze
|
||
self.strategy = strategy
|
||
def setStrategy(self, strategy):
|
||
self.strategy = strategy
|
||
def solve(self):
|
||
if not self.maze or not self.strategy:
|
||
return None
|
||
start_time = time.perf_counter()
|
||
path, visited_count = self.strategy.findPath(self.maze, self.maze.start, self.maze.exit)
|
||
end_time = time.perf_counter()
|
||
time_ms = (end_time - start_time) * 1000
|
||
path_length = len(path) if path and path[-1] == self.maze.exit else 0
|
||
return SearchStats(round(time_ms, 4), visited_count, path_length)
|
||
|
||
def create_maze_with_walls(size, wall_probability=0.3):
|
||
maze = Maze(size, size)
|
||
maze.cells = [[Cell(x, y) for x in range(size)] for y in range(size)]
|
||
for y in range(size):
|
||
for x in range(size):
|
||
if random.random() < wall_probability:
|
||
maze.cells[y][x].is_wall = True
|
||
maze.start = maze.cells[0][0]
|
||
maze.exit = maze.cells[size-1][size-1]
|
||
maze.start.is_start = True
|
||
maze.exit.is_exit = True
|
||
maze.start.is_wall = False
|
||
maze.exit.is_wall = False
|
||
return maze
|
||
|
||
def create_empty_maze(size):
|
||
maze = Maze(size, size)
|
||
maze.cells = [[Cell(x, y) for x in range(size)] for y in range(size)]
|
||
maze.start = maze.cells[0][0]
|
||
maze.exit = maze.cells[size-1][size-1]
|
||
maze.start.is_start = True
|
||
maze.exit.is_exit = True
|
||
return maze
|
||
|
||
def create_no_exit_maze(size, wall_probability=0.3):
|
||
maze = create_maze_with_walls(size, wall_probability)
|
||
maze.exit.is_wall = True
|
||
return maze
|
||
|
||
def run_experiment():
|
||
maze_configs = {
|
||
"10x10_simple": {"size": 10, "type": "normal", "wall_prob": 0.1},
|
||
"50x50_with_deadends": {"size": 50, "type": "normal", "wall_prob": 0.3},
|
||
"100x100_complex": {"size": 100, "type": "normal", "wall_prob": 0.35},
|
||
"empty": {"size": 30, "type": "empty"},
|
||
"no_exit": {"size": 30, "type": "no_exit", "wall_prob": 0.3},
|
||
}
|
||
strategies = {
|
||
"BFS": BFSStrategy(),
|
||
"DFS": DFSStrategy(),
|
||
"AStar": AStarStrategy()
|
||
}
|
||
results = []
|
||
for maze_name, config in maze_configs.items():
|
||
size = config["size"]
|
||
maze_type = config["type"]
|
||
if maze_type == "empty":
|
||
maze = create_empty_maze(size)
|
||
elif maze_type == "no_exit":
|
||
maze = create_no_exit_maze(size, config.get("wall_prob", 0.3))
|
||
else:
|
||
maze = create_maze_with_walls(size, config.get("wall_prob", 0.3))
|
||
for strat_name, strategy in strategies.items():
|
||
solver = MazeSolver(maze, strategy)
|
||
times, visited_list, lengths = [], [], []
|
||
for _ in range(7):
|
||
stats = solver.solve()
|
||
times.append(stats.time_ms)
|
||
visited_list.append(stats.visited_cells)
|
||
lengths.append(stats.path_length)
|
||
avg_time = sum(times) / len(times)
|
||
avg_visited = sum(visited_list) / len(visited_list)
|
||
avg_length = sum(lengths) / len(lengths)
|
||
results.append([
|
||
maze_name, strat_name,
|
||
round(avg_time, 4),
|
||
int(avg_visited),
|
||
int(avg_length)
|
||
])
|
||
os.makedirs("results", exist_ok=True)
|
||
csv_path = "results/results.csv"
|
||
with open(csv_path, "w", newline="", encoding="utf-8") as f:
|
||
writer = csv.writer(f)
|
||
writer.writerow(["лабиринт", "стратегия", "время_мс", "посещено_клеток", "длина_пути"])
|
||
writer.writerows(results)
|
||
df = pd.read_csv(csv_path)
|
||
plt.figure(figsize=(12, 6))
|
||
for strat in df["стратегия"].unique():
|
||
subset = df[df["стратегия"] == strat]
|
||
plt.plot(subset["лабиринт"], subset["время_мс"], marker='o', label=strat)
|
||
plt.title("Сравнение времени работы алгоритмов")
|
||
plt.xlabel("Лабиринт")
|
||
plt.ylabel("Время (мс)")
|
||
plt.legend()
|
||
plt.grid(True)
|
||
plt.xticks(rotation=45)
|
||
plt.tight_layout()
|
||
plt.savefig("results/time_comparison.png")
|
||
plt.close()
|
||
plt.figure(figsize=(12, 6))
|
||
for strat in df["стратегия"].unique():
|
||
subset = df[df["стратегия"] == strat]
|
||
plt.plot(subset["лабиринт"], subset["посещено_клеток"], marker='o', label=strat)
|
||
plt.title("Количество посещённых клеток")
|
||
plt.xlabel("Лабиринт")
|
||
plt.ylabel("Посещено клеток")
|
||
plt.legend()
|
||
plt.grid(True)
|
||
plt.xticks(rotation=45)
|
||
plt.tight_layout()
|
||
plt.savefig("results/visited_comparison.png")
|
||
plt.close()
|
||
|
||
if __name__ == "__main__":
|
||
run_experiment() |