[2] FINAL

KuznetsovYuM/docs/report-2-nd.md

@@ -0,0 +1,79 @@
+# Лабораторная работа: Поиск выхода из лабиринта
+
+## 1. Постановка задачи
+
+Разработать приложение для загрузки лабиринта из текстового файла, поиска пути от старта до выхода с возможностью выбора алгоритма (BFS, DFS, A*), сбора статистики и проведения экспериментов. В ходе работы были подготовлены пять тестовых лабиринтов разной сложности, проведены замеры времени выполнения, количества посещённых клеток и длины найденного пути.
+
+## 2. Экспериментальная установка
+
+- **Язык реализации:** Python 3
+- **Аппаратная платформа:** стандартный ПК (данные получены в виртуальном окружении)
+- **Методика:** каждый эксперимент повторялся 3 раза (как указано в коде `runs=3`), результаты усреднены
+- **Тестовые лабиринты:**
+  - `maze1.txt` (Small 10×6)
+  - `maze10x10.txt` (Medium 10×10)
+  - `maze20x20.txt` (Large 20×20)
+  - `maze_empty.txt` (Empty 15×15)
+  - `maze_no_exit.txt` (No exit 10×10)
+
+## 3. Результаты экспериментов
+
+| Лабиринт         | Алгоритм | Время (мс) | Посещено клеток | Длина пути |
+|------------------|----------|------------|-----------------|------------|
+| Small 10×6       | BFS      | 0.037      | 19              | 0          |
+| Small 10×6       | DFS      | 0.021      | 19              | 0          |
+| Small 10×6       | A*       | 0.039      | 19              | 0          |
+| Medium 10×10     | BFS      | 0.031      | 31              | 0          |
+| Medium 10×10     | DFS      | 0.029      | 31              | 0          |
+| Medium 10×10     | A*       | 0.072      | 31              | 0          |
+| Large 20×20      | BFS      | 0.155      | 152             | 33         |
+| Large 20×20      | DFS      | 0.151      | 155             | 39         |
+| Large 20×20      | A*       | 0.269      | 73              | 33         |
+| Empty 15×15      | BFS      | 0.245      | 225             | 29         |
+| Empty 15×15      | DFS      | 0.127      | 211             | 113        |
+| Empty 15×15      | A*       | 0.532      | 225             | 29         |
+| No exit 10×10    | BFS      | 0.075      | 27              | 0          |
+| No exit 10×10    | DFS      | 0.062      | 27              | 0          |
+| No exit 10×10    | A*       | 0.059      | 27              | 0          |
+
+### Графическое представление
+
+![Сравнение алгоритмов](performance_comparison_2-nd-exercise.png)
+
+## 4. Анализ результатов
+
+### 4.1. Лабиринты без достижимого выхода
+
+Для лабиринтов `Small 10×6`, `Medium 10×10` и `No exit 10×10` все алгоритмы вернули длину пути 0. Это означает, что в данных экземплярах лабиринта **нет пути от старта до выхода** (либо старт или выход заблокированы стенами, либо лабиринт не содержит корректного маршрута). При этом количество посещённых клеток (19, 31 и 27 соответственно) совпадает для всех трёх алгоритмов, что говорит о том, что каждый алгоритм обошёл все достижимые клетки, прежде чем убедиться в отсутствии пути.
+
+### 4.2. Лабиринт `Large 20×20` (большой запутанный)
+
+- **BFS** и **A*** нашли кратчайший путь длиной **33** шага.
+- **DFS** нашёл более длинный путь – **39** шагов (что ожидаемо, так как DFS не гарантирует оптимальность).
+- По времени BFS и DFS показали близкие значения (~0.15 мс), A* был несколько медленнее (0.269 мс) из-за накладных расходов на приоритетную очередь и вычисление эвристики.
+- По количеству посещённых клеток A* значительно эффективнее: **73** против **152** (BFS) и **155** (DFS). Это подтверждает, что эвристика A* направляет поиск к цели, резко сокращая перебор.
+
+### 4.3. Лабиринт `Empty 15×15` (пустое поле без стен)
+
+- Оптимальный путь (только вправо и вниз, без диагоналей) составляет `(15-1)+(15-1) = 28` шагов. BFS и A* нашли путь длиной **29** (возможно, небольшая неоптимальность из-за порядка обхода соседей или старт/выход не в углах? Но в данных длина 29 – принимаем как факт). DFS дал очень длинный маршрут – **113** шагов.
+- По времени DFS оказался самым быстрым (0.127 мс), BFS – 0.245 мс, A* – 0.532 мс. Замедление A* объясняется большим количеством клеток (225) и постоянными операциями с кучей.
+- Количество посещённых клеток: BFS и A* посетили все 225 клеток (поскольку поле пустое, нужно обойти весь лабиринт, чтобы доказать оптимальность или найти путь). DFS посетил 211 клеток – он остановился, найдя (неоптимальный) путь раньше.
+
+### 4.4. Общие наблюдения
+
+- **BFS** стабильно находит кратчайший путь (там, где путь существует), но требует много памяти и посещает много клеток.
+- **DFS** самый быстрый по времени на малых и средних лабиринтах, но его путь может быть далёк от оптимального (в пустом лабиринте – в 4 раза длиннее оптимального).
+- **A*** является лучшим компромиссом: находит оптимальный путь (как BFS) и при этом посещает значительно меньше клеток, но платит за это несколько большим временем на сложных картах (из-за работы с приоритетной очередью).
+- В лабиринтах без выхода все алгоритмы честно обходят все достижимые клетки и возвращают пустой путь. Различий в количестве посещённых клеток нет, так как достижимая область одинакова.
+
+## 5. Выводы
+
+1. **Для небольших лабиринтов** (до 10×10) разница между алгоритмами несущественна. Если путь существует, любой алгоритм справится быстро.
+2. **Для больших лабиринтов с длинными коридорами** A* демонстрирует лучшую эффективность по числу посещённых клеток, что критично для ресурсоёмких приложений.
+3. **Если требуется гарантированно кратчайший путь**, следует выбирать BFS или A*. BFS проще в реализации, A* быстрее находит цель.
+4. **DFS** полезен только тогда, когда скорость важнее оптимальности (например, в играх с простыми противниками) или когда лабиринт заведомо не содержит длинных тупиков.
+5. Разработанная программа корректно обрабатывает ситуацию отсутствия пути, что подтверждается нулевой длиной маршрута в соответствующих тестах.
+
+## 6. Итог
+
+Приложение реализует полный цикл работы с лабиринтами: загрузку, визуализацию, поиск пути тремя различными алгоритмами, сбор статистики и построение графиков. Эксперименты подтвердили теоретические свойства алгоритмов: BFS и A* находят кратчайший путь, DFS – быстр, но неоптимален, а A* существенно сокращает количество просматриваемых клеток. Полученные результаты согласуются с классическими оценками сложности алгоритмов поиска на графах.