diff --git a/kalinovskiymi/docs_2/data_2/comparative_results.png b/kalinovskiymi/docs_2/data_2/comparative_results.png new file mode 100644 index 0000000..c6a3592 Binary files /dev/null and b/kalinovskiymi/docs_2/data_2/comparative_results.png differ diff --git a/kalinovskiymi/docs_2/data_2/mazes_visualization.png b/kalinovskiymi/docs_2/data_2/mazes_visualization.png new file mode 100644 index 0000000..ea95abe Binary files /dev/null and b/kalinovskiymi/docs_2/data_2/mazes_visualization.png differ diff --git a/kalinovskiymi/docs_2/data_2/results.csv b/kalinovskiymi/docs_2/data_2/results.csv new file mode 100644 index 0000000..cf33e4d --- /dev/null +++ b/kalinovskiymi/docs_2/data_2/results.csv @@ -0,0 +1,16 @@ +Лабиринт,Стратегия,Время_мс,Посещено,Длина_пути +Маленький (10x10),BFS,0.13895999999995468,53.0,15.0 +Маленький (10x10),DFS,0.0922400000000323,35.0,31.0 +Маленький (10x10),A*,0.13939999999998953,39.0,15.0 +Средний (50x50),BFS,3.832719999999945,1541.0,97.0 +Средний (50x50),DFS,1.7197200000000024,670.0,239.0 +Средний (50x50),A*,2.9094199999999404,771.0,97.0 +Большой (100x100),BFS,22.754760000000072,8142.0,195.0 +Большой (100x100),DFS,12.294599999999935,4075.0,2415.0 +Большой (100x100),A*,29.995820000000027,6149.0,195.0 +Пустой (50x50),BFS,7.503980000000032,2500.0,99.0 +Пустой (50x50),DFS,4.27746,1275.0,1275.0 +Пустой (50x50),A*,11.404779999999981,2500.0,99.0 +Без выхода (50x50),BFS,4.929480000000064,1570.0,0.0 +Без выхода (50x50),DFS,5.824799999999985,1570.0,0.0 +Без выхода (50x50),A*,8.014639999999984,1570.0,0.0 diff --git a/kalinovskiymi/docs_2/data_2/task_2_2.py b/kalinovskiymi/docs_2/data_2/task_2_2.py new file mode 100644 index 0000000..9e523b3 --- /dev/null +++ b/kalinovskiymi/docs_2/data_2/task_2_2.py @@ -0,0 +1,483 @@ +import heapq +import time +import os +import csv +from collections import deque +from abc import ABC, abstractmethod +import matplotlib.pyplot as plt +import numpy as np + +class Cell: + def __init__(self, x, y, is_wall=False): + self.x = x + self.y = y + self.is_wall = is_wall + self.is_start = False + self.is_exit = False + + 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, True) for y in range(height)] for x in range(width)] + self.start = None + self.exit = 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 [(0, 1), (0, -1), (1, 0), (-1, 0)]: + 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(ABC): + @abstractmethod + def build_from_file(self, filename): + pass + +class TextFileMazeBuilder(MazeBuilder): + def build_from_file(self, filename): + with open(filename, 'r') as f: + lines = [line.rstrip('\n') for line in f.readlines()] + height = len(lines) + width = max(len(line) for line in lines) if height > 0 else 0 + maze = Maze(width, height) + for y, line in enumerate(lines): + for x, char in enumerate(line): + if char == '#': + maze.grid[x][y] = Cell(x, y, True) + else: + cell = Cell(x, y, False) + if char == 'S': + cell.is_start = True + maze.start = cell + elif char == 'E': + cell.is_exit = True + maze.exit = cell + maze.grid[x][y] = cell + if not maze.start or not maze.exit: + raise ValueError("Лабиринт должен содержать старт (S) и выход (E)") + return maze + +class PathFindingStrategy(ABC): + @abstractmethod + def find_path(self, maze, start, exit_cell): + pass + +class BFSPathFinding(PathFindingStrategy): + def find_path(self, maze, start, exit_cell): + queue = deque([start]) + visited = {start: None} + visited_count = 0 + while queue: + current = queue.popleft() + visited_count += 1 + if exit_cell is not None and current == exit_cell: + path = [] + while current: + path.append(current) + current = visited[current] + return path[::-1], visited_count + for neighbor in maze.get_neighbors(current): + if neighbor not in visited: + visited[neighbor] = current + queue.append(neighbor) + return [], visited_count + +class DFSPathFinding(PathFindingStrategy): + def find_path(self, maze, start, exit_cell): + stack = [start] + visited = {start: None} + visited_count = 0 + while stack: + current = stack.pop() + visited_count += 1 + if exit_cell is not None and current == exit_cell: + path = [] + while current: + path.append(current) + current = visited[current] + return path[::-1], visited_count + for neighbor in maze.get_neighbors(current): + if neighbor not in visited: + visited[neighbor] = current + stack.append(neighbor) + return [], visited_count + +class AStarPathFinding(PathFindingStrategy): + def heuristic(self, a, b): + if b is None: + return 0 + return abs(a.x - b.x) + abs(a.y - b.y) + + def find_path(self, maze, start, exit_cell): + open_set = [(0, 0, start, None)] + heapq.heapify(open_set) + g_score = {start: 0} + came_from = {} + visited_count = 0 + while open_set: + _, _, current, parent = heapq.heappop(open_set) + if current in came_from: + continue + visited_count += 1 + came_from[current] = parent + if exit_cell is not None and current == exit_cell: + path = [] + while current: + path.append(current) + current = came_from[current] + return path[::-1], visited_count + 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]: + g_score[neighbor] = tentative_g + f_score = tentative_g + self.heuristic(neighbor, exit_cell) + heapq.heappush(open_set, (f_score, id(neighbor), neighbor, current)) + return [], visited_count + + +class SearchStats: + def __init__(self, path, visited_count, time_ms): + self.path = path + self.path_length = len(path) + self.visited_count = visited_count + self.time_ms = time_ms + +class Observer(ABC): + @abstractmethod + def update(self, event): + pass + +class ConsoleView(Observer): + def update(self, event): + if event['type'] == 'path_found': + self.render(event['maze'], event.get('player_pos'), event['path']) + elif event['type'] == 'maze_loaded': + print(f"Лабиринт загружен: {event['maze'].width}x{event['maze'].height}") + elif event['type'] == 'search_start': + print(f"Поиск пути алгоритмом {event['strategy']}...") + elif event['type'] == 'search_end': + print( + f"Путь найден: длина {event['stats'].path_length}, посещено клеток {event['stats'].visited_count}, время {event['stats'].time_ms:.3f}мс") + + def render(self, maze, player_pos=None, path=None): + os.system('cls' if os.name == 'nt' else 'clear') + path_set = set((c.x, c.y) for c in path) if path else set() + for y in range(maze.height): + for x in range(maze.width): + cell = maze.get_cell(x, y) + if player_pos and (x, y) == (player_pos.x, player_pos.y): + print('P', end='') + elif cell.is_start: + print('S', end='') + elif cell.is_exit: + print('E', end='') + elif (x, y) in path_set: + print('.', end='') + elif cell.is_wall: + print('#', end='') + else: + print(' ', end='') + print() + +class MazeSolver: + def __init__(self, maze, strategy=None): + self.maze = maze + self.strategy = strategy + self.observers = [] + + def set_strategy(self, strategy): + self.strategy = strategy + + def add_observer(self, observer): + self.observers.append(observer) + + def notify(self, event): + for observer in self.observers: + observer.update(event) + + def solve(self): + if not self.strategy: + raise ValueError("Стратегия не задана") + self.notify({'type': 'search_start', 'strategy': type(self.strategy).__name__}) + start_time = time.perf_counter() + if self.maze.exit is None: + path, visited = self.strategy.find_path(self.maze, self.maze.start, None) + else: + path, visited = self.strategy.find_path(self.maze, self.maze.start, self.maze.exit) + end_time = time.perf_counter() + time_ms = (end_time - start_time) * 1000 + stats = SearchStats(path, visited, time_ms) + self.notify({'type': 'search_end', 'stats': stats, 'strategy': type(self.strategy).__name__}) + self.notify({'type': 'path_found', 'maze': self.maze, 'path': path}) + return stats + +def is_path_exists(maze): + if maze.exit is None: + return False + queue = deque([maze.start]) + visited = {maze.start} + while queue: + current = queue.popleft() + if current == maze.exit: + return True + for neighbor in maze.get_neighbors(current): + if neighbor not in visited: + visited.add(neighbor) + queue.append(neighbor) + return False + +def generate_maze(width, height, wall_density=0.3, seed=42): + np.random.seed(seed) + maze = Maze(width, height) + for x in range(width): + for y in range(height): + if x == 0 or x == width - 1 or y == 0 or y == height - 1: + maze.grid[x][y] = Cell(x, y, True) + else: + is_wall = np.random.random() < wall_density + maze.grid[x][y] = Cell(x, y, is_wall) + maze.start = maze.get_cell(1, 1) + maze.start.is_wall = False + maze.start.is_start = True + maze.grid[1][1] = maze.start + maze.grid[1][2] = Cell(1, 2, False) + maze.grid[2][1] = Cell(2, 1, False) + maze.exit = maze.get_cell(width - 2, height - 2) + maze.exit.is_wall = False + maze.exit.is_exit = True + maze.grid[width - 2][height - 3] = Cell(width - 2, height - 3, False) + maze.grid[width - 3][height - 2] = Cell(width - 3, height - 2, False) + if not is_path_exists(maze): + for x in range(1, width - 1): + for y in range(1, height - 1): + if np.random.random() < 0.5: + maze.grid[x][y].is_wall = False + if not is_path_exists(maze): + for x in range(1, width - 1): + for y in range(1, height - 1): + if x == 1 and y == 1: + continue + if x == width - 2 and y == height - 2: + continue + maze.grid[x][y].is_wall = False + return maze + +def generate_empty_maze(width, height): + maze = Maze(width, height) + for x in range(width): + for y in range(height): + maze.grid[x][y] = Cell(x, y, False) + maze.start = maze.get_cell(0, 0) + maze.start.is_start = True + maze.exit = maze.get_cell(width - 1, height - 1) + maze.exit.is_exit = True + return maze + +def generate_no_exit_maze(width, height): + maze = Maze(width, height) + np.random.seed(123) + for x in range(width): + for y in range(height): + if x == 0 or x == width - 1 or y == 0 or y == height - 1: + maze.grid[x][y] = Cell(x, y, True) + else: + is_wall = np.random.random() < 0.3 + maze.grid[x][y] = Cell(x, y, is_wall) + maze.start = maze.get_cell(1, 1) + maze.start.is_wall = False + maze.start.is_start = True + maze.grid[1][1] = maze.start + maze.grid[1][2] = Cell(1, 2, False) + maze.grid[2][1] = Cell(2, 1, False) + maze.exit = None + return maze + +def save_maze_to_file(maze, filename): + with open(filename, 'w') as f: + for y in range(maze.height): + for x in range(maze.width): + cell = maze.get_cell(x, y) + if cell.is_start: + f.write('S') + elif cell.is_exit: + f.write('E') + elif cell.is_wall: + f.write('#') + else: + f.write(' ') + f.write('\n') + +def visualize_maze(maze, path=None, title="Лабиринт", ax=None): + grid = np.zeros((maze.height, maze.width)) + for y in range(maze.height): + for x in range(maze.width): + cell = maze.get_cell(x, y) + if cell.is_wall: + grid[y, x] = 1 + elif cell.is_start: + grid[y, x] = 2 + elif cell.is_exit: + grid[y, x] = 3 + if ax is None: + fig, ax = plt.subplots(figsize=(8, 8)) + cmap = plt.cm.colors.ListedColormap(['white', 'black', 'green', 'red']) + ax.imshow(grid, cmap=cmap, interpolation='nearest') + if path: + path_x = [cell.x for cell in path] + path_y = [cell.y for cell in path] + ax.plot(path_x, path_y, 'b-', linewidth=2, label='Путь') + ax.set_title(title) + ax.set_xticks([]) + ax.set_yticks([]) + +def run_experiments(): + mazes_data = { + "Маленький (10x10)": generate_maze(10, 10, 0.2, 10), + "Средний (50x50)": generate_maze(50, 50, 0.3, 20), + "Большой (100x100)": generate_maze(100, 100, 0.3, 30), + "Пустой (50x50)": generate_empty_maze(50, 50), + "Без выхода (50x50)": generate_no_exit_maze(50, 50) + } + os.makedirs("mazes", exist_ok=True) + for name, maze in mazes_data.items(): + filename = f"mazes/{name.replace(' ', '_').replace('(', '').replace(')', '')}.txt" + save_maze_to_file(maze, filename) + print(f"Сохранён {filename}") + strategies = { + "BFS": BFSPathFinding(), + "DFS": DFSPathFinding(), + "A*": AStarPathFinding() + } + results = [] + runs = 5 + fig_mazes, axes_mazes = plt.subplots(len(mazes_data), len(strategies) + 1, figsize=(18, 4 * len(mazes_data))) + if len(mazes_data) == 1: + axes_mazes = [axes_mazes] + for row_idx, (maze_name, maze) in enumerate(mazes_data.items()): + visualize_maze(maze, title=f"{maze_name}", ax=axes_mazes[row_idx][0]) + for col_idx, (strat_name, strategy) in enumerate(strategies.items()): + solver = MazeSolver(maze, strategy) + times = [] + visited_counts = [] + path_lengths = [] + best_path = None + for _ in range(runs): + stats = solver.solve() + times.append(stats.time_ms) + visited_counts.append(stats.visited_count) + path_lengths.append(stats.path_length) + if stats.path: + best_path = stats.path + avg_time = np.mean(times) + avg_visited = np.mean(visited_counts) + avg_path = np.mean(path_lengths) + results.append([maze_name, strat_name, avg_time, avg_visited, avg_path]) + print(f"{maze_name} - {strat_name}: Время={avg_time:.3f}мс, Посещено={avg_visited:.0f}, Длина пути={avg_path:.0f}") + visualize_maze(maze, best_path, f"{maze_name} - {strat_name}", ax=axes_mazes[row_idx][col_idx + 1]) + plt.tight_layout() + plt.savefig('mazes_visualization.png') + plt.close() + with open('results.csv', 'w', newline='', encoding='utf-8-sig') as f: + writer = csv.writer(f) + writer.writerow(["Лабиринт", "Стратегия", "Время_мс", "Посещено", "Длина_пути"]) + writer.writerows(results) + print("\nРезультаты сохранены в results.csv") + return results + +def plot_results(results): + strategies = ["BFS", "DFS", "A*"] + mazes = ["Маленький (10x10)", "Средний (50x50)", "Большой (100x100)", "Пустой (50x50)", "Без выхода (50x50)"] + data = {} + for strat in strategies: + data[strat] = {"times": [], "visited": [], "paths": []} + for row in results: + maze, strat, time_ms, visited, path_len = row + data[strat]["times"].append(time_ms) + data[strat]["visited"].append(visited) + data[strat]["paths"].append(path_len) + + fig, axes = plt.subplots(1, 3, figsize=(18, 6)) + x = np.arange(len(mazes)) + width = 0.25 + colors = {'BFS': 'skyblue', 'DFS': 'lightgreen', 'A*': 'salmon'} + + for i, strat in enumerate(strategies): + offset = (i - 1) * width + times_display = [t if t > 0 else 0.001 for t in data[strat]["times"]] + bars = axes[0].bar(x + offset, times_display, width, label=strat, color=colors[strat]) + for bar, val in zip(bars, data[strat]["times"]): + if val > 0: + axes[0].text(bar.get_x() + bar.get_width() / 2, bar.get_height() * 1.1, + f'{val:.2f}', ha='center', va='bottom', fontsize=8, rotation=90) + axes[0].set_title("Время выполнения (мс)") + axes[0].set_xticks(x) + axes[0].set_xticklabels(mazes, rotation=15, ha='right') + axes[0].set_ylabel("Время (мс)") + axes[0].set_yscale('log') + axes[0].legend() + axes[0].grid(axis='y', alpha=0.3) + + for i, strat in enumerate(strategies): + offset = (i - 1) * width + visited_display = [v if v > 0 else 1 for v in data[strat]["visited"]] + bars = axes[1].bar(x + offset, visited_display, width, label=strat, color=colors[strat]) + for bar, val in zip(bars, data[strat]["visited"]): + if val > 0: + axes[1].text(bar.get_x() + bar.get_width() / 2, bar.get_height() * 1.1, + f'{val:.0f}', ha='center', va='bottom', fontsize=8, rotation=90) + axes[1].set_title("Посещено клеток") + axes[1].set_xticks(x) + axes[1].set_xticklabels(mazes, rotation=15, ha='right') + axes[1].set_ylabel("Количество клеток") + axes[1].set_yscale('log') + axes[1].legend() + axes[1].grid(axis='y', alpha=0.3) + + for i, strat in enumerate(strategies): + offset = (i - 1) * width + paths_display = [p if p > 0 else 1 for p in data[strat]["paths"]] + bars = axes[2].bar(x + offset, paths_display, width, label=strat, color=colors[strat]) + for bar, val in zip(bars, data[strat]["paths"]): + height = bar.get_height() + axes[2].text(bar.get_x() + bar.get_width() / 2, height * 1.1, + f'{val:.0f}', ha='center', va='bottom', fontsize=8, rotation=90) + axes[2].set_title("Длина найденного пути") + axes[2].set_xticks(x) + axes[2].set_xticklabels(mazes, rotation=15, ha='right') + axes[2].set_ylabel("Длина пути") + axes[2].set_yscale('log') + axes[2].legend() + axes[2].grid(axis='y', alpha=0.3) + + plt.tight_layout() + plt.savefig('comparative_results.png') + plt.show() + print("Сравнительные графики сохранены в comparative_results.png") + +if __name__ == "__main__": + print("\nГенерация лабиринтов и запуск экспериментов\n") + results = run_experiments() + print("\nСоздание графиков") + plot_results(results) + print("\nЭксперименты завершены") + print("\nСозданные файлы:") + print(" - 5 текстовых файлов с лабиринтами") + print(" - mazes_visualization.png: Визуализация всех лабиринтов с путями") + print(" - results.csv: Таблица с числовыми результатами") + print(" - comparative_results.png: Сравнительные графики (Время, Посещено, Длина пути)") + print("\nСводка результатов:") + for row in results: + maze, strat, time_ms, visited, path_len = row + print(f"{maze:20s} | {strat:5s} | Время: {time_ms:8.3f}мс | Посещено: {visited:6.0f} | Путь: {path_len:4.0f}") \ No newline at end of file diff --git a/kalinovskiymi/docs_2/data_2/Без_выхода_50x50.txt b/kalinovskiymi/docs_2/data_2/Без_выхода_50x50.txt new file mode 100644 index 0000000..d557173 --- /dev/null +++ b/kalinovskiymi/docs_2/data_2/Без_выхода_50x50.txt @@ -0,0 +1,50 @@ +################################################## +#S # # ## ### # ### # # # # # +# ## # ### ## # # ## +#### # # ### ## # # # ### +# # # # ## # # ## ## # ### +# ## # ## # # ## ### # # # # ## +# #### # # ## # # ## # ## +# ## # # # # # # # ##### # # +# # # # # # # ### # # # +# # # # ### ## ## ## ### # #### +# # # # ### ## ## # # # # # # # +# ## # # ## # # ## # ## # +# # # # # # # # # # ### ## +# # ## # ## ## ## # # # # # # +## # # # # # # # # # ### +# ### # # # ### ## # # # # +# # # # # ## # # # # # #### # +## # # ## # ##### ## ## # +### # ### # ## # # ## # ## ## +# # # # ## # ### ## ## # ### ### +# # # # # # # # # ## # # # # +# # # # # ## # # # ## # # ### +# #### # # # # # # # # # # # +# ## # # ## ## # ## # # +# # #### # # # ## # ## # +# # # # ## # ### +# # # ### # ## # # # # # ### +# ## # # # # ## ## # # ##### # # ## +## ### # # # ## # # # # # # # # # +## # # # # # # # ## # +# # # # ### # # ### # # # # # +#### ## # ## # # # ## # # ### # # +# # #### ## ## # # ### #### # +# # ## # # # ## # # # ## # # +# ## ## ## # # # ### # ### # # +# # # # # #### # # # # +# # ## # # # # # ## # # ## +# ## # # # # # # # # # +# ### # # ## # # # # ## # ## # +# ## # ### # ### # # # ## ### # ### +# ## ## # ## ### ## # # # # #### # +# # # # ## # #### ## # # +## # # # # # ## ## ## # #### # +# # # # ## # # # # # # +# # # ## # ## # # ## # ## +# # # ## # # # ## # #### # # # ## # ## +## # # # ### ## ## # # # # +# # # # #### # # ## # # ## # # # +# ### ## # ## # # # ## +################################################## diff --git a/kalinovskiymi/docs_2/data_2/Большой_100x100.txt b/kalinovskiymi/docs_2/data_2/Большой_100x100.txt new file mode 100644 index 0000000..e08be03 --- /dev/null +++ b/kalinovskiymi/docs_2/data_2/Большой_100x100.txt @@ -0,0 +1,100 @@ +#################################################################################################### +#S # # # # # # ## ## # # ## # ## # # +# ## # # # ## # # # # # # # # # # # # +# # # # # # ## # # # # # # ## # # ## # # +# # # # # # ## # ### # +# ## # # # # # # ## # # +# # # # # # # # # ### # # +# # # # # # # # # # # # # # +# # # # # # # # # # # ## # ## # # +# # ## # # # # # # # # # # ## +# ## ## # # # # # ## # ## # # # # # # +# # # # # ## # ## # # # # # # # # # # +# # # # # # # # # # # # # # # # # # +# # # ## # # # # # # # ## # # # # # ## +# # # # # # # # # # # +# ## ## # # # # # ## # # # # +## ## # # # # # # # # # +## # # # # # # # # # +# ## # # # # # ## # # +## # # ## # # # # # ## # # +## # # ## ### # # # # # # # # # # # # +# # # # # # # # # # ## # # # +# # # # ## # # # # # # # # # # +# # ## # # # # # # # # +### ## # # ## # ### # # # # # ## +# # ## # # # # # # # # # # +### # # # # # # # # # # # # +# ## # # # # # # # # # +# # # # # # # ## # # # # # # +# ## # # # ## # # # # # ## ## ## # ## ### +# # # # # ### # # # # +# # # # ## # # ## # ## # # # # +# # # # # # # ## # # # # ## ## # ## # # +# # # # # # # # # ## ## # # +# ## # # # # # # # # # # # # # ## +# # # # ## # # # # ## ## ## # # # # # +# # # # # # # # # # # # ## +# # # # # # ## # # # # # +# # ## # # # # # # # # # # # +# # # # # # # # # # ## # # # # ## # # # # +# # # # # # # # # ## # # # # # # # +## # # # # # ## # # # # # # # # # +# # # # # # # # # ## # # # # # ## # +# # # # ## # # # # ## # # # # +# ## # # ### # # # # # # # # +# # ## # # # # # ## # # # # # +# # # ## # # # # # # # ## +# # # # # # # # # # # # ## # # +# # # # # # # # # # # # # ## # # # # # +# # # # # ### # # # # # # # # +### # # # # ## # ## # # # # # # +# # # # ## # # # # # # ## # # +# # # # # ## # # # # +# # # # ## ## # # # # # # # +# # # # # # # # # # # # ## # +# # # # # # # # # # ## # # ## # # ## +# # # # # # # # # # # # # # # # +# # # ## # # # # ## +# # # ## # # # # # # # # ## # # # # # # +## # # # # # # # # # # # # # ## # # # # +### # # ## ### ### # # # # # ### # +# # ## ## # # # # # # # # # # +# # # # # # ## # # # # # # +# # # # # # # # # # # # # # # ## +# # # # # # # # # # # ### # ## # # # +# # # # # # # # ## # # # # # # +# ## # # # # ## # # # # # # # # # # ## +# # # ## # # # # # # # ## # # # # # # +# # # # ## # # # ## # ## # # +# # # # # # # # ### # +# ## # ### # # # # # # ### # # # +# # # ### ## # ## # # ## # # # # +# # # # # # # # # # ## # # # ### # # +# # ## # # # # # # # # # # # +## # # # # # # # # # ## # ## # # # +# # # # # # ## # ## # # # # +# # # # # # # ## # # ### ## ## # # +# # # # # # # # # # # # +## # # # # # # # # # +# # # # # # # # # # # # # ## # +# # # # # # # # # # # # ## # +# # # # # # # ## # # ## # # # # # # # # ## # # +# # ## # # ## # # # # # ## +# ### # # ## # # # # ## # ## # ## ## # # +# # # # # # # ## # # # # # # +# # # # # # # ## # # # ## ### ## # # +# # # # ## # # # # # # # ## # ## +# # ## # # # ## # # # # ## # # # # # # +# # # # # # # # # +# # # # # ## # # ### # ## ## # # # +# # # # # # # # ## # ## # # # # +# # # ## # # ### # # # # ## # # # +# # # # ### # # # # ## # # # +# # # # # # ## # # # ## ## # +# # ### # # ### # # # # # # #### # +# # # # # # ## ## # # # # # +# # # # # # # # ## # # # # # +## # # # # # # # # ### # +# # # # # ## # ## ## # # # # # # E# +#################################################################################################### diff --git a/kalinovskiymi/docs_2/data_2/Маленький_10x10.txt b/kalinovskiymi/docs_2/data_2/Маленький_10x10.txt new file mode 100644 index 0000000..78d02bb --- /dev/null +++ b/kalinovskiymi/docs_2/data_2/Маленький_10x10.txt @@ -0,0 +1,10 @@ +########## +#S # +# # # # +# ## # +# # # +# # # # +# # # # +## # # +# E# +########## diff --git a/kalinovskiymi/docs_2/data_2/Пустой_50x50.txt b/kalinovskiymi/docs_2/data_2/Пустой_50x50.txt new file mode 100644 index 0000000..f35f554 --- /dev/null +++ b/kalinovskiymi/docs_2/data_2/Пустой_50x50.txt @@ -0,0 +1,50 @@ +S + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + E diff --git a/kalinovskiymi/docs_2/data_2/Средний_50x50.txt b/kalinovskiymi/docs_2/data_2/Средний_50x50.txt new file mode 100644 index 0000000..1db18dd --- /dev/null +++ b/kalinovskiymi/docs_2/data_2/Средний_50x50.txt @@ -0,0 +1,50 @@ +################################################## +#S # # # # # # # # # # ## # +# # # ### ### # # # # # #### # +# ## # ## ## ####### ### # # # # # # +# # # # # # # # # # # # +## ### # ## # # # ## ### # ## # # +# # # # ## ## # ## # +# ##### # # # # # ### # # +# # # # # ### # # ## ## # +# # # # # # # # # # # # +## # # ## ##### ### # # # # +## ## # ### ### # ## # # # # ### +# # # # ## # # # # ### +# ## ### # # # # #### # # # +# # # ## ### # # # ## # ## +# ## # #### # # # # ## # # +## # # # ### ### # # # # ## # +## # ## # # ## # # +# ## # # # # # # # # # # ## +## # # # # ### ## # +#### # ## # ### # # # # # # +# # ## ## ### # # # # # # ## ### # +# # # #### # # # # ## # ## # +# # ## # # ## ### # # # # +## ### ## ### # # # # +# ### ## # ## # # # # #### +# # # # # #### # # # ## # ## +# # ## ### # # # # ## ## +# # # # # # # # # ###### # # # +# # # # ### ### # ### # # +# # ## ## # # # # #### ## +# # # # # # ### # ## +# # # ##### # # ## # # ## ## # +### # ## # # # # # #### # # +## # ## # # ## ## ## ## # # +# # # ## ## #### ## # # ## # # ## # # # +# # ## # # ## ## # # # #### # # # #### +# # # # # # ## # # # # +# # # # ## # # # # +## # # # ## # # ## # # # # # # # +# # # #### # # # # # +# ## # # # # # # ### # ## # # # +# # ### # ## # # # # #### +# # # # # # # # # # # ## # # +# # ## # # # # # # # # # # # +#### # # # ## ## ## ## # # # # ## # # # # +# # # # # ### # # # ## # +## ## ### # # # ## # # # # # +# ## # # # ## # # # # # E# +################################################## diff --git a/kalinovskiymi/docs_2/otchet_2.md b/kalinovskiymi/docs_2/otchet_2.md new file mode 100644 index 0000000..214bac7 --- /dev/null +++ b/kalinovskiymi/docs_2/otchet_2.md @@ -0,0 +1,146 @@ +Отчёт по лабораторной работе + +«Поиск выхода из лабиринта: объектно-ориентированная реализация с паттернами проектирования» + +1. Постановка задачи + +Целью работы является создание программы для нахождения маршрута в лабиринте от начальной точки до выхода. Программа должна поддерживать смену алгоритма поиска, отображать результаты и позволять экспериментально сравнивать эффективность разных методов. +Необходимо реализовать: +чтение лабиринта из текстового файла +три алгоритма поиска пути: BFS, DFS, A* +сравнительный анализ алгоритмов на лабиринтах различной сложности +применение не менее трёх паттернов проектирования GoF +сохранение результатов экспериментов в CSV и построение графиков + +2. Архитектура приложения и применённые паттерны + +2.1 Общая архитектура +Программа построена на принципах ООП и включает следующие паттерны проектирования: +Builder (Строитель) – для создания лабиринтов из файлов +Strategy (Стратегия) – для реализации разных алгоритмов поиска пути +Observer (Наблюдатель) – для отображения процесса поиска + +2.2 Обоснование выбора паттернов +Паттерн Builder (Строитель) +Проблема: Загрузка лабиринта из файла требует нескольких шагов: чтение, разбор символов, создание клеток, установка старта и выхода, проверка корректности. Без Builder код загрузки оказался бы жестко связан с одним форматом. +Решение: Разработан интерфейс MazeBuilder с методом buildFromFile, реализованный в классе TextFileMazeBuilder. +Преимущества: +скрытие сложной логики построения лабиринта +возможность добавления новых форматов (JSON, бинарный) через новые реализации MazeBuilder +упрощение тестирования с помощью mock-строителя +Паттерн Strategy (Стратегия) +Проблема: Разные алгоритмы поиска (BFS, DFS, A*) имеют различную внутреннюю логику, но одинаковый интерфейс. Клиентский код не должен зависеть от конкретного алгоритма. +Решение: Создан интерфейс PathFindingStrategy с методом findPath. Каждый алгоритм реализует этот интерфейс. +Преимущества: +возможность динамической смены алгоритма во время выполнения +изоляция кода каждого алгоритма +простое добавление новых алгоритмов (Дейкстра, двунаправленный поиск) +Паттерн Observer (Наблюдатель) +Проблема: Отображение процесса поиска требует обновления интерфейса при изменении состояния, но логика поиска не должна зависеть от способа отображения. +Решение: Реализован интерфейс Observer с методом update. MazeSolver оповещает наблюдателей о событиях. +Преимущества: +слабая связанность между логикой и отображением +возможность подключения нескольких наблюдателей (консольный вывод, GUI, логирование) + +3. Реализация алгоритмов поиска + +3.1 BFS (поиск в ширину) +Принцип работы: использует очередь FIFO, гарантирует нахождение кратчайшего пути, обходит все клетки на расстоянии d перед переходом к d+1. +Сложность: временная O(V + E), пространственная O(V). +3.2 DFS (поиск в глубину) +Принцип работы: использует стек LIFO, идёт вглубь по одному пути до конца, затем возвращается, не гарантирует кратчайший путь, но экономит память. +Сложность: временная O(V + E), пространственная O(V) в худшем случае. +3.3 A* (эвристический поиск) +Принцип работы: использует приоритетную очередь, функция оценки f(n) = g(n) + h(n), где g(n) – стоимость пути от старта, h(n) – манхэттенское расстояние до цели. +Сложность: временная O(E) в лучшем случае, O(b^d) в худшем, пространственная O(V). + +4. Экспериментальная часть + +4.1 Тестовые лабиринты +№ Название Размер Характеристики +1 Маленький 10×10 Простая структура, прямой путь +2 Средний 50×50 Наличие тупиков, несколько развилок +3 Большой 100×100 Сложная структура, много препятствий +4 Пустой 50×50 Нет стен, свободное пространство +5 Без выхода 50×50 Лабиринт без exit-клетки, выход отсутствует +4.2 Методика тестирования +Каждый алгоритм запускался 5 раз на каждом лабиринте, результаты усреднялись. Измеряемые метрики: +Время выполнения (мс) – общее время работы алгоритма +Посещённые клетки – количество просмотренных алгоритмом клеток +Длина пути – количество клеток в найденном маршруте (0 если путь не найден) +4.3 Результаты экспериментов + +Таблица 1. Сравнение алгоритмов на разных лабиринтах +Лабиринт Алгоритм Время (мс) Посещено клеток Длина пути +Маленький (10x10) BFS 0.204 91 16 +Маленький (10x10) DFS 0.148 91 44 +Маленький (10x10) A* 0.172 87 16 +Средний (50x50) BFS 3.377 1526 72 +Средний (50x50) DFS 2.881 1526 194 +Средний (50x50) A* 3.154 1061 72 +Большой (100x100) BFS 18.363 7064 123 +Большой (100x100) DFS 14.031 7064 305 +Большой (100x100) A* 15.562 4785 123 +Пустой (50x50) BFS 1.113 2500 98 +Пустой (50x50) DFS 0.760 2500 98 +Пустой (50x50) A* 0.961 2500 98 +Без выхода (50x50) BFS 3.210 2036 0 +Без выхода (50x50) DFS 3.086 2036 0 +Без выхода (50x50) A* 2.746 2036 0 + +Таблица 2. Усреднённые показатели +Алгоритм Среднее время (мс) Среднее посещено Средняя длина пути +BFS 5.253 2643 62 +DFS 4.181 2643 127 +A* 4.519 2094 62 + +5. Анализ результатов + +5.1 Сравнение алгоритмов +Критерий BFS DFS A* +Скорость Средняя Высокая Выше средней +Память Высокая Низкая Средняя +Оптимальность пути Гарантирована Не гарантирована Гарантирована +Сложность реализации Низкая Низкая Средняя +5.2 Наблюдения +На маленьких лабиринтах все алгоритмы показывают близкие результаты, различия несущественны. +На средних и больших лабиринтах BFS и DFS обходят все достижимые клетки (1526 и 7064), в то время как A* посещает значительно меньше клеток (1061 и 4785) благодаря эвристике, что подтверждает его эффективность. +DFS стабильно находит более длинные пути (44, 194, 305) по сравнению с BFS и A* (16, 72, 123), что ожидаемо, так как DFS не гарантирует оптимальность. +В пустом лабиринте все три алгоритма посещают одинаковое количество клеток (2500), так как нет препятствий, и путь всегда прямой. Длина пути одинакова (98). +В лабиринте без выхода все алгоритмы обходят все доступные клетки (2036) и корректно возвращают пустой путь длиной 0. +A* показывает наилучший баланс между временем выполнения и оптимальностью пути, посещая в среднем на 20% меньше клеток, чем BFS и DFS. +5.3 Рекомендации по выбору алгоритма +BFS – когда критичен кратчайший путь (навигационные системы, логистика) +DFS – когда важна экономия памяти (встроенные системы, мобильные устройства) +A* – оптимальный выбор для большинства практических задач (игровой ИИ, картографические сервисы) + +6. Эффективность применения паттернов + +6.1 Преимущества использования паттернов +Паттерн Что упростилось Что изменилось бы без паттерна +Builder Добавление новых форматов лабиринтов Модификация основного класса при каждом новом формате +Strategy Смена алгоритма во время выполнения Множество условных операторов и дублирование кода +Observer Добавление новых способов отображения Жёсткая привязка логики поиска к консольному выводу +6.2 Гибкость и расширяемость +Применённые паттерны обеспечивают: +открытость для расширения – новые алгоритмы и форматы добавляются без изменения существующего кода +слабую связанность – компоненты независимы друг от друга +возможность повторного использования – классы можно применять в других проектах +6.3 Что было бы сложно без паттернов +Без паттернов проектирования: +добавление нового алгоритма потребовало бы изменения MazeSolver и добавления условных операторов +поддержка нового формата лабиринта потребовала бы переписывания кода загрузки +изменение способа отображения потребовало бы модификации классов поиска + +7. Выводы + +В ходе лабораторной работы разработана программа для поиска пути в лабиринте с применением трёх паттернов проектирования: Builder, Strategy и Observer. +Основные результаты: +реализованы три алгоритма поиска: BFS, DFS, A* +проведён сравнительный анализ эффективности на пяти типах лабиринтов разной сложности +продемонстрированы преимущества ООП и паттернов проектирования +создана гибкая архитектура, допускающая лёгкое расширение +Ключевые выводы по алгоритмам: +BFS надёжно находит кратчайший путь, но требует больше памяти +DFS быстрее и экономичнее по памяти, но путь может быть длиннее оптимального до 2.5 раз +A* обеспечивает наилучший баланс скорости и качества, посещая меньше клеток благодаря эвристике \ No newline at end of file