WikiDer > Алгоритм Йена - Википедия

Yens algorithm - Wikipedia

Алгоритм Йены вычисляет единый источник K-короткие пути без петель для график с неотрицательным край Стоимость.^[1] Алгоритм был опубликован Jin Y. Yen в 1971 году и использует любые алгоритм кратчайшего пути найти лучший путь, затем переходит к поиску K - 1 отклонение от наилучшего пути.^[2]

Алгоритм

Терминология и обозначения

Обозначение	Описание
${ displaystyle N}$	Размер графа, то есть количество узлов в сети.
${ Displaystyle (я)}$	В ${ displaystyle i ^ {th}}$ узел графа, где ${ displaystyle i}$ колеблется от ${ displaystyle 1}$ к ${ displaystyle N}$ . Это означает, что ${ displaystyle (1)}$ является исходным узлом графа и ${ displaystyle (N)}$ является приемным узлом графа.
${ displaystyle d_ {ij}}$	Стоимость грани между ${ Displaystyle (я)}$ и ${ displaystyle (j)}$ , при условии, что ${ Displaystyle (я) neq (j)}$ и ${ displaystyle d_ {ij} geq 0}$ .
${ displaystyle A ^ {k}}$	В ${ displaystyle k ^ {th}}$ кратчайший путь от ${ displaystyle (1)}$ к ${ displaystyle (N)}$ , куда ${ displaystyle k}$ колеблется от ${ displaystyle 1}$ к ${ displaystyle K}$ . потом ${ Displaystyle A ^ {k} = (1) - (2 ^ {k}) - (3 ^ {k}) - cdots - ({Q_ {k}} ^ {k}) - (N)}$ , куда ${ displaystyle (2 ^ {k})}$ это 2-й узел ${ displaystyle k ^ {th}}$ кратчайший путь и ${ displaystyle (3 ^ {k})}$ это третий узел ${ displaystyle k ^ {th}}$ кратчайший путь и так далее.
${ displaystyle {A ^ {k}} _ {i}}$	Путь отклонения от ${ Displaystyle А ^ {к-1}}$ в узле ${ Displaystyle (я ^ {к})}$ , куда ${ displaystyle i}$ колеблется от ${ displaystyle 1}$ к ${ displaystyle Q_ {k}}$ . Обратите внимание, что максимальное значение ${ displaystyle i}$ является ${ displaystyle Q_ {k}}$ , который является узлом непосредственно перед стоком в ${ displaystyle k}$ кратчайший путь. Это означает, что путь отклонения не может отклоняться от ${ displaystyle k-1}$ кратчайший путь у раковины. Пути ${ displaystyle A ^ {k}}$ и ${ Displaystyle А ^ {к-1}}$ следуйте по тому же пути, пока ${ displaystyle i_ {th}}$ узел, тогда ${ Displaystyle (я) ^ {к} - (я + 1) ^ {к}}$ край отличается от любого пути в ${ displaystyle A ^ {j}}$ , куда ${ displaystyle j}$ колеблется от ${ displaystyle 1}$ к ${ displaystyle k-1}$ .
${ displaystyle {R ^ {k}} _ {i}}$	Корневой путь ${ displaystyle {A ^ {k}} _ {i}}$ что следует за этим ${ Displaystyle А ^ {к-1}}$ до ${ displaystyle i_ {th}}$ узел ${ Displaystyle А ^ {к-1}}$ .
${ displaystyle {S ^ {k}} _ {i}}$	Подъездной путь ${ displaystyle {A ^ {k}} _ {i}}$ что начинается в ${ displaystyle i_ {th}}$ узел ${ displaystyle {A ^ {k}} _ {i}}$ и заканчивается у раковины.

Описание

Алгоритм можно разбить на две части, определяя первую k-кратчайший путь, ${ displaystyle A ^ {k}}$ , а затем определяя все остальные k-кратчайшие пути. Предполагается, что контейнер ${ displaystyle A}$ проведет k-самый короткий путь, тогда как контейнер ${ displaystyle B}$ , будет иметь потенциал k-короткие пути. Чтобы определить ${ displaystyle A ^ {1}}$ , то кратчайший путь от истока до раковины, любой эффективный алгоритм кратчайшего пути может быть использован.

Чтобы найти ${ displaystyle A ^ {k}}$ , куда ${ displaystyle k}$ колеблется от ${ displaystyle 2}$ к ${ displaystyle K}$ , алгоритм предполагает, что все пути из ${ displaystyle A ^ {1}}$ к ${ Displaystyle А ^ {к-1}}$ ранее были найдены. В ${ displaystyle k}$ итерацию можно разделить на два процесса, выявляя все отклонения ${ displaystyle {A ^ {k}} _ {i}}$ и выбирая путь минимальной длины, чтобы стать ${ displaystyle A ^ {k}}$ . Обратите внимание, что в этой итерации ${ displaystyle i}$ колеблется от ${ displaystyle 1}$ к ${ displaystyle {Q ^ {k}} _ {k}}$ .

Первый процесс можно далее разделить на три операции, выбрав ${ displaystyle {R ^ {k}} _ {i}}$ , нахождение ${ displaystyle {S ^ {k}} _ {i}}$ , а затем добавив ${ displaystyle {A ^ {k}} _ {i}}$ в контейнер ${ displaystyle B}$ . Корневой путь, ${ displaystyle {R ^ {k}} _ {i}}$ , выбирается путем нахождения подпути в ${ Displaystyle А ^ {к-1}}$ что следует за первым ${ displaystyle i}$ узлы ${ displaystyle A ^ {j}}$ , куда ${ displaystyle j}$ колеблется от ${ displaystyle 1}$ к ${ displaystyle k-1}$ . Тогда, если путь найден, стоимость ребра ${ Displaystyle d_ {я (я + 1)}}$ из ${ displaystyle A ^ {j}}$ установлен на бесконечность. Далее подъездная дорога, ${ Displaystyle {S ^ {k}} _ {я}}$ , находится путем вычисления кратчайшего пути от ответвительного узла, узла ${ displaystyle i}$ , в раковину. Удаление ранее использованных кромок из ${ Displaystyle (я)}$ к ${ Displaystyle (я + 1)}$ гарантирует, что ответвление будет другим. ${ displaystyle {A ^ {k}} _ {i} = {R ^ {k}} _ {i} + {S ^ {k}} _ {i}}$ , добавление корневого пути и ответвления добавляется к ${ displaystyle B}$ . Затем ребра, которые были удалены, т.е. для которых была установлена бесконечная стоимость, восстанавливаются до своих исходных значений.

Второй процесс определяет подходящий путь для ${ displaystyle A ^ {k}}$ найдя путь в контейнере ${ displaystyle B}$ с наименьшей стоимостью. Этот путь удален из контейнера ${ displaystyle B}$ и вставлен в контейнер ${ displaystyle A}$ и алгоритм переходит к следующей итерации.

Псевдокод

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

функция ЙенКСП (График, источник, сток, К): // Определяем кратчайший путь от источника до приемника.    A [0] = Дейкстра (График, источник, сток); // Инициализируем набор для хранения потенциального k-го кратчайшего пути.    B = []; за k из 1 к K: // Узел ответвления находится в диапазоне от первого узла до предпоследнего узла в предыдущем k-кратчайшем пути.        за я из 0 к размер (A [k - 1]) - 2: // Узел ответвления извлекается из предыдущего k-кратчайшего пути, k - 1.            spurNode = A [k-1] .node (i); // Последовательность узлов от источника до ответвительного узла предыдущего k-кратчайшего пути.            rootPath = A [k-1] .nodes (0, я); для каждого путь p в А: если rootPath == p.nodes (0, i): // Удаляем ссылки, которые являются частью предыдущих кратчайших путей с одним и тем же корневым путем.                    удалить p.edge (i, i + 1) из График; для каждого узел rootPathNode в rootPath, кроме spurNode: удалить rootPathNode из График; // Вычислить путь ответвления от узла ответвления до стока.            spurPath = Dijkstra (График, spurNode, сток); // Весь путь состоит из корневого и ответвительного пути.            totalPath = rootPath + spurPath; // Добавляем в кучу потенциальный k-кратчайший путь.            если (totalPath не входит в B): B.append (totalPath); // Добавляем обратно ребра и узлы, которые были удалены из графа.            восстановить края к График; восстановить узлы в rootPath к График; если B пусто: // Это обрабатывает случай, когда нет ответвлений или не осталось ответвлений.            // Это могло произойти, если ответвления уже исчерпаны (добавлены в A),             // или нет никаких ответвлений - например, когда и исходная, и приемная вершины             // лежать в «тупике».            перемена; // Сортируем возможные k-кратчайшие пути по стоимости.        B.sort (); // Добавление пути с наименьшей стоимостью становится k-кратчайшим путем.        A [k] = B [0]; // На самом деле нам лучше использовать shift, так как мы удаляем первый элемент        B.pop (); возвращаться А;

Пример

Алгоритм k-кратчайшего пути Йена, K = 3, от A до F

В примере используется йен K-Алгоритм кратчайшего пути для вычисления трех путей из ${ displaystyle (C)}$ к ${ displaystyle (H)}$ . Алгоритм Дейкстры используется для вычисления наилучшего пути от ${ displaystyle (C)}$ к ${ displaystyle (H)}$ , который ${ Displaystyle (C) - (E) - (F) - (H)}$ со стоимостью 5. Этот путь добавляется к контейнеру ${ displaystyle A}$ и становится первым k- кратчайший путь, ${ displaystyle A ^ {1}}$ .

Узел ${ displaystyle (C)}$ из ${ displaystyle A ^ {1}}$ становится ответвительным узлом с корневым путем, ${ displaystyle {R ^ {2}} _ {1} = (C)}$ . Край, ${ Displaystyle (С) - (Е)}$ , удаляется, потому что он совпадает с корневым путем и путем в контейнере ${ displaystyle A}$ . Алгоритм Дейкстры используется для вычисления ответвления ${ displaystyle {S ^ {2}} _ {1}}$ , который ${ Displaystyle (C) - (D) - (F) - (H)}$ , стоимостью 8. ${ Displaystyle {A ^ {2}} _ {1} = {R ^ {2}} _ {1} + {S ^ {2}} _ {1} = (C) - (D) - (F) -(ЧАС)}$ добавлен в контейнер ${ displaystyle B}$ как потенциальный k-коротчайший путь.

Узел ${ displaystyle (E)}$ из ${ displaystyle A ^ {1}}$ становится ответвительным узлом с ${ displaystyle {R ^ {2}} _ {2} = (C) - (E)}$ . Край, ${ Displaystyle (E) - (F)}$ , удаляется, потому что он совпадает с корневым путем и путем в контейнере ${ displaystyle A}$ . Алгоритм Дейкстры используется для вычисления ответвления ${ displaystyle {S ^ {2}} _ {2}}$ , который ${ Displaystyle (E) - (G) - (H)}$ , стоимостью 7. ${ Displaystyle {A ^ {2}} _ {2} = {R ^ {2}} _ {2} + {S ^ {2}} _ {2} = (C) - (E) - (G) -(ЧАС)}$ добавлен в контейнер ${ displaystyle B}$ как потенциальный k-коротчайший путь.

Узел ${ Displaystyle (F)}$ из ${ displaystyle A ^ {1}}$ становится ответвительным узлом с корневым путем, ${ Displaystyle {R ^ {2}} _ {3} = (C) - (E) - (F)}$ . Край, ${ displaystyle (F) - (H)}$ , удаляется, потому что он совпадает с корневым путем и путем в контейнере ${ displaystyle A}$ . Алгоритм Дейкстры используется для вычисления ответвления ${ displaystyle {S ^ {2}} _ {3}}$ , который ${ Displaystyle (F) - (G) - (H)}$ , стоимостью 8. ${ displaystyle {A ^ {2}} _ {3} = {R ^ {2}} _ {3} + {S ^ {2}} _ {3} = (C) - (E) - (F) - (G) - (H)}$ добавлен в контейнер ${ displaystyle B}$ как потенциальный k-коротчайший путь.

Из трех путей в контейнере B, ${ displaystyle {A ^ {2}} _ {2}}$ выбран, чтобы стать ${ displaystyle A ^ {2}}$ потому что у него самая низкая стоимость 7. Этот процесс продолжается до 3-го числа. k-коротчайший путь. Однако в рамках этой 3-й итерации обратите внимание, что некоторые ответвления не существуют. И путь, который выбран стать ${ displaystyle A ^ {3}}$ является ${ Displaystyle (C) - (D) - (F) - (H)}$ .

Функции

Космическая сложность

Для хранения ребер графа список кратчайших путей ${ displaystyle A}$ , и список потенциальных кратчайших путей ${ displaystyle B}$ , ${ displaystyle N ^ {2} + KN}$ требуются адреса памяти.^[2] В худшем случае каждый узел в графе имеет ребро по отношению к каждому другому узлу в графе, таким образом ${ displaystyle N ^ {2}}$ адреса нужны. Только ${ displaystyle KN}$ адреса нужны для обоих списков ${ displaystyle A}$ и ${ displaystyle B}$ потому что самое большее только ${ displaystyle K}$ пути будут сохранены,^[2] где можно для каждого пути иметь ${ displaystyle N}$ узлы.

Сложность времени

Временная сложность алгоритма Йена зависит от алгоритма кратчайшего пути, используемого при вычислении ответвлений, поэтому предполагается алгоритм Дейкстры. Алгоритм Дейкстры имеет худшую временную сложность, равную ${ displaystyle O (N ^ {2})}$ , но с использованием кучи Фибоначчи становится ${ Displaystyle О (М + N журнал N)}$ ,^[3] куда ${ displaystyle M}$ количество ребер в графе. Поскольку алгоритм Йены делает ${ displaystyle Kl}$ обращается к Дейкстре при вычислении ответвлений, где ${ displaystyle l}$ - длина ответвлений. В сокращенном графике ожидаемое значение ${ displaystyle l}$ является ${ Displaystyle О ( журнал N)}$ , а в худшем случае ${ displaystyle N}$ . , временная сложность становится ${ Displaystyle О (КН (М + N журнал N))}$ .^[4]

Улучшения

Алгоритм Йены можно улучшить, используя кучу для хранения ${ displaystyle B}$ , множество потенциальных k-короткие пути. Использование кучи вместо списка улучшит производительность алгоритма, но не усложнит его.^[5] Один из способов немного снизить сложность - пропустить узлы, где нет ответвлений. Этот случай возникает, когда все ответвительные пути от ответвительного узла были использованы в предыдущем ${ displaystyle A ^ {k}}$ . Также, если контейнер ${ displaystyle B}$ имеет ${ displaystyle K-k}$ пути минимальной длины, относительно путей в контейнере ${ displaystyle A}$ , затем их можно извлечь и вставить в контейнер ${ displaystyle A}$ поскольку более коротких путей найти не удастся.

Модификация Лоулера

Юджин Лоулер предложила модификацию алгоритма Йена, в которой путь дубликатов не вычисляется, в отличие от исходного алгоритма, в котором они вычисляются и затем отбрасываются, когда обнаруживаются дубликаты.^[6] Эти дублирующиеся пути являются результатом вычисления ответвлений узлов в корне ${ displaystyle A ^ {k}}$ . Например, ${ displaystyle A ^ {k}}$ отклоняется от ${ Displaystyle А ^ {к-1}}$ в каком-то узле ${ Displaystyle (я)}$ . Любая подъездная дорога, ${ displaystyle {S ^ {k}} _ {j}}$ куда ${ displaystyle j = 0, ldots, i}$ , который рассчитывается, будет дублироваться, потому что они уже были рассчитаны во время ${ displaystyle k-1}$ итерация. Следовательно, только ответвительные пути для узлов, которые были на ответвительном пути ${ Displaystyle А ^ {к-1}}$ должны быть рассчитаны, т.е. только ${ displaystyle {S ^ {k}} _ {h}}$ куда ${ displaystyle h}$ колеблется от ${ Displaystyle (я + 1) ^ {к-1}}$ к ${ displaystyle (Q_ {k}) ^ {k-1}}$ . Чтобы выполнить эту операцию для ${ displaystyle A ^ {k}}$ , необходима запись для идентификации узла, в котором ${ Displaystyle А ^ {к-1}}$ разветвленный от ${ displaystyle A ^ {k-2}}$ .