Добавлен отчет

YanyaevAA/task2/docs/Report_2.md

@@ -0,0 +1,238 @@
+# Поиск выхода из лабиринта (объектно-ориентированная реализация с паттернами)
+Цель работы:
+Разработать гибкую, расширяемую программу для загрузки лабиринта из файла, поиска пути от старта до выхода с возможностью выбора алгоритма, визуализации процесса и экспериментального сравнения алгоритмов. В ходе работы необходимо применить минимум 3 паттерна проектирования из списка GoF, обосновать их выбор и продемонстрировать преимущества такой архитектуры.
+## Выбранные паттерны проектирования
+- Builder: шаблон проектирования, который инкапсулирует создание объекта и позволяет разделить его на различные этапы. В программе позволяет загружать лабиринт из файла.
+- Strategy: поведенческий шаблон проектирования, предназначенный для определения семейства алгоритмов, инкапсуляции каждого из них и обеспечения их взаимозаменяемости. Это позволяет выбирать алгоритм путём определения соответствующего класса. В программе помогает менять способ поиска пути.
+- Observer: это поведенческий паттерн, который позволяет объектам оповещать другие объекты об изменениях своего состояния. В программе служит для визуализации лабиринта и пути к выходу, а также для уведомляет о событиях ("path_found").
+
+## Диаграмма классов
+![](data/mermaid_diagram.png)
+# Листинги ключевых классов
+## Паттерн Builder
+```Python
+class MazeBuilder(ABC):
+    @abstractmethod
+    def buildFromFile(self, filename):
+        pass
+
+class TextFileMazeBuilder(MazeBuilder):
+    def buildFromFile(self, filename):
+        with open(filename, 'r') as f:
+            lines = [line.rstrip('\n') for line in f]
+        height = len(lines)
+        width = max(len(line) for line in lines)
+
+        grid=[]
+        start_cell=None
+        exit_cell=None
+        for y in range(height):
+            row=[]
+            for x in range(width):
+                char=lines[y][x]
+
+                isWall = (char == '#')
+                isStart = (char == 'S')
+                isExit = (char == 'E')
+
+                cell=Cell(x, y, isWall, isStart, isExit)
+
+                if isStart:
+                    start_cell =cell
+                if isExit:
+                    exit_cell =cell
+                row.append(cell)
+            grid.append(row)
+        return Maze(grid, width, height, start_cell, exit_cell)
+```
+## Паттерн Strategy
+```Python
+class PathFindingStrategy(ABC):
+    @abstractmethod
+    def findPath(self,maze, start, exit):
+        pass
+
+class BFS(PathFindingStrategy):
+    def findPath(self, maze, start, exit):
+        queue = deque([start])
+        traveled_path={start: None}
+
+        while queue:
+            current = queue.popleft()
+            if current==exit:
+                path=[]
+                while current is not None:
+                    path.append(current)
+                    current = traveled_path[current]
+                return path[::-1], len(traveled_path)
+            for neighbor in maze.getNeighbors(current):
+                if neighbor not in traveled_path:
+                    traveled_path[neighbor] = current
+                    queue.append(neighbor)
+        return [], len(traveled_path)
+
+class DFS(PathFindingStrategy):
+    def findPath(self, maze, start, exit):
+        stack = [start]
+        traveled_path={start: None}
+
+        while stack:
+            current = stack.pop()
+            if current == exit:
+                path = []
+                while current is not None:
+                    path.append(current)
+                    current = traveled_path[current]
+                return path[::-1], len(traveled_path)
+            for neighbor in maze.getNeighbors(current):
+                if neighbor not in traveled_path:
+                    traveled_path[neighbor] = current
+                    stack.append(neighbor)
+        return [], len(traveled_path)
+class AStar(PathFindingStrategy):
+    def findPath(self, maze, start, exit):
+        count = 0
+        open_set = [(0, count, start)]
+        traveled_path = {start: None}
+        g_score = {start: 0}
+        while open_set:
+            _,_,current = heapq.heappop(open_set)
+            if current == exit:
+                path = []
+                while current is not None:
+                    path.append(current)
+                    current = traveled_path[current]
+                return path[::-1], len(traveled_path)
+            for neighbor in maze.getNeighbors(current):
+                g_score_new = g_score[current]+1
+                if neighbor not in g_score or g_score_new < g_score[neighbor]:
+                    traveled_path[neighbor] = current
+                    g_score[neighbor] = g_score_new
+                    f_score = g_score_new + abs(neighbor.x - exit.x) + abs(neighbor.y - exit.y)
+                    count += 1
+                    heapq.heappush(open_set, (f_score, count, neighbor))
+        return [],len(traveled_path)
+```
+## Паттерн Observer с объектом Event
+```Python
+class Event:
+    def __init__(self, event_type, data=None):
+        self.event_type = event_type
+        self.data = data
+
+class Observer(ABC):
+    @abstractmethod
+    def update(self, event):
+        pass
+
+class ConsoleView(Observer):
+    def update(self, event):
+        if event.event_type == "path_found":
+            stats=event.data
+            print("Путь найден:")
+            print("Время выполнения:", stats.time)
+            print("Количество посещённых клеток:", stats.visited_cells)
+            print("Длина найденного пути:", stats.path_length)
+        if event.event_type == "maze_loaded":
+            print("Загружен новый лабиринт")
+
+    def render(self, maze, path):
+        for y in range(maze.height):
+            row_str=""
+            for x in range(maze.width):
+                cell=maze.getCell(x, y)
+                if cell == maze.start:
+                    row_str += "S"
+                elif cell == maze.exit:
+                    row_str += "E"
+                elif cell in path:
+                    row_str += "·"
+                elif cell.isWall:
+                    row_str += "#"
+                else:
+                    row_str += " "
+            print(row_str)
+```
+## Реализация программы
+```Python
+mazes = ["10x10.txt","50x50.txt","100x100.txt","empty.txt","without_exit.txt"]
+results =[["лабиринт",
+            "стратегия",
+            "время_мс",
+            "посещено_клеток",
+            "длина_пути"]]
+strategies = {
+    "BFS": BFS(),
+    "DFS": DFS(),
+    "AStar": AStar()
+}
+builder = TextFileMazeBuilder()
+n=10
+directory = os.path.join("docs", "data")
+
+for maze_name in mazes:
+    print(maze_name)
+    file_name=os.path.join(directory, maze_name)
+    maze = builder.buildFromFile(file_name)
+    viewer=ConsoleView()
+    for strategy_name, strategy in strategies.items():
+        total_time = 0.0
+        total_visited = 0
+        total_path_length = 0
+
+        solver = MazeSolver(maze, strategy)
+
+        for i in range(n):
+            stats = solver.solve()
+            total_time += stats.time
+            total_visited += stats.visited_cells
+            total_path_length += stats.path_length
+        avg_time = total_time/n
+        avg_visited = total_visited/n
+        avg_path_length = total_path_length/n
+        print("-"*100)
+        print(f"{maze_name} стратегия: {strategy_name}  время_мс: {avg_time} посещено_клеток: {avg_visited} длина_пути: {avg_path_length}")
+        results.append([maze_name, strategy_name, avg_time, avg_visited, avg_path_length])
+        path, _ = strategy.findPath(maze, maze.start, maze.exit)
+        viewer.render(maze,  path)
+csv_filename = os.path.join(directory, "maze_results.csv")
+with open(csv_filename, "w", newline="", encoding="utf-8-sig") as f:
+    writer = csv.writer(f)
+    writer.writerows(results)
+```
+# Результаты экспериментов
+В ходе тестирования каждый алгоритм запускался по 10 раз на каждом типе лабиринта
+
+| Лабиринт | Стратегия |           Время (мс)           | Посещено клеток | Длина пути |
+| :--- | :--- |:------------------------------:| :---: | :---: |
+| **10x10.txt** | BFS <br> DFS <br> AStar | 0.0264 <br> 0.0368 <br> 0.0320 | 30.0 <br> 43.0 <br> 30.0 | 29.0 <br> 29.0 <br> 29.0 |
+| **50x50.txt** | BFS <br> DFS <br> AStar | 0.6698 <br> 0.4722 <br> 0.5986 | 799.0 <br> 562.0 <br> 539.0 | 316.0 <br> 350.0 <br> 316.0 |
+| **100x100.txt** | BFS <br> DFS <br> AStar | 3.0005 <br> 0.4454 <br> 0.5787 | 3576.0 <br> 595.0 <br> 536.0 | 196.0 <br> 364.0 <br> 196.0 |
+| **empty.txt** | BFS <br> DFS <br> AStar | 0.2904 <br> 0.1618 <br> 0.4074 | 324.0 <br> 324.0 <br> 324.0 | 35.0 <br> 171.0 <br> 35.0 |
+| **without_exit.txt** | BFS <br> DFS <br> AStar | 0.0407 <br> 0.0408 <br> 0.0519 | 48.0 <br> 48.0 <br> 48.0 | 0.0 <br> 0.0 <br> 0.0 |
+
+Сравнительные графики:
+![](data/maze_graphics.png)
+# Анализ эффективности алгоритмов и применимости паттернов.
+- **BFS**:
+  - Время: Алгоритм демонстрирует рост времени с увеличением площади лабиринта и количества ветвлений: минимальное время в лабиринте 10x10: 0.0264; максимальное время в лабиринте 100x100: 3.0005.
+  - Количество посещенных клеток: Также показывает рост количества посещенных клеток с увеличением площади лабиринта. В лабиринтах 50x50, 100x100 показывает неэффективность алгоритма с точки зрения объема работы: 799 и 3576 соответственно.
+  - Длина пути: Во всех алгоритмах показывает выбор оптимального пути.
+- **DFS**:
+  - Время: В маленьком лабиринте (10x10) работает медленнее других, но на больших и пустом лабиринтах является быстрейшим алгоритмом. Это происходит, потому что DFS использует стек, который в Python имеет сложность O(1).
+  - Количество посещенных клеток: На полученных данных, мы видим хорошие значения посещенных клеток, но для такого же по размерам лабиринта, но с другими путями, количество посещенных клеток может измениться. Это происходит из-за того, что количество посещенных клеток зависит от лабиринта, и "повезло" ли алгоритму сразу же наткнуться на коридор, ведущий к выходу.
+  - Длина пути: На маленьком лабиринте (10x10) показывает одинаковую длину пути со всеми алгоритмами. Но для других лабиринтов показывает пути значительно больше чем у других. DFS не гарантирует оптимальность пути, потому что ищет до первого пути ведущего к выходу, который может быть большим. Но на лабиринте без развилок (10x10) показывает результат на ровне с другими алгоритмами.
+- **A***:
+  - Время: На большинстве лабиринтах показывает средние результат, в лабиринте без выхода и в пустом лабиринте показывает худшие результаты. Это происходит, потому что алгоритм использует приоритетную очередь, которая имеет логарифмическую сложность O(log n), также постоянная перестройка очереди занимает чуть больше времени.
+  - Количество посещенных клеток: Во всех случаях имеет минимальное количество посещенных клеток. Это происходит благодаря эвристической функции (Манхэттенское расстояние). Она минимизирует количество посещенных клеток, избегая ложные направления. Преимущество алгоритма хорошо видно на больших лабиринтах (50x50, 100x100)
+  - Длина пути: Также, как и BFS, показывает минимальную длину пути. Алгоритм выбирает кратчайший путь, также благодаря эвристике.
+## Выводы по алгоритмам
+- **BFS**: Всегда находит кратчайший путь, но для больших лабиринтов тратит много времени, а также для поиска пути исследует большое количество клеток.
+- **DFS**: Алгоритм подходит для быстрого нахождения пути для простых или линейных лабиринтов. Но не подходит для выбора кратчайшего пути.
+- **A***: Алгоритм показывает наибольшую общую эффективность. Всегда находит кратчайший путь и для поиска посещает наименьшее количество клеток, имеет хорошую скорость выполнения.
+## Применяемость паттернов
+- **Builder**: Позволяет отделить структуру самого лабиринта от источника его данных. Позволяет свободно, при необходимости, добавлять другие форматы, из которых будет строиться лабиринт.
+- **Strategy**: Инкапсулирует алгоритмы поиска пути в отдельные классы, что позволяет свободно добавлять другие алгоритмы поиска
+- **Observer**: Реализует механизм уведомления о шагах алгоритма. Позволяет визуализировать процесс поиска клеток, полностью отделяя логику вычислений от графического интерфейса.
+# Вывод
+Применение принципов И паттернов ООП позволило создать устойчивую к изменениям программу. Можно свободно добавлять новые алгоритмы поиска или новые способы вывода данных, создавая новые подклассы и не меняя ни единой строчки кода. Без ООП стало бы невозможно легко переключиться с чтения текстовых файлов на файлы другого формата или на алгоритм случайной генерации карт. В итоге ООП позволяет расширять код, не затрагивая работоспособность других компонентов.