Эвристики для поиска кратчайших путей

Материал из Викиконспекты
Перейти к: навигация, поиск

Проблема поиска кратчайшего пути[править]

Задача:
Дана сеть автомобильных дорог:
  • ориентированный граф [math]G=(V,E)[/math], где
    • [math]V[/math] — множество перекрёстков,
    • [math]E[/math] — множество дорог;
  • [math]l(u,v) \geqslant 0[/math] — среднее время, которое занимает проезд по дороге,
  • [math]|V|=n, |E|=m[/math],
  • отправная точка — вершина [math]s[/math], пункт назначения — вершина [math]t[/math]
Цель: найти кратчайший путь [math] s \rightsquigarrow t[/math]

Количество перекрёстков и дорог может быть очень большим, тогда обычные алгоритмы поиска пути будут работать очень долго, поэтому попытаемся оптимизировать их для более быстрой работы.

Алгоритм Дейкстры[править]

Алгоритм Дейкстры:

  • На каждом шаге выбирает из множества непросмотренных вершин вершину с наименьшим расстоянием до старта и релаксирует рёбра, исходящие из неё,
  • завершает свою работу, когда цель достигнута (или просмотрены все вершины).

Скорость работы алгоритма Дейкстры сильно зависит от скорости операций с приоритетной очередью.

Поскольку мы рассматриваем сеть автомобильных дорог, то [math]m = O(n)[/math] (граф планарен почти везде).

Для фибоначчиевых куч время работы алгоритма составляет [math]O(n\log{n}+n)[/math], для двоичных куч: [math]O(n\log{n})[/math]

Но на практике чаще используются 2-, 4- и 8-ичные кучи: они более простые, оценка времени работы содержит меньшее количество скрытых констант.

Улучшения алгоритма Дейкстры[править]

Многоуровневые корзины (англ. multi-level buckets, MLB)[править]

Multilevel buckets.jpg
Сравнение различных структур данных для поиска кратчайшего пути на карте Европы (CPU 2,4GHz, 16MB RAM)
Структура данных Время работы (сек)
Двоичная куча 12,38
4-куча 11,53
8-куча 11,52
MLB 9,36
MLB + калибровка 8,04

Подходит только графов с целочисленными рёбрами.

  • Будем складывать вершины в "корзины" [math]B[i] = \{u \in B[i] : d(u)=i\}[/math],
  • наша структура данных будет поддерживать индекс [math]L = \{\forall i : i\lt L \Rightarrow B[i] = \emptyset\}[/math]
  • на каждом шаге алгоритма, если [math]B[L][/math] пусто, то увеличим [math]L[/math], а иначе достанем одну вершину из [math]B[L][/math],
  • при релаксации будем убирать вершину из исходной корзины и класть в корзину, соответствующую новому значению [math]d(u)[/math].

Можно заметить, что при такой реализации, все операции с приоритетной очередью будут выполняться за [math]O(1)[/math]. Тогда, для одноуровневой реализации время работы алгоритма Дейкстры можно оценить как [math]O(m+nC)[/math], где [math]C[/math] — максимальная длина ребра в графе.

При двухуровневой реализации будем поддерживать два уровня корзин: первый уровень будет соответствовать одноуровневой реализации, а корзины второго уровня будут содержать диапазон значений корзин первого уровня, которые в них входят. В этом случае, нам нужно поддерживать два индекса [math]L_{top}[/math] и [math]L_{bottom}[/math] для каждого из уровней соответственно.

При такой реализации, время работы алгоритма Дейкстры можно оценить как [math]O(m+n(1+ \sqrt{C}))[/math]

Калибровка (англ. caliber)[править]

Введём величину калибр вершины [math]c(v)[/math] — вес минимального ребра, входящего в [math]v[/math] , или [math]\infty[/math], если в вершину не входит ни одно ребро. Будем говорить, что текущее значение [math]d(v)[/math] точно, если оно равно длине пути [math]s \rightsquigarrow v[/math].

Лемма (1):
Предположим, что длины рёбер неотрицательны. Пусть [math]\mu[/math] — минимальное из текущих значений [math]d(v):v \in V[/math]. Тогда, если существует такая вершина [math]u[/math], что [math]\mu + c(u) \geqslant d(u)[/math], то текущее значение [math]d(u)[/math] точно.

Эта лемма позволяет нам смягчить правило выбора текущей вершины в алгоритме Дейкстры, при этом сохраняя инвариант (почти все вершины обрабатываются единожды). Калибровка использует Лемму 1 чтобы находить и обрабатывать вершины с точными текущими значениями расстояния до них.

Модифицируем нашу MLB — структуру: будем хранить помеченные вершины в двух структурах: дерево поиска [math]F[/math] и приоритетная очередь [math]B[/math], реализованная на MLB. Алгоритм, приведённый ниже, называется алгоритмом умной очереди (англ. smart queue).

Вершины в [math]F[/math] будут иметь точные метки [math]d(u)[/math]. Если [math]F[/math] непусто, мы удалим оттуда вершину и прорелаксируем всех её соседей. Если же [math]F[/math] пусто, мы достанем из [math]B[/math] вершину с минимальной меткой и прорелаксируем всех её соседей.

Рассмотрим механизм релаксации: пусть мы уменьшаем [math]d(u)[/math]. Заметим, что в этом случае [math]u[/math] не могло лежать в [math]F[/math] (иначе [math]d(u)[/math] было не точно). Если [math]u \in B[/math] — применим [math]\mathtt{decrease — key}[/math] к [math]u[/math]. Эта операция либо переместила [math]u[/math] внутри [math]B[/math], либо определила, что метка [math]d(u)[/math] точна и переместила [math]u[/math] в [math]F[/math]. Если же [math]u \notin F [/math] и [math]u \notin B[/math], мы применим операцию [math]\mathtt{insert}[/math], и [math]u[/math] запишется в [math]F[/math] или [math]B[/math], в зависимости от того, выполняется ли условие леммы.

Двунаправленный поиск[править]

Мы можем уменьшить количество посещённых вершин в алгоритме Дейкстры, просто запустив его и из начальной и из конечной вершины. Такая эвристика не испортит скорость работы в худшем случае.

Создадим две приоритетных очереди и запустим на одной из них алгоритм Дейкстры, ищущий [math]d_{forward}(v)[/math] из [math]s[/math], а на другой — ищущий [math]d_{reverse}(v)[/math] из [math]t[/math]. Алгоритм завершит свою работу, когда какая-нибудь вершина [math]z[/math] будет удалена из обеих очередей.

Тонкость этого алгоритма заключается в том, что кратчайший путь [math]s \rightsquigarrow t[/math] не обязательно пройдёт через вершину [math]z[/math]. Поэтому после остановки двунаправленного поиска, нам необходимо перебрать все рёбра из вершин, имеющих [math]d_{forward}(u)[/math] в вершины с [math]d_{reverse}(v)[/math] и найти ребро [math]uv[/math] с минимальным [math]d_{forward}(u)+\ell(uv)+ d_{reverse}(v) [/math]. Если эта величина меньше, чем длина первоначально найденного пути — то это и есть результат работы алгоритма.

На практике, такой двунаправленный поиск быстрее обычного алгоритма Дейкстры примерно в два раза.

Алгоритм A*[править]

Приведём немного изменённую версию этого алгоритма.

Возьмём функцию [math]h(v): V \rightarrow \mathbb{R} [/math]потенциал (aнгл. potential) вершины. Тогда, с её помощью можно определить потенциальную стоимость (англ. reduced cost) каждого ребра как [math]\ell_{h}(v,w) = \ell(v,w)-h(v)+h(w)[/math]

Заметим, что замена [math]\ell[/math] на [math]\ell_{h}[/math] не изменит кратчайших путей: возьмём любой путь [math]P = (s=v_{0},v_{1},...,v_{k},v_{k+1}=t)[/math]. Тогда [math]\ell_{h}(P) = \ell_{h}(s,v_{1}), \ell_{h}(s,v_{w})[/math]. Тогда [math]\ell_{h}(P) = \ell_{h}(s,v_{1})+\ell_{h}(v_{1},v_{2})+...+\ell_{h}(v_{k},t) =[/math] [math] \ell(s,v_{1})-h(s)+h(v_{1})+\ell(v_{1},v_{2})-h(v_1)+h(v_{2})+...+\ell(v_{k},t)-h(v_k)+h(t) = [/math] [math]\ell(P)-h(s)+h(t)[/math].

Таким образом длины все путей [math]s \rightsquigarrow t[/math] изменятся на одну и ту же величину [math]h(t)-h(s)[/math]

В нашем случае, алгоритм A* будет эквивалентен алгоритму Дейкстры, на графе [math]G_{h}[/math], у которого стоимости рёбер заменили на их потенциальные стоимости. На каждом шаге необходимо будет выбирать из очереди вершину [math]v[/math] с минимальным значением [math]\ell(P_{s \rightsquigarrow v})-h(s)+h(v)[/math]. Очевидно, [math]h(s)[/math] будет одинаковым для любой вершины [math]v[/math].

Назовём функцию [math]h[/math] правдоподобной (англ. feasible), если [math]\forall (u,v): \ell_{h}(u,v) \geqslant 0[/math]. Известно, что, если [math]h(t)\leqslant 0[/math] и [math]h[/math] правдоподобна, то для любого [math]v[/math], [math]h(v)[/math] — нижняя граница [math]d(v,t)[/math]

Главное отличие от алгоритма Дейкстры в том, что A* является информированным алгоритмом — он обрабатывает в первую очередь те вершины, которые находятся ближе к результату.

Скорость работы алгоритма A*:

  • в худшем случае — [math]h(v)=0[/math] — вырождается в алгоритм Дейкстры
  • в лучшем случае — [math]\forall v: h(v)=d(v,t)[/math]
    • [math]\ell_{h}(v,w)=0[/math], если ребро [math](v,w)[/math] лежит на кратчайшем пути, иначе потенциальная стоимость положительна
    • все посещённые вершины будут лежать на кратчайшем пути

Двунаправленный A*[править]

Для двунаправленной версии алгоритма нам нужны две потенциальные функции:

  • [math]p_{f}(v)[/math], оценивающая [math]d(v,t)[/math]
  • [math]p_{r}(v)[/math], оценивающая [math]d(s,v)[/math]

В этом случае появляется дополнительная проблема: различные потенциальные стоимости у рёбер для различных обходов:

  • [math]\ell_{p_{f}}(v,w) = \ell(v,w)-p_{f}(v)+p_{f}(w)[/math] — если ребро обрабатывается в обходе, начатом в [math]s[/math]
  • [math]\ell_{p_{r}}(v,w) = \ell(v,w)-p_{r}(w)+p_{r}(v)[/math] — если ребро обрабатывается в обходе, начатом в [math]t[/math]

Чтобы избежать этой проблемы, необходимо, чтобы [math]\ell_{p_{f}}(v,w) = \ell_{p_{r}}(v,w) \Leftrightarrow p_{f}(v) + p_{r}(v) = p_{f}(w) + p_{r}(w) = const[/math]. Кроме того, функции должны быть монотонными.

Решение — использовать усреднённые потенциальные функции:

  • [math]h_{f}(v) = \dfrac{p_{f}(v)-p_{r}(v)}{2}[/math]
  • [math]h_{r}(v) = \dfrac{p_{r}(v)-p_{f}(v)}{2} = -h_{f}(v)[/math]

При таком выборе потенциальных функций, выполняется [math]\forall u : h_{f}(u)+h_{r}(u)=0[/math] и тогда двунаправленный A* становится аналогичен двунаправленному алгоритму Дейкстры

Двухэтапные алгоритмы[править]

К сожалению, двунаправленный алгоритм Дейкстры всего в два раза быстрее обычного, а это слишком медленно. Рассмотрим алгоритм поиска кратчайшего пути, состоящий из двух этапов:

  1. Препроцессинг:
    • запускается единожды для графа,
    • может занимать много времени,
    • рассчитывает некую вспомогательную информацию.
  2. Запрос:
    • может использовать данные, полученные во время препроцессинга,
    • запускается по требованию для пары [math](s,t)[/math],
    • должен выполняться очень быстро (в реальном времени).

Можно рассмотреть в этом ключе два примера:

  • Алгоритм Дейкстры: препроцессинг — ничего не делать, запрос — выполнение алгоритма Дейкстры;
  • Полный перебор: препроцессинг — посчитать таблицу расстояний размером [math]n \times n[/math] (займёт порядка 5 лет времени и 1 петабайта памяти для карты Европы), запрос — обратиться к элементу таблицы.

Оба эти примера — крайние случаи. Нам нужно нечто более гибкое: препроцессинг за часы/минуты, рост количества предпосчитанных данных линейно от размера графа и запросы в реальном времени.

ALT[править]

Аббревиатура ALT расшифровывается как A* +Landmarks + Triangle inequality : A* + ориентиры + неравенство треугольника.

  1. Препроцессинг:
    • взять небольшое количество вершин (например, 16), обозначив их как ориентиры (англ. landmarks),
    • для каждого из ориентиров посчитать кратчайшие пути до всех вершин,
    • сохранить эти пути.
  2. Запрос:
    • используем A*,
    • если некоторое ребро находится на кратчайшем пути между исходной точкой и ориентиром — по нему идём в первую очередь.
рис. 1

Будем использовать неравенство треугольника для нижних оценок пути (см. рис. 1). Пусть [math]A[/math] — один из ориентиров, тогда:

  • [math]dist(v,w)\geqslant dist(A,w)-dist(A,v)[/math],
  • [math]dist(v,w)\geqslant dist(v,A)-dist(w,A)[/math],
  • [math]dist(v,w)\geqslant \max\{dist(A,w)-dist(A,v),dist(v,A)-dist(w,A)\}[/math].

Эта эвристика хорошо работает, на дорожных графах, для которых верно следующее: как правило, кратчайший путь затрагивает небольшое количество локальных дорог, потом крупную автомагистраль и снова некоторое количество локальных дорог.

Сложности в выборе ориентиров:

  • хороший ориентир для запроса [math]s \rightsquigarrow t[/math] должен находиться "до" [math]s[/math] (точно не будет общих рёбер на кратчайшем пути) или "за" [math]t[/math] (чем острее угол, тем меньше отклонение от предварительно посчитанного кратчайшего пути до искомого),
  • нам нужно выбрать такие ориентиры, которые будут неплохими для всех запросов.

Выглядит логичным выбирать ориентиры на краю дорожной сети, тогда будет больше острых углов и ориентиры будут лучше.

Существуют различные алгоритмы выбора ориентиров:

Случайный выбор (random)[править]

PlanarLandmarks.jpg

Как следует из названия, ориентиры выбираются случайным образом

Плоскостной (planar)[править]

  • Разделим карту на [math]k[/math] секторов одинаковой площади,
  • возьмём ориентиром наиболее удалённую точку от центра в каждом секторе.

Такой способ подходит, только если граф имеет относительно правильную форму. На практике обычно используется оптимизированная версия этого алгоритма.

Избирательный (avoid)[править]

Этот алгоритм добавляет ориентиры по одному, глядя на вершины, которые плохо покрыты текущим набором ориентиров [math]S[/math].

Построим из случайно выбранной вершины [math]r[/math] дерево кратчайших путей [math]T_{r}[/math]. Весом каждой вершины [math]v[/math] в этом дереве назовём разность между истинной длиной пути [math]d(v,r)[/math] и нижней оценкой этой длины [math]\underline{d}(v,r)[/math], полученной по текущему набору ориентиров. Размером вершины [math]v[/math] назовём сумму её веса и размеров всех её потомков в [math]T_{r}[/math]. Если поддерево [math]T_{r}[/math] с корнем в [math]v[/math] содержит ориентир, размер [math]v[/math] равен 0.

Начиная с максимальной по размеру вершины, пойдём вниз по дереву [math]T_{r}[/math] и найдём лист с максимальным размером. Примем его за новый ориентир.

Поиск максимального покрытия (maxCover)[править]

Основным минусом избирательного метода является то, что первый ориентир выбирается случайным образом и выбор последующих ориентиров будет сильно зависеть от первоначального.

Мы можем улучшить найденные ориентиры, если сначала, используя избирательный метод, найдём набор ориентиров в несколько (обычно, 4) раза больше, чем необходимо, а потом отсеем лишние минимизируя время запроса.

Оценим качество набора ориентиров [math]S[/math] основываясь на покрытии дуг. Будем говорить, что ориентир [math]L[/math] покрывает дугу [math](v,w)[/math], если вершина [math]v[/math] находится на кратчайшем пути [math]L \rightsquigarrow w[/math]. То есть, [math]\ell(v,w) = dist(L,w)-dist(L,v)[/math], тогда такой выбор ориентира даст нам нижнюю границу для всех путей, содержащих [math](v,w)[/math].

Если хотя бы один ориентир из [math]S[/math] покрывает дугу [math](v,w)[/math], то и весь [math]S[/math] покрывает эту дугу.

Этот метод является наилучшим, но является наиболее медленным. Задача выбора ориентиров в этом случае становится NP-полной.

Reach[править]

Эта эвристика основывается на интуитивном наблюдении: не стоит посещать "локальные" дороги, когда мы находимся достаточно далеко и от [math]s[/math], и от [math]t[/math]

Пусть вершина [math]v[/math] лежит на кратчайшем пути [math]P: s \rightsquigarrow t[/math]. Тогда, назовём охватом (англ. reach) вершины [math]v[/math] относительно [math]P[/math] величину [math]r(v,P) = \min\{dist(s,v), dist(v,t)\}[/math]. Охватом вершины относительно всего графа назовём величину [math]r(v) = \max\limits_{P} r(v,P)[/math] — максимум по всем кратчайшим путям, содержащим [math]v[/math].

Помимо этого, будет полезным ввести понятие охвата ребра. Назовём охватом ребра [math](v,w)\in P[/math] относительно [math]P[/math] величину [math]\min\{dist(s,v), dist(w,t)\}[/math]. Аналогично, охватом ребра относительно всего графа назовём величину [math]r(v,w) = \max\limits_{P} r((v,w),P)[/math] — максимум по всем кратчайшим путям, содержащим [math](v,w)[/math].

Reach1.jpg

Заметим, что вершины с большим охватом находятся вблизи середины некоторого длинного кратчайшего пути, то есть

  • на больших автомагистралях вершины имеют большой охват,
  • на локальных перекрёстках (внутри населённых пунктов) вершины имеют маленький охват.

Во время обработки ребра [math](v,w)[/math]:

  • удалим вершину [math]w[/math], если [math]r(w)\lt \min\{d(s,v)+\ell(v,w), LB(w,t)\}[/math],
  • оценка [math]LB(w,t)[/math] должна быть подобрана таким образом, чтобы, если бы [math]P=(s,..,v,w,...,t)[/math] было кратчайшим путём, [math]r(w)[/math] было бы больше.
Reach2.jpg

Как искать нижнюю оценку длины пути [math]LB(w,t)[/math]?

  • Явно: Евклидово расстояние, с помощью ориентиров.
  • Неявно: сделать поиск двунаправленным.

Например, радиус [math]R_{t}[/math] поиска в обратную сторону может быть нижней оценкой, т.к. если вершина [math]w[/math] не была посещена поиском в обратную сторону, то [math]d(w,t)\geq R_{t}[/math]

Таким образом, будем удалять [math]w[/math], если [math]r(w)\textless \min\{d(s,v)+\ell(v,w), R_{t}\}[/math]

Для улучшения результата, нам необходимо сбалансировать прямой и обратный поиск.

Рассмотрим препроцессинг:

Reach3.jpg
  • на начальном этапе [math]\forall v: r(v)\leftarrow 0[/math],
  • для каждой вершины [math]s \in V[/math] рассмотрим дерево кратчайших путей до всех других вершин [math]T_{s}[/math],
    • найдём наиболее длинный путь [math]P_{s\rightsquigarrow t}[/math], содержащий [math]v[/math],
    • Назовём глубиной вершины [math]d_{s}(v)[/math] расстояние от [math]s[/math], высотой вершины [math]h_{s}(v)[/math] — расстояние до наиболее далёкого потомка вершины,
    • Тогда, охватом вершины в этом дереве будет величина [math]r_{s}(v) = \min\{d_{s}(v),h_{s}(v)\}[/math],
    • Тогда обновим значение охвата [math]r(v) \leftarrow \max\{r(v),r_{s}(v)\}[/math].

Сложность алгоритма: [math]O(nm)[/math], поэтому он слишком медленный для больших графов и его нужно улучшить.

Финальная версия препроцессинга будет иметь две фазы:

  • основная фаза (строятся частично обработанные деревья и добавляются сокращающие путь рёбра)
  • фаза отладки (вершины с большим охватом обрабатываются указанным выше алгоритмом — их гораздо меньше, поэтому обработка будет быстрой)

Сокращение области поиска[править]

Заметим, что нам нужны только вершины с маленьким охватом [math]r(v)\textless \varepsilon, \varepsilon=const[/math]. Заметим также, что если [math]r(v) \geqslant \varepsilon[/math], то существует такой путь [math]P[/math], что на нем лежит вершина [math]v \in P[/math], для которой выполняется условие [math]r(v,P)\geqslant \varepsilon[/math]

Назовём кратчайший путь [math]P_{s\rightsquigarrow t} = (s, s',...,v,...,t',t)[/math] [math]\varepsilon[/math]-минимальным, если выполняются условия:

  • [math]dist(s,v)\geqslant\varepsilon[/math],
  • [math]dist(s',v)\textless\varepsilon[/math],
  • [math]dist(v,t)\geqslant\varepsilon[/math],
  • [math]dist(v,t')\textless\varepsilon[/math].

Таким образом, алгоритм будет выглядеть так:

  • найдём оценку охвата [math]r'(v)[/math], используя только [math]\varepsilon[/math] — минимальные пути,
  • если [math]r'(v)\lt \varepsilon[/math], то оценка корректна: [math]r(v)=r'(v)[/math],
  • если же [math]r'(v)\geqslant \varepsilon[/math], то она нас не интересует: [math]r(v)\geqslant r'(v)[/math].

Полезно будет рассматривать частично обработанные деревья (англ. partial trees) — деревья кратчайших путей, хранящие пути длиной, меньшей определённого порога. Тогда дерево кратчайших путей будет глубиной порядка [math]2\varepsilon[/math]:

  • установим [math]G'\leftarrow G[/math] и [math]\varepsilon\leftarrow \varepsilon_{0}[/math] (маленькое число),
  • пока [math]G'[/math] не пусто:
    • найдём частично обработанное дерево кратчайших путей из [math]v[/math], чтобы найти вершины с охватом [math]r(v) \geqslant \varepsilon[/math],
    • удалим из [math]G'[/math] оставшиеся вершины (с охватом [math]r(v) \textless\varepsilon[/math], уже обработанные),
    • установим [math]\varepsilon\leftarrow 3\varepsilon[/math].
Reach5.jpg
Reach6.jpg

Пенальти[править]

Предыдущее улучшение создаёт проблему: мы должны предполагать, что кратчайший путь может начинаться в вершине с маленьким охватом, которые мы отбрасываем на каждой итерации. Для того, чтобы принять их во внимание, мы введём новую величину — пенальти(англ. penalty) — верхнюю оценку на длину кратчайшего пути в "отброшенной" зоне.

Пусть [math]G_{i} = (V_{i},A_{i})[/math] — подграф исходного графа, полученный на [math]i[/math]-й итерации алгоритма, описанного выше. Назовём входящим пенальти (in-penalty) вершины [math]v\in V_{i}[/math] величину [math]\max\{ \overline{r}(u,v) : u,v \in A \backslash A_{i}\}[/math], если у [math]v[/math] было как минимум одно выброшенное в процессе алгоритма входящее ребро, или ноль в противном случае. Аналогично определим исходящее пенальти для исходящих из вершины рёбер.

Изменим алгоритм, чтобы заменить вершины на их пенальти. Для этого переопределим глубину и высоту вершины.

  • Глубиной вершины [math]v\in T_{x}[/math], где [math]T_{x}[/math] — частично обработанное дерево с корнем в [math]x[/math] величину [math]depth(v)=d(v)+in\textrm{-}penalty(x)[/math] , где [math]d(v)[/math] — длина пути от корня до вершины в дереве.
  • Чтобы определить высоту вершины, нам нужно понятие "ложных листьев". Для каждой вершины [math]v[/math] в дереве кратчайших путей добавим потомка [math]v'[/math] — ложный лист, и ребро [math](v,v') = out\textrm{-}penalty(v)[/math]. В некотором смысле, [math]v'[/math] будет выступать в роли всех рёбер, изначально инцидентных вершине [math]v[/math], которые мы отсекли. Тогда высотой вершины [math]v[/math] будет расстояние от неё, до наиболее далёкого ложного листа. Подчеркнём, что в данный момент ложные листья добавляются неявно, и только после того, как дерево будет частично обработано.

Сокращение путей[править]

Представим последовательность вершин степени 2 с большим охватом, идущих подряд. Добавим, сокращающее ребро (англ. shortcut) — ребро, проходящее из начала пути в его конец с длиной, равной длине этого пути. Таким образом мы можем уменьшить охваты вершин на этом пути и ускорить препроцессинг (уменьшив количество проходимых рёбер), но увеличим память, необходимую для хранения нашего графа.

На этом шаге мы будем искать пропускаемые (англ. bypassable) вершины. Назовём вершину [math]v[/math] пропускаемой, если выполняется одно из двух условий:

  • [math]v[/math] имеет только одно входящее ребро [math](u,v)[/math] и одно исходящее ребро [math](v,w)[/math],
  • [math]v[/math] имеет два входящих ребра [math](u,v)[/math], [math](w,v)[/math] и два исходящих ребра [math](v,w)[/math] ,[math](v,u)[/math].

В обоих случаях подразумевается, что [math]u\neq w[/math], то есть у [math]v[/math] обязательно есть только два соседа. В первом случае, [math]v[/math] — кандидат на односторонний пропуск (англ. one-way bypass), во втором — на двухсторонний (англ. two-way bypass). Мы будем использовать сокращающие рёбра, чтобы пропускать такие вершины.

Линия (line) — путь в графе, содержащий как минимум три вершины, так, что все вершины, кроме начальной и конечной, пропускаемые. Каждая пропускаемая вершина может принадлежать только одной линии. Линии также могут быть односторонне- и двухсторонне- пропускаемыми, в зависимости от типа вершин, которые они содержат. Легко заметить, что на линии могут лежать вершины только одного типа.

Как только мы нашли линию, самым простым решением будет добавить одно сокращающее ребро из начала в конец. Но практика показывает, что лучше сократить ещё и входящие в её состав линии меньшего размера, это ещё более уменьшит охваты пропускаемых вершин. Для этого перед добавлением сокращающего ребра по линии, рекурсивно найдём вершину, которая находится примерно на её середине и обработаем левый и правый отрезки как полноценные линии.

Удаление пропущенных вершин[править]

Представим одностороннюю линию, состоящую из трёх вершин [math]u[/math], [math]v[/math], [math]w[/math]. Когда мы добавили сокращающее ребро [math](u,w)[/math], мы знали, что ребро [math](u,v)[/math] больше никогда не будет использоваться на кратчайшем пути содержащем подпуть [math]u\rightsquigarrow w[/math]. Кроме того, любой кратчайший путь, содержащий [math](u,v)[/math], будет оканчиваться либо в [math]v[/math], либо в близлежащей вершине с низким охватом. Тогда, корректной верхней оценкой охвата [math](u,v)[/math] является [math]\overline{r}(u,v)=\ell(u,v)+out\textrm{-}penalty(v)[/math]. Аналогично, [math]\overline{r}(v,w)=\ell(v,w)+in\textrm{-}penalty(v)[/math]. Зная это, мы можем удалить вершину [math]v[/math] и смежные ей рёбра из графа и обновить соответствующие значения пенальти для её соседей.

Такую же процедуру можно проделать с двусторонней линией, т.к. помимо оценок, указанных выше, можно добавить:

  • [math]\overline{r}(w,v)=\ell(w,v)+out\textrm{-}penalty(v)[/math],
  • [math]\overline{r}(v,u)=\ell(v,u)+in\textrm{-}penalty(v)[/math].

Фаза отладки[править]

Тот факт, что мы используем пенальти, для ускорения вычисления корректных верхних оценок охвата, приводит к тому, что оценки становятся менее точными в процессе работы алгоритма и с ростом пенальти. Следовательно, для вершин, которые дольше находятся в графе, ошибки накапливаются. Это плохо, потом что такие вершины и являются самыми важными в графе — у них высокий охват, их посещает большое количество кратчайших путей. Если бы мы могли сделать их более точными, во время запроса можно было бы пропустить большее количество вершин.

В этом и заключается цель фазы отладки. После того, как мы найдём верные значения верхних оценок, используя частично обработанные деревья, во время фазы отладки мы пересчитаем охват [math]\delta = const[/math] вершин с наибольшими значениями охвата (в них больше всего ошибок).

Пусть [math]V_{\delta} \subset G[/math] — множество вершин с высоким охватом мощностью [math]\delta[/math]. Чтобы пересчитать их охваты, сначала необходимо найти подграф [math]G_{\delta} = (V_{\delta},A_{\delta})[/math]. Этот граф содержит не только первоначальные рёбра, но и добавленные во время основной фазы сокращающие рёбра. Затем мы запустим поиск точных значений охвата для каждой вершины этого подграфа. Так как деревья кратчайших путей будут содержать только вершины из [math]G_{\delta}[/math], то нам всё ещё нужно использовать входящие и исходящие пенальти для остальных вершин. Но, тем не менее, они будут меньше, т.к. для самых больших мы подсчитали точное значение охвата.

Во время фазы отладки мы заботимся о точности, а не о скорости, поэтому не добавляем новых сокращающих рёбер и используем точный алгоритм. Поэтому, время работы алгоритма как минимум [math]\Omega(\delta^{2})[/math]

Итог[править]

Сравнение различных эвристик для поиска кратчайшего пути на карте США
Метод Время препроцессинга, м Память для препроцессинга, MB Сканируемые запросом вершины, шт Время запроса, мс
Алгоритм Дейкстры - 536 11 808 864 5440,5
ALT(16 ориентиров) 18 2563 187 968 295,45
Reach 28 893 2 405 1,77


Работа различных алгоритмов на карте севера США
Алгоритм Дейкстры ALT (16 ориентиров) Reach
Ex1.jpg Ex2.jpg Ex3.jpg

Условные обозначения:

  • зелёный квадрат — начало пути
  • синий квадрат — конец пути
  • зелёные линии — пути, пройденные прямым обходом
  • синие линии — пути, пройденные обратным обходом
  • красные ромбы — ориентиры
  • жёлтые ромбы — выбранные при поиске пути ориентиры

См. также[править]

Источники информации[править]