update README.md

Author: UmbrellaLeaf5

additional_tasks/petya_and_vasya_labyrinth/README.md

@@ -95,7 +95,7 @@ P0#000#000#
   * В случае, когда из лабиринта не удается выйти, вывести "Standoff! Valery!", тем самым обозначая, что охранник провел друзей.
 
 
-# Используемый алгоритм: построение дерева кратчайших путей: DAG Relaxation (как выяснилось, для этой задачи подходит очень не очень...)
+# Используемый алгоритм: построение дерева кратчайших путей: DAG Relaxation (для этой задачи подходит очень не очень)
 
 Алгоритм релаксации  является стандартным алгоритмом для нахождения кратчайших путей в направленном ацикличном графе (DAG). Алгоритм работает, последовательно обновляя расстояния до каждой вершины, используя информацию о расстояниях до её предков. Он работает за линейное время (`O(|V|+|E|)`, где `V` - количество вершин, а `E` - количество ребер).
 
@@ -140,7 +140,7 @@ P0#000#000#
  */
 template <AllowedVertType vert_t, AllowedWeightType weight_t>
 std::unordered_map<vert_t, weight_t> DAGRelaxation(
-    const Graph<vert_t, weight_t>& graph, vert_t start_vert)
+    const Graph<vert_t, weight_t>& graph, vert_t start);
 ```
 
 1. Проверяет, что граф направленный и что начальная вершина существует.
@@ -150,8 +150,69 @@ std::unordered_map<vert_t, weight_t> DAGRelaxation(
 
 В итоге `dists` будет содержать кратчайшие расстояния от начальной вершины до всех остальных вершин в графе.
 
-Основные моменты:
+### Основные моменты:
 * Топологическая сортировка важна, чтобы гарантировать, что мы не будем обновлять расстояния до вершины, пока не найдем кратчайший путь к ее предку.
 * Релаксация - это процесс обновления расстояний до вершин, используя информацию о расстояниях до их предков.
 * Код работает только для DAG, так как для циклических графов может не сходиться.
 
+# Используемый алгоритм: нахождение кратчайшего расстояния между двумя вершинами: A* (для этой задачи подходит лучше)
+
+Алгоритм A* — это эвристический алгоритм поиска пути, который находит кратчайший путь между начальной и конечной вершинами в графе. Он использует эвристическую функцию для оценки стоимости пути до конечной вершины, что позволяет ему эффективно обходить пространство поиска. В отличие от алгоритмов полного перебора, A* ориентирован на поиск наиболее перспективных путей.
+
+## Теория алгоритма:
+
+A* основывается на концепции функции стоимости `f(n) = g(n) + h(n)`, где:
+
+`n` — текущая вершина.
+
+`g(n)` — фактическая стоимость пути от начальной вершины до `n`.
+
+`h(n)` — эвристическая оценка стоимости пути от n до конечной вершины. Эта функция должна быть допустимой (никогда не завышает фактическую стоимость) и монотонной (для улучшения эффективности, хотя это не является обязательным условием корректности).
+
+Алгоритм A* использует приоритетную очередь для хранения вершин, которые ещё нужно посетить, отсортированных по возрастанию значения `f(n)`. На каждом шаге выбирается вершина с наименьшим `f(n)`, и её соседи рассматриваются. Если стоимость пути до соседа через текущую вершину меньше, чем текущая лучшая оценка стоимости до соседа, то оценка обновляется, и сосед добавляется в приоритетную очередь (или его приоритет изменяется).
+
+Процесс повторяется до тех пор, пока не будет найдена конечная вершина, или приоритетная очередь не опустеет (в последнем случае путь не существует).
+
+## Объяснение кода:
+```C++
+/**
+ * @brief Вычисляет кратчайший путь между двумя вершинами с помощью A*.
+ * @tparam vert_t: тип вершины в графе
+ * @tparam weight_t: тип веса в графе
+ * @param start: начальная вершина.
+ * @param goal: конечная вершина.
+ * @param graph: граф, для которого необходимо вычислить кратчайшие пути.
+ * @param heuristic_range: функция эвристической оценки расстояния от
+ * произвольной вершины до конечной вершины. Должна принимать две вершины в
+ * качестве аргументов и возвращать вес (оценку расстояния).
+ * @throw `std::invalid_argument("AStar: there is no such start vertice in
+ * graph.")`.
+ * @throw `std::invalid_argument("AStar: there is no such goal vertice in
+ * graph.")`.
+ * @return `weight_t`: стоимость кратчайшего пути от `start` до `goal`
+ * (если до вершины нет пути, то значение будет равно
+ * `std::numeric_limits<weight_t>::max()`).
+ */
+template <AllowedVertType vert_t, AllowedWeightType weight_t>
+weight_t AStar(
+    const vert_t& start, const vert_t& goal,
+    const Graph<vert_t, weight_t>& graph,
+    std::function<weight_t(const vert_t&, const vert_t&)> heuristic_range);
+```
+
+Код реализует алгоритм A* с использованием приоритетной очереди (`std::priority_queue`) и словарей для хранения стоимости пути от начальной вершины (`cost_from_start`) и суммы стоимости пути и эвристики (`range_plus_cost`).
+
+1. Проверка входных данных: Код проверяет наличие начальной и конечной вершин в графе.
+2. Инициализация: Создаётся приоритетная очередь `visited_verts`, отсортированная по возрастанию стоимости `f(n)`. Словари `cost_from_start` и `range_plus_cost` инициализируются. Стоимость пути до начальной вершины устанавливается в 0, а до всех остальных — в бесконечность.
+3. Поиск пути: Пока приоритетная очередь не пуста, алгоритм извлекает вершину с наименьшей оценкой `f(n)`. Если это конечная вершина, то алгоритм возвращает стоимость пути. В противном случае, алгоритм рассматривает соседей текущей вершины, обновляет оценки стоимости пути и добавляет соседей в приоритетную очередь.
+
+Возврат результата: Если конечная вершина не найдена после обработки всех вершин, алгоритм возвращает бесконечность, указывая на отсутствие пути.
+
+### Основные моменты:
+
+1. Эвристическая функция: качество работы A* сильно зависит от качества эвристической функции. Более точная эвристика приводит к более быстрому поиску.
+2. Допустимость и монотонность: эвристическая функция должна быть допустимой (не завышать фактическую стоимость) для гарантии нахождения кратчайшего пути. Монотонность (согласованность) эвристики улучшает производительность, но не является необходимым условием корректности.
+3. Сложность: сложность A* зависит от размера графа и качества эвристики. В худшем случае она может быть экспоненциальной, но на практике часто работает значительно быстрее, чем полный перебор.
+
+Этот алгоритм является одним из наиболее эффективных алгоритмов поиска кратчайшего пути в графах, особенно когда пространство поиска велико. Выбор эвристики является ключевым фактором, влияющим на производительность алгоритма.
+