http://neerc.ifmo.ru/wiki/api.php?action=feedcontributions&feedformat=atom&user=6yry6eВикиконспекты - Вклад участника [ru]2026-08-03T23:04:27ZВклад участникаMediaWiki 1.30.0http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0_%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B5%D0%B3%D0%BE_%D0%BF%D0%BE%D1%82%D0%BE%D0%BA%D0%B0_%D0%B2_%D0%B0%D1%86%D0%B8%D0%BA%D0%BB%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B9_%D1%81%D0%B5%D1%82%D0%B8&diff=52092Алгоритм поиска блокирующего потока в ациклической сети2016-01-28T20:43:10Z<p>6yry6e: /* Источники информации */</p>
<hr />
<div>==Жадный алгоритм==<br />
Идея заключается в том, чтобы по одному находить пути из [[Определение_сети,_потока|истока]] <tex>s</tex> в [[Определение_сети,_потока|сток]] <tex>t</tex>, пока это возможно. [[Обход в глубину, цвета вершин| Обход в глубину]] найдёт все пути из <tex>s</tex> в <tex>t</tex>, если из <tex>s</tex> достижима <tex>t</tex>, а [[Определение_сети,_потока|пропускная способность]] каждого ребра <tex>c(u, v)>0</tex> поэтому, насыщая рёбра, мы хотя бы единожды достигнем стока <tex>t</tex>, следовательно блокирующий поток всегда найдётся.<br />
<br />
Используя <tex>dfs</tex>, каждый путь находится за <tex>O(E)</tex>, где <tex>E</tex> — число рёбер в графе. Поскольку каждый путь насыщает как минимум одно ребро, всего будет <tex>O(E)</tex> путей. Итого общая асимптотика составляет <tex>O(E^2)</tex>.<br />
<br />
==Удаляющий обход==<br />
Аналогично предыдущей идее, однако будем удалять в процессе обхода в глубину из графа все рёбра, вдоль которых не получится дойти до стока <tex>t</tex>. Это очень легко реализовать: достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое не удалённое ребро, и увеличивать этот указать в цикле внутри обхода в глубину. Корректность при этом сохраняется согласно предыдущему пункту. <br />
<br />
'''int''' dfs('''int''' <tex>v</tex>, '''int''' flow) <br />
'''if''' (flow == 0) <br />
'''return''' 0<br />
'''if''' (<tex>v</tex> == <tex>t</tex>)<br />
'''return''' flow<br />
'''for''' (<tex>u</tex> = ptr[<tex>v</tex>] '''to''' n)<br />
ptr[<tex>v</tex>]++<br />
'''if''' (<tex>vu \in E</tex>)<br />
pushed = dfs(<tex>u</tex>, min(flow, c(<tex>vu</tex>) - f(<tex>vu</tex>)))<br />
f(<tex>vu</tex>) += pushed<br />
f(<tex>uv</tex>) -= pushed<br />
'''return''' pushed<br />
'''return''' 0<br />
<br />
'''main'''()<br />
'''...'''<br />
flow = 0<br />
'''for''' ('''int''' i = 1 '''to''' n)<br />
ptr[i] = 0<br />
'''do'''<br />
pushed = dfs(<tex>s</tex>, <tex>\infty</tex>)<br />
flow += pushed<br />
'''while''' (pushed > 0)<br />
<br />
<br />
Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Значит один запуск обхода в глубину работает за <tex>O(V + K)</tex>, где <tex>V</tex> — число вершин в графе, а <tex>K</tex> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного [[Блокирующий поток|блокирующего потока]] будет <tex>O(P)</tex>, где <tex>P</tex> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <tex>O(PV + \sum\limits_i{K_i})</tex>, что, учитывая, что все указатели в сумме прошли расстояние <tex>O(E)</tex>, дает асимптотику <tex>O(PV + E)</tex>. В худшем случае, когда блокирующий поток насыщает все ребра, асимптотика получается <tex>O(VE)</tex>.<br />
<br />
<b>Замечание:</b> Если в [[Схема алгоритма Диница|алгоритме Диница]] искать блокирующий поток удаляющим обходом, то его эффективность составит <tex>O(V^2E)</tex>, что уже лучше эффективности [[Алоритм Эдмондса-Карпа|алгоритма Эдмондса-Карпа]] <tex>O(VE^2)</tex>.<br />
<br />
==Алгоритм Малхотры — Кумара — Махешвари==<br />
===Идея===<br />
Для каждой вершины вводится потенциал потока, равный максимальному дополнительному потоку, который может пройти через эту вершину. Далее запускаем цикл, на каждой итерации которого определяем вершину <tex>v</tex> с минимальным потенциалом <tex>p</tex>. Затем пускается поток величины <tex>p</tex> из истока в сток, проходящий через эту вершину. При этом если [[Дополняющая сеть, дополняющий путь|остаточная пропускная способность]] ребра равна нулю, то это ребро удаляется. Также, удаляются все вершины, у которых не остаётся ни одного входящего и/или ни одного выходящего ребра. При удалении вершины все смежные ребра удаляются.<br />
<br />
===Подробное описание===<br />
* Для каждой вершины <tex>v</tex> вычислим входящий и исходящий потенциал: <tex>p_{in}=\sum \limits_{u} c(u, v)</tex> и <tex>p_{out}=\sum \limits_{u} c(u, v)</tex>. Пусть <tex>p_{in}(s)=\infty</tex> и <tex>p_{out}(t)=\infty</tex>. Определим потенциал или пропускную способность вершины в [[Определение сети, потока|сети]] <tex>p(v)=min(p_{in}(v), p_{out}(v))</tex>. Таким образом, потенциал вершины определяет максимально возможное количество потока, который может через нее проходить. Ясно, что через вершины с <tex>p(v)=0</tex> поток проходить не может. Следовательно, их можно удалить из [[Дополняющая сеть, дополняющий путь|вспомогательной сети]]. Удалим эти вершины и дуги, им инцидентные, обновив должным образом потенциалы вершин, смежных с удаленными. Если в результате появятся новые вершины с <tex>p(v)=0</tex>, удалим рекурсивно и их. В результате во вспомогательной сети останутся только вершины с <tex>p(v)\ne0</tex>.<br />
<br />
* После этого приступим к построению [[Блокирующий поток|блокирующего потока]]. Пусть вершина <tex>v</tex> принадлежит <tex>k</tex>-ому слою и <tex>p(v)=min (p(w), w \in L_k)</tex>, где <tex>L_k</tex> — <tex>k</tex>-й слой. Протолкнем <tex>p(v)</tex> единиц потока из вершины <tex>v</tex> в смежные с ней вершины по исходящим дугам с [[Дополняющая сеть, дополняющий путь | остаточной пропускной способностью]] <tex>c_f \ne 0</tex>. Попутно будем переносить проталкиваемый поток в исходную сеть, а также корректировать потенциалы вершин, отправляющих и принимающих избыток потока. В результате, весь (в виду минимальности потенциала вершины <tex>v</tex>) проталкиваемый поток соберется в вершинах <tex>(k+1)</tex>-го слоя. <br />
<br />
* Повторим процесс отправки потока из вершин <tex>(k+1)</tex>-го слоя, содержащих избыток потока, в смежные им вершины <tex>(k+2)</tex>-го слоя. И так до тех пор, пока весь поток не соберется в последнем слое, в котором содержится только сток <tex>t</tex>, ибо все остальные вершины, ранее ему принадлежащие, были удалены, поскольку их потенциалы нулевые. Следовательно, весь поток величины <tex>p(v)</tex>, отправленный из вершины <tex>v</tex>, где <tex>p(v)</tex> - минимальный полностью соберется в <tex>t</tex>. <br />
<br />
* На втором этапе вновь, начиная с вершины <tex>v</tex>, осуществляется подвод потока уже по входящим дугам. В результате на первом шаге недостаток потока переадресуется к узлам <tex>(k-1)</tex>-го слоя, затем <tex>(k-2)</tex>-го. И так до тех пор, пока весь потока величины <tex>p(v)</tex>, отправленные из вершины <tex>v</tex>, где <tex>p(v)</tex> - минимальный, не соберется в истоке <tex>s</tex>. Таким образом, поток и во вспомогательной и в основной сети увеличится на величину <tex>p</tex>. <br />
<br />
<br />
MPM algorithm(<tex>s, t</tex>)<br />
{<br />
foreach <tex>(uv) \in E</tex><br />
<tex>f(uv) \leftarrow 0 </tex>;<br />
Вычисляем остаточную сеть <tex>R</tex>;<br />
Найдём вспомогательный граф <tex>L</tex> для <tex>R</tex>;<br />
while (<tex>t \in L</tex>)<br />
{<br />
while (<tex>t</tex> достижима из <tex>s</tex> в <tex>L</tex>)<br />
{<br />
найдём <tex>v</tex> с минимальной пропускной способностью <tex>g</tex>;<br />
проталкиваем <tex>g</tex> единиц потока из <tex>v</tex> в <tex>t</tex>;<br />
проталкиваем <tex>g</tex> единиц потока из <tex>s</tex> в <tex>v</tex>;<br />
изменяем <tex>f</tex>, <tex>L</tex> и <tex>R</tex>;<br />
}<br />
вычисляем новый вспомогательный граф <tex>L</tex> из <tex>R</tex>;<br />
}<br />
}<br />
<br />
===Асимптотика===<br />
Если информация о входящих и исходящих дугах будет храниться в виде связных списков, то для того, чтобы пропустить поток, на каждой итерации будет выполнено <tex>O(K + E_i)</tex> действий, где <tex>K</tex> соответствует числу рёбер, для которых остаточная пропускная способность уменьшилась, но осталась положительной, а <tex>E_i</tex> — числу удалённых ребер. Таким образом, для поиска блокирующего потока будет выполнено <tex>\sum\limits_i{O(K+E_i)} = O(K^2)</tex> действий.<br />
<br />
== См. также ==<br />
* [[Блокирующий поток]]<br />
* [[Схема алгоритма Диница]]<br />
<br />
==Источники информации==<br />
* [http://e-maxx.ru/algo/dinic MAXimal :: algo :: Алгоритм Диница]<br />
*[http://www.facweb.iitkgp.ernet.in/~arijit/courses/autumn2006/cs60001/lec-flow-4.pdf The MPM Algorithm]<br />
*[http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9C%D0%B0%D0%BB%D1%85%D0%BE%D1%82%D1%80%D1%8B_%E2%80%94_%D0%9A%D1%83%D0%BC%D0%B0%D1%80%D0%B0_%E2%80%94_%D0%9C%D0%B0%D1%85%D0%B5%D1%88%D0%B2%D0%B0%D1%80%D0%B8 Алгоритм Малхотры — Кумара — Махешвари]<br />
*[http://eprints.utas.edu.au/160/1/iplFlow.pdf Оригинальная публикация алгоритма Малхотры — Кумара — Махешвари.]<br />
<br />
<br />
[[Категория:Алгоритмы и структуры данных]]<br />
[[Категория:Задача о максимальном потоке]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0_%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B5%D0%B3%D0%BE_%D0%BF%D0%BE%D1%82%D0%BE%D0%BA%D0%B0_%D0%B2_%D0%B0%D1%86%D0%B8%D0%BA%D0%BB%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B9_%D1%81%D0%B5%D1%82%D0%B8&diff=52091Алгоритм поиска блокирующего потока в ациклической сети2016-01-28T20:37:19Z<p>6yry6e: </p>
<hr />
<div>==Жадный алгоритм==<br />
Идея заключается в том, чтобы по одному находить пути из [[Определение_сети,_потока|истока]] <tex>s</tex> в [[Определение_сети,_потока|сток]] <tex>t</tex>, пока это возможно. [[Обход в глубину, цвета вершин| Обход в глубину]] найдёт все пути из <tex>s</tex> в <tex>t</tex>, если из <tex>s</tex> достижима <tex>t</tex>, а [[Определение_сети,_потока|пропускная способность]] каждого ребра <tex>c(u, v)>0</tex> поэтому, насыщая рёбра, мы хотя бы единожды достигнем стока <tex>t</tex>, следовательно блокирующий поток всегда найдётся.<br />
<br />
Используя <tex>dfs</tex>, каждый путь находится за <tex>O(E)</tex>, где <tex>E</tex> — число рёбер в графе. Поскольку каждый путь насыщает как минимум одно ребро, всего будет <tex>O(E)</tex> путей. Итого общая асимптотика составляет <tex>O(E^2)</tex>.<br />
<br />
==Удаляющий обход==<br />
Аналогично предыдущей идее, однако будем удалять в процессе обхода в глубину из графа все рёбра, вдоль которых не получится дойти до стока <tex>t</tex>. Это очень легко реализовать: достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое не удалённое ребро, и увеличивать этот указать в цикле внутри обхода в глубину. Корректность при этом сохраняется согласно предыдущему пункту. <br />
<br />
'''int''' dfs('''int''' <tex>v</tex>, '''int''' flow) <br />
'''if''' (flow == 0) <br />
'''return''' 0<br />
'''if''' (<tex>v</tex> == <tex>t</tex>)<br />
'''return''' flow<br />
'''for''' (<tex>u</tex> = ptr[<tex>v</tex>] '''to''' n)<br />
ptr[<tex>v</tex>]++<br />
'''if''' (<tex>vu \in E</tex>)<br />
pushed = dfs(<tex>u</tex>, min(flow, c(<tex>vu</tex>) - f(<tex>vu</tex>)))<br />
f(<tex>vu</tex>) += pushed<br />
f(<tex>uv</tex>) -= pushed<br />
'''return''' pushed<br />
'''return''' 0<br />
<br />
'''main'''()<br />
'''...'''<br />
flow = 0<br />
'''for''' ('''int''' i = 1 '''to''' n)<br />
ptr[i] = 0<br />
'''do'''<br />
pushed = dfs(<tex>s</tex>, <tex>\infty</tex>)<br />
flow += pushed<br />
'''while''' (pushed > 0)<br />
<br />
<br />
Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Значит один запуск обхода в глубину работает за <tex>O(V + K)</tex>, где <tex>V</tex> — число вершин в графе, а <tex>K</tex> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного [[Блокирующий поток|блокирующего потока]] будет <tex>O(P)</tex>, где <tex>P</tex> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <tex>O(PV + \sum\limits_i{K_i})</tex>, что, учитывая, что все указатели в сумме прошли расстояние <tex>O(E)</tex>, дает асимптотику <tex>O(PV + E)</tex>. В худшем случае, когда блокирующий поток насыщает все ребра, асимптотика получается <tex>O(VE)</tex>.<br />
<br />
<b>Замечание:</b> Если в [[Схема алгоритма Диница|алгоритме Диница]] искать блокирующий поток удаляющим обходом, то его эффективность составит <tex>O(V^2E)</tex>, что уже лучше эффективности [[Алоритм Эдмондса-Карпа|алгоритма Эдмондса-Карпа]] <tex>O(VE^2)</tex>.<br />
<br />
==Алгоритм Малхотры — Кумара — Махешвари==<br />
===Идея===<br />
Для каждой вершины вводится потенциал потока, равный максимальному дополнительному потоку, который может пройти через эту вершину. Далее запускаем цикл, на каждой итерации которого определяем вершину <tex>v</tex> с минимальным потенциалом <tex>p</tex>. Затем пускается поток величины <tex>p</tex> из истока в сток, проходящий через эту вершину. При этом если [[Дополняющая сеть, дополняющий путь|остаточная пропускная способность]] ребра равна нулю, то это ребро удаляется. Также, удаляются все вершины, у которых не остаётся ни одного входящего и/или ни одного выходящего ребра. При удалении вершины все смежные ребра удаляются.<br />
<br />
===Подробное описание===<br />
* Для каждой вершины <tex>v</tex> вычислим входящий и исходящий потенциал: <tex>p_{in}=\sum \limits_{u} c(u, v)</tex> и <tex>p_{out}=\sum \limits_{u} c(u, v)</tex>. Пусть <tex>p_{in}(s)=\infty</tex> и <tex>p_{out}(t)=\infty</tex>. Определим потенциал или пропускную способность вершины в [[Определение сети, потока|сети]] <tex>p(v)=min(p_{in}(v), p_{out}(v))</tex>. Таким образом, потенциал вершины определяет максимально возможное количество потока, который может через нее проходить. Ясно, что через вершины с <tex>p(v)=0</tex> поток проходить не может. Следовательно, их можно удалить из [[Дополняющая сеть, дополняющий путь|вспомогательной сети]]. Удалим эти вершины и дуги, им инцидентные, обновив должным образом потенциалы вершин, смежных с удаленными. Если в результате появятся новые вершины с <tex>p(v)=0</tex>, удалим рекурсивно и их. В результате во вспомогательной сети останутся только вершины с <tex>p(v)\ne0</tex>.<br />
<br />
* После этого приступим к построению [[Блокирующий поток|блокирующего потока]]. Пусть вершина <tex>v</tex> принадлежит <tex>k</tex>-ому слою и <tex>p(v)=min (p(w), w \in L_k)</tex>, где <tex>L_k</tex> — <tex>k</tex>-й слой. Протолкнем <tex>p(v)</tex> единиц потока из вершины <tex>v</tex> в смежные с ней вершины по исходящим дугам с [[Дополняющая сеть, дополняющий путь | остаточной пропускной способностью]] <tex>c_f \ne 0</tex>. Попутно будем переносить проталкиваемый поток в исходную сеть, а также корректировать потенциалы вершин, отправляющих и принимающих избыток потока. В результате, весь (в виду минимальности потенциала вершины <tex>v</tex>) проталкиваемый поток соберется в вершинах <tex>(k+1)</tex>-го слоя. <br />
<br />
* Повторим процесс отправки потока из вершин <tex>(k+1)</tex>-го слоя, содержащих избыток потока, в смежные им вершины <tex>(k+2)</tex>-го слоя. И так до тех пор, пока весь поток не соберется в последнем слое, в котором содержится только сток <tex>t</tex>, ибо все остальные вершины, ранее ему принадлежащие, были удалены, поскольку их потенциалы нулевые. Следовательно, весь поток величины <tex>p(v)</tex>, отправленный из вершины <tex>v</tex>, где <tex>p(v)</tex> - минимальный полностью соберется в <tex>t</tex>. <br />
<br />
* На втором этапе вновь, начиная с вершины <tex>v</tex>, осуществляется подвод потока уже по входящим дугам. В результате на первом шаге недостаток потока переадресуется к узлам <tex>(k-1)</tex>-го слоя, затем <tex>(k-2)</tex>-го. И так до тех пор, пока весь потока величины <tex>p(v)</tex>, отправленные из вершины <tex>v</tex>, где <tex>p(v)</tex> - минимальный, не соберется в истоке <tex>s</tex>. Таким образом, поток и во вспомогательной и в основной сети увеличится на величину <tex>p</tex>. <br />
<br />
<br />
MPM algorithm(<tex>s, t</tex>)<br />
{<br />
foreach <tex>(uv) \in E</tex><br />
<tex>f(uv) \leftarrow 0 </tex>;<br />
Вычисляем остаточную сеть <tex>R</tex>;<br />
Найдём вспомогательный граф <tex>L</tex> для <tex>R</tex>;<br />
while (<tex>t \in L</tex>)<br />
{<br />
while (<tex>t</tex> достижима из <tex>s</tex> в <tex>L</tex>)<br />
{<br />
найдём <tex>v</tex> с минимальной пропускной способностью <tex>g</tex>;<br />
проталкиваем <tex>g</tex> единиц потока из <tex>v</tex> в <tex>t</tex>;<br />
проталкиваем <tex>g</tex> единиц потока из <tex>s</tex> в <tex>v</tex>;<br />
изменяем <tex>f</tex>, <tex>L</tex> и <tex>R</tex>;<br />
}<br />
вычисляем новый вспомогательный граф <tex>L</tex> из <tex>R</tex>;<br />
}<br />
}<br />
<br />
===Асимптотика===<br />
Если информация о входящих и исходящих дугах будет храниться в виде связных списков, то для того, чтобы пропустить поток, на каждой итерации будет выполнено <tex>O(K + E_i)</tex> действий, где <tex>K</tex> соответствует числу рёбер, для которых остаточная пропускная способность уменьшилась, но осталась положительной, а <tex>E_i</tex> — числу удалённых ребер. Таким образом, для поиска блокирующего потока будет выполнено <tex>\sum\limits_i{O(K+E_i)} = O(K^2)</tex> действий.<br />
<br />
== См. также ==<br />
* [[Блокирующий поток]]<br />
* [[Схема алгоритма Диница]]<br />
<br />
==Источники информации==<br />
*[http://www.e-maxx.ru/algo/dinic Алгоритм Диница. Необходимые определения.]<br />
*[http://www.facweb.iitkgp.ernet.in/~arijit/courses/autumn2006/cs60001/lec-flow-4.pdf The MPM Algorithm]<br />
*[http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9C%D0%B0%D0%BB%D1%85%D0%BE%D1%82%D1%80%D1%8B_%E2%80%94_%D0%9A%D1%83%D0%BC%D0%B0%D1%80%D0%B0_%E2%80%94_%D0%9C%D0%B0%D1%85%D0%B5%D1%88%D0%B2%D0%B0%D1%80%D0%B8 Алгоритм Малхотры — Кумара — Махешвари]<br />
*[http://eprints.utas.edu.au/160/1/iplFlow.pdf Оригинальная публикация алгоритма Малхотры — Кумара — Махешвари.]<br />
<br />
<br />
[[Категория:Алгоритмы и структуры данных]]<br />
[[Категория:Задача о максимальном потоке]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0_%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B5%D0%B3%D0%BE_%D0%BF%D0%BE%D1%82%D0%BE%D0%BA%D0%B0_%D0%B2_%D0%B0%D1%86%D0%B8%D0%BA%D0%BB%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B9_%D1%81%D0%B5%D1%82%D0%B8&diff=52090Алгоритм поиска блокирующего потока в ациклической сети2016-01-28T20:35:31Z<p>6yry6e: </p>
<hr />
<div>==Жадный алгоритм==<br />
Идея заключается в том, чтобы по одному находить пути из [[Определение_сети,_потока|истока]] <tex>s</tex> в [[Определение_сети,_потока|сток]] <tex>t</tex>, пока это возможно. [[Обход в глубину, цвета вершин| Обход в глубину]] найдёт все пути из <tex>s</tex> в <tex>t</tex>, если из <tex>s</tex> достижима <tex>t</tex>, а [[Определение_сети,_потока|пропускная способность]] каждого ребра <tex>c(u, v)>0</tex> поэтому, насыщая рёбра, мы хотя бы единожды достигнем стока <tex>t</tex>, следовательно блокирующий поток всегда найдётся.<br />
<br />
Используя <tex>dfs</tex>, каждый путь находится за <tex>O(E)</tex>, где <tex>E</tex> — число рёбер в графе. Поскольку каждый путь насыщает как минимум одно ребро, всего будет <tex>O(E)</tex> путей. Итого общая асимптотика составляет <tex>O(E^2)</tex>.<br />
<br />
==Удаляющий обход==<br />
Аналогично предыдущей идее, однако будем удалять в процессе обхода в глубину из графа все рёбра, вдоль которых не получится дойти до стока <tex>t</tex>. Это очень легко реализовать: достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое не удалённое ребро, и увеличивать этот указать в цикле внутри обхода в глубину. Корректность при этом сохраняется согласно предыдущему пункту. <br />
<br />
'''int''' dfs('''int''' <tex>v</tex>, '''int''' flow) <br />
'''if''' (flow == 0) <br />
'''return''' 0<br />
'''if''' (<tex>v</tex> == <tex>t</tex>)<br />
'''return''' flow<br />
'''for''' (<tex>u</tex> = ptr[<tex>v</tex>] '''to''' n)<br />
ptr[<tex>v</tex>]++<br />
'''if''' (<tex>vu \in E</tex>)<br />
pushed = dfs(<tex>u</tex>, min(flow, c(<tex>vu</tex>) - f(<tex>vu</tex>)))<br />
f(<tex>vu</tex>) += pushed<br />
f(<tex>uv</tex>) -= pushed<br />
'''return''' pushed<br />
'''return''' 0<br />
<br />
'''main'''()<br />
'''...'''<br />
flow = 0<br />
'''for''' ('''int''' i = 1 '''to''' n)<br />
ptr[i] = 0<br />
'''do'''<br />
pushed = dfs(<tex>s</tex>, <tex>\infty</tex>)<br />
flow += pushed<br />
'''while''' (pushed > 0)<br />
<br />
<br />
Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Значит один запуск обхода в глубину работает за <tex>O(V + K)</tex>, где <tex>V</tex> — число вершин в графе, а <tex>K</tex> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного [[Блокирующий поток|блокирующего потока]] будет <tex>O(P)</tex>, где <tex>P</tex> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <tex>O(PV + \sum\limits_i{K_i})</tex>, что, учитывая, что все указатели в сумме прошли расстояние <tex>O(E)</tex>, дает асимптотику <tex>O(PV + E)</tex>. В худшем случае, когда блокирующий поток насыщает все ребра, асимптотика получается <tex>O(VE)</tex>.<br />
<br />
<b>Замечание:</b> Если в [[Схема алгоритма Диница|алгоритме Диница]] искать блокирующий поток удаляющим обходом, то его эффективность составит <tex>O(V^2E)</tex>, что уже лучше эффективности [[Алоритм Эдмондса-Карпа|алгоритма Эдмондса-Карпа]] <tex>O(VE^2)</tex>.<br />
<br />
==Алгоритм Малхотры — Кумара — Махешвари==<br />
===Идея===<br />
Для каждой вершины вводится потенциал потока, равный максимальному дополнительному потоку, который может пройти через эту вершину. Далее запускаем цикл, на каждой итерации которого определяем вершину <tex>v</tex> с минимальным потенциалом <tex>p</tex>. Затем пускается поток величины <tex>p</tex> из истока в сток, проходящий через эту вершину. При этом если [[Дополняющая сеть, дополняющий путь|остаточная пропускная способность]] ребра равна нулю, то это ребро удаляется. Также, удаляются все вершины, у которых не остаётся ни одного входящего и/или ни одного выходящего ребра. При удалении вершины все смежные ребра удаляются.<br />
<br />
===Подробное описание===<br />
* Для каждой вершины <tex>v</tex> вычислим входящий и исходящий потенциал: <tex>p_{in}=\sum \limits_{u} c(u, v)</tex> и <tex>p_{out}=\sum \limits_{u} c(u, v)</tex>. Пусть <tex>p_{in}(s)=\infty</tex> и <tex>p_{out}(t)=\infty</tex>. Определим потенциал или пропускную способность вершины в [[Определение сети, потока|сети]] <tex>p(v)=min(p_{in}(v), p_{out}(v))</tex>. Таким образом, потенциал вершины определяет максимально возможное количество потока, который может через нее проходить. Ясно, что через вершины с <tex>p(v)=0</tex> поток проходить не может. Следовательно, их можно удалить из [[Дополняющая сеть, дополняющий путь|вспомогательной сети]]. Удалим эти вершины и дуги, им инцидентные, обновив должным образом потенциалы вершин, смежных с удаленными. Если в результате появятся новые вершины с <tex>p(v)=0</tex>, удалим рекурсивно и их. В результате во вспомогательной сети останутся только вершины с <tex>p(v)\ne0</tex>.<br />
<br />
* После этого приступим к построению [[Блокирующий поток|блокирующего потока]]. Пусть вершина <tex>v</tex> принадлежит <tex>k</tex>-ому слою и <tex>p(v)=min (p(w), w \in L_k)</tex>, где <tex>L_k</tex> — <tex>k</tex>-й слой. Протолкнем <tex>p(v)</tex> единиц потока из вершины <tex>v</tex> в смежные с ней вершины по исходящим дугам с [[Дополняющая сеть, дополняющий путь | остаточной пропускной способностью]] <tex>c_f \ne 0</tex>. Попутно будем переносить проталкиваемый поток в исходную сеть, а также корректировать потенциалы вершин, отправляющих и принимающих избыток потока. В результате, весь (в виду минимальности потенциала вершины <tex>v</tex>) проталкиваемый поток соберется в вершинах <tex>(k+1)</tex>-го слоя. <br />
<br />
* Повторим процесс отправки потока из вершин <tex>(k+1)</tex>-го слоя, содержащих избыток потока, в смежные им вершины <tex>(k+2)</tex>-го слоя. И так до тех пор, пока весь поток не соберется в последнем слое, в котором содержится только сток <tex>t</tex>, ибо все остальные вершины, ранее ему принадлежащие, были удалены, поскольку их потенциалы нулевые. Следовательно, весь поток величины <tex>p(v)</tex>, отправленный из вершины <tex>v</tex>, где <tex>p(v)</tex> - минимальный полностью соберется в <tex>t</tex>. <br />
<br />
* На втором этапе вновь, начиная с вершины <tex>v</tex>, осуществляется подвод потока уже по входящим дугам. В результате на первом шаге недостаток потока переадресуется к узлам <tex>(k-1)</tex>-го слоя, затем <tex>(k-2)</tex>-го. И так до тех пор, пока весь потока величины <tex>p(v)</tex>, отправленные из вершины <tex>v</tex>, где <tex>p(v)</tex> - минимальный, не соберется в истоке <tex>s</tex>. Таким образом, поток и во вспомогательной и в основной сети увеличится на величину <tex>p</tex>. <br />
<br />
<br />
MPM algorithm(<tex>s, t</tex>)<br />
{<br />
foreach <tex>(uv) \in E</tex><br />
<tex>f(uv) \leftarrow 0 </tex>;<br />
Вычисляем остаточную сеть <tex>R</tex>;<br />
Найдём вспомогательный граф <tex>L</tex> для <tex>R</tex>;<br />
while (<tex>t \in L</tex>)<br />
{<br />
while (<tex>t</tex> достижима из <tex>s</tex> в <tex>L</tex>)<br />
{<br />
найдём <tex>v</tex> с минимальной пропускной способностью <tex>g</tex>;<br />
проталкиваем <tex>g</tex> единиц потока из <tex>v</tex> в <tex>t</tex>;<br />
проталкиваем <tex>g</tex> единиц потока из <tex>s</tex> в <tex>v</tex>;<br />
изменяем <tex>f</tex>, <tex>L</tex> и <tex>R</tex>;<br />
}<br />
вычисляем новый вспомогательный граф <tex>L</tex> из <tex>R</tex>;<br />
}<br />
}<br />
<br />
===Асимптотика===<br />
Если информация о входящих и исходящих дугах будет храниться в виде связных списков, то для того, чтобы пропустить поток, на каждой итерации будет выполнено <tex>O(K + E_i)</tex> действий, где <tex>K</tex> соответствует числу рёбер, для которых остаточная пропускная способность уменьшилась, но осталась положительной, а <tex>E_i</tex> — числу удалённых ребер. Таким образом, для поиска блокирующего потока будет выполнено <tex>\sum\limits_i{O(K+E_i)} = O(K^2)</tex> действий.<br />
<br />
== См. также ==<br />
* [[Блокирующий поток]]<br />
* [[Схема алгоритма Диница]]<br />
<br />
==Источники информации==<br />
*[http://www.e-maxx.ru/algo/dinic Алгоритм Диница. Необходимые определения.]<br />
*[http://www.facweb.iitkgp.ernet.in/~arijit/courses/autumn2006/cs60001/lec-flow-4.pdf The MPM Algorithm]<br />
*[http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9C%D0%B0%D0%BB%D1%85%D0%BE%D1%82%D1%80%D1%8B_%E2%80%94_%D0%9A%D1%83%D0%BC%D0%B0%D1%80%D0%B0_%E2%80%94_%D0%9C%D0%B0%D1%85%D0%B5%D1%88%D0%B2%D0%B0%D1%80%D0%B8 Алгоритм Малхотры — Кумара — Махешвари]<br />
*[http://eprints.utas.edu.au/160/1/iplFlow.pdf Оригинальная публикация алгоритма Малхотры — Кумара — Махешвари.]<br />
<br />
<br />
[[Категория:Алгоритмы и структуры данных]]<br />
[[Категория:Задача о максимальном потоке]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0_%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B5%D0%B3%D0%BE_%D0%BF%D0%BE%D1%82%D0%BE%D0%BA%D0%B0_%D0%B2_%D0%B0%D1%86%D0%B8%D0%BA%D0%BB%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B9_%D1%81%D0%B5%D1%82%D0%B8&diff=52089Алгоритм поиска блокирующего потока в ациклической сети2016-01-28T20:32:15Z<p>6yry6e: </p>
<hr />
<div>==Жадный алгоритм==<br />
Идея заключается в том, чтобы по одному находить пути из [[Определение_сети,_потока|истока]] <tex>s</tex> в [[Определение_сети,_потока|сток]] <tex>t</tex>, пока это возможно. [[Обход в глубину, цвета вершин| Обход в глубину]] найдёт все пути из <tex>s</tex> в <tex>t</tex>, если из <tex>s</tex> достижима <tex>t</tex>, а [[Определение_сети,_потока|пропускная способность]] каждого ребра <tex>c(u, v)>0</tex> поэтому, насыщая рёбра, мы хотя бы единожды достигнем стока <tex>t</tex>, следовательно блокирующий поток всегда найдётся.<br />
<br />
Используя <tex>dfs</tex>, каждый путь находится за <tex>O(E)</tex>, где <tex>E</tex> — число рёбер в графе. Поскольку каждый путь насыщает как минимум одно ребро, всего будет <tex>O(E)</tex> путей. Итого общая асимптотика составляет <tex>O(E^2)</tex>.<br />
<br />
==Удаляющий обход==<br />
Аналогично предыдущей идее, однако будем удалять в процессе обхода в глубину из графа все рёбра, вдоль которых не получится дойти до стока <tex>t</tex>. Это очень легко реализовать: достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое не удалённое ребро, и увеличивать этот указать в цикле внутри обхода в глубину. Корректность при этом сохраняется согласно предыдущему пункту. <br />
<br />
'''int''' dfs('''int''' <tex>v</tex>, '''int''' flow) <br />
'''if''' (flow == 0) <br />
'''return''' 0<br />
'''if''' (<tex>v</tex> == <tex>t</tex>)<br />
'''return''' flow<br />
'''for''' (<tex>u</tex> = ptr[<tex>v</tex>] '''to''' n)<br />
ptr[<tex>v</tex>]++<br />
'''if''' (<tex>vu \in E</tex>)<br />
pushed = dfs(<tex>u</tex>, min(flow, c(<tex>vu</tex>) - f(<tex>vu</tex>)))<br />
f(<tex>vu</tex>) += pushed<br />
f(<tex>uv</tex>) -= pushed<br />
'''return''' pushed<br />
'''return''' 0<br />
<br />
'''main'''()<br />
'''...'''<br />
flow = 0<br />
'''for''' ('''int''' i = 1 '''to''' n)<br />
ptr[i] = 0<br />
'''do'''<br />
pushed = dfs(<tex>s</tex>, <tex>\infty</tex>)<br />
flow += pushed<br />
'''while''' (pushed > 0)<br />
<br />
<br />
Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Значит один запуск обхода в глубину работает за <tex>O(V + K)</tex>, где <tex>V</tex> — число вершин в графе, а <tex>K</tex> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного [[Блокирующий поток|блокирующего потока]] будет <tex>O(P)</tex>, где <tex>P</tex> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <tex>O(PV + \sum\limits_i{K_i})</tex>, что, учитывая, что все указатели в сумме прошли расстояние <tex>O(E)</tex>, дает асимптотику <tex>O(PV + E)</tex>. В худшем случае, когда блокирующий поток насыщает все ребра, асимптотика получается <tex>O(VE)</tex>.<br />
<br />
<b>Замечание:</b> Если в [[Схема алгоритма Диница|алгоритме Диница]] искать блокирующий поток удаляющим обходом, то его эффективность составит <tex>O(V^2E)</tex>, что уже лучше эффективности [[Алоритм Эдмондса-Карпа|алгоритма Эдмондса-Карпа]] <tex>O(VE^2)</tex>.<br />
<br />
==Алгоритм Малхотры — Кумара — Махешвари==<br />
===Идея===<br />
Для каждой вершины вводится потенциал потока, равный максимальному дополнительному потоку, который может пройти через эту вершину. Далее запускаем цикл, на каждой итерации которого определяем вершину <tex>v</tex> с минимальным потенциалом <tex>p</tex>. Затем пускается поток величины <tex>p</tex> из истока в сток, проходящий через эту вершину. При этом если [[Дополняющая сеть, дополняющий путь|остаточная пропускная способность]] ребра равна нулю, то это ребро удаляется. Также, удаляются все вершины, у которых не остаётся ни одного входящего и/или ни одного выходящего ребра. При удалении вершины все смежные ребра удаляются.<br />
<br />
===Подробное описание===<br />
* Для каждой вершины <tex>v</tex> вычислим входящий и исходящий потенциал: <tex>p_{in}=\sum \limits_{u} c(u, v)</tex> и <tex>p_{out}=\sum \limits_{u} c(u, v)</tex>. Пусть <tex>p_{in}(s)=\infty</tex> и <tex>p_{out}(t)=\infty</tex>. Определим потенциал или пропускную способность вершины в [[Определение сети, потока|сети]] <tex>p(v)=min(p_{in}(v), p_{out}(v))</tex>. Таким образом, потенциал вершины определяет максимально возможное количество потока, который может через нее проходить. Ясно, что через вершины с <tex>p(v)=0</tex> поток проходить не может. Следовательно, их можно удалить из [[Дополняющая сеть, дополняющий путь|вспомогательной сети]]. Удалим эти вершины и дуги, им инцидентные, обновив должным образом потенциалы вершин, смежных с удаленными. Если в результате появятся новые вершины с <tex>p(v)=0</tex>, удалим рекурсивно и их. В результате во вспомогательной сети останутся только вершины с <tex>p(v)\ne0</tex>.<br />
<br />
* После этого приступим к построению [[Блокирующий поток|блокирующего потока]]. Пусть вершина <tex>v</tex> принадлежит <tex>k</tex>-ому слою и <tex>p(v)=min (p(w), w \in L_k)</tex>, где <tex>L_k</tex> — <tex>k</tex>-й слой. Протолкнем <tex>p(v)</tex> единиц потока из вершины <tex>v</tex> в смежные с ней вершины по исходящим дугам с [[Дополняющая сеть, дополняющий путь | остаточной пропускной способностью]] <tex>c_f \ne 0</tex>. Попутно будем переносить проталкиваемый поток в исходную сеть, а также корректировать потенциалы вершин, отправляющих и принимающих избыток потока. В результате, весь (в виду минимальности потенциала вершины <tex>v</tex>) проталкиваемый поток соберется в вершинах <tex>(k+1)</tex>-го слоя. <br />
<br />
* Повторим процесс отправки потока из вершин <tex>(k+1)</tex>-го слоя, содержащих избыток потока, в смежные им вершины <tex>(k+2)</tex>-го слоя. И так до тех пор, пока весь поток не соберется в последнем слое, в котором содержится только сток <tex>t</tex>, ибо все остальные вершины, ранее ему принадлежащие, были удалены, поскольку их потенциалы нулевые. Следовательно, весь поток величины <tex>p(v)</tex>, отправленный из вершины <tex>v</tex>, где <tex>p(v)</tex> - минимальный полностью соберется в <tex>t</tex>. <br />
<br />
* На втором этапе вновь, начиная с вершины <tex>v</tex>, осуществляется подвод потока уже по входящим дугам. В результате на первом шаге недостаток потока переадресуется к узлам <tex>(k-1)</tex>-го слоя, затем <tex>(k-2)</tex>-го. И так до тех пор, пока весь потока величины <tex>p(v)</tex>, отправленные из вершины <tex>v</tex>, где <tex>p(v)</tex> - минимальный, не соберется в истоке <tex>s</tex>. Таким образом, поток и во вспомогательной и в основной сети увеличится на величину <tex>p</tex>. <br />
<br />
<br />
MPM algorithm(<tex>s, t</tex>)<br />
{<br />
foreach <tex>(uv) \in E</tex><br />
<tex>f(uv) \leftarrow 0 </tex>;<br />
Вычисляем остаточную сеть <tex>R</tex>;<br />
Найдём вспомогательный граф <tex>L</tex> для <tex>R</tex>;<br />
while (<tex>t \in L</tex>)<br />
{<br />
while (<tex>t</tex> достижима из <tex>s</tex> в <tex>L</tex>)<br />
{<br />
найдём <tex>v</tex> с минимальной пропускной способностью <tex>g</tex>;<br />
проталкиваем <tex>g</tex> единиц потока из <tex>v</tex> в <tex>t</tex>;<br />
проталкиваем <tex>g</tex> единиц потока из <tex>s</tex> в <tex>v</tex>;<br />
изменяем <tex>f</tex>, <tex>L</tex> и <tex>R</tex>;<br />
}<br />
вычисляем новый вспомогательный граф <tex>L</tex> из <tex>R</tex>;<br />
}<br />
}<br />
<br />
===Асимптотика===<br />
Если информация о входящих и исходящих дугах будет храниться в виде связных списков, то для того, чтобы пропустить поток, на каждой итерации будет выполнено <tex>O(K + E_i)</tex> действий, где <tex>K</tex> соответствует числу рёбер, для которых остаточная пропускная способность уменьшилась, но осталась положительной, а <tex>E_i</tex> — числу удалённых ребер. Таким образом, для поиска блокирующего потока будет выполнено <tex>\sum\limits_i{O(K+E_i)} = O(K^2)</tex> действий.<br />
<br />
== См. также ==<br />
* [[Блокирующий поток]]<br />
* [[Схема алгоритма Диница]]<br />
<br />
==Источники информации==<br />
*[http://www.e-maxx.ru/algo/dinic Алгоритм Диница. Необходимые определения.]<br />
*[http://www.facweb.iitkgp.ernet.in/~arijit/courses/autumn2006/cs60001/lec-flow-4.pdf The MPM Algorithm]<br />
*[http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9C%D0%B0%D0%BB%D1%85%D0%BE%D1%82%D1%80%D1%8B_%E2%80%94_%D0%9A%D1%83%D0%BC%D0%B0%D1%80%D0%B0_%E2%80%94_%D0%9C%D0%B0%D1%85%D0%B5%D1%88%D0%B2%D0%B0%D1%80%D0%B8 Алгоритм Малхотры — Кумара — Махешвари]<br />
*[http://eprints.utas.edu.au/160/1/iplFlow.pdf Оригинальная публикация алгоритма Малхотры — Кумара — Махешвари.]<br />
<br />
<br />
[[Категория:Алгоритмы и структуры данных]]<br />
[[Категория:Задача о максимальном потоке]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0_%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B5%D0%B3%D0%BE_%D0%BF%D0%BE%D1%82%D0%BE%D0%BA%D0%B0_%D0%B2_%D0%B0%D1%86%D0%B8%D0%BA%D0%BB%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B9_%D1%81%D0%B5%D1%82%D0%B8&diff=52088Алгоритм поиска блокирующего потока в ациклической сети2016-01-28T20:30:37Z<p>6yry6e: </p>
<hr />
<div>==Жадный алгоритм==<br />
Идея заключается в том, чтобы по одному находить пути из [[Определение_сети,_потока|истока]] <tex>s</tex> в [[Определение_сети,_потока|сток]] <tex>t</tex>, пока это возможно. [[Обход в глубину, цвета вершин| Обход в глубину]] найдёт все пути из <tex>s</tex> в <tex>t</tex>, если из <tex>s</tex> достижима <tex>t</tex>, а [[Определение_сети,_потока|пропускная способность]] каждого ребра <tex>c(u, v)>0</tex> поэтому, насыщая рёбра, мы хотя бы единожды достигнем стока <tex>t</tex>, следовательно блокирующий поток всегда найдётся.<br />
<br />
Используя <tex>dfs</tex>, каждый путь находится за <tex>O(E)</tex>, где <tex>E</tex> — число рёбер в графе. Поскольку каждый путь насыщает как минимум одно ребро, всего будет <tex>O(E)</tex> путей. Итого общая асимптотика составляет <tex>O(E^2)</tex>.<br />
<br />
==Удаляющий обход==<br />
Аналогично предыдущей идее, однако будем удалять в процессе обхода в глубину из графа все рёбра, вдоль которых не получится дойти до стока <tex>t</tex>. Это очень легко реализовать: достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое не удалённое ребро, и увеличивать этот указать в цикле внутри обхода в глубину. Корректность при этом сохраняется согласно предыдущему пункту. <br />
<br />
'''int''' dfs('''int''' <tex>v</tex>, '''int''' flow) <br />
'''if''' (flow == 0) <br />
'''return''' 0<br />
'''if''' (<tex>v</tex> == <tex>t</tex>)<br />
'''return''' flow<br />
'''for''' (<tex>u</tex> = ptr[<tex>v</tex>] '''to''' n)<br />
ptr[<tex>v</tex>]++<br />
'''if''' (<tex>vu \in E</tex>)<br />
pushed = dfs(<tex>u</tex>, min(flow, c(<tex>vu</tex>) - f(<tex>vu</tex>)))<br />
f(<tex>vu</tex>) += pushed<br />
f(<tex>uv</tex>) -= pushed<br />
'''return''' pushed<br />
'''return''' 0<br />
<br />
'''main'''()<br />
'''...'''<br />
flow = 0<br />
'''for''' ('''int''' i = 1 '''to''' n)<br />
ptr[i] = 0<br />
'''do'''<br />
pushed = dfs(<tex>s</tex>, <tex>\infty</tex>)<br />
flow += pushed<br />
'''while''' (pushed > 0)<br />
<br />
<br />
Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Значит один запуск обхода в глубину работает за <tex>O(V + K)</tex>, где <tex>V</tex> — число вершин в графе, а <tex>K</tex> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного [[Блокирующий поток|блокирующего потока]] будет <tex>O(P)</tex>, где <tex>P</tex> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <tex>O(PV + \sum\limits_i{K_i})</tex>, что, учитывая, что все указатели в сумме прошли расстояние <tex>O(E)</tex>, дает асимптотику <tex>O(PV + E)</tex>. В худшем случае, когда блокирующий поток насыщает все ребра, асимптотика получается <tex>O(VE)</tex>.<br />
<br />
<b>Замечание:</b> Если в [[Схема алгоритма Диница|алгоритме Диница]] искать блокирующий поток удаляющим обходом, то его эффективность составит <tex>O(V^2E)</tex>, что уже лучше эффективности [[Алоритм Эдмондса-Карпа|алгоритма Эдмондса-Карпа]] <tex>O(VE^2)</tex>.<br />
<br />
==Алгоритм Малхотры — Кумара — Махешвари==<br />
===Идея===<br />
Для каждой вершины вводится потенциал потока, равный максимальному дополнительному потоку, который может пройти через эту вершину. Далее запускаем цикл, на каждой итерации которого определяем вершину <tex>v</tex> с минимальным потенциалом <tex>p</tex>. Затем пускается поток величины <tex>p</tex> из истока в сток, проходящий через эту вершину. При этом если [[Дополняющая сеть, дополняющий путь|остаточная пропускная способность]] ребра равна нулю, то это ребро удаляется. Также, удаляются все вершины, у которых не остаётся ни одного входящего и/или ни одного выходящего ребра. При удалении вершины все смежные ребра удаляются.<br />
<br />
===Подробное описание===<br />
* Для каждой вершины <tex>v</tex> вычислим входящий и исходящий потенциал: <tex>p_{in}=\sum \limits_{u} c(u, v)</tex> и <tex>p_{out}=\sum \limits_{u} c(u, v)</tex>. Пусть <tex>p_{in}(s)=\infty</tex> и <tex>p_{out}(t)=\infty</tex>. Определим потенциал или пропускную способность вершины в [[Определение сети, потока|сети]] <tex>p(v)=min(p_{in}(v), p_{out}(v))</tex>. Таким образом, потенциал вершины определяет максимально возможное количество потока, который может через нее проходить. Ясно, что через вершины с <tex>p(v)=0</tex> поток проходить не может. Следовательно, их можно удалить из [[Дополняющая сеть, дополняющий путь|вспомогательной сети]]. Удалим эти вершины и дуги, им инцидентные, обновив должным образом потенциалы вершин, смежных с удаленными. Если в результате появятся новые вершины с <tex>p(v)=0</tex>, удалим рекурсивно и их. В результате во вспомогательной сети останутся только вершины с <tex>p(v)\ne0</tex>.<br />
<br />
* После этого приступим к построению [[Блокирующий поток|блокирующего потока]]. Пусть вершина <tex>v</tex> принадлежит <tex>k</tex>-ому слою и <tex>p(v)=min (p(w), w \in L_k)</tex>, где <tex>L_k</tex> — <tex>k</tex>-й слой. Протолкнем <tex>p(v)</tex> единиц потока из вершины <tex>v</tex> в смежные с ней вершины по исходящим дугам с [[Дополняющая сеть, дополняющий путь | остаточной пропускной способностью]] <tex>c_f \ne 0</tex>. Попутно будем переносить проталкиваемый поток в исходную сеть, а также корректировать потенциалы вершин, отправляющих и принимающих избыток потока. В результате, весь (в виду минимальности потенциала вершины <tex>v</tex>) проталкиваемый поток соберется в вершинах <tex>(k+1)</tex>-го слоя. <br />
<br />
* Повторим процесс отправки потока из вершин <tex>(k+1)</tex>-го слоя, содержащих избыток потока, в смежные им вершины <tex>(k+2)</tex>-го слоя. И так до тех пор, пока весь поток не соберется в последнем слое, в котором содержится только сток <tex>t</tex>, ибо все остальные вершины, ранее ему принадлежащие, были удалены, поскольку их потенциалы нулевые. Следовательно, весь поток величины <tex>p(v)</tex>, отправленный из вершины <tex>v</tex>, где <tex>p(v)</tex> - минимальный полностью соберется в <tex>t</tex>. <br />
<br />
* На втором этапе вновь, начиная с вершины <tex>v</tex>, осуществляется подвод потока уже по входящим дугам. В результате на первом шаге недостаток потока переадресуется к узлам <tex>(k-1)</tex>-го слоя, затем <tex>(k-2)</tex>-го. И так до тех пор, пока весь потока величины <tex>p(v)</tex>, отправленные из вершины <tex>v</tex>, где <tex>p(v)</tex> - минимальный, не соберется в истоке <tex>s</tex>. Таким образом, поток и во вспомогательной и в основной сети увеличится на величину <tex>p</tex>. <br />
<br />
<br />
MPM algorithm(<tex>s, t</tex>)<br />
{<br />
foreach <tex>(uv) \in E</tex><br />
<tex>f(uv) \leftarrow 0 </tex>;<br />
Вычисляем остаточную сеть <tex>R</tex>;<br />
Найдём вспомогательный граф <tex>L</tex> для <tex>R</tex>;<br />
while (<tex>t \in L</tex>)<br />
{<br />
while (<tex>t</tex> достижима из <tex>s</tex> в <tex>L</tex>)<br />
{<br />
найдём <tex>v</tex> с минимальной пропускной способностью <tex>g</tex>;<br />
проталкиваем <tex>g</tex> единиц потока из <tex>v</tex> в <tex>t</tex>;<br />
проталкиваем <tex>g</tex> единиц потока из <tex>s</tex> в <tex>v</tex>;<br />
изменяем <tex>f</tex>, <tex>L</tex> и <tex>R</tex>;<br />
}<br />
вычисляем новый вспомогательный граф <tex>L</tex> из <tex>R</tex>;<br />
}<br />
}<br />
<br />
===Асимптотика===<br />
Если информация о входящих и исходящих дугах будет храниться в виде связных списков, то для того, чтобы пропустить поток, на каждой итерации будет выполнено <tex>O(K + E_i)</tex> действий, где <tex>K</tex> соответствует числу рёбер, для которых остаточная пропускная способность уменьшилась, но осталась положительной, а <tex>E_i</tex> — числу удалённых ребер. Таким образом, для поиска блокирующего потока будет выполнено <tex>\sum\limits_i{O(K+E_i)} = O(K^2)</tex> действий.<br />
<br />
== См. также ==<br />
* [[Блокирующий поток]]<br />
* [[Схема алгоритма Диница]]<br />
<br />
==Источники информации==<br />
*[http://www.e-maxx.ru/algo/dinic Алгоритм Диница. Необходимые определения.]<br />
*[http://www.facweb.iitkgp.ernet.in/~arijit/courses/autumn2006/cs60001/lec-flow-4.pdf The MPM Algorithm]<br />
*[http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9C%D0%B0%D0%BB%D1%85%D0%BE%D1%82%D1%80%D1%8B_%E2%80%94_%D0%9A%D1%83%D0%BC%D0%B0%D1%80%D0%B0_%E2%80%94_%D0%9C%D0%B0%D1%85%D0%B5%D1%88%D0%B2%D0%B0%D1%80%D0%B8 Алгоритм Малхотры — Кумара — Махешвари]<br />
*[http://eprints.utas.edu.au/160/1/iplFlow.pdf Оригинальная публикация алгоритма Малхотры — Кумара — Махешвари.]<br />
<br />
<br />
[[Категория:Алгоритмы и структуры данных]]<br />
[[Категория:Задача о максимальном потоке]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0_%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B5%D0%B3%D0%BE_%D0%BF%D0%BE%D1%82%D0%BE%D0%BA%D0%B0_%D0%B2_%D0%B0%D1%86%D0%B8%D0%BA%D0%BB%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B9_%D1%81%D0%B5%D1%82%D0%B8&diff=52085Алгоритм поиска блокирующего потока в ациклической сети2016-01-28T20:21:49Z<p>6yry6e: </p>
<hr />
<div>==Жадный алгоритм==<br />
Идея заключается в том, чтобы по одному находить пути из [[Определение_сети,_потока|истока]] <tex>s</tex> в [[Определение_сети,_потока|сток]] <tex>t</tex>, пока это возможно. [[Обход в глубину, цвета вершин| Обход в глубину]] найдёт все пути из <tex>s</tex> в <tex>t</tex>, если из <tex>s</tex> достижима <tex>t</tex>, а [[Определение_сети,_потока|пропускная способность]] каждого ребра <tex>c(u, v)>0</tex> поэтому, насыщая рёбра, мы хотя бы единожды достигнем стока <tex>t</tex>, следовательно блокирующий поток всегда найдётся.<br />
<br />
Используя <tex>dfs</tex>, каждый путь находится за <tex>O(E)</tex>, где <tex>E</tex> — число рёбер в графе. Поскольку каждый путь насыщает как минимум одно ребро, всего будет <tex>O(E)</tex> путей. Итого общая асимптотика составляет <tex>O(E^2)</tex>.<br />
<br />
==Удаляющий обход==<br />
Аналогично предыдущей идее, однако будем удалять в процессе обхода в глубину из графа все рёбра, вдоль которых не получится дойти до стока <tex>t</tex>. Это очень легко реализовать: достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое не удалённое ребро, и увеличивать этот указать в цикле внутри обхода в глубину. Корректность при этом сохраняется согласно предыдущему пункту. <br />
<br />
'''int''' dfs('''int''' <tex>v</tex>, '''int''' flow) <br />
'''if''' (flow == 0) <br />
'''return''' 0<br />
'''if''' (<tex>v</tex> == <tex>t</tex>)<br />
'''return''' flow<br />
'''for''' (<tex>u</tex> = ptr[<tex>v</tex>] '''to''' n) <font color=darkgreen> // u - ссылочный тип</font><br />
'''if''' (<tex>vu \in E</tex>)<br />
pushed = dfs(<tex>u</tex>, min(flow, c(<tex>vu</tex>) - f(<tex>vu</tex>)));<br />
f(<tex>vu</tex>) += pushed<br />
f(<tex>uv</tex>) -= pushed<br />
'''return''' pushed<br />
'''return''' 0<br />
<br />
'''main'''( )<br />
'''...'''<br />
flow = 0<br />
'''for''' ('''int''' i = 1 '''to''' n)<br />
ptr[i] = 0;<br />
'''do'''<br />
pushed = '''dfs''' (<tex>s</tex>, <tex>\infty</tex>)<br />
flow += pushed;<br />
'''while''' (pushed > 0)<br />
<br />
<br />
Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Значит один запуск обхода в глубину работает за <tex>O(V + K)</tex>, где <tex>V</tex> — число вершин в графе, а <tex>K</tex> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного [[Блокирующий поток|блокирующего потока]] будет <tex>O(P)</tex>, где <tex>P</tex> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <tex>O(PV + \sum\limits_i{K_i})</tex>, что, учитывая, что все указатели в сумме прошли расстояние <tex>O(E)</tex>, дает асимптотику <tex>O(PV + E)</tex>. В худшем случае, когда блокирующий поток насыщает все ребра, асимптотика получается <tex>O(VE)</tex>.<br />
<br />
<b>Замечание:</b> Если в [[Схема алгоритма Диница|алгоритме Диница]] искать блокирующий поток удаляющим обходом, то его эффективность составит <tex>O(V^2E)</tex>, что уже лучше эффективности [[Алоритм Эдмондса-Карпа|алгоритма Эдмондса-Карпа]] <tex>O(VE^2)</tex>.<br />
<br />
==Алгоритм Малхотры — Кумара — Махешвари==<br />
===Идея===<br />
Для каждой вершины вводится потенциал потока, равный максимальному дополнительному потоку, который может пройти через эту вершину. Далее запускаем цикл, на каждой итерации которого определяем вершину <tex>v</tex> с минимальным потенциалом <tex>p</tex>. Затем пускается поток величины <tex>p</tex> из истока в сток, проходящий через эту вершину. При этом если [[Дополняющая сеть, дополняющий путь|остаточная пропускная способность]] ребра равна нулю, то это ребро удаляется. Также, удаляются все вершины, у которых не остаётся ни одного входящего и/или ни одного выходящего ребра. При удалении вершины все смежные ребра удаляются.<br />
<br />
===Подробное описание===<br />
* Для каждой вершины <tex>v</tex> вычислим входящий и исходящий потенциал: <tex>p_{in}=\sum \limits_{u} c(u, v)</tex> и <tex>p_{out}=\sum \limits_{u} c(u, v)</tex>. Пусть <tex>p_{in}(s)=\infty</tex> и <tex>p_{out}(t)=\infty</tex>. Определим потенциал или пропускную способность вершины в [[Определение сети, потока|сети]] <tex>p(v)=min(p_{in}(v), p_{out}(v))</tex>. Таким образом, потенциал вершины определяет максимально возможное количество потока, который может через нее проходить. Ясно, что через вершины с <tex>p(v)=0</tex> поток проходить не может. Следовательно, их можно удалить из [[Дополняющая сеть, дополняющий путь|вспомогательной сети]]. Удалим эти вершины и дуги, им инцидентные, обновив должным образом потенциалы вершин, смежных с удаленными. Если в результате появятся новые вершины с <tex>p(v)=0</tex>, удалим рекурсивно и их. В результате во вспомогательной сети останутся только вершины с <tex>p(v)\ne0</tex>.<br />
<br />
* После этого приступим к построению [[Блокирующий поток|блокирующего потока]]. Пусть вершина <tex>v</tex> принадлежит <tex>k</tex>-ому слою и <tex>p(v)=min (p(w), w \in L_k)</tex>, где <tex>L_k</tex> — <tex>k</tex>-й слой. Протолкнем <tex>p(v)</tex> единиц потока из вершины <tex>v</tex> в смежные с ней вершины по исходящим дугам с [[Дополняющая сеть, дополняющий путь | остаточной пропускной способностью]] <tex>c_f \ne 0</tex>. Попутно будем переносить проталкиваемый поток в исходную сеть, а также корректировать потенциалы вершин, отправляющих и принимающих избыток потока. В результате, весь (в виду минимальности потенциала вершины <tex>v</tex>) проталкиваемый поток соберется в вершинах <tex>(k+1)</tex>-го слоя. <br />
<br />
* Повторим процесс отправки потока из вершин <tex>(k+1)</tex>-го слоя, содержащих избыток потока, в смежные им вершины <tex>(k+2)</tex>-го слоя. И так до тех пор, пока весь поток не соберется в последнем слое, в котором содержится только сток <tex>t</tex>, ибо все остальные вершины, ранее ему принадлежащие, были удалены, поскольку их потенциалы нулевые. Следовательно, весь поток величины <tex>p(v)</tex>, отправленный из вершины <tex>v</tex>, где <tex>p(v)</tex> - минимальный полностью соберется в <tex>t</tex>. <br />
<br />
* На втором этапе вновь, начиная с вершины <tex>v</tex>, осуществляется подвод потока уже по входящим дугам. В результате на первом шаге недостаток потока переадресуется к узлам <tex>(k-1)</tex>-го слоя, затем <tex>(k-2)</tex>-го. И так до тех пор, пока весь потока величины <tex>p(v)</tex>, отправленные из вершины <tex>v</tex>, где <tex>p(v)</tex> - минимальный, не соберется в истоке <tex>s</tex>. Таким образом, поток и во вспомогательной и в основной сети увеличится на величину <tex>p</tex>. <br />
<br />
<br />
MPM algorithm(<tex>s, t</tex>)<br />
{<br />
foreach <tex>(uv) \in E</tex><br />
<tex>f(uv) \leftarrow 0 </tex>;<br />
Вычисляем остаточную сеть <tex>R</tex>;<br />
Найдём вспомогательный граф <tex>L</tex> для <tex>R</tex>;<br />
while (<tex>t \in L</tex>)<br />
{<br />
while (<tex>t</tex> достижима из <tex>s</tex> в <tex>L</tex>)<br />
{<br />
найдём <tex>v</tex> с минимальной пропускной способностью <tex>g</tex>;<br />
проталкиваем <tex>g</tex> единиц потока из <tex>v</tex> в <tex>t</tex>;<br />
проталкиваем <tex>g</tex> единиц потока из <tex>s</tex> в <tex>v</tex>;<br />
изменяем <tex>f</tex>, <tex>L</tex> и <tex>R</tex>;<br />
}<br />
вычисляем новый вспомогательный граф <tex>L</tex> из <tex>R</tex>;<br />
}<br />
}<br />
<br />
===Асимптотика===<br />
Если информация о входящих и исходящих дугах будет храниться в виде связных списков, то для того, чтобы пропустить поток, на каждой итерации будет выполнено <tex>O(K + E_i)</tex> действий, где <tex>K</tex> соответствует числу рёбер, для которых остаточная пропускная способность уменьшилась, но осталась положительной, а <tex>E_i</tex> — числу удалённых ребер. Таким образом, для поиска блокирующего потока будет выполнено <tex>\sum\limits_i{O(K+E_i)} = O(K^2)</tex> действий.<br />
<br />
== См. также ==<br />
* [[Блокирующий поток]]<br />
* [[Схема алгоритма Диница]]<br />
<br />
==Источники информации==<br />
*[http://www.e-maxx.ru/algo/dinic Алгоритм Диница. Необходимые определения.]<br />
*[http://www.facweb.iitkgp.ernet.in/~arijit/courses/autumn2006/cs60001/lec-flow-4.pdf The MPM Algorithm]<br />
*[http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9C%D0%B0%D0%BB%D1%85%D0%BE%D1%82%D1%80%D1%8B_%E2%80%94_%D0%9A%D1%83%D0%BC%D0%B0%D1%80%D0%B0_%E2%80%94_%D0%9C%D0%B0%D1%85%D0%B5%D1%88%D0%B2%D0%B0%D1%80%D0%B8 Алгоритм Малхотры — Кумара — Махешвари]<br />
*[http://eprints.utas.edu.au/160/1/iplFlow.pdf Оригинальная публикация алгоритма Малхотры — Кумара — Махешвари.]<br />
<br />
<br />
[[Категория:Алгоритмы и структуры данных]]<br />
[[Категория:Задача о максимальном потоке]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0_%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B5%D0%B3%D0%BE_%D0%BF%D0%BE%D1%82%D0%BE%D0%BA%D0%B0_%D0%B2_%D0%B0%D1%86%D0%B8%D0%BA%D0%BB%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B9_%D1%81%D0%B5%D1%82%D0%B8&diff=52084Алгоритм поиска блокирующего потока в ациклической сети2016-01-28T20:19:46Z<p>6yry6e: </p>
<hr />
<div>==Жадный алгоритм==<br />
Идея заключается в том, чтобы по одному находить пути из [[Определение_сети,_потока|истока]] <tex>s</tex> в [[Определение_сети,_потока|сток]] <tex>t</tex>, пока это возможно. [[Обход в глубину, цвета вершин| Обход в глубину]] найдёт все пути из <tex>s</tex> в <tex>t</tex>, если из <tex>s</tex> достижима <tex>t</tex>, а [[Определение_сети,_потока|пропускная способность]] каждого ребра <tex>c(u, v)>0</tex> поэтому, насыщая рёбра, мы хотя бы единожды достигнем стока <tex>t</tex>, следовательно блокирующий поток всегда найдётся.<br />
<br />
Используя <tex>dfs</tex>, каждый путь находится за <tex>O(E)</tex>, где <tex>E</tex> — число рёбер в графе. Поскольку каждый путь насыщает как минимум одно ребро, всего будет <tex>O(E)</tex> путей. Итого общая асимптотика составляет <tex>O(E^2)</tex>.<br />
<br />
==Удаляющий обход==<br />
Аналогично предыдущей идее, однако будем удалять в процессе обхода в глубину из графа все рёбра, вдоль которых не получится дойти до стока <tex>t</tex>. Это очень легко реализовать: достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое не удалённое ребро, и увеличивать этот указать в цикле внутри обхода в глубину. Корректность при этом сохраняется согласно предыдущему пункту. <br />
<br />
'''int''' dfs('''int''' <tex>v</tex>, '''int''' flow) <br />
'''if''' (flow == 0) <br />
'''return''' 0<br />
'''if''' (<tex>v</tex> == <tex>t</tex>)<br />
'''return''' flow<br />
'''for''' (<tex>u</tex> = ptr[<tex>v</tex>] '''to''' n) <font color=darkgreen> // u - ссылочный тип</font><br />
'''if''' (<tex>vu \in E</tex>)<br />
pushed = dfs(<tex>u</tex>, min(flow, c(<tex>vu</tex>) - f(<tex>vu</tex>)));<br />
f(<tex>vu</tex>) += pushed<br />
f(<tex>uv</tex>) -= pushed<br />
'''return''' pushed<br />
'''return''' 0<br />
<br />
'''main'''( )<br />
'''...'''<br />
flow = 0<br />
'''for''' ('''int''' i = 0 '''to''' n)<br />
ptr[i] = 0;<br />
'''do'''<br />
pushed = '''dfs''' (<tex>s</tex>, <tex>\infty</tex>)<br />
flow += pushed;<br />
'''while''' (pushed > 0)<br />
<br />
<br />
Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Значит один запуск обхода в глубину работает за <tex>O(V + K)</tex>, где <tex>V</tex> — число вершин в графе, а <tex>K</tex> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного [[Блокирующий поток|блокирующего потока]] будет <tex>O(P)</tex>, где <tex>P</tex> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <tex>O(PV + \sum\limits_i{K_i})</tex>, что, учитывая, что все указатели в сумме прошли расстояние <tex>O(E)</tex>, дает асимптотику <tex>O(PV + E)</tex>. В худшем случае, когда блокирующий поток насыщает все ребра, асимптотика получается <tex>O(VE)</tex>.<br />
<br />
<b>Замечание:</b> Если в [[Схема алгоритма Диница|алгоритме Диница]] искать блокирующий поток удаляющим обходом, то его эффективность составит <tex>O(V^2E)</tex>, что уже лучше эффективности [[Алоритм Эдмондса-Карпа|алгоритма Эдмондса-Карпа]] <tex>O(VE^2)</tex>.<br />
<br />
==Алгоритм Малхотры — Кумара — Махешвари==<br />
===Идея===<br />
Для каждой вершины вводится потенциал потока, равный максимальному дополнительному потоку, который может пройти через эту вершину. Далее запускаем цикл, на каждой итерации которого определяем вершину <tex>v</tex> с минимальным потенциалом <tex>p</tex>. Затем пускается поток величины <tex>p</tex> из истока в сток, проходящий через эту вершину. При этом если [[Дополняющая сеть, дополняющий путь|остаточная пропускная способность]] ребра равна нулю, то это ребро удаляется. Также, удаляются все вершины, у которых не остаётся ни одного входящего и/или ни одного выходящего ребра. При удалении вершины все смежные ребра удаляются.<br />
<br />
===Подробное описание===<br />
* Для каждой вершины <tex>v</tex> вычислим входящий и исходящий потенциал: <tex>p_{in}=\sum \limits_{u} c(u, v)</tex> и <tex>p_{out}=\sum \limits_{u} c(u, v)</tex>. Пусть <tex>p_{in}(s)=\infty</tex> и <tex>p_{out}(t)=\infty</tex>. Определим потенциал или пропускную способность вершины в [[Определение сети, потока|сети]] <tex>p(v)=min(p_{in}(v), p_{out}(v))</tex>. Таким образом, потенциал вершины определяет максимально возможное количество потока, который может через нее проходить. Ясно, что через вершины с <tex>p(v)=0</tex> поток проходить не может. Следовательно, их можно удалить из [[Дополняющая сеть, дополняющий путь|вспомогательной сети]]. Удалим эти вершины и дуги, им инцидентные, обновив должным образом потенциалы вершин, смежных с удаленными. Если в результате появятся новые вершины с <tex>p(v)=0</tex>, удалим рекурсивно и их. В результате во вспомогательной сети останутся только вершины с <tex>p(v)\ne0</tex>.<br />
<br />
* После этого приступим к построению [[Блокирующий поток|блокирующего потока]]. Пусть вершина <tex>v</tex> принадлежит <tex>k</tex>-ому слою и <tex>p(v)=min (p(w), w \in L_k)</tex>, где <tex>L_k</tex> — <tex>k</tex>-й слой. Протолкнем <tex>p(v)</tex> единиц потока из вершины <tex>v</tex> в смежные с ней вершины по исходящим дугам с [[Дополняющая сеть, дополняющий путь | остаточной пропускной способностью]] <tex>c_f \ne 0</tex>. Попутно будем переносить проталкиваемый поток в исходную сеть, а также корректировать потенциалы вершин, отправляющих и принимающих избыток потока. В результате, весь (в виду минимальности потенциала вершины <tex>v</tex>) проталкиваемый поток соберется в вершинах <tex>(k+1)</tex>-го слоя. <br />
<br />
* Повторим процесс отправки потока из вершин <tex>(k+1)</tex>-го слоя, содержащих избыток потока, в смежные им вершины <tex>(k+2)</tex>-го слоя. И так до тех пор, пока весь поток не соберется в последнем слое, в котором содержится только сток <tex>t</tex>, ибо все остальные вершины, ранее ему принадлежащие, были удалены, поскольку их потенциалы нулевые. Следовательно, весь поток величины <tex>p(v)</tex>, отправленный из вершины <tex>v</tex>, где <tex>p(v)</tex> - минимальный полностью соберется в <tex>t</tex>. <br />
<br />
* На втором этапе вновь, начиная с вершины <tex>v</tex>, осуществляется подвод потока уже по входящим дугам. В результате на первом шаге недостаток потока переадресуется к узлам <tex>(k-1)</tex>-го слоя, затем <tex>(k-2)</tex>-го. И так до тех пор, пока весь потока величины <tex>p(v)</tex>, отправленные из вершины <tex>v</tex>, где <tex>p(v)</tex> - минимальный, не соберется в истоке <tex>s</tex>. Таким образом, поток и во вспомогательной и в основной сети увеличится на величину <tex>p</tex>. <br />
<br />
<br />
MPM algorithm(<tex>s, t</tex>)<br />
{<br />
foreach <tex>(uv) \in E</tex><br />
<tex>f(uv) \leftarrow 0 </tex>;<br />
Вычисляем остаточную сеть <tex>R</tex>;<br />
Найдём вспомогательный граф <tex>L</tex> для <tex>R</tex>;<br />
while (<tex>t \in L</tex>)<br />
{<br />
while (<tex>t</tex> достижима из <tex>s</tex> в <tex>L</tex>)<br />
{<br />
найдём <tex>v</tex> с минимальной пропускной способностью <tex>g</tex>;<br />
проталкиваем <tex>g</tex> единиц потока из <tex>v</tex> в <tex>t</tex>;<br />
проталкиваем <tex>g</tex> единиц потока из <tex>s</tex> в <tex>v</tex>;<br />
изменяем <tex>f</tex>, <tex>L</tex> и <tex>R</tex>;<br />
}<br />
вычисляем новый вспомогательный граф <tex>L</tex> из <tex>R</tex>;<br />
}<br />
}<br />
<br />
===Асимптотика===<br />
Если информация о входящих и исходящих дугах будет храниться в виде связных списков, то для того, чтобы пропустить поток, на каждой итерации будет выполнено <tex>O(K + E_i)</tex> действий, где <tex>K</tex> соответствует числу рёбер, для которых остаточная пропускная способность уменьшилась, но осталась положительной, а <tex>E_i</tex> — числу удалённых ребер. Таким образом, для поиска блокирующего потока будет выполнено <tex>\sum\limits_i{O(K+E_i)} = O(K^2)</tex> действий.<br />
<br />
== См. также ==<br />
* [[Блокирующий поток]]<br />
* [[Схема алгоритма Диница]]<br />
<br />
==Источники информации==<br />
*[http://www.e-maxx.ru/algo/dinic Алгоритм Диница. Необходимые определения.]<br />
*[http://www.facweb.iitkgp.ernet.in/~arijit/courses/autumn2006/cs60001/lec-flow-4.pdf The MPM Algorithm]<br />
*[http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9C%D0%B0%D0%BB%D1%85%D0%BE%D1%82%D1%80%D1%8B_%E2%80%94_%D0%9A%D1%83%D0%BC%D0%B0%D1%80%D0%B0_%E2%80%94_%D0%9C%D0%B0%D1%85%D0%B5%D1%88%D0%B2%D0%B0%D1%80%D0%B8 Алгоритм Малхотры — Кумара — Махешвари]<br />
*[http://eprints.utas.edu.au/160/1/iplFlow.pdf Оригинальная публикация алгоритма Малхотры — Кумара — Махешвари.]<br />
<br />
<br />
[[Категория:Алгоритмы и структуры данных]]<br />
[[Категория:Задача о максимальном потоке]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0_%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B5%D0%B3%D0%BE_%D0%BF%D0%BE%D1%82%D0%BE%D0%BA%D0%B0_%D0%B2_%D0%B0%D1%86%D0%B8%D0%BA%D0%BB%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B9_%D1%81%D0%B5%D1%82%D0%B8&diff=52083Алгоритм поиска блокирующего потока в ациклической сети2016-01-28T20:19:04Z<p>6yry6e: отступы в псевдокоде</p>
<hr />
<div>==Жадный алгоритм==<br />
Идея заключается в том, чтобы по одному находить пути из [[Определение_сети,_потока|истока]] <tex>s</tex> в [[Определение_сети,_потока|сток]] <tex>t</tex>, пока это возможно. [[Обход в глубину, цвета вершин| Обход в глубину]] найдёт все пути из <tex>s</tex> в <tex>t</tex>, если из <tex>s</tex> достижима <tex>t</tex>, а [[Определение_сети,_потока|пропускная способность]] каждого ребра <tex>c(u, v)>0</tex> поэтому, насыщая рёбра, мы хотя бы единожды достигнем стока <tex>t</tex>, следовательно блокирующий поток всегда найдётся.<br />
<br />
Используя <tex>dfs</tex>, каждый путь находится за <tex>O(E)</tex>, где <tex>E</tex> — число рёбер в графе. Поскольку каждый путь насыщает как минимум одно ребро, всего будет <tex>O(E)</tex> путей. Итого общая асимптотика составляет <tex>O(E^2)</tex>.<br />
<br />
==Удаляющий обход==<br />
Аналогично предыдущей идее, однако будем удалять в процессе обхода в глубину из графа все рёбра, вдоль которых не получится дойти до стока <tex>t</tex>. Это очень легко реализовать: достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое не удалённое ребро, и увеличивать этот указать в цикле внутри обхода в глубину. Корректность при этом сохраняется согласно предыдущему пункту. <br />
<br />
'''int''' dfs('''int''' <tex>v</tex>, '''int''' flow) <br />
'''if''' (flow == 0) <br />
'''return''' 0<br />
'''if''' (<tex>v</tex> == <tex>t</tex>)<br />
'''return''' flow<br />
'''for''' (<tex>u</tex> = ptr[<tex>v</tex>] '''to''' n) <font color=darkgreen> // u - ссылочный тип</font><br />
'''if''' (<tex>vu \in E</tex>)<br />
pushed = dfs(<tex>u</tex>, min(flow, c(<tex>vu</tex>) - f(<tex>vu</tex>)));<br />
f(<tex>vu</tex>) += pushed<br />
f(<tex>uv</tex>) -= pushed<br />
'''return''' pushed<br />
'''return''' 0<br />
<br />
'''main'''( )<br />
'''...'''<br />
flow = 0<br />
'''for''' ('''int''' i = 0 '''to''' n)<br />
ptr[i] = 0;<br />
'''do'''<br />
pushed = '''dfs''' (<tex>s</tex>, <tex>\infty</tex>)<br />
flow += pushed;<br />
'''while''' (pushed > 0)<br />
<br />
<br />
Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Значит один запуск обхода в глубину работает за <tex>O(V + K)</tex>, где <tex>V</tex> — число вершин в графе, а <tex>K</tex> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного [[Блокирующий поток|блокирующего потока]] будет <tex>O(P)</tex>, где <tex>P</tex> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <tex>O(PV + \sum\limits_i{K_i})</tex>, что, учитывая, что все указатели в сумме прошли расстояние <tex>O(E)</tex>, дает асимптотику <tex>O(PV + E)</tex>. В худшем случае, когда блокирующий поток насыщает все ребра, асимптотика получается <tex>O(VE)</tex>.<br />
<br />
<b>Замечание:</b> Если в [[Схема алгоритма Диница|алгоритме Диница]] искать блокирующий поток удаляющим обходом, то его эффективность составит <tex>O(V^2E)</tex>, что уже лучше эффективности [[Алоритм Эдмондса-Карпа|алгоритма Эдмондса-Карпа]] <tex>O(VE^2)</tex>.<br />
<br />
==Алгоритм Малхотры — Кумара — Махешвари==<br />
===Идея===<br />
Для каждой вершины вводится потенциал потока, равный максимальному дополнительному потоку, который может пройти через эту вершину. Далее запускаем цикл, на каждой итерации которого определяем вершину <tex>v</tex> с минимальным потенциалом <tex>p</tex>. Затем пускается поток величины <tex>p</tex> из истока в сток, проходящий через эту вершину. При этом если [[Дополняющая сеть, дополняющий путь|остаточная пропускная способность]] ребра равна нулю, то это ребро удаляется. Также, удаляются все вершины, у которых не остаётся ни одного входящего и/или ни одного выходящего ребра. При удалении вершины все смежные ребра удаляются.<br />
<br />
===Подробное описание===<br />
* Для каждой вершины <tex>v</tex> вычислим входящий и исходящий потенциал: <tex>p_{in}=\sum \limits_{u} c(u, v)</tex> и <tex>p_{out}=\sum \limits_{u} c(u, v)</tex>. Пусть <tex>p_{in}(s)=\infty</tex> и <tex>p_{out}(t)=\infty</tex>. Определим потенциал или пропускную способность вершины в [[Определение сети, потока|сети]] <tex>p(v)=min(p_{in}(v), p_{out}(v))</tex>. Таким образом, потенциал вершины определяет максимально возможное количество потока, который может через нее проходить. Ясно, что через вершины с <tex>p(v)=0</tex> поток проходить не может. Следовательно, их можно удалить из [[Дополняющая сеть, дополняющий путь|вспомогательной сети]]. Удалим эти вершины и дуги, им инцидентные, обновив должным образом потенциалы вершин, смежных с удаленными. Если в результате появятся новые вершины с <tex>p(v)=0</tex>, удалим рекурсивно и их. В результате во вспомогательной сети останутся только вершины с <tex>p(v)\ne0</tex>.<br />
<br />
* После этого приступим к построению [[Блокирующий поток|блокирующего потока]]. Пусть вершина <tex>v</tex> принадлежит <tex>k</tex>-ому слою и <tex>p(v)=min (p(w), w \in L_k)</tex>, где <tex>L_k</tex> — <tex>k</tex>-й слой. Протолкнем <tex>p(v)</tex> единиц потока из вершины <tex>v</tex> в смежные с ней вершины по исходящим дугам с [[Дополняющая сеть, дополняющий путь | остаточной пропускной способностью]] <tex>c_f \ne 0</tex>. Попутно будем переносить проталкиваемый поток в исходную сеть, а также корректировать потенциалы вершин, отправляющих и принимающих избыток потока. В результате, весь (в виду минимальности потенциала вершины <tex>v</tex>) проталкиваемый поток соберется в вершинах <tex>(k+1)</tex>-го слоя. <br />
<br />
* Повторим процесс отправки потока из вершин <tex>(k+1)</tex>-го слоя, содержащих избыток потока, в смежные им вершины <tex>(k+2)</tex>-го слоя. И так до тех пор, пока весь поток не соберется в последнем слое, в котором содержится только сток <tex>t</tex>, ибо все остальные вершины, ранее ему принадлежащие, были удалены, поскольку их потенциалы нулевые. Следовательно, весь поток величины <tex>p(v)</tex>, отправленный из вершины <tex>v</tex>, где <tex>p(v)</tex> - минимальный полностью соберется в <tex>t</tex>. <br />
<br />
* На втором этапе вновь, начиная с вершины <tex>v</tex>, осуществляется подвод потока уже по входящим дугам. В результате на первом шаге недостаток потока переадресуется к узлам <tex>(k-1)</tex>-го слоя, затем <tex>(k-2)</tex>-го. И так до тех пор, пока весь потока величины <tex>p(v)</tex>, отправленные из вершины <tex>v</tex>, где <tex>p(v)</tex> - минимальный, не соберется в истоке <tex>s</tex>. Таким образом, поток и во вспомогательной и в основной сети увеличится на величину <tex>p</tex>. <br />
<br />
<br />
MPM algorithm(<tex>s, t</tex>)<br />
{<br />
foreach <tex>(uv) \in E</tex><br />
<tex>f(uv) \leftarrow 0 </tex>;<br />
Вычисляем остаточную сеть <tex>R</tex>;<br />
Найдём вспомогательный граф <tex>L</tex> для <tex>R</tex>;<br />
while (<tex>t \in L</tex>)<br />
{<br />
while (<tex>t</tex> достижима из <tex>s</tex> в <tex>L</tex>)<br />
{<br />
найдём <tex>v</tex> с минимальной пропускной способностью <tex>g</tex>;<br />
проталкиваем <tex>g</tex> единиц потока из <tex>v</tex> в <tex>t</tex>;<br />
проталкиваем <tex>g</tex> единиц потока из <tex>s</tex> в <tex>v</tex>;<br />
изменяем <tex>f</tex>, <tex>L</tex> и <tex>R</tex>;<br />
}<br />
вычисляем новый вспомогательный граф <tex>L</tex> из <tex>R</tex>;<br />
}<br />
}<br />
<br />
===Асимптотика===<br />
Если информация о входящих и исходящих дугах будет храниться в виде связных списков, то для того, чтобы пропустить поток, на каждой итерации будет выполнено <tex>O(K + E_i)</tex> действий, где <tex>K</tex> соответствует числу рёбер, для которых остаточная пропускная способность уменьшилась, но осталась положительной, а <tex>E_i</tex> — числу удалённых ребер. Таким образом, для поиска блокирующего потока будет выполнено <tex>\sum\limits_i{O(K+E_i)} = O(K^2)</tex> действий.<br />
<br />
== См. также ==<br />
* [[Блокирующий поток]]<br />
* [[Схема алгоритма Диница]]<br />
<br />
==Источники информации==<br />
*[http://www.e-maxx.ru/algo/dinic Алгоритм Диница. Необходимые определения.]<br />
*[http://www.facweb.iitkgp.ernet.in/~arijit/courses/autumn2006/cs60001/lec-flow-4.pdf The MPM Algorithm]<br />
*[http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9C%D0%B0%D0%BB%D1%85%D0%BE%D1%82%D1%80%D1%8B_%E2%80%94_%D0%9A%D1%83%D0%BC%D0%B0%D1%80%D0%B0_%E2%80%94_%D0%9C%D0%B0%D1%85%D0%B5%D1%88%D0%B2%D0%B0%D1%80%D0%B8 Алгоритм Малхотры — Кумара — Махешвари]<br />
*[http://eprints.utas.edu.au/160/1/iplFlow.pdf Оригинальная публикация алгоритма Малхотры — Кумара — Махешвари.]<br />
<br />
<br />
[[Категория:Алгоритмы и структуры данных]]<br />
[[Категория:Задача о максимальном потоке]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0_%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B5%D0%B3%D0%BE_%D0%BF%D0%BE%D1%82%D0%BE%D0%BA%D0%B0_%D0%B2_%D0%B0%D1%86%D0%B8%D0%BA%D0%BB%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B9_%D1%81%D0%B5%D1%82%D0%B8&diff=52082Алгоритм поиска блокирующего потока в ациклической сети2016-01-28T20:08:28Z<p>6yry6e: оформление</p>
<hr />
<div>==Жадный алгоритм==<br />
Идея заключается в том, чтобы по одному находить пути из [[Определение_сети,_потока|истока]] <tex>s</tex> в [[Определение_сети,_потока|сток]] <tex>t</tex>, пока это возможно. [[Обход в глубину, цвета вершин| Обход в глубину]] найдёт все пути из <tex>s</tex> в <tex>t</tex>, если из <tex>s</tex> достижима <tex>t</tex>, а [[Определение_сети,_потока|пропускная способность]] каждого ребра <tex>c(u, v)>0</tex> поэтому, насыщая рёбра, мы хотя бы единожды достигнем стока <tex>t</tex>, следовательно блокирующий поток всегда найдётся.<br />
<br />
Используя <tex>dfs</tex>, каждый путь находится за <tex>O(E)</tex>, где <tex>E</tex> — число рёбер в графе. Поскольку каждый путь насыщает как минимум одно ребро, всего будет <tex>O(E)</tex> путей. Итого общая асимптотика составляет <tex>O(E^2)</tex>.<br />
<br />
==Удаляющий обход==<br />
Аналогично предыдущей идее, однако будем удалять в процессе обхода в глубину из графа все рёбра, вдоль которых не получится дойти до стока <tex>t</tex>. Это очень легко реализовать: достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое не удалённое ребро, и увеличивать этот указать в цикле внутри обхода в глубину. Корректность при этом сохраняется согласно предыдущему пункту. <br />
<br />
'''int''' dfs('''int''' <tex>v</tex>, '''int''' flow) <br />
'''if''' (flow == 0) <br />
'''return''' 0<br />
'''if''' (<tex>v</tex> == <tex>t</tex>)<br />
'''return''' flow<br />
'''for''' (<tex>u</tex> = ptr[<tex>v</tex>] '''to''' n) <font color=darkgreen> // u - ссылочный тип</font><br />
'''if''' (<tex>vu \in E</tex>)<br />
pushed = dfs(<tex>u</tex>, min(flow, c(<tex>vu</tex>) - f(<tex>vu</tex>)));<br />
f(<tex>vu</tex>) += pushed<br />
f(<tex>uv</tex>) -= pushed<br />
'''return''' pushed<br />
'''return''' 0<br />
<br />
'''main'''( )<br />
'''...'''<br />
flow = 0<br />
'''for''' ('''int''' i = 0 '''to''' n)<br />
ptr[i] = 0;<br />
'''do'''<br />
pushed = '''dfs''' (<tex>s</tex>, <tex>\infty</tex>)<br />
flow += pushed;<br />
'''while''' (pushed > 0)<br />
<br />
<br />
Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Значит один запуск обхода в глубину работает за <tex>O(V + K)</tex>, где <tex>V</tex> — число вершин в графе, а <tex>K</tex> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного [[Блокирующий поток|блокирующего потока]] будет <tex>O(P)</tex>, где <tex>P</tex> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <tex>O(PV + \sum\limits_i{K_i})</tex>, что, учитывая, что все указатели в сумме прошли расстояние <tex>O(E)</tex>, дает асимптотику <tex>O(PV + E)</tex>. В худшем случае, когда блокирующий поток насыщает все ребра, асимптотика получается <tex>O(VE)</tex>.<br />
<br />
<b>Замечание:</b> Если в [[Схема алгоритма Диница|алгоритме Диница]] искать блокирующий поток удаляющим обходом, то его эффективность составит <tex>O(V^2E)</tex>, что уже лучше эффективности [[Алоритм Эдмондса-Карпа|алгоритма Эдмондса-Карпа]] <tex>O(VE^2)</tex>.<br />
<br />
==Алгоритм Малхотры — Кумара — Махешвари==<br />
===Идея===<br />
Для каждой вершины вводится потенциал потока, равный максимальному дополнительному потоку, который может пройти через эту вершину. Далее запускаем цикл, на каждой итерации которого определяем вершину <tex>v</tex> с минимальным потенциалом <tex>p</tex>. Затем пускается поток величины <tex>p</tex> из истока в сток, проходящий через эту вершину. При этом если [[Дополняющая сеть, дополняющий путь|остаточная пропускная способность]] ребра равна нулю, то это ребро удаляется. Также, удаляются все вершины, у которых не остаётся ни одного входящего и/или ни одного выходящего ребра. При удалении вершины все смежные ребра удаляются.<br />
<br />
===Подробное описание===<br />
* Для каждой вершины <tex>v</tex> вычислим входящий и исходящий потенциал: <tex>p_{in}=\sum \limits_{u} c(u, v)</tex> и <tex>p_{out}=\sum \limits_{u} c(u, v)</tex>. Пусть <tex>p_{in}(s)=\infty</tex> и <tex>p_{out}(t)=\infty</tex>. Определим потенциал или пропускную способность вершины в [[Определение сети, потока|сети]] <tex>p(v)=min(p_{in}(v), p_{out}(v))</tex>. Таким образом, потенциал вершины определяет максимально возможное количество потока, который может через нее проходить. Ясно, что через вершины с <tex>p(v)=0</tex> поток проходить не может. Следовательно, их можно удалить из [[Дополняющая сеть, дополняющий путь|вспомогательной сети]]. Удалим эти вершины и дуги, им инцидентные, обновив должным образом потенциалы вершин, смежных с удаленными. Если в результате появятся новые вершины с <tex>p(v)=0</tex>, удалим рекурсивно и их. В результате во вспомогательной сети останутся только вершины с <tex>p(v)\ne0</tex>.<br />
<br />
* После этого приступим к построению [[Блокирующий поток|блокирующего потока]]. Пусть вершина <tex>v</tex> принадлежит <tex>k</tex>-ому слою и <tex>p(v)=min (p(w), w \in L_k)</tex>, где <tex>L_k</tex> — <tex>k</tex>-й слой. Протолкнем <tex>p(v)</tex> единиц потока из вершины <tex>v</tex> в смежные с ней вершины по исходящим дугам с [[Дополняющая сеть, дополняющий путь | остаточной пропускной способностью]] <tex>c_f \ne 0</tex>. Попутно будем переносить проталкиваемый поток в исходную сеть, а также корректировать потенциалы вершин, отправляющих и принимающих избыток потока. В результате, весь (в виду минимальности потенциала вершины <tex>v</tex>) проталкиваемый поток соберется в вершинах <tex>(k+1)</tex>-го слоя. <br />
<br />
* Повторим процесс отправки потока из вершин <tex>(k+1)</tex>-го слоя, содержащих избыток потока, в смежные им вершины <tex>(k+2)</tex>-го слоя. И так до тех пор, пока весь поток не соберется в последнем слое, в котором содержится только сток <tex>t</tex>, ибо все остальные вершины, ранее ему принадлежащие, были удалены, поскольку их потенциалы нулевые. Следовательно, весь поток величины <tex>p(v)</tex>, отправленный из вершины <tex>v</tex>, где <tex>p(v)</tex> - минимальный полностью соберется в <tex>t</tex>. <br />
<br />
* На втором этапе вновь, начиная с вершины <tex>v</tex>, осуществляется подвод потока уже по входящим дугам. В результате на первом шаге недостаток потока переадресуется к узлам <tex>(k-1)</tex>-го слоя, затем <tex>(k-2)</tex>-го. И так до тех пор, пока весь потока величины <tex>p(v)</tex>, отправленные из вершины <tex>v</tex>, где <tex>p(v)</tex> - минимальный, не соберется в истоке <tex>s</tex>. Таким образом, поток и во вспомогательной и в основной сети увеличится на величину <tex>p</tex>. <br />
<br />
<br />
MPM algorithm(<tex>s, t</tex>)<br />
{<br />
foreach <tex>(uv) \in E</tex><br />
<tex>f(uv) \leftarrow 0 </tex>;<br />
Вычисляем остаточную сеть <tex>R</tex>;<br />
Найдём вспомогательный граф <tex>L</tex> для <tex>R</tex>;<br />
while (<tex>t \in L</tex>)<br />
{<br />
while (<tex>t</tex> достижима из <tex>s</tex> в <tex>L</tex>)<br />
{<br />
найдём <tex>v</tex> с минимальной пропускной способностью <tex>g</tex>;<br />
проталкиваем <tex>g</tex> единиц потока из <tex>v</tex> в <tex>t</tex>;<br />
проталкиваем <tex>g</tex> единиц потока из <tex>s</tex> в <tex>v</tex>;<br />
изменяем <tex>f</tex>, <tex>L</tex> и <tex>R</tex>;<br />
}<br />
вычисляем новый вспомогательный граф <tex>L</tex> из <tex>R</tex>;<br />
}<br />
}<br />
<br />
===Асимптотика===<br />
Если информация о входящих и исходящих дугах будет храниться в виде связных списков, то для того, чтобы пропустить поток, на каждой итерации будет выполнено <tex>O(K + E_i)</tex> действий, где <tex>K</tex> соответствует числу рёбер, для которых остаточная пропускная способность уменьшилась, но осталась положительной, а <tex>E_i</tex> — числу удалённых ребер. Таким образом, для поиска блокирующего потока будет выполнено <tex>\sum\limits_i{O(K+E_i)} = O(K^2)</tex> действий.<br />
<br />
== См. также ==<br />
* [[Блокирующий поток]]<br />
* [[Схема алгоритма Диница]]<br />
<br />
==Источники информации==<br />
*[http://www.e-maxx.ru/algo/dinic Алгоритм Диница. Необходимые определения.]<br />
*[http://www.facweb.iitkgp.ernet.in/~arijit/courses/autumn2006/cs60001/lec-flow-4.pdf The MPM Algorithm]<br />
*[http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9C%D0%B0%D0%BB%D1%85%D0%BE%D1%82%D1%80%D1%8B_%E2%80%94_%D0%9A%D1%83%D0%BC%D0%B0%D1%80%D0%B0_%E2%80%94_%D0%9C%D0%B0%D1%85%D0%B5%D1%88%D0%B2%D0%B0%D1%80%D0%B8 Алгоритм Малхотры — Кумара — Махешвари]<br />
*[http://eprints.utas.edu.au/160/1/iplFlow.pdf Оригинальная публикация алгоритма Малхотры — Кумара — Махешвари.]<br />
<br />
<br />
[[Категория:Алгоритмы и структуры данных]]<br />
[[Категория:Задача о максимальном потоке]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%BF%D0%BE%D0%B8%D1%81%D0%BA%D0%B0_%D0%B1%D0%BB%D0%BE%D0%BA%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B5%D0%B3%D0%BE_%D0%BF%D0%BE%D1%82%D0%BE%D0%BA%D0%B0_%D0%B2_%D0%B0%D1%86%D0%B8%D0%BA%D0%BB%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B9_%D1%81%D0%B5%D1%82%D0%B8&diff=52078Алгоритм поиска блокирующего потока в ациклической сети2016-01-28T19:32:15Z<p>6yry6e: изменен псевдокод и исправлены опечатки</p>
<hr />
<div>==Жадный алгоритм==<br />
Идея заключается в том, чтобы по одному находить пути из [[Определение_сети,_потока|истока]] <tex>s</tex> в [[Определение_сети,_потока|сток]] <tex>t</tex>, пока это возможно. [[Обход в глубину, цвета вершин| Обход в глубину]] найдёт все пути из <tex>s</tex> в <tex>t</tex>, если из <tex>s</tex> достижима <tex>t</tex>, а [[Определение_сети,_потока|пропускная способность]] каждого ребра <tex>c(u, v)>0</tex> поэтому, насыщая рёбра, мы хотя бы единожды достигнем стока <tex>t</tex>, следовательно блокирующий поток всегда найдётся.<br />
<br />
Используя <tex>dfs</tex>, каждый путь находится за <tex>O(E)</tex>, где <tex>E</tex> — число рёбер в графе. Поскольку каждый путь насыщает как минимум одно ребро, всего будет <tex>O(E)</tex> путей. Итого общая асимптотика составляет <tex>O(E^2)</tex>.<br />
<br />
==Удаляющий обход==<br />
Аналогично предыдущей идее, однако будем удалять в процессе обхода в глубину из графа все рёбра, вдоль которых не получится дойти до стока <tex>t</tex>. Это очень легко реализовать: достаточно удалять ребро после того, как мы просмотрели его в обходе в глубину (кроме того случая, когда мы прошли вдоль ребра и нашли путь до стока). С точки зрения реализации, надо просто поддерживать в списке смежности каждой вершины указатель на первое не удалённое ребро, и увеличивать этот указать в цикле внутри обхода в глубину. Корректность при этом сохраняется согласно предыдущему пункту. <br />
<br />
'''dfs''' (''v'', ''flow'') <br />
'''if''' (''flow'' == 0) <br />
'''return''' 0;<br />
'''if''' (''v'' == '''t''')<br />
'''return''' ''flow'';<br />
'''for''' (''u'' = ptr[''v''] '''to''' n) // ''u'' is reference value<br />
'''if''' (''vu'' <tex>\in E</tex>)<br />
pushed = '''dfs''' (''u'', min (flow, c(''vu'') - f(''vu'')));<br />
f(''vu'') += pushed;<br />
f(''uv'') -= pushed;<br />
'''return''' pushed;<br />
'''return''' 0;<br />
<br />
'''main''' ( )<br />
'''...'''<br />
''flow'' = 0;<br />
ptr[''i''] = 0, ''i'' = ''1...n'';<br />
'''while''' (pushed = '''dfs''' ('''s''', ''INF''))<br />
''flow'' += pushed;<br />
<br />
Если обход в глубину достигает стока, насыщается как минимум одно ребро, иначе как минимум один указатель продвигается вперед. Значит один запуск обхода в глубину работает за <tex>O(V + K)</tex>, где <tex>V</tex> — число вершин в графе, а <tex>K</tex> — число продвижения указателей. Ввиду того, что всего запусков обхода в глубину в рамках поиска одного [[Блокирующий поток|блокирующего потока]] будет <tex>O(P)</tex>, где <tex>P</tex> — число рёбер, насыщенных этим блокирующим потоком, то весь алгоритм поиска блокирующего потока отработает за <tex>O(PV + \sum\limits_i{K_i})</tex>, что, учитывая, что все указатели в сумме прошли расстояние <tex>O(E)</tex>, дает асимптотику <tex>O(PV + E)</tex>. В худшем случае, когда блокирующий поток насыщает все ребра, асимптотика получается <tex>O(VE)</tex>.<br />
<br />
<b>Замечание:</b> Если в [[Схема алгоритма Диница|алгоритме Диница]] искать блокирующий поток удаляющим обходом, то его эффективность составит <tex>O(V^2E)</tex>, что уже лучше эффективности [[Алоритм Эдмондса-Карпа|алгоритма Эдмондса-Карпа]] <tex>O(VE^2)</tex>.<br />
<br />
==Алгоритм Малхотры — Кумара — Махешвари==<br />
===Идея===<br />
Для каждой вершины вводится потенциал потока, равный максимальному дополнительному потоку, который может пройти через эту вершину. Далее запускаем цикл, на каждой итерации которого определяем вершину <tex>v</tex> с минимальным потенциалом <tex>p</tex>. Затем пускается поток величины <tex>p</tex> из истока в сток, проходящий через эту вершину. При этом если [[Дополняющая сеть, дополняющий путь|остаточная пропускная способность]] ребра равна нулю, то это ребро удаляется. Также, удаляются все вершины, у которых не остаётся ни одного входящего и/или ни одного выходящего ребра. При удалении вершины все смежные ребра удаляются.<br />
<br />
===Подробное описание===<br />
* Для каждой вершины <tex>v</tex> вычислим входящий и исходящий потенциал: <tex>p_{in}=\sum \limits_{u} c(u, v)</tex> и <tex>p_{out}=\sum \limits_{u} c(u, v)</tex>. Пусть <tex>p_{in}(s)=\infty</tex> и <tex>p_{out}(t)=\infty</tex>. Определим потенциал или пропускную способность вершины в [[Определение сети, потока|сети]] <tex>p(v)=min(p_{in}(v), p_{out}(v))</tex>. Таким образом, потенциал вершины определяет максимально возможное количество потока, который может через нее проходить. Ясно, что через вершины с <tex>p(v)=0</tex> поток проходить не может. Следовательно, их можно удалить из [[Дополняющая сеть, дополняющий путь|вспомогательной сети]]. Удалим эти вершины и дуги, им инцидентные, обновив должным образом потенциалы вершин, смежных с удаленными. Если в результате появятся новые вершины с <tex>p(v)=0</tex>, удалим рекурсивно и их. В результате во вспомогательной сети останутся только вершины с <tex>p(v)\ne0</tex>.<br />
<br />
* После этого приступим к построению [[Блокирующий поток|блокирующего потока]]. Пусть вершина <tex>v</tex> принадлежит <tex>k</tex>-ому слою и <tex>p(v)=min (p(w), w \in L_k)</tex>, где <tex>L_k</tex> — <tex>k</tex>-й слой. Протолкнем <tex>p(v)</tex> единиц потока из вершины <tex>v</tex> в смежные с ней вершины по исходящим дугам с [[Дополняющая сеть, дополняющий путь | остаточной пропускной способностью]] <tex>c_f \ne 0</tex>. Попутно будем переносить проталкиваемый поток в исходную сеть, а также корректировать потенциалы вершин, отправляющих и принимающих избыток потока. В результате, весь (в виду минимальности потенциала вершины <tex>v</tex>) проталкиваемый поток соберется в вершинах <tex>(k+1)</tex>-го слоя. <br />
<br />
* Повторим процесс отправки потока из вершин <tex>(k+1)</tex>-го слоя, содержащих избыток потока, в смежные им вершины <tex>(k+2)</tex>-го слоя. И так до тех пор, пока весь поток не соберется в последнем слое, в котором содержится только сток <tex>t</tex>, ибо все остальные вершины, ранее ему принадлежащие, были удалены, поскольку их потенциалы нулевые. Следовательно, весь поток величины <tex>p(v)</tex>, отправленный из вершины <tex>v</tex>, где <tex>p(v)</tex> - минимальный полностью соберется в <tex>t</tex>. <br />
<br />
* На втором этапе вновь, начиная с вершины <tex>v</tex>, осуществляется подвод потока уже по входящим дугам. В результате на первом шаге недостаток потока переадресуется к узлам <tex>(k-1)</tex>-го слоя, затем <tex>(k-2)</tex>-го. И так до тех пор, пока весь потока величины <tex>p(v)</tex>, отправленные из вершины <tex>v</tex>, где <tex>p(v)</tex> - минимальный, не соберется в истоке <tex>s</tex>. Таким образом, поток и во вспомогательной и в основной сети увеличится на величину <tex>p</tex>. <br />
<br />
<br />
MPM algorithm(<tex>s, t</tex>)<br />
{<br />
foreach <tex>(uv) \in E</tex><br />
<tex>f(uv) \leftarrow 0 </tex>;<br />
Вычисляем остаточную сеть <tex>R</tex>;<br />
Найдём вспомогательный граф <tex>L</tex> для <tex>R</tex>;<br />
while (<tex>t \in L</tex>)<br />
{<br />
while (<tex>t</tex> достижима из <tex>s</tex> в <tex>L</tex>)<br />
{<br />
найдём <tex>v</tex> с минимальной пропускной способностью <tex>g</tex>;<br />
проталкиваем <tex>g</tex> единиц потока из <tex>v</tex> в <tex>t</tex>;<br />
проталкиваем <tex>g</tex> единиц потока из <tex>s</tex> в <tex>v</tex>;<br />
изменяем <tex>f</tex>, <tex>L</tex> и <tex>R</tex>;<br />
}<br />
вычисляем новый вспомогательный граф <tex>L</tex> из <tex>R</tex>;<br />
}<br />
}<br />
<br />
===Асимптотика===<br />
Если информация о входящих и исходящих дугах будет храниться в виде связных списков, то для того, чтобы пропустить поток, на каждой итерации будет выполнено <tex>O(K + E_i)</tex> действий, где <tex>K</tex> соответствует числу рёбер, для которых остаточная пропускная способность уменьшилась, но осталась положительной, а <tex>E_i</tex> — числу удалённых ребер. Таким образом, для поиска блокирующего потока будет выполнено <tex>\sum\limits_i{O(K+E_i)} = O(K^2)</tex> действий.<br />
<br />
==Источники==<br />
*[http://e-maxx.ru/algo/dinic#8 e-maxx Алгоритм Диница]<br />
*[http://www.facweb.iitkgp.ernet.in/~arijit/courses/autumn2006/cs60001/lec-flow-4.pdf The MPM Algorithm]<br />
*[http://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9C%D0%B0%D0%BB%D1%85%D0%BE%D1%82%D1%80%D1%8B_%E2%80%94_%D0%9A%D1%83%D0%BC%D0%B0%D1%80%D0%B0_%E2%80%94_%D0%9C%D0%B0%D1%85%D0%B5%D1%88%D0%B2%D0%B0%D1%80%D0%B8 Алгоритм Малхотры — Кумара — Махешвари]<br />
*[http://eprints.utas.edu.au/160/1/iplFlow.pdf Оригинальная публикация алгоритма Малхотры — Кумара — Махешвари.]<br />
<br />
<br />
[[Категория:Алгоритмы и структуры данных]]<br />
[[Категория:Задача о максимальном потоке]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D0%A5%D0%B0%D0%BD%D0%B0&diff=48069Сортировка Хана2015-06-07T21:14:45Z<p>6yry6e: </p>
<hr />
<div>'''Сортировка Хана''' (англ. ''Hansort'') {{---}} сложный алгоритм сортировки целых чисел со сложностью <tex dpi="130">O(n \log\log n)</tex>, где <tex dpi="130">n</tex> {{---}} количество элементов для сортировки.<br />
<br />
Данная статья писалась на основе брошюры Хана (англ. ''Yijie Han''), посвященной этой сортировке.<br />
<br />
== Описание ==<br />
Алгоритм построен на основе '''экспоненциального поискового дерева Андерсона''' (англ. ''Andersson's exponential search tree''). Сортировка происходит за счет вставки целых чисел в экспоненциальное поисковое дерево (''далее {{---}} ЭП-дерево'').<br />
<br />
== Экспоненциальное поисковое дерево Андерсона ==<br />
<br />
{{Определение<br />
|definition = '''ЭП-дерево''' {{---}} это дерево поиска, в котором все ключи хранятся в листьях этого дерева и количество детей у каждого узла уменьшается экспоненциально от глубины узла.<br />
}}<br />
<br />
[[Файл:Exp-tree.png|400px|thumb|right|Общая структура ЭП-дерева]]<br />
<br />
Структура ЭП-дерева:<br />
<br />
1) Корень имеет <tex dpi="130">\Theta (n^e)</tex> сыновей <tex dpi="130">( 0 < e < 1 )</tex>. Все сыновья являются ЭП-деревьями.<br />
<br />
2) Каждое поддерево корня имеет <tex dpi="130">\Theta(n^{1-e})</tex> сыновей.<br />
<br />
В этом дереве <tex dpi="130">O(n \log\log n)</tex> уровней. При нарушении баланса дерева необходимо балансирование, которое требует <tex dpi="130">O(n \log\log n)</tex> времени при <tex dpi="130">n</tex> вставленных целых числах. Такое время достигается за счет вставки чисел группами, а не поодиночке, как изначально предлагал Андерссон.<br />
<br />
==Определения== <br />
{{ Определение | definition =<br />
'''Контейнер''' {{---}} объект, в которым хранятся наши данные. Например: 32-битные и 64-битные числа, массивы, вектора.}}<br />
{{ Определение | definition =<br />
Алгоритм, сортирующий <tex dpi="130">n</tex> целых чисел из множества <tex dpi="130">\{0, 1, \ldots, m - 1\}</tex>, называется '''консервативным''', если длина контейнера (число бит в контейнере) равна <tex dpi="130">O(\log(m + n))</tex>. Если длина больше, то алгоритм '''неконсервативный'''.<br />
}}<br />
{{ Определение | definition =<br />
Если сортируются целые числа из множества <tex dpi="130">\{0, 1, \ldots, m - 1\}</tex> с длиной контейнера <tex dpi="130">k \log (m + n)</tex> с <tex dpi="130">k \geqslant 1</tex>, тогда сортировка происходит с '''неконсервативным преимуществом''' <tex dpi="130">k</tex>.<br />
}}<br />
{{ Определение | definition =<br />
Для множества <tex dpi="130">S</tex> определим<br />
<br />
<tex dpi="130">\min(S) = \min\limits_{a \in S} a</tex> <br />
<br />
<tex dpi="130">\max(S) = \max\limits_{a \in S} a</tex><br />
<br />
Набор <tex dpi="130">S1 < S2</tex> если <tex dpi="130">\max(S1) \leqslant \min(S2)</tex><br />
}}<br />
<br />
{{ Определение | definition =<br />
Предположим, есть набор <tex dpi="130">T</tex> из <tex dpi="130">p</tex> чисел, которые уже отсортированы как <tex dpi="130">a_{1}, a_{2}, \ldots, a_{p}</tex> и набор <tex dpi="130">S</tex> из <tex dpi="130">q</tex> чисел <tex dpi="130">b_{1}, b_{2}, \ldots, b_{q}</tex>. Тогда '''разделением''' <tex dpi="130">q</tex> чисел <tex dpi="130">p</tex> числами называется <tex dpi="130">p + 1</tex> набор <tex dpi="130">S_{0}, S_{1}, \ldots, S_{p}</tex>, где <tex dpi="130">S_{0} < a_{1} < S_{1} < \ldots < a_{p} < S_{p}</tex>.<br />
}}<br />
<br />
==Леммы==<br />
<br />
{{Лемма<br />
|id = lemma1<br />
|about = № 1<br />
|statement = <br />
Даны целые числа <tex dpi="130">b \geqslant s \geqslant 0</tex>, и <tex dpi="130">T</tex> является подмножеством множества <tex dpi="130">\{0, \ldots, 2^b - 1\}</tex>, содержащим <tex dpi="130">n</tex> элементов, и <tex dpi="130">t \geqslant 2^{-s + 1}С^k_{n}</tex>. Функция <tex dpi="130">h_{a}</tex>, принадлежащая <tex dpi="130">H_{b,s}</tex>, может быть выбрана за время <tex dpi="130">O(bn^2)</tex> так, что количество коллизий <tex dpi="130">coll(h_{a}, T) \leqslant t</tex>.<br />
}}<br />
<br />
{{Лемма<br />
|id = lemma2<br />
|about = № 2<br />
|statement = <br />
Выбор <tex dpi="130">s</tex>-ого наибольшего числа среди <tex dpi="130">n</tex> чисел, упакованных в <tex dpi="150">\frac{n}{g}</tex> контейнеров, может быть сделан за время <tex dpi="150">O(\frac{n \log g}{g})</tex> и с использованием <tex dpi="150">O(\frac{n}{g})</tex> памяти. В том числе, так может быть найдена медиана.<br />
<br />
|proof = <br />
Так как возможно делать попарное сравнение <tex dpi="130">g</tex> чисел в одном контейнере с <tex dpi="130">g</tex> числами в другом и извлекать большие числа из одного контейнера и меньшие из другого за константное время, возможно упаковать медианы из первого, второго, <tex dpi="130">\ldots</tex>, <tex dpi="130">g</tex>-ого чисел из 5 контейнеров в один контейнер за константное время. Таким образом, набор <tex dpi="130">S</tex> из медиан теперь содержится в <tex dpi="150">\frac{n}{5g}</tex> контейнерах. Рекурсивно находим медиану <tex dpi="130">m</tex> в <tex dpi="130">S</tex>. Используя <tex dpi="130">m</tex>, уберем хотя бы <tex dpi="150">\frac{n}{4}</tex> чисел среди <tex dpi="130">n</tex>. Затем упакуем оставшиеся из <tex dpi="150">\frac{n}{g}</tex> контейнеров в <tex dpi="150">\frac{3n}{4g}</tex> контейнеров и затем продолжим рекурсию.<br />
}}<br />
<br />
{{Лемма<br />
|id = lemma3<br />
|about = № 3<br />
|statement = <br />
Если <tex dpi="130">g</tex> целых чисел, в сумме использующих <tex dpi="150">\frac{\log n}{2}</tex> бит, упакованы в один контейнер, тогда <tex dpi="130">n</tex> чисел в <tex dpi="150">\frac{n}{g}</tex> контейнерах могут быть отсортированы за время <tex dpi="150">O(\frac{n \log g}{g})</tex> с использованием <tex dpi="150">O(\frac{n}{g})</tex> памяти.<br />
<br />
<br />
|proof = <br />
Так как используется только <tex dpi="150">\frac{\log n}{2}</tex> бит в каждом контейнере для хранения <tex dpi="130">g</tex> чисел, используем bucket sort, чтобы отсортировать все контейнеры, представляя каждый как число, что занимает <tex dpi="150">O(\frac{n}{g})</tex> времени и памяти. Так как используется <tex dpi="150">\frac{\log n}{2}</tex> бит на контейнер, понадобится <tex dpi="130">\sqrt{n}</tex> шаблонов для всех контейнеров. Затем поместим <tex dpi="150">g < \frac{\log n}{2}</tex> контейнеров с одинаковым шаблоном в одну группу. Для каждого шаблона останется не более <tex dpi="130">g - 1</tex> контейнеров, которые не смогут образовать группу. Поэтому не более <tex dpi="130">\sqrt{n}(g - 1)</tex> контейнеров не смогут сформировать группу. Для каждой группы помещаем <tex dpi="130">i</tex>-е число во всех <tex dpi="130">g</tex> контейнерах в один. Таким образом берутся <tex dpi="130">g</tex> <tex dpi="130">g</tex>-целых векторов и получаются <tex dpi="130">g</tex> <tex dpi="130">g</tex>-целых векторов, где <tex dpi="130">i</tex>-ый вектор содержит <tex dpi="130">i</tex>-ое число из входящего вектора. Эта транспозиция может быть сделана за время <tex dpi="130">O(g \log g)</tex>, с использованием <tex dpi="130">O(g)</tex> памяти. Для всех групп это занимает время <tex dpi="150">O(\frac{n \log g}{g})</tex>, с использованием <tex dpi="150">O(\frac{n}{g})</tex> памяти.<br />
<br />
Для контейнеров вне групп (которых <tex dpi="130">\sqrt{n}(g - 1)</tex> штук) разбираем и собираем заново контейнеры. На это потребуется не более <tex dpi="150">O(\frac{n}{g})</tex> времени и памяти. После всего этого используем карманную сортировку вновь для сортировки <tex dpi="130">n</tex> контейнеров. Таким образом, все числа отсортированы.<br />
<br />
<br />
Заметим, что когда <tex dpi="130">g = O( \log n)</tex>, сортировка <tex dpi="130">O(n)</tex> чисел в <tex dpi="150">\frac{n}{g}</tex> контейнеров произойдет за время <tex dpi="150">O((\frac{n}{g})</tex> <tex dpi="130">\log\log n)</tex> с использованием <tex dpi="150">O(\frac{n}{g})</tex> памяти. Выгода очевидна.<br />
}}<br />
<br />
{{Лемма<br />
|id = lemma4<br />
|about = № 4<br />
|statement = <br />
Примем, что каждый контейнер содержит <tex dpi="130"> \log m > \log n</tex> бит, и <tex dpi="130">g</tex> чисел, в каждом из которых <tex dpi="150">\frac{\log m}{g}</tex> бит, упакованы в один контейнер. Если каждое число имеет маркер, содержащий <tex dpi="150">\frac{\log n}{2g}</tex> бит, и <tex dpi="130">g</tex> маркеров упакованы в один контейнер таким же образом<tex dpi="130">^*</tex>, что и числа, тогда <tex dpi="130">n</tex> чисел в <tex dpi="150">\frac{n}{g}</tex> контейнерах могут быть отсортированы по их маркерам за время <tex dpi="150">O(\frac{n \log\log n}{g})</tex> с использованием <tex dpi="150">O(\frac{n}{g})</tex> памяти.<br />
(*): если число <tex dpi="130">a</tex> упаковано как <tex dpi="130">s</tex>-ое число в <tex dpi="130">t</tex>-ом контейнере для чисел, тогда маркер для <tex dpi="130">a</tex> упакован как <tex dpi="130">s</tex>-ый маркер в <tex dpi="130">t</tex>-ом контейнере для маркеров.<br />
<br />
<br />
|proof = <br />
Контейнеры для маркеров могут быть отсортированы с помощью bucket sort потому, что каждый контейнер использует <tex dpi="150">\frac{\log n}{2}</tex> бит. Сортировка сгруппирует контейнеры для чисел как в [[#lemma3|лемме №3]]. Перемещаем каждую группу контейнеров для чисел.<br />
}}<br />
<br />
{{Лемма<br />
|id = lemma5<br />
|about = № 5<br />
|statement =<br />
Предположим, что каждый контейнер содержит <tex dpi="130">\log m \log\log n > \log n</tex> бит, что <tex dpi="130">g</tex> чисел, в каждом из которых <tex dpi="150">\frac{\log m}{g}</tex> бит, упакованы в один контейнер, что каждое число имеет маркер, содержащий <tex dpi="150">\frac{\log n}{2g}</tex> бит, и что <tex dpi="130">g</tex> маркеров упакованы в один контейнер тем же образом что и числа. Тогда <tex dpi="130">n</tex> чисел в <tex dpi="150">\frac{n}{g}</tex> контейнерах могут быть отсортированы по своим маркерам за время <tex dpi="150">O(\frac{n}{g})</tex> с использованием <tex dpi="150">O(\frac{n}{g})</tex> памяти.<br />
<br />
|proof = <br />
Заметим, что несмотря на то, что длина контейнера <tex dpi="130">\log m \log\log n</tex> бит, всего <tex dpi="130">\log m</tex> бит используется для хранения упакованных чисел. Так же как в [[#lemma3|лемме №3]] и [[#lemma4|лемме №4]] сортируем контейнеры упакованных маркеров с помощью bucket sort. Для того, чтобы перемещать контейнеры чисел, помещаем <tex dpi="130">g \log\log n</tex> вместо <tex dpi="130">g</tex> контейнеров чисел в одну группу. Для транспозиции чисел в группе, содержащей <tex dpi="130">g \log\log n</tex> контейнеров, упаковываем <tex dpi="130">g \log\log n</tex> контейнеров в <tex dpi="130">g</tex>, упаковывая <tex dpi="130">\log\log n</tex> контейнеров в один. Далее делаем транспозицию над <tex dpi="130">g</tex> контейнерами. Таким образом перемещение занимает всего <tex dpi="130">O(g \log\log n)</tex> времени для каждой группы и <tex dpi="150">O(\frac{n}{g})</tex> времени для всех чисел. После завершения транспозиции, распаковываем <tex dpi="130">g</tex> контейнеров в <tex dpi="130">g \log\log n</tex> контейнеров.<br />
<br />
<br />
Заметим, что если длина контейнера <tex dpi="130">\log m \log\log n</tex> и только <tex dpi="130">\log m</tex> бит используется для упаковки <tex dpi="130">g \leqslant \log n</tex> чисел в один контейнер, тогда выбор в [[#lemma2|лемме №2]] может быть сделан за время и память <tex dpi="150">O(\frac{n}{g})</tex>, потому что упаковка в доказательстве [[#lemma2|лемме №2]] теперь может быть сделана за время <tex dpi="150">O(\frac{n}{g})</tex>.<br />
}}<br />
<br />
<br />
{{Лемма<br />
|id = lemma6<br />
|about = № 6<br />
|statement = <br />
<tex dpi="130">n</tex> целых чисел можно отсортировать в <tex dpi="130">\sqrt{n}</tex> наборов <tex dpi="130">S_{1}</tex>, <tex dpi="130">S_{2}</tex>, <tex dpi="130">\ldots</tex>, <tex dpi="130">S_{\sqrt{n}}</tex> таким образом, что в каждом наборе <tex dpi="130">\sqrt{n}</tex> чисел и <tex dpi="130">S_{i} < S_{j}</tex> при <tex dpi="130">i < j</tex>, за время <tex dpi="150">O(\frac{n \log\log n} {\log k})</tex> и место <tex dpi="130">O(n)</tex> с неконсервативным преимуществом <tex dpi="130">k \log\log n</tex>.<br />
<br />
<br />
|proof = <br />
Алгоритм сортировки <tex dpi="130">n</tex> целых чисел в <tex dpi="130">\sqrt{n}</tex> наборов, представленный ниже, является доказательством данной леммы. <br />
<br />
Постановка задачи и решение некоторых проблем:<br />
<br />
<br />
Рассмотрим проблему сортировки <tex dpi="130">n</tex> целых чисел из множества <tex dpi="130">\{0, 1, \ldots, m - 1\}</tex> в <tex dpi="130">\sqrt{n}</tex> наборов, как в условии леммы. Предполагаем, что каждый контейнер содержит <tex dpi="130">k \log\log n \log m</tex> бит и хранит число в <tex dpi="130">\log m</tex> бит. Поэтому неконсервативное преимущество {{---}} <tex dpi="130">k \log \log n</tex>. Также предполагаем, что <tex dpi="130">\log m \geqslant \log n \log\log n</tex>. Иначе можно использовать radix sort для сортировки за время <tex dpi="130">O(n \log\log n)</tex> и линейную память. Делим <tex dpi="130">\log m</tex> бит, используемых для представления каждого числа, в <tex dpi="130">\log n</tex> блоков. Таким образом, каждый блок содержит как минимум <tex dpi="130">\log\log n</tex> бит. <tex dpi="130">i</tex>-ый блок содержит с <br />
<tex dpi="150">\frac{i \log m} {\log n}</tex>-ого по <tex dpi="150">(\frac{(i + 1) \log m} {\log n - 1})</tex>-ый биты. Биты считаются с наименьшего бита, начиная с нуля. Теперь у нас имеется <tex dpi="130">2 \log n</tex>-уровневый алгоритм, который работает следующим образом:<br />
<br />
<br />
На каждой стадии работаем с одним блоком бит. Назовем эти блоки маленькими числами (далее м.ч.), потому что каждое м.ч. теперь содержит только <tex dpi="150">\frac{\log m}{\log n}</tex> бит. Каждое число представлено и соотносится с м.ч., над которым работаем в данный момент. Положим, что нулевая стадия работает с самым большим блоком (блок номер <tex dpi="130">\log n - 1</tex>). Предполагаем, что биты этих м.ч. упакованы в <tex dpi="150">\frac{n}{\log n}</tex> контейнеров с <tex dpi="130">\log n</tex> м.ч. упакованными в один контейнер. Пренебрегая временем, потраченным на эту упаковку, считаем, что она бесплатна. По [[#lemma2|лемме №2]] находим медиану этих <tex dpi="130">n</tex> м.ч. за время и память <tex dpi="150">O(\frac{n}{\log n})</tex>. Пусть <tex dpi="130">a</tex> {{---}} это найденная медиана. Тогда <tex dpi="130">n</tex> м.ч. могут быть разделены на не более чем три группы: <tex dpi="130">S_{1}</tex>, <tex dpi="130">S_{2}</tex> и <tex dpi="130">S_{3}</tex>. <tex dpi="130">S_{1}</tex> содержит м.ч., которые меньше <tex dpi="130">a</tex>, <tex dpi="130">S_{2}</tex> содержит м.ч., равные <tex dpi="130">a</tex>, <tex dpi="130">S_{3}</tex> содержит м.ч., большие <tex dpi="130">a</tex>. Также мощность <tex dpi="130">S_{1}</tex> и <tex dpi="130">S_{3} </tex> не превосходит <tex dpi="130">n/2</tex>. Мощность <tex dpi="130">S_{2}</tex> может быть любой. Пусть <tex dpi="130">S'_{2}</tex> {{---}} это набор чисел, у которых наибольший блок находится в <tex dpi="130">S_{2}</tex>. Тогда убираем из дальнейшего рассмотрения <tex dpi="150">\frac{\log m}{\log n}</tex> бит (наибольший блок) из каждого числа, принадлежащего <tex dpi="130">S'_{2}</tex>. Таким образом, после первой стадии каждое число находится в наборе размера не большего половины размера начального набора или один из блоков в числе убран из дальнейшего рассмотрения. Так как в каждом числе только <tex dpi="130">\log n</tex> блоков, для каждого числа потребуется не более <tex dpi="130">\log n</tex> стадий, чтобы поместить его в набор половинного размера. За <tex dpi="130">2 \log n</tex> стадий все числа будут отсортированы. Так как на каждой стадии работаем с <tex dpi="150">\frac{n}{\log n}</tex> контейнерами, то игнорируя время, необходимое на упаковку м.ч. в контейнеры и помещение м.ч. в нужный набор, затрачивается <tex dpi="130">O(n)</tex> времени из-за <tex dpi="130">2 \log n</tex> стадий.<br />
<br />
<br />
Сложная часть алгоритма заключается в том, как поместить м.ч. в набор, которому принадлежит соответствующее число, после предыдущих операций деления набора в нашем алгоритме. Предположим, что <tex dpi="130">n</tex> чисел уже поделены в <tex dpi="130">e</tex> наборов. Используем <tex dpi="130">\log e</tex> битов чтобы сделать марки для каждого набора. Теперь используем [[#lemma5|лемме №5]]. Полный размер маркера для каждого контейнера должен быть <tex dpi="150">\frac{\log n}{2}</tex>, и маркер использует <tex dpi="130">\log e</tex> бит, значит количество маркеров <tex dpi="130">g</tex> в каждом контейнере должно быть не более <tex dpi="150">\frac{\log n}{2\log e}</tex>. В дальнейшем, так как <tex dpi="150">g = \frac{\log n}{2 \log e}</tex>, м.ч. должны влезать в контейнер. Каждый контейнер содержит <tex dpi="130">k \log\log n \log n</tex> блоков, каждое м.ч. может содержать <tex dpi="150">O(\frac{k \log n}{g}) = O(k \log e)</tex> блоков. Заметим, что используется неконсервативное преимущество в <tex dpi="130">\log\log n</tex> для [[#lemma5|лемме №5]] Поэтому предполагается, что <tex dpi="150">\frac{\log n}{2 \log e}</tex> м.ч., в каждом из которых <tex dpi="130">k \log e</tex> блоков битов числа, упакованны в один контейнер. Для каждого м.ч. используется маркер из <tex dpi="130">\log e</tex> бит, который показывает, к какому набору он принадлежит. Предполагаем, что маркеры так же упакованы в контейнеры, как и м.ч. Так как каждый контейнер для маркеров содержит <tex dpi="150">\frac{\log n}{2 \log e}</tex> маркеров, то для каждого контейнера требуется <tex dpi="150">\frac{\log n}{2}</tex> бит. Таким образом, [[#lemma5|лемма №5]] может быть применена для помещения м.ч. в наборы, которым они принадлежат. Так как используется <tex dpi="150">O(\frac{n \log e}{ \log n})</tex> контейнеров, то время, необходимое для помещения м.ч. в их наборы, равно <tex dpi="150">O(\frac{n \log e}{ \log n})</tex>.<br />
<br />
Стоит отметить, что процесс помещения нестабилен, т.к. основан на алгоритме из [[#lemma5|леммы №5]].<br />
<br />
<br />
При таком помещении сразу возникает следующая проблема.<br />
<br />
Рассмотрим число <tex dpi="130">a</tex>, которое является <tex dpi="130">i</tex>-ым в наборе <tex dpi="130">S</tex>. Рассмотрим блок <tex dpi="130">a</tex> (назовем его <tex dpi="130">a'</tex>), который является <tex dpi="130">i</tex>-ым м.ч. в <tex dpi="130">S</tex>. Когда используется вышеописанный метод перемещения нескольких следующих блоков <tex dpi="130">a</tex> (назовем это <tex dpi="130">a''</tex>) в <tex dpi="130">S</tex>, <tex dpi="130">a''</tex> просто перемещен на позицию в наборе <tex dpi="130">S</tex>, но не обязательно на позицию <tex dpi="130">i</tex> (где расположен <tex dpi="130">a'</tex>). Если значение блока <tex dpi="130">a'</tex> одинаково для всех чисел в <tex dpi="130">S</tex>, то это не создаст проблемы потому, что блок одинаков вне зависимости от того в какое место в <tex dpi="130">S</tex> помещен <tex dpi="130">a''</tex>. Иначе у нас возникает проблема дальнейшей сортировки. Поэтому поступаем следующим образом: На каждой стадии числа в одном наборе работают на общем блоке, который назовем "текущий блок набора". Блоки, которые предшествуют текущему блоку содержат важные биты и идентичны для всех чисел в наборе. Когда помещаем больше бит в набор, последующие блоки помещаются в набор вместе с текущим блоком. Так вот, в вышеописанном процессе помещения предполагается, что самый значимый блок среди <tex dpi="130">k \log e</tex> блоков {{---}} это текущий блок. Таким образом, после того, как эти <tex dpi="130">k \log e</tex> блоков помещены в набор, изначальный текущий блок удаляется, потому что известно, что эти <tex dpi="130">k \log e</tex> блоков перемещены в правильный набор, и нам не важно где находился начальный текущий блок. Тот текущий блок находится в перемещенных <tex dpi="130">k \log e</tex> блоках.<br />
<br />
<br />
Стоит отметить, что после нескольких уровней деления размер наборов станет маленьким. Леммы [[#lemma3|3]], [[#lemma4|4]], [[#lemma5|5]] расчитаны на не очень маленькие наборы. Но поскольку сортируется набор из <tex dpi="130">n</tex> элементов в наборы размера <tex dpi="130">\sqrt{n}</tex>, то проблем быть не должно.<br />
<br />
<br />
===Алгоритм сортировки===<br />
<br />
Algorithm <tex>Sort(advantage</tex>, <tex>level</tex>, <tex>a_{0}</tex>, <tex>a_{1}</tex>, <tex>\ldots</tex>, <tex>a_{t}</tex>)<br />
<br />
<tex>advantage</tex> {{---}} это неконсервативное преимущество равное <tex>k\log\log n</tex>, <tex>a_{i}</tex>-ые это входящие целые числа в наборе, которые надо отсортировать, <tex>level</tex> это уровень рекурсии.<br />
<br />
# Если <tex>level</tex> равен <tex>1</tex> тогда изучаем размер набора. Если размер меньше или равен <tex>\sqrt{n}</tex>, то <tex>return</tex>. Иначе делим этот набор в <tex>\leqslant</tex> 3 набора, используя [[#lemma2|лемму №2]], чтобы найти медиану, а затем используем [[#lemma5|лемму №5]] для сортировки. Для набора, где все элементы равны медиане, не рассматриваем текущий блок и текущим блоком делаем следующий. Создаем маркер, являющийся номером набора для каждого из чисел (0, 1 или 2). Затем направляем маркер для каждого числа назад к месту, где число находилось в начале. Также направляем двубитное число для каждого входного числа, указывающее на текущий блок.<br />
# От <tex dpi="130">u = 1</tex> до <tex dpi="130">k</tex><br />
## Упаковываем <tex dpi="130">a^{(u)}_{i}</tex>-ый в часть из <tex dpi="130">1/k</tex>-ых номеров контейнеров. Где <tex dpi="130">a^{(u)}_{i}</tex> содержит несколько непрерывных блоков, которые состоят из <tex dpi="150">\frac{1}{k}</tex>-ых битов <tex dpi="130">a_{i}</tex>. При этом у <tex dpi="130">a^{(u)}_{i}</tex> текущий блок это самый крупный блок.<br />
## Вызываем <tex>Sort(advantage</tex>, <tex>level - 1</tex>, <tex dpi="130">a^{(u)}_{0}</tex>, <tex dpi="130">a^{(u)}_{1}</tex>, <tex>\ldots</tex>, <tex dpi="130">a^{(u)}_{t}</tex>). Когда алгоритм возвращается из этой рекурсии, маркер, показывающий для каждого числа, к какому набору это число относится, уже направлен назад к месту, где число находится во входных данных. Число, имеющее наибольшее число бит в <tex dpi="130">a_{i}</tex>, показывающее на текущий блок в нем, так же направлено назад к <tex dpi="130">a_{i}</tex>.<br />
## Отправляем <tex dpi="130">a_{i}</tex>-ые к их наборам, используя [[#lemma5|лемму №5]].<br />
<br />
Algorithm IterateSort<br />
Call <tex>Sort(advantage</tex>, <tex dpi="130">\log_{k}((\log n)/4)</tex>, <tex dpi="130">a_{0}</tex>, <tex dpi="130">a_{1}</tex>, <tex dpi="130">\ldots</tex>, <tex dpi="130">a_{n - 1}</tex>);<br />
<br />
от 1 до 5<br />
# Помещаем <tex dpi="130">a_{i}</tex> в соответствующий набор с помощью блочной сортировки (англ. ''bucket sort''), потому что наборов около <tex dpi="130">\sqrt{n}</tex>.<br />
# Для каждого набора <tex dpi="130">S = </tex>{<tex dpi="130">a_{i_{0}}, a_{i_{1}}, \ldots, a_{i_{t}}</tex>}, если <tex dpi="130">t > \sqrt{n}</tex>, вызываем <tex>Sort(advantage</tex>, <tex dpi="130">\log_{k}(\frac{\log n}{4})</tex>, <tex dpi="130">a_{i_{0}}, a_{i_{1}}, \ldots, a_{i_{t}}</tex>).<br />
<br />
Время работы алгоритма <tex dpi="150">O(\frac{n \log\log n}{\log k})</tex>, что доказывает лемму.<br />
}}<br />
<br />
<br />
<br />
==Уменьшение числа бит в числах==<br />
Один из способов ускорить сортировку {{---}} уменьшить число бит в числе. Один из способов уменьшить число бит в числе {{---}} использовать деление пополам (эту идею впервые подал van Emde Boas). Деление пополам заключается в том, что количество оставшихся бит в числе уменьшается в 2 раза. Это быстрый способ, требующий <tex dpi="130">O(m)</tex> памяти. Для своего дерева Андерссон использует хеширование, что позволяет сократить количество памяти до <tex dpi="130">O(n)</tex>. Для того чтобы еще ускорить алгоритм, необходимо упаковать несколько чисел в один контейнер, чтобы затем за константное количество шагов произвести хеширование для всех чисел, хранимых в контейнере. Для этого используется хеш-функция для хеширования <tex dpi="130">n</tex> чисел в таблицу размера <tex dpi="130">O(n^2)</tex> за константное время без коллизий. Для этого используется модифицированная хеш-функция авторства: Dierzfelbinger и Raman.<br />
<br />
<br />
Алгоритм: Пусть целое число <tex dpi="130">b \geqslant 0</tex> и пусть <tex dpi="130">U = \{0, \ldots, 2^b - 1\}</tex>. Класс <tex dpi="130">H_{b,s}</tex> хеш-функций из <tex dpi="130">U</tex> в <tex dpi="130">\{0, \ldots, 2^s - 1\}</tex> определен как <tex dpi="130">H_{b,s} = \{h_{a} \mid 0 < a < 2^b, a \equiv 1 (\bmod 2)\}</tex> и для всех <tex dpi="130">x</tex> из <tex dpi="130">U</tex>: <tex dpi="130">h_{a}(x) = (ax</tex> <tex dpi="130">\bmod</tex> <tex dpi="130">2^b)</tex> <tex dpi="130">div</tex> <tex dpi="130">2^{b - s}</tex>.<br />
<br />
Данный алгоритм базируется на [[#lemma1|лемме №1]].<br />
<br />
<br />
Взяв <tex dpi="130">s = 2 \log n</tex>, получаем хеш-функцию <tex dpi="130">h_{a}</tex>, которая захеширует <tex dpi="130">n</tex> чисел из <tex dpi="130">U</tex> в таблицу размера <tex dpi="130">O(n^2)</tex> без коллизий. Очевидно, что <tex dpi="130">h_{a}(x)</tex> может быть посчитана для любого <tex dpi="130">x</tex> за константное время. Если упаковать несколько чисел в один контейнер так, что они разделены несколькими битами нулей, то можно применить <tex dpi="130">h_{a}</tex> ко всему контейнеру, и в результате все хеш-значения для всех чисел в контейнере будут посчитаны. Заметим, что это возможно только потому, что в вычисление хеш-значения вовлечены только (<tex dpi="130">\bmod</tex> <tex dpi="130">2^b</tex>) и (<tex dpi="130">div</tex> <tex dpi="130">2^{b - s}</tex>). <br />
<br />
<br />
Такая хеш-функция может быть найдена за <tex dpi="130">O(n^3)</tex>.<br />
<br />
Следует отметить, что, несмотря на размер таблицы <tex dpi="130">O(n^2)</tex>, потребность в памяти не превышает <tex dpi="130">O(n)</tex>, потому что хеширование используется только для уменьшения количества бит в числе.<br />
<br />
==Сортировка по ключу==<br />
Предположим, что <tex dpi="130">n</tex> чисел должны быть отсортированы, и в каждом <tex dpi="130">\log m</tex> бит. Будем считать, что в каждом числе есть <tex dpi="130">h</tex> сегментов, в каждом из которых <tex dpi="130">\log</tex> <tex dpi="150">\frac{m}{h}</tex> бит. Теперь применяем хеширование ко всем сегментам и получаем <tex dpi="130">2h \log n</tex> бит хешированных значений для каждого числа. После сортировки на хешированных значениях для всех начальных чисел начальная задача по сортировке <tex dpi="130">n</tex> чисел по <tex dpi="130">\log m</tex> бит в каждом стала задачей по сортировке <tex dpi="130">n</tex> чисел по <tex dpi="130">\log</tex> <tex dpi="150">\frac{m}{h}</tex> бит в каждом.<br />
<br />
<br />
Также рассмотрим проблему последующего разделения. Пусть <tex dpi="130">a_{1}</tex>, <tex dpi="130">a_{2}</tex>, <tex dpi="130">\ldots</tex>, <tex dpi="130">a_{p}</tex> {{---}} <tex dpi="130">p</tex> чисел и <tex dpi="130">S</tex> {{---}} множество чисeл. Необходимо разделить <tex dpi="130">S</tex> в <tex dpi="130">p + 1</tex> наборов, таких, что: <tex dpi="130">S_{0} < a_{1} < S_{1} < a_{2} < \ldots < a_{p} < S_{p}</tex>. Так как используется '''сортировка по ключу''' (англ. ''signature sorting'') то перед тем, как делать вышеописанное разделение, необходимо поделить биты в <tex dpi="130">a_{i}</tex> на <tex dpi="130">h</tex> сегментов и взять некоторые из них. Так же делим биты для каждого числа из <tex dpi="130">S</tex> и оставляем только один в каждом числе. По существу, для каждого <tex dpi="130">a_{i}</tex> берутся все <tex dpi="130">h</tex> сегментов. Если соответствующие сегменты <tex dpi="130">a_{i}</tex> и <tex dpi="130">a_{j}</tex> совпадают, то нам понадобится только один. Сегмент, который берется для числа в <tex dpi="130">S</tex> это сегмент, который выделяется из <tex dpi="130">a_{i}</tex>. Таким образом, начальная задача о разделении <tex dpi="130">n</tex> чисел по <tex dpi="130">\log m</tex> бит преобразуется в несколько задач на разделение с числами по <tex dpi="150">\frac{\log m}{h}</tex> бит.<br />
<br />
<br />
'''Пример''':<br />
[[Файл:Han-example.png|500px|thumb]]<br />
<br />
<tex dpi="130">a_{1} = 3, a_{2} = 5, a_{3} = 7, a_{4} = 10, S = \{1, 4, 6, 8, 9, 13, 14\}</tex>.<br />
<br />
Делим числа на два сегмента. Для <tex dpi="130">a_{1}</tex> получим верхний сегмент <tex dpi="130">0</tex>, нижний <tex dpi="130">3</tex>; <tex dpi="130">a_{2}</tex> {{---}} верхний <tex dpi="130">1</tex>, нижний <tex dpi="130">1</tex>; <tex dpi="130">a_{3}</tex> {{---}} верхний <tex dpi="130">1</tex>, нижний <tex dpi="130">3</tex>; <tex dpi="130">a_{4}</tex> {{---}} верхний <tex dpi="130">2</tex>, нижний <tex dpi="130">2</tex>. Для элементов из S получим: для <tex dpi="130">1</tex> нижний <tex dpi="130">1</tex>, так как он выделяется из нижнего сегмента <tex dpi="130">a_{1}</tex>; для <tex dpi="130">4</tex> нижний <tex dpi="130">0</tex>; для <tex dpi="130">8</tex> нижний <tex dpi="130">0</tex>; для <tex dpi="130">9</tex> нижний <tex dpi="130">1</tex>; для <tex dpi="130">13</tex> верхний <tex dpi="130">3</tex>; для <tex dpi="130">14</tex> верхний <tex dpi="130">3</tex>. Теперь все верхние сегменты, нижние сегменты <tex dpi="130">1</tex> и <tex dpi="130">3</tex>, нижние сегменты <tex dpi="130">4, 5, 6, 7,</tex> нижние сегменты <tex dpi="130">8, 9, 10</tex> формируют <tex dpi="130">4</tex> новые задачи на разделение.<br />
<br />
<br />
<br />
Использование '''сортировки по ключу''' в данном алгоритме:<br />
<br />
Есть набор <tex dpi="130">T</tex> из <tex dpi="130">p</tex> чисел, которые отсортированы как <tex dpi="130">a_{1}, a_{2}, \ldots, a_{p}</tex>. Используем числа в <tex dpi="130">T</tex> для разделения набора <tex dpi="130">S</tex> из <tex dpi="130">q</tex> чисел <tex dpi="130">b_{1}, b_{2}, \ldots, b_{q}</tex> в <tex dpi="130">p + 1</tex> наборов <tex dpi="130">S_{0}, S_{1}, \ldots, S_{p}</tex>. Пусть <tex dpi="150">h = \frac{\log n}{c \log p}</tex> для константы <tex dpi="130">c > 1</tex>. (<tex dpi="150">\frac{h}{\log\log n \log p}</tex>)-битные числа могут храниться в одном контейнере, содержащим <tex dpi="150">\frac{\log n}{c \log\log n}</tex> бит. Сначала рассматриваем биты в каждом <tex dpi="130">a_{i}</tex> и каждом <tex dpi="130">b_{i}</tex> как сегменты одинаковой длины <tex dpi="150">\frac{h} {\log\log n}</tex>. Рассматриваем сегменты как числа. Чтобы получить неконсервативное преимущество для сортировки, числа в этих контейнерах (<tex dpi="130">a_{i}</tex>-ом и <tex dpi="130">b_{i}</tex>-ом) хешируются, и получается <tex dpi="150">\frac{h}{\log\log n}</tex> хешированных значений в одном контейнере. При вычислении хеш-значений сегменты не влияют друг на друга, можно даже отделить четные и нечетные сегменты в два контейнера. Не умаляя общности считаем, что хеш-значения считаются за константное время. Затем, посчитав значения, два контейнера объединяем в один. Пусть <tex dpi="130">a'_{i}</tex> {{---}} хеш-контейнер для <tex dpi="130">a_{i}</tex>, аналогично <tex dpi="130">b'_{i}</tex>. В сумме хеш-значения имеют <tex dpi="150">\frac{2 \log n}{c \log\log n}</tex> бит, хотя эти значения разделены на сегменты по <tex dpi="150">\frac{h}{ \log\log n}</tex> бит в каждом контейнере. Между сегментами получаются пустоты, которые забиваются нулями. Сначала упаковываются все сегменты в <tex dpi="150">\frac{2 \log n}{c \log\log n}</tex> бит. Потом рассматривается каждый хеш-контейнер как число, и эти хеш-контейнеры сортируются за линейное время (сортировка будет рассмотрена чуть позже). После этой сортировки биты в <tex dpi="130">a_{i}</tex> и <tex dpi="130">b_{i}</tex> разрезаны на <tex dpi="150">\frac{\log\log n}{h}</tex> сегментов. Таким образом, получилось дополнительное мультипликативное преимущество (англ. ''additional multiplicative advantage'') в <tex dpi="150">\frac{h} {\log\log n}</tex>.<br />
<br />
После того, как вышеописанный процесс повторится <tex dpi="130">g</tex> раз, получится неконсервативное преимущество в <tex dpi="150">(\frac{h} {\log\log n})^g</tex> раз, в то время как потрачено только <tex dpi="130">O(gqt)</tex> времени, так как каждое многократное деление происходит за линейное время <tex dpi="130">O(qt)</tex>.<br />
<br />
<br />
Хеш-функция, которая используется, находится следующим образом. Будут хешироватся сегменты, <tex dpi="150">\frac{\log\log n}{h}</tex>-ые, <tex dpi="150">(\frac{\log\log n}{h})^2</tex>-ые, <tex dpi="130">\ldots</tex> по счету в числе. Хеш-функцию для <tex dpi="150">(\frac{\log\log n}{h})^t</tex>-ых по счету сегментов, получаем нарезанием всех <tex dpi="130">p</tex> чисел на <tex dpi="150">(\frac{\log\log n}{h})^t</tex> сегментов. Рассматривая каждый сегмент как число, получаем <tex dpi="150">p(\frac{\log\log n}{h})^t</tex> чисел. Затем получаем одну хеш-функцию для этих чисел. Так как <tex dpi="130">t < \log n</tex>, то получится не более <tex dpi="130">\log n</tex> хеш-функций.<br />
<br />
<br />
Рассмотрим сортировку за линейное время, о которой было упомянуто ранее. Предполагается, что хешированные значения для каждого контейнера упакованы в <tex dpi="150">\frac{2 \log n}{c \log\log n}</tex> бит. Есть <tex dpi="130">t</tex> наборов, в каждом из которых <tex dpi="130">q + p</tex> хешированных контейнеров по <tex dpi="150">\frac{2 \log n}{c \log\log n}</tex> бит в каждом. Эти контейнеры должны быть отсортированы в каждом наборе. Комбинируя все хеш-контейнеры в один pool, сортируем следующим образом.<br />
<br />
<br />
Операция '''сортировки за линейное время''' (англ. ''Linear-Time-Sort'')<br />
<br />
Входные данные: <tex dpi="150">r \geqslant n^{\frac{2}{5}}</tex> чисел <tex dpi="130">d_{i}</tex>, <tex dpi="130">d_{i}.value</tex> — значение числа <tex dpi="130">d_{i}</tex>, в котором <tex dpi="150">\frac{2 \log n}{c \log\log n}</tex> бит, <tex dpi="130">d_{i}.set</tex> — набор, в котором находится <tex dpi="130">d_{i}</tex>. Следует отметить, что всего есть <tex dpi="130">t</tex> наборов.<br />
<br />
# Сортируем все <tex dpi="130">d_{i}</tex> по <tex dpi="130">d_{i}.value</tex>, используя bucket sort. Пусть все отсортированные числа в <tex dpi="130">A[1..r]</tex>. Этот шаг занимает линейное время, так как сортируется не менее <tex dpi="150">n^{\frac{2}{5}}</tex> чисел.<br />
# Помещаем все <tex dpi="130">A[j]</tex> в <tex dpi="130">A[j].set</tex>.<br />
<br />
==Сортировка с использованием O(n log log n) времени и памяти==<br />
Для сортировки <tex dpi="130">n</tex> целых чисел в диапазоне <tex dpi="130">\{0, 1, \ldots, m - 1\}</tex> предполагается, что в нашем консервативном алгоритме используется контейнер длины <tex dpi="130">O(\log (m + n))</tex>. Далее везде считается, что все числа упакованы в контейнеры одинаковой длины. <br />
<br />
<br />
Берем <tex dpi="130">1/e = 5</tex> для ЭП-дерева Андерссона. Следовательно, у корня будет <tex dpi="150">n^{\frac{1}{5}}</tex> детей, и каждое ЭП-дерево в каждом ребенке будет иметь <tex dpi="150">n^{\frac{4}{5}}</tex> листьев. В отличие от оригинального дерева, за раз вставляется не один элемент, а <tex dpi="130">d^2</tex>, где <tex dpi="130">d</tex> — количество детей узла дерева, в котором числа должны спуститься вниз. Алгоритм полностью опускает все <tex dpi="130">d^2</tex> чисел на один уровень. В корне опускаются <tex dpi="150">n^{\frac{2}{5}}</tex> чисел на следующий уровень. После того, как все числа опустились на следующий уровень, они успешно разделились на <tex dpi="130">t_{1} = n^{1/5}</tex> наборов <tex dpi="130">S_{1}, S_{2}, \ldots, S_{t_{1}}</tex>, в каждом из которых <tex dpi="150">n^{\frac{4}{5}}</tex> чисел и <tex dpi="130">S_{i} < S_{j}, i < j</tex>. Затем, берутся <tex dpi="150">n^{\frac{8}{25}}</tex> чисел из <tex dpi="130">S_{i}</tex> и опускаются на следующий уровень ЭП-дерева. Это повторяется, пока все числа не опустятся на следующий уровень. На этом шаге числа разделены на <tex dpi="150">t_{2} = n^{\frac{1}{5}}n^{\frac{4}{25}} = n^{\frac{9}{25}}</tex> наборов <tex dpi="130">T_{1}, T_{2}, \ldots, T_{t_{2}}</tex>, аналогичных наборам <tex dpi="130">S_{i}</tex>, в каждом из которых <tex dpi="150">n^{\frac{16}{25}}</tex> чисел. Теперь числа опускаются дальше в ЭП-дереве.<br />
<br />
Нетрудно заметить, что перебалансирока занимает <tex dpi="130">O(n \log\log n)</tex> времени с <tex dpi="130">O(n)</tex> времени на уровень, аналогично стандартному ЭП-дереву Андерссона.<br />
<br />
<br />
Нам следует нумеровать уровни ЭП-дерева с корня, начиная с нуля. Рассмотрим спуск вниз на уровне <tex dpi="130">s</tex>. Имеется <tex dpi="150">t = n^{1 - (\frac{4}{5})^S}</tex> наборов по <tex dpi="150">n^{(\frac{4}{5})^S}</tex> чисел в каждом. Так как каждый узел на данном уровне имеет <tex dpi="150">p = n^{\frac{1}{5} \cdot (\frac{4}{5})^S}</tex> детей, то на <tex dpi="130">s + 1</tex> уровень опускаются <tex dpi="150">q = n^{\frac{2}{5} \cdot (\frac{4}{5})^S}</tex> чисел для каждого набора, или всего <tex dpi="150">qt \geqslant n^{\frac{2}{5}}</tex> чисел для всех наборов за один раз.<br />
<br />
<br />
Спуск вниз можно рассматривать как сортировку <tex dpi="130">q</tex> чисел в каждом наборе вместе с <tex dpi="130">p</tex> числами <tex dpi="130">a_{1}, a_{2}, \ldots, a_{p}</tex> из ЭП-дерева, так, что эти <tex dpi="130">q</tex> чисел разделены в <tex dpi="130">p + 1</tex> наборов <tex dpi="130">S_{0}, S_{1}, \ldots, S_{p}</tex> таких, что <tex dpi="130">S_{0} < a_{1} < \ldots < a_{p} < S_{p}</tex>.<br />
<br />
<br />
Так как <tex dpi="130">q</tex> чисел не надо полностью сортировать и <tex dpi="130">q = p^2</tex>, то можно использовать [[#lemma6|лемму №6]] для сортировки. Для этого необходимо неконсервативное преимущество, которое получается с помощью [[Сортировка Хана#Signature sorting|signature sorting]]. Для этого используется линейная техника многократного деления (англ. ''multi-dividing technique'').<br />
<br />
<br />
После <tex dpi="130">g</tex> сокращений бит в [[Сортировка Хана#Signature sorting|signature sorting]] получаем неконсервативное преимущество в <tex dpi="150">(\frac{h}{ \log\log n})^g</tex>. Мы не волнуемся об этих сокращениях до конца потому, что после получения неконсервативного преимущества мы можем переключиться на [[#lemma6|лемму №6]] для завершения разделения <tex dpi="130">q</tex> чисел с помощью <tex dpi="130">p</tex> чисел на наборы. Заметим, что по природе битового сокращения начальная задача разделения для каждого набора перешла в <tex dpi="130">w</tex> подзадач разделения на <tex dpi="130">w</tex> поднаборов для какого-то числа <tex dpi="130">w</tex>.<br />
<br />
<br />
Теперь для каждого набора все его поднаборы в подзадачах собираются в один набор. Затем, используя [[#lemma6|лемму №6]], делается разделение. Так как получено неконсервативное преимущество в <tex dpi="150">(\frac{h}{\log\log n})^g</tex> и работа происходит на уровнях не ниже, чем <tex dpi="130">2 \log\log\log n</tex>, то алгоритм занимает <tex dpi="150">O(\frac{qt \log\log n}{g(\log h - \log\log\log n) - \log\log\log n}) = O(\log\log n)</tex> времени.<br />
<br />
<br />
В итоге разделились <tex dpi="130">q</tex> чисел <tex dpi="130">p</tex> числами в каждый набор. То есть получилось, что <tex dpi="130">S_{0} < e_{1} < S_{1} < \ldots < e_{p} < S_{p}</tex>, где <tex dpi="130">e_{i}</tex> {{---}} сегмент <tex dpi="130">a_{i}</tex>, полученный с помощью битового сокращения. Такое разделение получилось комбинированием всех поднаборов в подзадачах. Предполагаем, что числа хранятся в массиве <tex dpi="130">B</tex> так, что числа в <tex dpi="130">S_{i}</tex> предшествуют числам в <tex dpi="130">S_{j}</tex> если <tex dpi="130">i < j</tex> и <tex dpi="130">e_{i}</tex> хранится после <tex dpi="130">S_{i - 1}</tex>, но до <tex dpi="130">S_{i}</tex>. <br />
<br />
<br />
Пусть <tex dpi="130">B[i]</tex> находится в поднаборе <tex dpi="130">B[i].subset</tex>. Чтобы позволить разделению выполниться, для каждого поднабора помещаем все <tex dpi="130">B[j]</tex> в <tex dpi="130">B[j].subset</tex>.<br />
<br />
На это потребуется линейное время и место.<br />
<br />
<br />
Теперь рассмотрим проблему упаковки, которая решается следующим образом. Считается, что число бит в контейнере <tex dpi="130">\log m \geqslant \log\log\log n</tex>, потому что в противном случае можно использовать radix sort для сортировки чисел. У контейнера есть <tex dpi="150">\frac{h}{\log\log n}</tex> хешированных значений (сегментов) в себе на уровне <tex dpi="130">\log h</tex> в ЭП-дереве. Полное число хешированных бит в контейнере равно <tex dpi="130">(2 \log n)(c \log\log n)</tex> бит. Хешированные биты в контейнере выглядят как <tex dpi="130">0^{i}t_{1}0^{i}t_{2} \ldots t</tex><tex dpi="150">_{\frac{h}{\log\log n}}</tex>, где <tex dpi="130">t_{k}</tex>-ые — хешированные биты, а нули {{---}} это просто нули. Сначала упаковываем <tex dpi="130">\log\log n</tex> контейнеров в один и получаем <tex dpi="130">w_{1} = 0^{j}t_{1, 1}t_{2, 1} \ldots t_{\log\log n, 1}0^{j}t_{1, 2} \ldots t_{\log\log n,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex>, где <tex dpi="130">t_{i, k}</tex>: элемент с номером <tex dpi="130">k = 1, 2, \ldots, </tex><tex dpi="150">\frac{h}{\log\log n}</tex> из <tex dpi="130">i</tex>-ого контейнера. Используем <tex dpi="130">O(\log\log n)</tex> шагов, чтобы упаковать <tex dpi="130">w_{1}</tex> в <tex dpi="130">w_{2} = 0</tex><tex dpi="150">^{\frac{jh}{\log\log n}}</tex><tex dpi="130">t_{1, 1}t_{2, 1} \ldots t_{\log\log n, 1}t_{1, 2}t_{2, 2} \ldots t_{1,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex><tex dpi="130">t_{2,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex><tex dpi="130">\ldots t_{\log\log n,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex>. Теперь упакованные хеш-биты занимают <tex dpi="130">2 \log</tex><tex dpi="150">\frac{n}{c}</tex> бит. Используем <tex dpi="130">O(\log\log n)</tex> времени чтобы распаковать <tex dpi="130">w_{2}</tex> в <tex dpi="130">\log\log n</tex> контейнеров <tex dpi="130">w_{3, k} = 0</tex><tex dpi="150">^{\frac{jh}{\log\log n}}</tex><tex dpi="130">0^{r}t_{k, 1}0^{r}t_{k, 2} \ldots t_{k,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex> <tex dpi="130">k = 1, 2, \ldots, \log\log n</tex>. Затем, используя <tex dpi="130">O(\log\log n)</tex> времени, упаковываем эти <tex dpi="130">\log\log n</tex> контейнеров в один <tex dpi="130">w_{4} = 0^{r}t_{1, 1}0^{r}t_{1, 2} \ldots t_{1,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex><tex dpi="130">0^{r}t_{2, 1} \ldots t_{\log\log n,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex>. Затем, используя <tex dpi="130">O(\log\log n)</tex> шагов, упаковываем <tex dpi="130">w_{4}</tex> в <tex dpi="130">w_{5} = 0^{s}t_{1, 1}t_{1, 2} \ldots t_{1,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex><tex dpi="130">t_{2, 1}t_{2, 2} \ldots t_{\log\log n,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex>. В итоге используется <tex dpi="130">O(\log\log n)</tex> времени для упаковки <tex dpi="130">\log\log n</tex> контейнеров. Считаем, что время, потраченное на один контейнер — константа.<br />
<br />
==См. также==<br />
* [[Сортировка подсчетом]]<br />
* [[Цифровая сортировка]]<br />
<br />
==Источники информации==<br />
* [http://www.sciencedirect.com/science/article/pii/S019667740300155X Deterministic Sorting in O(n log log n) Time and Linear Space. Yijie Han.]<br />
* А. Андерссон. Fast deterministic sorting and searching in linear space. Proc. 1996 IEEE Symp. on Foundations of Computer Science. 135-141(1996)<br />
* [http://dl.acm.org/citation.cfm?id=1236460 A. Andersson, M. Thorup. Dynamic ordered sets with exponential search trees.]<br />
* [[wikipedia:en:Integer_sorting|Wikipedia {{---}} Integer sorting]]<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Сортировка]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D0%A5%D0%B0%D0%BD%D0%B0&diff=48001Сортировка Хана2015-06-07T17:27:49Z<p>6yry6e: </p>
<hr />
<div>'''Сортировка Хана''' (англ. ''Hansort'') {{---}} сложный алгоритм сортировки целых чисел со сложностью <tex dpi="130">O(n \log\log n)</tex>, где <tex dpi="130">n</tex> {{---}} количество элементов для сортировки.<br />
<br />
Данная статья писалась на основе брошюры Хана (англ. ''Yijie Han''), посвященной этой сортировке.<br />
<br />
== Описание ==<br />
Алгоритм построен на основе '''экспоненциального поискового дерева Андерсона''' (англ. ''Andersson's exponential search tree''). Сортировка происходит за счет вставки целых чисел в экспоненциальное поисковое дерево (''далее {{---}} ЭП-дерево'').<br />
<br />
== Экспоненциальное поисковое дерево Андерсона ==<br />
<br />
{{Определение<br />
|definition = '''ЭП-дерево''' {{---}} это дерево поиска, в котором все ключи хранятся в листьях этого дерева и количество детей у каждого узла уменьшается экспоненциально от глубины узла.<br />
}}<br />
<br />
[[Файл:Exp-tree.png|400px|thumb|right|Общая структура ЭП-дерева]]<br />
<br />
Структура ЭП-дерева:<br />
<br />
1) Корень имеет <tex dpi="130">\Theta (n^e)</tex> сыновей <tex dpi="130">( 0 < e < 1 )</tex>. Все сыновья являются ЭП-деревьями.<br />
<br />
2) Каждое поддерево корня имеет <tex dpi="130">\Theta(n^{1-e})</tex> сыновей.<br />
<br />
В этом дереве <tex dpi="130">O(n \log\log n)</tex> уровней. При нарушении баланса дерева необходимо балансирование, которое требует <tex dpi="130">O(n \log\log n)</tex> времени при <tex dpi="130">n</tex> вставленных целых числах. Такое время достигается за счет вставки чисел группами, а не поодиночке, как изначально предлагал Андерссон.<br />
<br />
==Определения== <br />
{{ Определение | definition =<br />
'''Контейнер''' {{---}} объект, в которым хранятся наши данные. Например: 32-битные и 64-битные числа, массивы, вектора.}}<br />
{{ Определение | definition =<br />
Алгоритм, сортирующий <tex dpi="130">n</tex> целых чисел из множества <tex dpi="130">\{0, 1, \ldots, m - 1\}</tex>, называется '''консервативным''', если длина контейнера (число бит в контейнере) равна <tex dpi="130">O(\log(m + n))</tex>. Если длина больше, то алгоритм '''неконсервативный'''.<br />
}}<br />
{{ Определение | definition =<br />
Если сортируются целые числа из множества <tex dpi="130">\{0, 1, \ldots, m - 1\}</tex> с длиной контейнера <tex dpi="130">k \log (m + n)</tex> с <tex dpi="130">k \geqslant 1</tex>, тогда сортировка происходит с '''неконсервативным преимуществом''' <tex dpi="130">k</tex>.<br />
}}<br />
{{ Определение | definition =<br />
Для множества <tex dpi="130">S</tex> определим<br />
<br />
<tex dpi="130">\min(S) = \min\limits_{a \in S} a</tex> <br />
<br />
<tex dpi="130">\max(S) = \max\limits_{a \in S} a</tex><br />
<br />
Набор <tex dpi="130">S1 < S2</tex> если <tex dpi="130">\max(S1) \leqslant \min(S2)</tex><br />
}}<br />
<br />
{{ Определение | definition =<br />
Предположим, есть набор <tex dpi="130">T</tex> из <tex dpi="130">p</tex> чисел, которые уже отсортированы как <tex dpi="130">a_{1}, a_{2}, \ldots, a_{p}</tex> и набор <tex dpi="130">S</tex> из <tex dpi="130">q</tex> чисел <tex dpi="130">b_{1}, b_{2}, \ldots, b_{q}</tex>. Тогда '''разделением''' <tex dpi="130">q</tex> чисел <tex dpi="130">p</tex> числами называется <tex dpi="130">p + 1</tex> набор <tex dpi="130">S_{0}, S_{1}, \ldots, S_{p}</tex>, где <tex dpi="130">S_{0} < a_{1} < S_{1} < \ldots < a_{p} < S_{p}</tex>.<br />
}}<br />
<br />
==Леммы==<br />
<br />
{{Лемма<br />
|id = lemma1<br />
|about = № 1<br />
|statement = <br />
Даны целые числа <tex dpi="130">b \geqslant s \geqslant 0</tex>, и <tex dpi="130">T</tex> является подмножеством множества <tex dpi="130">\{0, \ldots, 2^b - 1\}</tex>, содержащим <tex dpi="130">n</tex> элементов, и <tex dpi="130">t \geqslant 2^{-s + 1}С^k_{n}</tex>. Функция <tex dpi="130">h_{a}</tex>, принадлежащая <tex dpi="130">H_{b,s}</tex>, может быть выбрана за время <tex dpi="130">O(bn^2)</tex> так, что количество коллизий <tex dpi="130">coll(h_{a}, T) \leqslant t</tex>.<br />
}}<br />
<br />
{{Лемма<br />
|id = lemma2<br />
|about = № 2<br />
|statement = <br />
Выбор <tex dpi="130">s</tex>-ого наибольшего числа среди <tex dpi="130">n</tex> чисел, упакованных в <tex dpi="150">\frac{n}{g}</tex> контейнеров, может быть сделан за время <tex dpi="150">O(\frac{n \log g}{g})</tex> и с использованием <tex dpi="150">O(\frac{n}{g})</tex> памяти. В том числе, так может быть найдена медиана.<br />
<br />
|proof = <br />
Так как возможно делать попарное сравнение <tex dpi="130">g</tex> чисел в одном контейнере с <tex dpi="130">g</tex> числами в другом и извлекать большие числа из одного контейнера и меньшие из другого за константное время, возможно упаковать медианы из первого, второго, <tex dpi="130">\ldots</tex>, <tex dpi="130">g</tex>-ого чисел из 5 контейнеров в один контейнер за константное время. Таким образом, набор <tex dpi="130">S</tex> из медиан теперь содержится в <tex dpi="150">\frac{n}{5g}</tex> контейнерах. Рекурсивно находим медиану <tex dpi="130">m</tex> в <tex dpi="130">S</tex>. Используя <tex dpi="130">m</tex>, уберем хотя бы <tex dpi="150">\frac{n}{4}</tex> чисел среди <tex dpi="130">n</tex>. Затем упакуем оставшиеся из <tex dpi="150">\frac{n}{g}</tex> контейнеров в <tex dpi="150">\frac{3n}{4g}</tex> контейнеров и затем продолжим рекурсию.<br />
}}<br />
<br />
{{Лемма<br />
|id = lemma3<br />
|about = № 3<br />
|statement = <br />
Если <tex dpi="130">g</tex> целых чисел, в сумме использующих <tex dpi="150">\frac{\log n}{2}</tex> бит, упакованы в один контейнер, тогда <tex dpi="130">n</tex> чисел в <tex dpi="150">\frac{n}{g}</tex> контейнерах могут быть отсортированы за время <tex dpi="150">O(\frac{n \log g}{g})</tex> с использованием <tex dpi="150">O(\frac{n}{g})</tex> памяти.<br />
<br />
<br />
|proof = <br />
Так как используется только <tex dpi="150">\frac{\log n}{2}</tex> бит в каждом контейнере для хранения <tex dpi="130">g</tex> чисел, используем bucket sort, чтобы отсортировать все контейнеры, представляя каждый как число, что занимает <tex dpi="150">O(\frac{n}{g})</tex> времени и памяти. Так как используется <tex dpi="150">\frac{\log n}{2}</tex> бит на контейнер, понадобится <tex dpi="130">\sqrt{n}</tex> шаблонов для всех контейнеров. Затем поместим <tex dpi="150">g < \frac{\log n}{2}</tex> контейнеров с одинаковым шаблоном в одну группу. Для каждого шаблона останется не более <tex dpi="130">g - 1</tex> контейнеров, которые не смогут образовать группу. Поэтому не более <tex dpi="130">\sqrt{n}(g - 1)</tex> контейнеров не смогут сформировать группу. Для каждой группы помещаем <tex dpi="130">i</tex>-е число во всех <tex dpi="130">g</tex> контейнерах в один. Таким образом берутся <tex dpi="130">g</tex> <tex dpi="130">g</tex>-целых векторов и получаются <tex dpi="130">g</tex> <tex dpi="130">g</tex>-целых векторов, где <tex dpi="130">i</tex>-ый вектор содержит <tex dpi="130">i</tex>-ое число из входящего вектора. Эта транспозиция может быть сделана за время <tex dpi="130">O(g \log g)</tex>, с использованием <tex dpi="130">O(g)</tex> памяти. Для всех групп это занимает время <tex dpi="150">O(\frac{n \log g}{g})</tex>, с использованием <tex dpi="150">O(\frac{n}{g})</tex> памяти.<br />
<br />
Для контейнеров вне групп (которых <tex dpi="130">\sqrt{n}(g - 1)</tex> штук) разбираем и собираем заново контейнеры. На это потребуется не более <tex dpi="150">O(\frac{n}{g})</tex> времени и памяти. После всего этого используем карманную сортировку вновь для сортировки <tex dpi="130">n</tex> контейнеров. Таким образом, все числа отсортированы.<br />
<br />
<br />
Заметим, что когда <tex dpi="130">g = O( \log n)</tex>, сортировка <tex dpi="130">O(n)</tex> чисел в <tex dpi="150">\frac{n}{g}</tex> контейнеров произойдет за время <tex dpi="150">O((\frac{n}{g})</tex> <tex dpi="130">\log\log n)</tex> с использованием <tex dpi="150">O(\frac{n}{g})</tex> памяти. Выгода очевидна.<br />
}}<br />
<br />
{{Лемма<br />
|id = lemma4<br />
|about = № 4<br />
|statement = <br />
Примем, что каждый контейнер содержит <tex dpi="130"> \log m > \log n</tex> бит, и <tex dpi="130">g</tex> чисел, в каждом из которых <tex dpi="150">\frac{\log m}{g}</tex> бит, упакованы в один контейнер. Если каждое число имеет маркер, содержащий <tex dpi="150">\frac{\log n}{2g}</tex> бит, и <tex dpi="130">g</tex> маркеров упакованы в один контейнер таким же образом<tex dpi="130">^*</tex>, что и числа, тогда <tex dpi="130">n</tex> чисел в <tex dpi="150">\frac{n}{g}</tex> контейнерах могут быть отсортированы по их маркерам за время <tex dpi="150">O(\frac{n \log\log n}{g})</tex> с использованием <tex dpi="150">O(\frac{n}{g})</tex> памяти.<br />
(*): если число <tex dpi="130">a</tex> упаковано как <tex dpi="130">s</tex>-ое число в <tex dpi="130">t</tex>-ом контейнере для чисел, тогда маркер для <tex dpi="130">a</tex> упакован как <tex dpi="130">s</tex>-ый маркер в <tex dpi="130">t</tex>-ом контейнере для маркеров.<br />
<br />
<br />
|proof = <br />
Контейнеры для маркеров могут быть отсортированы с помощью bucket sort потому, что каждый контейнер использует <tex dpi="150">\frac{\log n}{2}</tex> бит. Сортировка сгруппирует контейнеры для чисел как в [[#lemma3|лемме №3]]. Перемещаем каждую группу контейнеров для чисел.<br />
}}<br />
<br />
{{Лемма<br />
|id = lemma5<br />
|about = № 5<br />
|statement =<br />
Предположим, что каждый контейнер содержит <tex dpi="130">\log m \log\log n > \log n</tex> бит, что <tex dpi="130">g</tex> чисел, в каждом из которых <tex dpi="150">\frac{\log m}{g}</tex> бит, упакованы в один контейнер, что каждое число имеет маркер, содержащий <tex dpi="150">\frac{\log n}{2g}</tex> бит, и что <tex dpi="130">g</tex> маркеров упакованы в один контейнер тем же образом что и числа. Тогда <tex dpi="130">n</tex> чисел в <tex dpi="150">\frac{n}{g}</tex> контейнерах могут быть отсортированы по своим маркерам за время <tex dpi="150">O(\frac{n}{g})</tex> с использованием <tex dpi="150">O(\frac{n}{g})</tex> памяти.<br />
<br />
|proof = <br />
Заметим, что несмотря на то, что длина контейнера <tex dpi="130">\log m \log\log n</tex> бит, всего <tex dpi="130">\log m</tex> бит используется для хранения упакованных чисел. Так же как в [[#lemma3|лемме №3]] и [[#lemma4|лемме №4]] сортируем контейнеры упакованных маркеров с помощью bucket sort. Для того, чтобы перемещать контейнеры чисел, помещаем <tex dpi="130">g \log\log n</tex> вместо <tex dpi="130">g</tex> контейнеров чисел в одну группу. Для транспозиции чисел в группе, содержащей <tex dpi="130">g \log\log n</tex> контейнеров, упаковываем <tex dpi="130">g \log\log n</tex> контейнеров в <tex dpi="130">g</tex>, упаковывая <tex dpi="130">\log\log n</tex> контейнеров в один. Далее делаем транспозицию над <tex dpi="130">g</tex> контейнерами. Таким образом перемещение занимает всего <tex dpi="130">O(g \log\log n)</tex> времени для каждой группы и <tex dpi="150">O(\frac{n}{g})</tex> времени для всех чисел. После завершения транспозиции, распаковываем <tex dpi="130">g</tex> контейнеров в <tex dpi="130">g \log\log n</tex> контейнеров.<br />
<br />
<br />
Заметим, что если длина контейнера <tex dpi="130">\log m \log\log n</tex> и только <tex dpi="130">\log m</tex> бит используется для упаковки <tex dpi="130">g \leqslant \log n</tex> чисел в один контейнер, тогда выбор в [[#lemma2|лемме №2]] может быть сделан за время и память <tex dpi="150">O(\frac{n}{g})</tex>, потому что упаковка в доказательстве [[#lemma2|лемме №2]] теперь может быть сделана за время <tex dpi="150">O(\frac{n}{g})</tex>.<br />
}}<br />
<br />
<br />
{{Лемма<br />
|id = lemma6<br />
|about = № 6<br />
|statement = <br />
<tex dpi="130">n</tex> целых чисел можно отсортировать в <tex dpi="130">\sqrt{n}</tex> наборов <tex dpi="130">S_{1}</tex>, <tex dpi="130">S_{2}</tex>, <tex dpi="130">\ldots</tex>, <tex dpi="130">S_{\sqrt{n}}</tex> таким образом, что в каждом наборе <tex dpi="130">\sqrt{n}</tex> чисел и <tex dpi="130">S_{i} < S_{j}</tex> при <tex dpi="130">i < j</tex>, за время <tex dpi="150">O(\frac{n \log\log n} {\log k})</tex> и место <tex dpi="130">O(n)</tex> с неконсервативным преимуществом <tex dpi="130">k \log\log n</tex>.<br />
<br />
<br />
|proof = <br />
Алгоритм сортировки <tex dpi="130">n</tex> целых чисел в <tex dpi="130">\sqrt{n}</tex> наборов, представленный ниже, является доказательством данной леммы. <br />
<br />
Постановка задачи и решение некоторых проблем:<br />
<br />
<br />
Рассмотрим проблему сортировки <tex dpi="130">n</tex> целых чисел из множества <tex dpi="130">\{0, 1, \ldots, m - 1\}</tex> в <tex dpi="130">\sqrt{n}</tex> наборов, как в условии леммы. Предполагаем, что каждый контейнер содержит <tex dpi="130">k \log\log n \log m</tex> бит и хранит число в <tex dpi="130">\log m</tex> бит. Поэтому неконсервативное преимущество {{---}} <tex dpi="130">k \log \log n</tex>. Также предполагаем, что <tex dpi="130">\log m \geqslant \log n \log\log n</tex>. Иначе можно использовать radix sort для сортировки за время <tex dpi="130">O(n \log\log n)</tex> и линейную память. Делим <tex dpi="130">\log m</tex> бит, используемых для представления каждого числа, в <tex dpi="130">\log n</tex> блоков. Таким образом, каждый блок содержит как минимум <tex dpi="130">\log\log n</tex> бит. <tex dpi="130">i</tex>-ый блок содержит с <br />
<tex dpi="150">\frac{i \log m} {\log n}</tex>-ого по <tex dpi="150">(\frac{(i + 1) \log m} {\log n - 1})</tex>-ый биты. Биты считаются с наименьшего бита, начиная с нуля. Теперь у нас имеется <tex dpi="130">2 \log n</tex>-уровневый алгоритм, который работает следующим образом:<br />
<br />
<br />
На каждой стадии работаем с одним блоком бит. Назовем эти блоки маленькими числами (далее м.ч.), потому что каждое м.ч. теперь содержит только <tex dpi="150">\frac{\log m}{\log n}</tex> бит. Каждое число представлено и соотносится с м.ч., над которым работаем в данный момент. Положим, что нулевая стадия работает с самым большим блоком (блок номер <tex dpi="130">\log n - 1</tex>). Предполагаем, что биты этих м.ч. упакованы в <tex dpi="150">\frac{n}{\log n}</tex> контейнеров с <tex dpi="130">\log n</tex> м.ч. упакованными в один контейнер. Пренебрегая временем, потраченным на эту упаковку, считаем, что она бесплатна. По [[#lemma2|лемме №2]] находим медиану этих <tex dpi="130">n</tex> м.ч. за время и память <tex dpi="150">O(\frac{n}{\log n})</tex>. Пусть <tex dpi="130">a</tex> {{---}} это найденная медиана. Тогда <tex dpi="130">n</tex> м.ч. могут быть разделены на не более чем три группы: <tex dpi="130">S_{1}</tex>, <tex dpi="130">S_{2}</tex> и <tex dpi="130">S_{3}</tex>. <tex dpi="130">S_{1}</tex> содержит м.ч., которые меньше <tex dpi="130">a</tex>, <tex dpi="130">S_{2}</tex> содержит м.ч., равные <tex dpi="130">a</tex>, <tex dpi="130">S_{3}</tex> содержит м.ч., большие <tex dpi="130">a</tex>. Также мощность <tex dpi="130">S_{1}</tex> и <tex dpi="130">S_{3} </tex> не превосходит <tex dpi="130">n/2</tex>. Мощность <tex dpi="130">S_{2}</tex> может быть любой. Пусть <tex dpi="130">S'_{2}</tex> {{---}} это набор чисел, у которых наибольший блок находится в <tex dpi="130">S_{2}</tex>. Тогда убираем из дальнейшего рассмотрения <tex dpi="150">\frac{\log m}{\log n}</tex> бит (наибольший блок) из каждого числа, принадлежащего <tex dpi="130">S'_{2}</tex>. Таким образом, после первой стадии каждое число находится в наборе размера не большего половины размера начального набора или один из блоков в числе убран из дальнейшего рассмотрения. Так как в каждом числе только <tex dpi="130">\log n</tex> блоков, для каждого числа потребуется не более <tex dpi="130">\log n</tex> стадий, чтобы поместить его в набор половинного размера. За <tex dpi="130">2 \log n</tex> стадий все числа будут отсортированы. Так как на каждой стадии работаем с <tex dpi="150">\frac{n}{\log n}</tex> контейнерами, то игнорируя время, необходимое на упаковку м.ч. в контейнеры и помещение м.ч. в нужный набор, затрачивается <tex dpi="130">O(n)</tex> времени из-за <tex dpi="130">2 \log n</tex> стадий.<br />
<br />
<br />
Сложная часть алгоритма заключается в том, как поместить м.ч. в набор, которому принадлежит соответствующее число, после предыдущих операций деления набора в нашем алгоритме. Предположим, что <tex dpi="130">n</tex> чисел уже поделены в <tex dpi="130">e</tex> наборов. Используем <tex dpi="130">\log e</tex> битов чтобы сделать марки для каждого набора. Теперь используем [[#lemma5|лемме №5]]. Полный размер маркера для каждого контейнера должен быть <tex dpi="150">\frac{\log n}{2}</tex>, и маркер использует <tex dpi="130">\log e</tex> бит, значит количество маркеров <tex dpi="130">g</tex> в каждом контейнере должно быть не более <tex dpi="150">\frac{\log n}{2\log e}</tex>. В дальнейшем, так как <tex dpi="150">g = \frac{\log n}{2 \log e}</tex>, м.ч. должны влезать в контейнер. Каждый контейнер содержит <tex dpi="130">k \log\log n \log n</tex> блоков, каждое м.ч. может содержать <tex dpi="150">O(\frac{k \log n}{g}) = O(k \log e)</tex> блоков. Заметим, что используется неконсервативное преимущество в <tex dpi="130">\log\log n</tex> для [[#lemma5|лемме №5]] Поэтому предполагается, что <tex dpi="150">\frac{\log n}{2 \log e}</tex> м.ч., в каждом из которых <tex dpi="130">k \log e</tex> блоков битов числа, упакованны в один контейнер. Для каждого м.ч. используется маркер из <tex dpi="130">\log e</tex> бит, который показывает, к какому набору он принадлежит. Предполагаем, что маркеры так же упакованы в контейнеры, как и м.ч. Так как каждый контейнер для маркеров содержит <tex dpi="150">\frac{\log n}{2 \log e}</tex> маркеров, то для каждого контейнера требуется <tex dpi="150">\frac{\log n}{2}</tex> бит. Таким образом, [[#lemma5|лемма №5]] может быть применена для помещения м.ч. в наборы, которым они принадлежат. Так как используется <tex dpi="150">O(\frac{n \log e}{ \log n})</tex> контейнеров, то время, необходимое для помещения м.ч. в их наборы, равно <tex dpi="150">O(\frac{n \log e}{ \log n})</tex>.<br />
<br />
Стоит отметить, что процесс помещения нестабилен, т.к. основан на алгоритме из [[#lemma5|леммы №5]].<br />
<br />
<br />
При таком помещении сразу возникает следующая проблема.<br />
<br />
Рассмотрим число <tex dpi="130">a</tex>, которое является <tex dpi="130">i</tex>-ым в наборе <tex dpi="130">S</tex>. Рассмотрим блок <tex dpi="130">a</tex> (назовем его <tex dpi="130">a'</tex>), который является <tex dpi="130">i</tex>-ым м.ч. в <tex dpi="130">S</tex>. Когда используется вышеописанный метод перемещения нескольких следующих блоков <tex dpi="130">a</tex> (назовем это <tex dpi="130">a''</tex>) в <tex dpi="130">S</tex>, <tex dpi="130">a''</tex> просто перемещен на позицию в наборе <tex dpi="130">S</tex>, но не обязательно на позицию <tex dpi="130">i</tex> (где расположен <tex dpi="130">a'</tex>). Если значение блока <tex dpi="130">a'</tex> одинаково для всех чисел в <tex dpi="130">S</tex>, то это не создаст проблемы потому, что блок одинаков вне зависимости от того в какое место в <tex dpi="130">S</tex> помещен <tex dpi="130">a''</tex>. Иначе у нас возникает проблема дальнейшей сортировки. Поэтому поступаем следующим образом: На каждой стадии числа в одном наборе работают на общем блоке, который назовем "текущий блок набора". Блоки, которые предшествуют текущему блоку содержат важные биты и идентичны для всех чисел в наборе. Когда помещаем больше бит в набор, последующие блоки помещаются в набор вместе с текущим блоком. Так вот, в вышеописанном процессе помещения предполагается, что самый значимый блок среди <tex dpi="130">k \log e</tex> блоков {{---}} это текущий блок. Таким образом, после того, как эти <tex dpi="130">k \log e</tex> блоков помещены в набор, изначальный текущий блок удаляется, потому что известно, что эти <tex dpi="130">k \log e</tex> блоков перемещены в правильный набор, и нам не важно где находился начальный текущий блок. Тот текущий блок находится в перемещенных <tex dpi="130">k \log e</tex> блоках.<br />
<br />
<br />
Стоит отметить, что после нескольких уровней деления размер наборов станет маленьким. Леммы [[#lemma3|3]], [[#lemma4|4]], [[#lemma5|5]] расчитаны на не очень маленькие наборы. Но поскольку сортируется набор из <tex dpi="130">n</tex> элементов в наборы размера <tex dpi="130">\sqrt{n}</tex>, то проблем быть не должно.<br />
<br />
<br />
===Алгоритм сортировки===<br />
<br />
Algorithm <tex>Sort(advantage</tex>, <tex>level</tex>, <tex>a_{0}</tex>, <tex>a_{1}</tex>, <tex>\ldots</tex>, <tex>a_{t}</tex>)<br />
<br />
<tex>advantage</tex> {{---}} это неконсервативное преимущество равное <tex>k\log\log n</tex>, <tex>a_{i}</tex>-ые это входящие целые числа в наборе, которые надо отсортировать, <tex>level</tex> это уровень рекурсии.<br />
<br />
# Если <tex>level</tex> равен <tex>1</tex> тогда изучаем размер набора. Если размер меньше или равен <tex>\sqrt{n}</tex>, то <tex>return</tex>. Иначе делим этот набор в <tex>\leqslant</tex> 3 набора, используя [[#lemma2|лемму №2]], чтобы найти медиану, а затем используем [[#lemma5|лемму №5]] для сортировки. Для набора, где все элементы равны медиане, не рассматриваем текущий блок и текущим блоком делаем следующий. Создаем маркер, являющийся номером набора для каждого из чисел (0, 1 или 2). Затем направляем маркер для каждого числа назад к месту, где число находилось в начале. Также направляем двубитное число для каждого входного числа, указывающее на текущий блок.<br />
# От <tex dpi="130">u = 1</tex> до <tex dpi="130">k</tex><br />
## Упаковываем <tex dpi="130">a^{(u)}_{i}</tex>-ый в часть из <tex dpi="130">1/k</tex>-ых номеров контейнеров. Где <tex dpi="130">a^{(u)}_{i}</tex> содержит несколько непрерывных блоков, которые состоят из <tex dpi="150">\frac{1}{k}</tex>-ых битов <tex dpi="130">a_{i}</tex>. При этом у <tex dpi="130">a^{(u)}_{i}</tex> текущий блок это самый крупный блок.<br />
## Вызываем <tex>Sort(advantage</tex>, <tex>level - 1</tex>, <tex dpi="130">a^{(u)}_{0}</tex>, <tex dpi="130">a^{(u)}_{1}</tex>, <tex>\ldots</tex>, <tex dpi="130">a^{(u)}_{t}</tex>). Когда алгоритм возвращается из этой рекурсии, маркер, показывающий для каждого числа, к какому набору это число относится, уже направлен назад к месту, где число находится во входных данных. Число, имеющее наибольшее число бит в <tex dpi="130">a_{i}</tex>, показывающее на текущий блок в нем, так же направлено назад к <tex dpi="130">a_{i}</tex>.<br />
## Отправляем <tex dpi="130">a_{i}</tex>-ые к их наборам, используя [[#lemma5|лемму №5]].<br />
<br />
Algorithm IterateSort<br />
Call <tex>Sort(advantage</tex>, <tex dpi="130">\log_{k}((\log n)/4)</tex>, <tex dpi="130">a_{0}</tex>, <tex dpi="130">a_{1}</tex>, <tex dpi="130">\ldots</tex>, <tex dpi="130">a_{n - 1}</tex>);<br />
<br />
от 1 до 5<br />
# Помещаем <tex dpi="130">a_{i}</tex> в соответствующий набор с помощью блочной сортировки (англ. ''bucket sort''), потому что наборов около <tex dpi="130">\sqrt{n}</tex>.<br />
# Для каждого набора <tex dpi="130">S = </tex>{<tex dpi="130">a_{i_{0}}, a_{i_{1}}, \ldots, a_{i_{t}}</tex>}, если <tex dpi="130">t > \sqrt{n}</tex>, вызываем <tex>Sort(advantage</tex>, <tex dpi="130">\log_{k}(\frac{\log n}{4})</tex>, <tex dpi="130">a_{i_{0}}, a_{i_{1}}, \ldots, a_{i_{t}}</tex>).<br />
<br />
Время работы алгоритма <tex dpi="150">O(\frac{n \log\log n}{\log k})</tex>, что доказывает лемму.<br />
}}<br />
<br />
<br />
<br />
==Уменьшение числа бит в числах==<br />
Один из способов ускорить сортировку {{---}} уменьшить число бит в числе. Один из способов уменьшить число бит в числе {{---}} использовать деление пополам (эту идею впервые подал van Emde Boas). Деление пополам заключается в том, что количество оставшихся бит в числе уменьшается в 2 раза. Это быстрый способ, требующий <tex dpi="130">O(m)</tex> памяти. Для своего дерева Андерссон использует хеширование, что позволяет сократить количество памяти до <tex dpi="130">O(n)</tex>. Для того чтобы еще ускорить алгоритм, необходимо упаковать несколько чисел в один контейнер, чтобы затем за константное количество шагов произвести хеширование для всех чисел, хранимых в контейнере. Для этого используется хеш-функция для хеширования <tex dpi="130">n</tex> чисел в таблицу размера <tex dpi="130">O(n^2)</tex> за константное время без коллизий. Для этого используется модифицированная хеш-функция авторства: Dierzfelbinger и Raman.<br />
<br />
<br />
Алгоритм: Пусть целое число <tex dpi="130">b \geqslant 0</tex> и пусть <tex dpi="130">U = \{0, \ldots, 2^b - 1\}</tex>. Класс <tex dpi="130">H_{b,s}</tex> хеш-функций из <tex dpi="130">U</tex> в <tex dpi="130">\{0, \ldots, 2^s - 1\}</tex> определен как <tex dpi="130">H_{b,s} = \{h_{a} \mid 0 < a < 2^b, a \equiv 1 (\bmod 2)\}</tex> и для всех <tex dpi="130">x</tex> из <tex dpi="130">U</tex>: <tex dpi="130">h_{a}(x) = (ax</tex> <tex dpi="130">\bmod</tex> <tex dpi="130">2^b)</tex> <tex dpi="130">div</tex> <tex dpi="130">2^{b - s}</tex>.<br />
<br />
Данный алгоритм базируется на [[#lemma1|лемме №1]].<br />
<br />
<br />
Взяв <tex dpi="130">s = 2 \log n</tex>, получаем хеш-функцию <tex dpi="130">h_{a}</tex>, которая захеширует <tex dpi="130">n</tex> чисел из <tex dpi="130">U</tex> в таблицу размера <tex dpi="130">O(n^2)</tex> без коллизий. Очевидно, что <tex dpi="130">h_{a}(x)</tex> может быть посчитана для любого <tex dpi="130">x</tex> за константное время. Если упаковать несколько чисел в один контейнер так, что они разделены несколькими битами нулей, то можно применить <tex dpi="130">h_{a}</tex> ко всему контейнеру, и в результате все хеш-значения для всех чисел в контейнере будут посчитаны. Заметим, что это возможно только потому, что в вычисление хеш-значения вовлечены только (<tex dpi="130">\bmod</tex> <tex dpi="130">2^b</tex>) и (<tex dpi="130">div</tex> <tex dpi="130">2^{b - s}</tex>). <br />
<br />
<br />
Такая хеш-функция может быть найдена за <tex dpi="130">O(n^3)</tex>.<br />
<br />
Следует отметить, что, несмотря на размер таблицы <tex dpi="130">O(n^2)</tex>, потребность в памяти не превышает <tex dpi="130">O(n)</tex>, потому что хеширование используется только для уменьшения количества бит в числе.<br />
<br />
==Сортировка по ключу==<br />
Предположим, что <tex dpi="130">n</tex> чисел должны быть отсортированы, и в каждом <tex dpi="130">\log m</tex> бит. Будем считать, что в каждом числе есть <tex dpi="130">h</tex> сегментов, в каждом из которых <tex dpi="130">\log m/h</tex> бит. Теперь применяем хеширование ко всем сегментам и получаем <tex dpi="130">2h \log n</tex> бит хешированных значений для каждого числа. После сортировки на хешированных значениях для всех начальных чисел начальная задача по сортировке <tex dpi="130">n</tex> чисел по <tex dpi="130">\log m</tex> бит в каждом стала задачей по сортировке <tex dpi="130">n</tex> чисел по <tex dpi="130">\log m/h</tex> бит в каждом.<br />
<br />
<br />
Также рассмотрим проблему последующего разделения. Пусть <tex dpi="130">a_{1}</tex>, <tex dpi="130">a_{2}</tex>, <tex dpi="130">\ldots</tex>, <tex dpi="130">a_{p}</tex> {{---}} <tex dpi="130">p</tex> чисел и <tex dpi="130">S</tex> {{---}} множество чисeл. Необходимо разделить <tex dpi="130">S</tex> в <tex dpi="130">p + 1</tex> наборов, таких, что: <tex dpi="130">S_{0} < a_{1} < S_{1} < a_{2} < \ldots < a_{p} < S_{p}</tex>. Так как используется '''сортировка по ключу''' (англ. ''signature sorting'') то перед тем, как делать вышеописанное разделение, необходимо поделить биты в <tex dpi="130">a_{i}</tex> на <tex dpi="130">h</tex> сегментов и взять некоторые из них. Так же делим биты для каждого числа из <tex dpi="130">S</tex> и оставляем только один в каждом числе. По существу, для каждого <tex dpi="130">a_{i}</tex> берутся все <tex dpi="130">h</tex> сегментов. Если соответствующие сегменты <tex dpi="130">a_{i}</tex> и <tex dpi="130">a_{j}</tex> совпадают, то нам понадобится только один. Сегмент, который берется для числа в <tex dpi="130">S</tex> это сегмент, который выделяется из <tex dpi="130">a_{i}</tex>. Таким образом, начальная задача о разделении <tex dpi="130">n</tex> чисел по <tex dpi="130">\log m</tex> бит преобразуется в несколько задач на разделение с числами по <tex dpi="150">\frac{\log m}{h}</tex> бит.<br />
<br />
<br />
'''Пример''':<br />
[[Файл:Han-example.png|500px|thumb]]<br />
<br />
<tex dpi="130">a_{1} = 3, a_{2} = 5, a_{3} = 7, a_{4} = 10, S = \{1, 4, 6, 8, 9, 13, 14\}</tex>.<br />
<br />
Делим числа на два сегмента. Для <tex dpi="130">a_{1}</tex> получим верхний сегмент <tex dpi="130">0</tex>, нижний <tex dpi="130">3</tex>; <tex dpi="130">a_{2}</tex> {{---}} верхний <tex dpi="130">1</tex>, нижний <tex dpi="130">1</tex>; <tex dpi="130">a_{3}</tex> {{---}} верхний <tex dpi="130">1</tex>, нижний <tex dpi="130">3</tex>; <tex dpi="130">a_{4}</tex> {{---}} верхний <tex dpi="130">2</tex>, нижний <tex dpi="130">2</tex>. Для элементов из S получим: для <tex dpi="130">1</tex> нижний <tex dpi="130">1</tex>, так как он выделяется из нижнего сегмента <tex dpi="130">a_{1}</tex>; для <tex dpi="130">4</tex> нижний <tex dpi="130">0</tex>; для <tex dpi="130">8</tex> нижний <tex dpi="130">0</tex>; для <tex dpi="130">9</tex> нижний <tex dpi="130">1</tex>; для <tex dpi="130">13</tex> верхний <tex dpi="130">3</tex>; для <tex dpi="130">14</tex> верхний <tex dpi="130">3</tex>. Теперь все верхние сегменты, нижние сегменты <tex dpi="130">1</tex> и <tex dpi="130">3</tex>, нижние сегменты <tex dpi="130">4, 5, 6, 7,</tex> нижние сегменты <tex dpi="130">8, 9, 10</tex> формируют <tex dpi="130">4</tex> новые задачи на разделение.<br />
<br />
<br />
<br />
Использование '''сортировки по ключу''' в данном алгоритме:<br />
<br />
Есть набор <tex dpi="130">T</tex> из <tex dpi="130">p</tex> чисел, которые отсортированы как <tex dpi="130">a_{1}, a_{2}, \ldots, a_{p}</tex>. Используем числа в <tex dpi="130">T</tex> для разделения набора <tex dpi="130">S</tex> из <tex dpi="130">q</tex> чисел <tex dpi="130">b_{1}, b_{2}, \ldots, b_{q}</tex> в <tex dpi="130">p + 1</tex> наборов <tex dpi="130">S_{0}, S_{1}, \ldots, S_{p}</tex>. Пусть <tex dpi="150">h = \frac{\log n}{c \log p}</tex> для константы <tex dpi="130">c > 1</tex>. (<tex dpi="150">\frac{h}{\log\log n \log p}</tex>)-битные числа могут храниться в одном контейнере, содержащим <tex dpi="150">\frac{\log n}{c \log\log n}</tex> бит. Сначала рассматриваем биты в каждом <tex dpi="130">a_{i}</tex> и каждом <tex dpi="130">b_{i}</tex> как сегменты одинаковой длины <tex dpi="150">\frac{h} {\log\log n}</tex>. Рассматриваем сегменты как числа. Чтобы получить неконсервативное преимущество для сортировки, числа в этих контейнерах (<tex dpi="130">a_{i}</tex>-ом и <tex dpi="130">b_{i}</tex>-ом) хешируются, и получается <tex dpi="150">\frac{h}{\log\log n}</tex> хешированных значений в одном контейнере. При вычислении хеш-значений сегменты не влияют друг на друга, можно даже отделить четные и нечетные сегменты в два контейнера. Не умаляя общности считаем, что хеш-значения считаются за константное время. Затем, посчитав значения, два контейнера объединяем в один. Пусть <tex dpi="130">a'_{i}</tex> {{---}} хеш-контейнер для <tex dpi="130">a_{i}</tex>, аналогично <tex dpi="130">b'_{i}</tex>. В сумме хеш-значения имеют <tex dpi="150">\frac{2 \log n}{c \log\log n}</tex> бит, хотя эти значения разделены на сегменты по <tex dpi="150">\frac{h}{ \log\log n}</tex> бит в каждом контейнере. Между сегментами получаются пустоты, которые забиваются нулями. Сначала упаковываются все сегменты в <tex dpi="150">\frac{2 \log n}{c \log\log n}</tex> бит. Потом рассматривается каждый хеш-контейнер как число, и эти хеш-контейнеры сортируются за линейное время (сортировка будет рассмотрена чуть позже). После этой сортировки биты в <tex dpi="130">a_{i}</tex> и <tex dpi="130">b_{i}</tex> разрезаны на <tex dpi="150">\frac{\log\log n}{h}</tex> сегментов. Таким образом, получилось дополнительное мультипликативное преимущество (англ. ''additional multiplicative advantage'') в <tex dpi="150">\frac{h} {\log\log n}</tex>.<br />
<br />
После того, как вышеописанный процесс повторится <tex dpi="130">g</tex> раз, получится неконсервативное преимущество в <tex dpi="150">(\frac{h} {\log\log n})^g</tex> раз, в то время как потрачено только <tex dpi="130">O(gqt)</tex> времени, так как каждое многократное деление происходит за линейное время <tex dpi="130">O(qt)</tex>.<br />
<br />
<br />
Хеш-функция, которая используется, находится следующим образом. Будут хешироватся сегменты, <tex dpi="150">\frac{\log\log n}{h}</tex>-ые, <tex dpi="150">(\frac{\log\log n}{h})^2</tex>-ые, <tex dpi="130">\ldots</tex> по счету в числе. Хеш-функцию для <tex dpi="150">(\frac{\log\log n}{h})^t</tex>-ых по счету сегментов, получаем нарезанием всех <tex dpi="130">p</tex> чисел на <tex dpi="150">(\frac{\log\log n}{h})^t</tex> сегментов. Рассматривая каждый сегмент как число, получаем <tex dpi="150">p(\frac{\log\log n}{h})^t</tex> чисел. Затем получаем одну хеш-функцию для этих чисел. Так как <tex dpi="130">t < \log n</tex>, то получится не более <tex dpi="130">\log n</tex> хеш-функций.<br />
<br />
<br />
Рассмотрим сортировку за линейное время, о которой было упомянуто ранее. Предполагается, что хешированные значения для каждого контейнера упакованы в <tex dpi="150">\frac{2 \log n}{c \log\log n}</tex> бит. Есть <tex dpi="130">t</tex> наборов, в каждом из которых <tex dpi="130">q + p</tex> хешированных контейнеров по <tex dpi="150">\frac{2 \log n}{c \log\log n}</tex> бит в каждом. Эти контейнеры должны быть отсортированы в каждом наборе. Комбинируя все хеш-контейнеры в один pool, сортируем следующим образом.<br />
<br />
<br />
Операция '''сортировки за линейное время''' (англ. ''Linear-Time-Sort'')<br />
<br />
Входные данные: <tex dpi="150">r > = n^{\frac{2}{5}}</tex> чисел <tex dpi="130">d_{i}</tex>, <tex dpi="130">d_{i}.value</tex> — значение числа <tex dpi="130">d_{i}</tex>, в котором <tex dpi="150">\frac{2 \log n}{c \log\log n}</tex> бит, <tex dpi="130">d_{i}.set</tex> — набор, в котором находится <tex dpi="130">d_{i}</tex>. Следует отметить, что всего есть <tex dpi="130">t</tex> наборов.<br />
<br />
# Сортируем все <tex dpi="130">d_{i}</tex> по <tex dpi="130">d_{i}.value</tex>, используя bucket sort. Пусть все отсортированные числа в <tex dpi="130">A[1..r]</tex>. Этот шаг занимает линейное время, так как сортируется не менее <tex dpi="150">n^{\frac{2}{5}}</tex> чисел.<br />
# Помещаем все <tex dpi="130">A[j]</tex> в <tex dpi="130">A[j].set</tex>.<br />
<br />
==Сортировка с использованием O(n log log n) времени и памяти==<br />
Для сортировки <tex dpi="130">n</tex> целых чисел в диапазоне <tex dpi="130">\{0, 1, \ldots, m - 1\}</tex> предполагается, что в нашем консервативном алгоритме используется контейнер длины <tex dpi="130">O(\log (m + n))</tex>. Далее везде считается, что все числа упакованы в контейнеры одинаковой длины. <br />
<br />
<br />
Берем <tex dpi="130">1/e = 5</tex> для ЭП-дерева Андерссона. Следовательно, у корня будет <tex dpi="150">n^{\frac{1}{5}}</tex> детей, и каждое ЭП-дерево в каждом ребенке будет иметь <tex dpi="150">n^{\frac{4}{5}}</tex> листьев. В отличие от оригинального дерева, за раз вставляется не один элемент, а <tex dpi="130">d^2</tex>, где <tex dpi="130">d</tex> — количество детей узла дерева, в котором числа должны спуститься вниз. Алгоритм полностью опускает все <tex dpi="130">d^2</tex> чисел на один уровень. В корне опускаются <tex dpi="150">n^{\frac{2}{5}}</tex> чисел на следующий уровень. После того, как все числа опустились на следующий уровень, они успешно разделились на <tex dpi="130">t_{1} = n^{1/5}</tex> наборов <tex dpi="130">S_{1}, S_{2}, \ldots, S_{t_{1}}</tex>, в каждом из которых <tex dpi="150">n^{\frac{4}{5}}</tex> чисел и <tex dpi="130">S_{i} < S_{j}, i < j</tex>. Затем, берутся <tex dpi="150">n^{\frac{8}{25}}</tex> чисел из <tex dpi="130">S_{i}</tex> и опускаются на следующий уровень ЭП-дерева. Это повторяется, пока все числа не опустятся на следующий уровень. На этом шаге числа разделены на <tex dpi="150">t_{2} = n^{\frac{1}{5}}n^{\frac{4}{25}} = n^{\frac{9}{25}}</tex> наборов <tex dpi="130">T_{1}, T_{2}, \ldots, T_{t_{2}}</tex>, аналогичных наборам <tex dpi="130">S_{i}</tex>, в каждом из которых <tex dpi="150">n^{\frac{16}{25}}</tex> чисел. Теперь числа опускаются дальше в ЭП-дереве.<br />
<br />
Нетрудно заметить, что перебалансирока занимает <tex dpi="130">O(n \log\log n)</tex> времени с <tex dpi="130">O(n)</tex> времени на уровень, аналогично стандартному ЭП-дереву Андерссона.<br />
<br />
<br />
Нам следует нумеровать уровни ЭП-дерева с корня, начиная с нуля. Рассмотрим спуск вниз на уровне <tex dpi="130">s</tex>. Имеется <tex dpi="150">t = n^{1 - (\frac{4}{5})^S}</tex> наборов по <tex dpi="150">n^{(\frac{4}{5})^S}</tex> чисел в каждом. Так как каждый узел на данном уровне имеет <tex dpi="150">p = n^{\frac{1}{5} \cdot (\frac{4}{5})^S}</tex> детей, то на <tex dpi="130">s + 1</tex> уровень опускаются <tex dpi="150">q = n^{\frac{2}{5} \cdot (\frac{4}{5})^S}</tex> чисел для каждого набора, или всего <tex dpi="150">qt \geqslant n^{\frac{2}{5}}</tex> чисел для всех наборов за один раз.<br />
<br />
<br />
Спуск вниз можно рассматривать как сортировку <tex dpi="130">q</tex> чисел в каждом наборе вместе с <tex dpi="130">p</tex> числами <tex dpi="130">a_{1}, a_{2}, \ldots, a_{p}</tex> из ЭП-дерева, так, что эти <tex dpi="130">q</tex> чисел разделены в <tex dpi="130">p + 1</tex> наборов <tex dpi="130">S_{0}, S_{1}, \ldots, S_{p}</tex> таких, что <tex dpi="130">S_{0} < a_{1} < \ldots < a_{p} < S_{p}</tex>.<br />
<br />
<br />
Так как <tex dpi="130">q</tex> чисел не надо полностью сортировать и <tex dpi="130">q = p^2</tex>, то можно использовать [[#lemma6|лемму №6]] для сортировки. Для этого необходимо неконсервативное преимущество, которое получается с помощью [[Сортировка Хана#Signature sorting|signature sorting]]. Для этого используется линейная техника многократного деления (англ. ''multi-dividing technique'').<br />
<br />
<br />
После <tex dpi="130">g</tex> сокращений бит в [[Сортировка Хана#Signature sorting|signature sorting]] получаем неконсервативное преимущество в <tex dpi="150">(\frac{h}{ \log\log n})^g</tex>. Мы не волнуемся об этих сокращениях до конца потому, что после получения неконсервативного преимущества мы можем переключиться на [[#lemma6|лемму №6]] для завершения разделения <tex dpi="130">q</tex> чисел с помощью <tex dpi="130">p</tex> чисел на наборы. Заметим, что по природе битового сокращения начальная задача разделения для каждого набора перешла в <tex dpi="130">w</tex> подзадач разделения на <tex dpi="130">w</tex> поднаборов для какого-то числа <tex dpi="130">w</tex>.<br />
<br />
<br />
Теперь для каждого набора все его поднаборы в подзадачах собираются в один набор. Затем, используя [[#lemma6|лемму №6]], делается разделение. Так как получено неконсервативное преимущество в <tex dpi="150">(\frac{h}{\log\log n})^g</tex> и работа происходит на уровнях не ниже, чем <tex dpi="130">2 \log\log\log n</tex>, то алгоритм занимает <tex dpi="150">O(\frac{qt \log\log n}{g(\log h - \log\log\log n) - \log\log\log n}) = O(\log\log n)</tex> времени.<br />
<br />
<br />
В итоге разделились <tex dpi="130">q</tex> чисел <tex dpi="130">p</tex> числами в каждый набор. То есть получилось, что <tex dpi="130">S_{0} < e_{1} < S_{1} < \ldots < e_{p} < S_{p}</tex>, где <tex dpi="130">e_{i}</tex> {{---}} сегмент <tex dpi="130">a_{i}</tex>, полученный с помощью битового сокращения. Такое разделение получилось комбинированием всех поднаборов в подзадачах. Предполагаем, что числа хранятся в массиве <tex dpi="130">B</tex> так, что числа в <tex dpi="130">S_{i}</tex> предшествуют числам в <tex dpi="130">S_{j}</tex> если <tex dpi="130">i < j</tex> и <tex dpi="130">e_{i}</tex> хранится после <tex dpi="130">S_{i - 1}</tex>, но до <tex dpi="130">S_{i}</tex>. <br />
<br />
<br />
Пусть <tex dpi="130">B[i]</tex> находится в поднаборе <tex dpi="130">B[i].subset</tex>. Чтобы позволить разделению выполниться, для каждого поднабора помещаем все <tex dpi="130">B[j]</tex> в <tex dpi="130">B[j].subset</tex>.<br />
<br />
На это потребуется линейное время и место.<br />
<br />
<br />
Теперь рассмотрим проблему упаковки, которая решается следующим образом. Считается, что число бит в контейнере <tex dpi="130">\log m \geqslant \log\log\log n</tex>, потому что в противном случае можно использовать radix sort для сортировки чисел. У контейнера есть <tex dpi="150">\frac{h}{\log\log n}</tex> хешированных значений (сегментов) в себе на уровне <tex dpi="130">\log h</tex> в ЭП-дереве. Полное число хешированных бит в контейнере равно <tex dpi="130">(2 \log n)(c \log\log n)</tex> бит. Хешированные биты в контейнере выглядят как <tex dpi="130">0^{i}t_{1}0^{i}t_{2} \ldots t</tex><tex dpi="150">_{\frac{h}{\log\log n}}</tex>, где <tex dpi="130">t_{k}</tex>-ые — хешированные биты, а нули {{---}} это просто нули. Сначала упаковываем <tex dpi="130">\log\log n</tex> контейнеров в один и получаем <tex dpi="130">w_{1} = 0^{j}t_{1, 1}t_{2, 1} \ldots t_{\log\log n, 1}0^{j}t_{1, 2} \ldots t_{\log\log n,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex>, где <tex dpi="130">t_{i, k}</tex>: элемент с номером <tex dpi="130">k = 1, 2, \ldots, </tex><tex dpi="150">\frac{h}{\log\log n}</tex> из <tex dpi="130">i</tex>-ого контейнера. Используем <tex dpi="130">O(\log\log n)</tex> шагов, чтобы упаковать <tex dpi="130">w_{1}</tex> в <tex dpi="130">w_{2} = 0</tex><tex dpi="150">^{\frac{jh}{\log\log n}}</tex><tex dpi="130">t_{1, 1}t_{2, 1} \ldots t_{\log\log n, 1}t_{1, 2}t_{2, 2} \ldots t_{1,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex><tex dpi="130">t_{2,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex><tex dpi="130">\ldots t_{\log\log n,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex>. Теперь упакованные хеш-биты занимают <tex dpi="130">2 \log</tex><tex dpi="150">\frac{n}{c}</tex> бит. Используем <tex dpi="130">O(\log\log n)</tex> времени чтобы распаковать <tex dpi="130">w_{2}</tex> в <tex dpi="130">\log\log n</tex> контейнеров <tex dpi="130">w_{3, k} = 0</tex><tex dpi="150">^{\frac{jh}{\log\log n}}</tex><tex dpi="130">0^{r}t_{k, 1}0^{r}t_{k, 2} \ldots t_{k,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex> <tex dpi="130">k = 1, 2, \ldots, \log\log n</tex>. Затем, используя <tex dpi="130">O(\log\log n)</tex> времени, упаковываем эти <tex dpi="130">\log\log n</tex> контейнеров в один <tex dpi="130">w_{4} = 0^{r}t_{1, 1}0^{r}t_{1, 2} \ldots t_{1,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex><tex dpi="130">0^{r}t_{2, 1} \ldots t_{\log\log n,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex>. Затем, используя <tex dpi="130">O(\log\log n)</tex> шагов, упаковываем <tex dpi="130">w_{4}</tex> в <tex dpi="130">w_{5} = 0^{s}t_{1, 1}t_{1, 2} \ldots t_{1,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex><tex dpi="130">t_{2, 1}t_{2, 2} \ldots t_{\log\log n,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex>. В итоге используется <tex dpi="130">O(\log\log n)</tex> времени для упаковки <tex dpi="130">\log\log n</tex> контейнеров. Считаем, что время, потраченное на один контейнер — константа.<br />
<br />
==См. также==<br />
* [[Сортировка подсчетом]]<br />
* [[Цифровая сортировка]]<br />
<br />
==Источники информации==<br />
* [http://www.sciencedirect.com/science/article/pii/S019667740300155X Deterministic Sorting in O(n log log n) Time and Linear Space. Yijie Han.]<br />
* А. Андерссон. Fast deterministic sorting and searching in linear space. Proc. 1996 IEEE Symp. on Foundations of Computer Science. 135-141(1996)<br />
* [http://dl.acm.org/citation.cfm?id=1236460 A. Andersson, M. Thorup. Dynamic ordered sets with exponential search trees.]<br />
* [[wikipedia:en:Integer_sorting|Wikipedia {{---}} Integer sorting]]<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Сортировка]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0_%D0%A5%D0%B0%D0%BD%D0%B0&diff=47999Сортировка Хана2015-06-07T17:24:07Z<p>6yry6e: </p>
<hr />
<div>'''Сортировка Хана''' (англ. ''Hansort'') {{---}} сложный алгоритм сортировки целых чисел со сложностью <tex dpi="130">O(n \log\log n)</tex>, где <tex dpi="130">n</tex> {{---}} количество элементов для сортировки.<br />
<br />
Данная статья писалась на основе брошюры Хана (англ. ''Yijie Han''), посвященной этой сортировке.<br />
<br />
== Описание ==<br />
Алгоритм построен на основе '''экспоненциального поискового дерева Андерсона''' (англ. ''Andersson's exponential search tree''). Сортировка происходит за счет вставки целых чисел в экспоненциальное поисковое дерево (''далее {{---}} ЭП-дерево'').<br />
<br />
== Экспоненциальное поисковое дерево Андерсона ==<br />
<br />
{{Определение<br />
|definition = '''ЭП-дерево''' {{---}} это дерево поиска, в котором все ключи хранятся в листьях этого дерева и количество детей у каждого узла уменьшается экспоненциально от глубины узла.<br />
}}<br />
<br />
[[Файл:Exp-tree.png|400px|thumb|right|Общая структура ЭП-дерева]]<br />
<br />
Структура ЭП-дерева:<br />
<br />
1) Корень имеет <tex dpi="130">\Theta (n^e)</tex> сыновей <tex dpi="130">( 0 < e < 1 )</tex>. Все сыновья являются ЭП-деревьями.<br />
<br />
2) Каждое поддерево корня имеет <tex dpi="130">\Theta(n^{1-e})</tex> сыновей.<br />
<br />
В этом дереве <tex dpi="130">O(n \log\log n)</tex> уровней. При нарушении баланса дерева необходимо балансирование, которое требует <tex dpi="130">O(n \log\log n)</tex> времени при <tex dpi="130">n</tex> вставленных целых числах. Такое время достигается за счет вставки чисел группами, а не поодиночке, как изначально предлагал Андерссон.<br />
<br />
==Определения== <br />
{{ Определение | definition =<br />
'''Контейнер''' {{---}} объект, в которым хранятся наши данные. Например: 32-битные и 64-битные числа, массивы, вектора.}}<br />
{{ Определение | definition =<br />
Алгоритм, сортирующий <tex dpi="130">n</tex> целых чисел из множества <tex dpi="130">\{0, 1, \ldots, m - 1\}</tex>, называется '''консервативным''', если длина контейнера (число бит в контейнере) равна <tex dpi="130">O(\log(m + n))</tex>. Если длина больше, то алгоритм '''неконсервативный'''.<br />
}}<br />
{{ Определение | definition =<br />
Если сортируются целые числа из множества <tex dpi="130">\{0, 1, \ldots, m - 1\}</tex> с длиной контейнера <tex dpi="130">k \log (m + n)</tex> с <tex dpi="130">k \geqslant 1</tex>, тогда сортировка происходит с '''неконсервативным преимуществом''' <tex dpi="130">k</tex>.<br />
}}<br />
{{ Определение | definition =<br />
Для множества <tex dpi="130">S</tex> определим<br />
<br />
<tex dpi="130">\min(S) = \min\limits_{a \in S} a</tex> <br />
<br />
<tex dpi="130">\max(S) = \max\limits_{a \in S} a</tex><br />
<br />
Набор <tex dpi="130">S1 < S2</tex> если <tex dpi="130">\max(S1) \leqslant \min(S2)</tex><br />
}}<br />
<br />
{{ Определение | definition =<br />
Предположим, есть набор <tex dpi="130">T</tex> из <tex dpi="130">p</tex> чисел, которые уже отсортированы как <tex dpi="130">a_{1}, a_{2}, \ldots, a_{p}</tex> и набор <tex dpi="130">S</tex> из <tex dpi="130">q</tex> чисел <tex dpi="130">b_{1}, b_{2}, \ldots, b_{q}</tex>. Тогда '''разделением''' <tex dpi="130">q</tex> чисел <tex dpi="130">p</tex> числами называется <tex dpi="130">p + 1</tex> набор <tex dpi="130">S_{0}, S_{1}, \ldots, S_{p}</tex>, где <tex dpi="130">S_{0} < a_{1} < S_{1} < \ldots < a_{p} < S_{p}</tex>.<br />
}}<br />
<br />
==Леммы==<br />
<br />
{{Лемма<br />
|id = lemma1<br />
|about = № 1<br />
|statement = <br />
Даны целые числа <tex dpi="130">b \geqslant s \geqslant 0</tex>, и <tex dpi="130">T</tex> является подмножеством множества <tex dpi="130">\{0, \ldots, 2^b - 1\}</tex>, содержащим <tex dpi="130">n</tex> элементов, и <tex dpi="130">t \geqslant 2^{-s + 1}С^k_{n}</tex>. Функция <tex dpi="130">h_{a}</tex>, принадлежащая <tex dpi="130">H_{b,s}</tex>, может быть выбрана за время <tex dpi="130">O(bn^2)</tex> так, что количество коллизий <tex dpi="130">coll(h_{a}, T) \leqslant t</tex>.<br />
}}<br />
<br />
{{Лемма<br />
|id = lemma2<br />
|about = № 2<br />
|statement = <br />
Выбор <tex dpi="130">s</tex>-ого наибольшего числа среди <tex dpi="130">n</tex> чисел, упакованных в <tex dpi="150">\frac{n}{g}</tex> контейнеров, может быть сделан за время <tex dpi="150">O(\frac{n \log g}{g})</tex> и с использованием <tex dpi="150">O(\frac{n}{g})</tex> памяти. В том числе, так может быть найдена медиана.<br />
<br />
|proof = <br />
Так как возможно делать попарное сравнение <tex dpi="130">g</tex> чисел в одном контейнере с <tex dpi="130">g</tex> числами в другом и извлекать большие числа из одного контейнера и меньшие из другого за константное время, возможно упаковать медианы из первого, второго, <tex dpi="130">\ldots</tex>, <tex dpi="130">g</tex>-ого чисел из 5 контейнеров в один контейнер за константное время. Таким образом, набор <tex dpi="130">S</tex> из медиан теперь содержится в <tex dpi="150">\frac{n}{5g}</tex> контейнерах. Рекурсивно находим медиану <tex dpi="130">m</tex> в <tex dpi="130">S</tex>. Используя <tex dpi="130">m</tex>, уберем хотя бы <tex dpi="150">\frac{n}{4}</tex> чисел среди <tex dpi="130">n</tex>. Затем упакуем оставшиеся из <tex dpi="150">\frac{n}{g}</tex> контейнеров в <tex dpi="150">\frac{3n}{4g}</tex> контейнеров и затем продолжим рекурсию.<br />
}}<br />
<br />
{{Лемма<br />
|id = lemma3<br />
|about = № 3<br />
|statement = <br />
Если <tex dpi="130">g</tex> целых чисел, в сумме использующих <tex dpi="150">\frac{\log n}{2}</tex> бит, упакованы в один контейнер, тогда <tex dpi="130">n</tex> чисел в <tex dpi="150">\frac{n}{g}</tex> контейнерах могут быть отсортированы за время <tex dpi="150">O(\frac{n \log g}{g})</tex> с использованием <tex dpi="150">O(\frac{n}{g})</tex> памяти.<br />
<br />
<br />
|proof = <br />
Так как используется только <tex dpi="150">\frac{\log n}{2}</tex> бит в каждом контейнере для хранения <tex dpi="130">g</tex> чисел, используем bucket sort, чтобы отсортировать все контейнеры, представляя каждый как число, что занимает <tex dpi="150">O(\frac{n}{g})</tex> времени и памяти. Так как используется <tex dpi="150">\frac{\log n}{2}</tex> бит на контейнер, понадобится <tex dpi="130">\sqrt{n}</tex> шаблонов для всех контейнеров. Затем поместим <tex dpi="150">g < \frac{\log n}{2}</tex> контейнеров с одинаковым шаблоном в одну группу. Для каждого шаблона останется не более <tex dpi="130">g - 1</tex> контейнеров, которые не смогут образовать группу. Поэтому не более <tex dpi="130">\sqrt{n}(g - 1)</tex> контейнеров не смогут сформировать группу. Для каждой группы помещаем <tex dpi="130">i</tex>-е число во всех <tex dpi="130">g</tex> контейнерах в один. Таким образом берутся <tex dpi="130">g</tex> <tex dpi="130">g</tex>-целых векторов и получаются <tex dpi="130">g</tex> <tex dpi="130">g</tex>-целых векторов, где <tex dpi="130">i</tex>-ый вектор содержит <tex dpi="130">i</tex>-ое число из входящего вектора. Эта транспозиция может быть сделана за время <tex dpi="130">O(g \log g)</tex>, с использованием <tex dpi="130">O(g)</tex> памяти. Для всех групп это занимает время <tex dpi="150">O(\frac{n \log g}{g})</tex>, с использованием <tex dpi="150">O(\frac{n}{g})</tex> памяти.<br />
<br />
Для контейнеров вне групп (которых <tex dpi="130">\sqrt{n}(g - 1)</tex> штук) разбираем и собираем заново контейнеры. На это потребуется не более <tex dpi="150">O(\frac{n}{g})</tex> времени и памяти. После всего этого используем карманную сортировку вновь для сортировки <tex dpi="130">n</tex> контейнеров. Таким образом, все числа отсортированы.<br />
<br />
<br />
Заметим, что когда <tex dpi="130">g = O( \log n)</tex>, сортировка <tex dpi="130">O(n)</tex> чисел в <tex dpi="150">\frac{n}{g}</tex> контейнеров произойдет за время <tex dpi="150">O((\frac{n}{g})</tex> <tex dpi="130">\log\log n)</tex> с использованием <tex dpi="150">O(\frac{n}{g})</tex> памяти. Выгода очевидна.<br />
}}<br />
<br />
{{Лемма<br />
|id = lemma4<br />
|about = № 4<br />
|statement = <br />
Примем, что каждый контейнер содержит <tex dpi="130"> \log m > \log n</tex> бит, и <tex dpi="130">g</tex> чисел, в каждом из которых <tex dpi="150">\frac{\log m}{g}</tex> бит, упакованы в один контейнер. Если каждое число имеет маркер, содержащий <tex dpi="150">\frac{\log n}{2g}</tex> бит, и <tex dpi="130">g</tex> маркеров упакованы в один контейнер таким же образом<tex dpi="130">^*</tex>, что и числа, тогда <tex dpi="130">n</tex> чисел в <tex dpi="150">\frac{n}{g}</tex> контейнерах могут быть отсортированы по их маркерам за время <tex dpi="150">O(\frac{n \log\log n}{g})</tex> с использованием <tex dpi="150">O(\frac{n}{g})</tex> памяти.<br />
(*): если число <tex dpi="130">a</tex> упаковано как <tex dpi="130">s</tex>-ое число в <tex dpi="130">t</tex>-ом контейнере для чисел, тогда маркер для <tex dpi="130">a</tex> упакован как <tex dpi="130">s</tex>-ый маркер в <tex dpi="130">t</tex>-ом контейнере для маркеров.<br />
<br />
<br />
|proof = <br />
Контейнеры для маркеров могут быть отсортированы с помощью bucket sort потому, что каждый контейнер использует <tex dpi="150">\frac{\log n}{2}</tex> бит. Сортировка сгруппирует контейнеры для чисел как в [[#lemma3|лемме №3]]. Перемещаем каждую группу контейнеров для чисел.<br />
}}<br />
<br />
{{Лемма<br />
|id = lemma5<br />
|about = № 5<br />
|statement =<br />
Предположим, что каждый контейнер содержит <tex dpi="130">\log m \log\log n > \log n</tex> бит, что <tex dpi="130">g</tex> чисел, в каждом из которых <tex dpi="150">\frac{\log m}{g}</tex> бит, упакованы в один контейнер, что каждое число имеет маркер, содержащий <tex dpi="150">\frac{\log n}{2g}</tex> бит, и что <tex dpi="130">g</tex> маркеров упакованы в один контейнер тем же образом что и числа. Тогда <tex dpi="130">n</tex> чисел в <tex dpi="150">\frac{n}{g}</tex> контейнерах могут быть отсортированы по своим маркерам за время <tex dpi="150">O(\frac{n}{g})</tex> с использованием <tex dpi="150">O(\frac{n}{g})</tex> памяти.<br />
<br />
|proof = <br />
Заметим, что несмотря на то, что длина контейнера <tex dpi="130">\log m \log\log n</tex> бит, всего <tex dpi="130">\log m</tex> бит используется для хранения упакованных чисел. Так же как в [[#lemma3|лемме №3]] и [[#lemma4|лемме №4]] сортируем контейнеры упакованных маркеров с помощью bucket sort. Для того, чтобы перемещать контейнеры чисел, помещаем <tex dpi="130">g \log\log n</tex> вместо <tex dpi="130">g</tex> контейнеров чисел в одну группу. Для транспозиции чисел в группе, содержащей <tex dpi="130">g \log\log n</tex> контейнеров, упаковываем <tex dpi="130">g \log\log n</tex> контейнеров в <tex dpi="130">g</tex>, упаковывая <tex dpi="130">\log\log n</tex> контейнеров в один. Далее делаем транспозицию над <tex dpi="130">g</tex> контейнерами. Таким образом перемещение занимает всего <tex dpi="130">O(g \log\log n)</tex> времени для каждой группы и <tex dpi="150">O(\frac{n}{g})</tex> времени для всех чисел. После завершения транспозиции, распаковываем <tex dpi="130">g</tex> контейнеров в <tex dpi="130">g \log\log n</tex> контейнеров.<br />
<br />
<br />
Заметим, что если длина контейнера <tex dpi="130">\log m \log\log n</tex> и только <tex dpi="130">\log m</tex> бит используется для упаковки <tex dpi="130">g \leqslant \log n</tex> чисел в один контейнер, тогда выбор в [[#lemma2|лемме №2]] может быть сделан за время и память <tex dpi="150">O(\frac{n}{g})</tex>, потому что упаковка в доказательстве [[#lemma2|лемме №2]] теперь может быть сделана за время <tex dpi="150">O(\frac{n}{g})</tex>.<br />
}}<br />
<br />
<br />
{{Лемма<br />
|id = lemma6<br />
|about = № 6<br />
|statement = <br />
<tex dpi="130">n</tex> целых чисел можно отсортировать в <tex dpi="130">\sqrt{n}</tex> наборов <tex dpi="130">S_{1}</tex>, <tex dpi="130">S_{2}</tex>, <tex dpi="130">\ldots</tex>, <tex dpi="130">S_{\sqrt{n}}</tex> таким образом, что в каждом наборе <tex dpi="130">\sqrt{n}</tex> чисел и <tex dpi="130">S_{i} < S_{j}</tex> при <tex dpi="130">i < j</tex>, за время <tex dpi="150">O(\frac{n \log\log n} {\log k})</tex> и место <tex dpi="130">O(n)</tex> с неконсервативным преимуществом <tex dpi="130">k \log\log n</tex>.<br />
<br />
<br />
|proof = <br />
Алгоритм сортировки <tex dpi="130">n</tex> целых чисел в <tex dpi="130">\sqrt{n}</tex> наборов, представленный ниже, является доказательством данной леммы. <br />
<br />
Постановка задачи и решение некоторых проблем:<br />
<br />
<br />
Рассмотрим проблему сортировки <tex dpi="130">n</tex> целых чисел из множества <tex dpi="130">\{0, 1, \ldots, m - 1\}</tex> в <tex dpi="130">\sqrt{n}</tex> наборов, как в условии леммы. Предполагаем, что каждый контейнер содержит <tex dpi="130">k \log\log n \log m</tex> бит и хранит число в <tex dpi="130">\log m</tex> бит. Поэтому неконсервативное преимущество {{---}} <tex dpi="130">k \log \log n</tex>. Также предполагаем, что <tex dpi="130">\log m \geqslant \log n \log\log n</tex>. Иначе можно использовать radix sort для сортировки за время <tex dpi="130">O(n \log\log n)</tex> и линейную память. Делим <tex dpi="130">\log m</tex> бит, используемых для представления каждого числа, в <tex dpi="130">\log n</tex> блоков. Таким образом, каждый блок содержит как минимум <tex dpi="130">\log\log n</tex> бит. <tex dpi="130">i</tex>-ый блок содержит с <br />
<tex dpi="150">\frac{i \log m} {\log n}</tex>-ого по <tex dpi="150">(\frac{(i + 1) \log m} {\log n - 1})</tex>-ый биты. Биты считаются с наименьшего бита, начиная с нуля. Теперь у нас имеется <tex dpi="130">2 \log n</tex>-уровневый алгоритм, который работает следующим образом:<br />
<br />
<br />
На каждой стадии работаем с одним блоком бит. Назовем эти блоки маленькими числами (далее м.ч.), потому что каждое м.ч. теперь содержит только <tex dpi="150">\frac{\log m}{\log n}</tex> бит. Каждое число представлено и соотносится с м.ч., над которым работаем в данный момент. Положим, что нулевая стадия работает с самым большим блоком (блок номер <tex dpi="130">\log n - 1</tex>). Предполагаем, что биты этих м.ч. упакованы в <tex dpi="150">\frac{n}{\log n}</tex> контейнеров с <tex dpi="130">\log n</tex> м.ч. упакованными в один контейнер. Пренебрегая временем, потраченным на эту упаковку, считаем, что она бесплатна. По [[#lemma2|лемме №2]] находим медиану этих <tex dpi="130">n</tex> м.ч. за время и память <tex dpi="150">O(\frac{n}{\log n})</tex>. Пусть <tex dpi="130">a</tex> {{---}} это найденная медиана. Тогда <tex dpi="130">n</tex> м.ч. могут быть разделены на не более чем три группы: <tex dpi="130">S_{1}</tex>, <tex dpi="130">S_{2}</tex> и <tex dpi="130">S_{3}</tex>. <tex dpi="130">S_{1}</tex> содержит м.ч., которые меньше <tex dpi="130">a</tex>, <tex dpi="130">S_{2}</tex> содержит м.ч., равные <tex dpi="130">a</tex>, <tex dpi="130">S_{3}</tex> содержит м.ч., большие <tex dpi="130">a</tex>. Также мощность <tex dpi="130">S_{1}</tex> и <tex dpi="130">S_{3} </tex> не превосходит <tex dpi="130">n/2</tex>. Мощность <tex dpi="130">S_{2}</tex> может быть любой. Пусть <tex dpi="130">S'_{2}</tex> {{---}} это набор чисел, у которых наибольший блок находится в <tex dpi="130">S_{2}</tex>. Тогда убираем из дальнейшего рассмотрения <tex dpi="150">\frac{\log m}{\log n}</tex> бит (наибольший блок) из каждого числа, принадлежащего <tex dpi="130">S'_{2}</tex>. Таким образом, после первой стадии каждое число находится в наборе размера не большего половины размера начального набора или один из блоков в числе убран из дальнейшего рассмотрения. Так как в каждом числе только <tex dpi="130">\log n</tex> блоков, для каждого числа потребуется не более <tex dpi="130">\log n</tex> стадий, чтобы поместить его в набор половинного размера. За <tex dpi="130">2 \log n</tex> стадий все числа будут отсортированы. Так как на каждой стадии работаем с <tex dpi="150">\frac{n}{\log n}</tex> контейнерами, то игнорируя время, необходимое на упаковку м.ч. в контейнеры и помещение м.ч. в нужный набор, затрачивается <tex dpi="130">O(n)</tex> времени из-за <tex dpi="130">2 \log n</tex> стадий.<br />
<br />
<br />
Сложная часть алгоритма заключается в том, как поместить м.ч. в набор, которому принадлежит соответствующее число, после предыдущих операций деления набора в нашем алгоритме. Предположим, что <tex dpi="130">n</tex> чисел уже поделены в <tex dpi="130">e</tex> наборов. Используем <tex dpi="130">\log e</tex> битов чтобы сделать марки для каждого набора. Теперь используем [[#lemma5|лемме №5]]. Полный размер маркера для каждого контейнера должен быть <tex dpi="150">\frac{\log n}{2}</tex>, и маркер использует <tex dpi="130">\log e</tex> бит, значит количество маркеров <tex dpi="130">g</tex> в каждом контейнере должно быть не более <tex dpi="150">\frac{\log n}{2\log e}</tex>. В дальнейшем, так как <tex dpi="150">g = \frac{\log n}{2 \log e}</tex>, м.ч. должны влезать в контейнер. Каждый контейнер содержит <tex dpi="130">k \log\log n \log n</tex> блоков, каждое м.ч. может содержать <tex dpi="150">O(\frac{k \log n}{g}) = O(k \log e)</tex> блоков. Заметим, что используется неконсервативное преимущество в <tex dpi="130">\log\log n</tex> для [[#lemma5|лемме №5]] Поэтому предполагается, что <tex dpi="150">\frac{\log n}{2 \log e}</tex> м.ч., в каждом из которых <tex dpi="130">k \log e</tex> блоков битов числа, упакованны в один контейнер. Для каждого м.ч. используется маркер из <tex dpi="130">\log e</tex> бит, который показывает, к какому набору он принадлежит. Предполагаем, что маркеры так же упакованы в контейнеры, как и м.ч. Так как каждый контейнер для маркеров содержит <tex dpi="150">\frac{\log n}{2 \log e}</tex> маркеров, то для каждого контейнера требуется <tex dpi="150">\frac{\log n}{2}</tex> бит. Таким образом, [[#lemma5|лемма №5]] может быть применена для помещения м.ч. в наборы, которым они принадлежат. Так как используется <tex dpi="150">O(\frac{n \log e}{ \log n})</tex> контейнеров, то время, необходимое для помещения м.ч. в их наборы, равно <tex dpi="150">O(\frac{n \log e}{ \log n})</tex>.<br />
<br />
Стоит отметить, что процесс помещения нестабилен, т.к. основан на алгоритме из [[#lemma5|леммы №5]].<br />
<br />
<br />
При таком помещении сразу возникает следующая проблема.<br />
<br />
Рассмотрим число <tex dpi="130">a</tex>, которое является <tex dpi="130">i</tex>-ым в наборе <tex dpi="130">S</tex>. Рассмотрим блок <tex dpi="130">a</tex> (назовем его <tex dpi="130">a'</tex>), который является <tex dpi="130">i</tex>-ым м.ч. в <tex dpi="130">S</tex>. Когда используется вышеописанный метод перемещения нескольких следующих блоков <tex dpi="130">a</tex> (назовем это <tex dpi="130">a''</tex>) в <tex dpi="130">S</tex>, <tex dpi="130">a''</tex> просто перемещен на позицию в наборе <tex dpi="130">S</tex>, но не обязательно на позицию <tex dpi="130">i</tex> (где расположен <tex dpi="130">a'</tex>). Если значение блока <tex dpi="130">a'</tex> одинаково для всех чисел в <tex dpi="130">S</tex>, то это не создаст проблемы потому, что блок одинаков вне зависимости от того в какое место в <tex dpi="130">S</tex> помещен <tex dpi="130">a''</tex>. Иначе у нас возникает проблема дальнейшей сортировки. Поэтому поступаем следующим образом: На каждой стадии числа в одном наборе работают на общем блоке, который назовем "текущий блок набора". Блоки, которые предшествуют текущему блоку содержат важные биты и идентичны для всех чисел в наборе. Когда помещаем больше бит в набор, последующие блоки помещаются в набор вместе с текущим блоком. Так вот, в вышеописанном процессе помещения предполагается, что самый значимый блок среди <tex dpi="130">k \log e</tex> блоков {{---}} это текущий блок. Таким образом, после того, как эти <tex dpi="130">k \log e</tex> блоков помещены в набор, изначальный текущий блок удаляется, потому что известно, что эти <tex dpi="130">k \log e</tex> блоков перемещены в правильный набор, и нам не важно где находился начальный текущий блок. Тот текущий блок находится в перемещенных <tex dpi="130">k \log e</tex> блоках.<br />
<br />
<br />
Стоит отметить, что после нескольких уровней деления размер наборов станет маленьким. Леммы [[#lemma3|3]], [[#lemma4|4]], [[#lemma5|5]] расчитаны на не очень маленькие наборы. Но поскольку сортируется набор из <tex dpi="130">n</tex> элементов в наборы размера <tex dpi="130">\sqrt{n}</tex>, то проблем быть не должно.<br />
<br />
<br />
===Алгоритм сортировки===<br />
<br />
Algorithm <tex>Sort(advantage</tex>, <tex>level</tex>, <tex>a_{0}</tex>, <tex>a_{1}</tex>, <tex>\ldots</tex>, <tex>a_{t}</tex>)<br />
<br />
<tex>advantage</tex> {{---}} это неконсервативное преимущество равное <tex>k\log\log n</tex>, <tex>a_{i}</tex>-ые это входящие целые числа в наборе, которые надо отсортировать, <tex>level</tex> это уровень рекурсии.<br />
<br />
# Если <tex>level</tex> равен <tex>1</tex> тогда изучаем размер набора. Если размер меньше или равен <tex>\sqrt{n}</tex>, то <tex>return</tex>. Иначе делим этот набор в <tex>\leqslant</tex> 3 набора, используя [[#lemma2|лемму №2]], чтобы найти медиану, а затем используем [[#lemma5|лемму №5]] для сортировки. Для набора, где все элементы равны медиане, не рассматриваем текущий блок и текущим блоком делаем следующий. Создаем маркер, являющийся номером набора для каждого из чисел (0, 1 или 2). Затем направляем маркер для каждого числа назад к месту, где число находилось в начале. Также направляем двубитное число для каждого входного числа, указывающее на текущий блок.<br />
# От <tex dpi="130">u = 1</tex> до <tex dpi="130">k</tex><br />
## Упаковываем <tex dpi="130">a^{(u)}_{i}</tex>-ый в часть из <tex dpi="130">1/k</tex>-ых номеров контейнеров. Где <tex dpi="130">a^{(u)}_{i}</tex> содержит несколько непрерывных блоков, которые состоят из <tex dpi="150">\frac{1}{k}</tex>-ых битов <tex dpi="130">a_{i}</tex>. При этом у <tex dpi="130">a^{(u)}_{i}</tex> текущий блок это самый крупный блок.<br />
## Вызываем <tex>Sort(advantage</tex>, <tex>level - 1</tex>, <tex dpi="130">a^{(u)}_{0}</tex>, <tex dpi="130">a^{(u)}_{1}</tex>, <tex>\ldots</tex>, <tex dpi="130">a^{(u)}_{t}</tex>). Когда алгоритм возвращается из этой рекурсии, маркер, показывающий для каждого числа, к какому набору это число относится, уже направлен назад к месту, где число находится во входных данных. Число, имеющее наибольшее число бит в <tex dpi="130">a_{i}</tex>, показывающее на текущий блок в нем, так же направлено назад к <tex dpi="130">a_{i}</tex>.<br />
## Отправляем <tex dpi="130">a_{i}</tex>-ые к их наборам, используя [[#lemma5|лемму №5]].<br />
<br />
Algorithm IterateSort<br />
Call <tex>Sort(advantage</tex>, <tex dpi="130">\log_{k}((\log n)/4)</tex>, <tex dpi="130">a_{0}</tex>, <tex dpi="130">a_{1}</tex>, <tex dpi="130">\ldots</tex>, <tex dpi="130">a_{n - 1}</tex>);<br />
<br />
от 1 до 5<br />
# Помещаем <tex dpi="130">a_{i}</tex> в соответствующий набор с помощью блочной сортировки (англ. ''bucket sort''), потому что наборов около <tex dpi="130">\sqrt{n}</tex>.<br />
# Для каждого набора <tex dpi="130">S = </tex>{<tex dpi="130">a_{i_{0}}, a_{i_{1}}, \ldots, a_{i_{t}}</tex>}, если <tex dpi="130">t > \sqrt{n}</tex>, вызываем <tex>Sort(advantage</tex>, <tex dpi="130">\log_{k}(\frac{\log n}{4})</tex>, <tex dpi="130">a_{i_{0}}, a_{i_{1}}, \ldots, a_{i_{t}}</tex>).<br />
<br />
Время работы алгоритма <tex dpi="150">O(\frac{n \log\log n}{\log k})</tex>, что доказывает лемму.<br />
}}<br />
<br />
<br />
<br />
==Уменьшение числа бит в числах==<br />
Один из способов ускорить сортировку {{---}} уменьшить число бит в числе. Один из способов уменьшить число бит в числе {{---}} использовать деление пополам (эту идею впервые подал van Emde Boas). Деление пополам заключается в том, что количество оставшихся бит в числе уменьшается в 2 раза. Это быстрый способ, требующий <tex dpi="130">O(m)</tex> памяти. Для своего дерева Андерссон использует хеширование, что позволяет сократить количество памяти до <tex dpi="130">O(n)</tex>. Для того чтобы еще ускорить алгоритм, необходимо упаковать несколько чисел в один контейнер, чтобы затем за константное количество шагов произвести хеширование для всех чисел, хранимых в контейнере. Для этого используется хеш-функция для хеширования <tex dpi="130">n</tex> чисел в таблицу размера <tex dpi="130">O(n^2)</tex> за константное время без коллизий. Для этого используется модифицированная хеш-функция авторства: Dierzfelbinger и Raman.<br />
<br />
<br />
Алгоритм: Пусть целое число <tex dpi="130">b \geqslant 0</tex> и пусть <tex dpi="130">U = \{0, \ldots, 2^b - 1\}</tex>. Класс <tex dpi="130">H_{b,s}</tex> хеш-функций из <tex dpi="130">U</tex> в <tex dpi="130">\{0, \ldots, 2^s - 1\}</tex> определен как <tex dpi="130">H_{b,s} = \{h_{a} \mid 0 < a < 2^b, a \equiv 1 (\bmod 2)\}</tex> и для всех <tex dpi="130">x</tex> из <tex dpi="130">U</tex>: <tex dpi="130">h_{a}(x) = (ax</tex> <tex dpi="130">\bmod</tex> <tex dpi="130">2^b)</tex> <tex dpi="130">div</tex> <tex dpi="130">2^{b - s}</tex>.<br />
<br />
Данный алгоритм базируется на [[#lemma1|лемме №1]].<br />
<br />
<br />
Взяв <tex dpi="130">s = 2 \log n</tex>, получаем хеш-функцию <tex dpi="130">h_{a}</tex>, которая захеширует <tex dpi="130">n</tex> чисел из <tex dpi="130">U</tex> в таблицу размера <tex dpi="130">O(n^2)</tex> без коллизий. Очевидно, что <tex dpi="130">h_{a}(x)</tex> может быть посчитана для любого <tex dpi="130">x</tex> за константное время. Если упаковать несколько чисел в один контейнер так, что они разделены несколькими битами нулей, то можно применить <tex dpi="130">h_{a}</tex> ко всему контейнеру, и в результате все хеш-значения для всех чисел в контейнере будут посчитаны. Заметим, что это возможно только потому, что в вычисление хеш-значения вовлечены только (<tex dpi="130">\bmod</tex> <tex dpi="130">2^b</tex>) и (<tex dpi="130">div</tex> <tex dpi="130">2^{b - s}</tex>). <br />
<br />
<br />
Такая хеш-функция может быть найдена за <tex dpi="130">O(n^3)</tex>.<br />
<br />
Следует отметить, что, несмотря на размер таблицы <tex dpi="130">O(n^2)</tex>, потребность в памяти не превышает <tex dpi="130">O(n)</tex>, потому что хеширование используется только для уменьшения количества бит в числе.<br />
<br />
==Сортировка по ключу==<br />
Предположим, что <tex dpi="130">n</tex> чисел должны быть отсортированы, и в каждом <tex dpi="130">\log m</tex> бит. Будем считать, что в каждом числе есть <tex dpi="130">h</tex> сегментов, в каждом из которых <tex dpi="130">\log m/h</tex> бит. Теперь применяем хеширование ко всем сегментам и получаем <tex dpi="130">2h \log n</tex> бит хешированных значений для каждого числа. После сортировки на хешированных значениях для всех начальных чисел начальная задача по сортировке <tex dpi="130">n</tex> чисел по <tex dpi="130">\log m</tex> бит в каждом стала задачей по сортировке <tex dpi="130">n</tex> чисел по <tex dpi="130">\log m/h</tex> бит в каждом.<br />
<br />
<br />
Также рассмотрим проблему последующего разделения. Пусть <tex dpi="130">a_{1}</tex>, <tex dpi="130">a_{2}</tex>, <tex dpi="130">\ldots</tex>, <tex dpi="130">a_{p}</tex> {{---}} <tex dpi="130">p</tex> чисел и <tex dpi="130">S</tex> {{---}} множество чисeл. Необходимо разделить <tex dpi="130">S</tex> в <tex dpi="130">p + 1</tex> наборов, таких, что: <tex dpi="130">S_{0} < a_{1} < S_{1} < a_{2} < \ldots < a_{p} < S_{p}</tex>. Так как используется '''сортировка по ключу''' (англ. ''signature sorting'') то перед тем, как делать вышеописанное разделение, необходимо поделить биты в <tex dpi="130">a_{i}</tex> на <tex dpi="130">h</tex> сегментов и взять некоторые из них. Так же делим биты для каждого числа из <tex dpi="130">S</tex> и оставляем только один в каждом числе. По существу, для каждого <tex dpi="130">a_{i}</tex> берутся все <tex dpi="130">h</tex> сегментов. Если соответствующие сегменты <tex dpi="130">a_{i}</tex> и <tex dpi="130">a_{j}</tex> совпадают, то нам понадобится только один. Сегмент, который берется для числа в <tex dpi="130">S</tex> это сегмент, который выделяется из <tex dpi="130">a_{i}</tex>. Таким образом, начальная задача о разделении <tex dpi="130">n</tex> чисел по <tex dpi="130">\log m</tex> бит преобразуется в несколько задач на разделение с числами по <tex dpi="150">\frac{\log m}{h}</tex> бит.<br />
<br />
<br />
'''Пример''':<br />
[[Файл:Han-example.png|500px|thumb]]<br />
<br />
<tex dpi="130">a_{1} = 3, a_{2} = 5, a_{3} = 7, a_{4} = 10, S = \{1, 4, 6, 8, 9, 13, 14\}</tex>.<br />
<br />
Делим числа на два сегмента. Для <tex dpi="130">a_{1}</tex> получим верхний сегмент <tex dpi="130">0</tex>, нижний <tex dpi="130">3</tex>; <tex dpi="130">a_{2}</tex> {{---}} верхний <tex dpi="130">1</tex>, нижний <tex dpi="130">1</tex>; <tex dpi="130">a_{3}</tex> {{---}} верхний <tex dpi="130">1</tex>, нижний <tex dpi="130">3</tex>; <tex dpi="130">a_{4}</tex> {{---}} верхний <tex dpi="130">2</tex>, нижний <tex dpi="130">2</tex>. Для элементов из S получим: для <tex dpi="130">1</tex> нижний <tex dpi="130">1</tex>, так как он выделяется из нижнего сегмента <tex dpi="130">a_{1}</tex>; для <tex dpi="130">4</tex> нижний <tex dpi="130">0</tex>; для <tex dpi="130">8</tex> нижний <tex dpi="130">0</tex>; для <tex dpi="130">9</tex> нижний <tex dpi="130">1</tex>; для <tex dpi="130">13</tex> верхний <tex dpi="130">3</tex>; для <tex dpi="130">14</tex> верхний <tex dpi="130">3</tex>. Теперь все верхние сегменты, нижние сегменты <tex dpi="130">1</tex> и <tex dpi="130">3</tex>, нижние сегменты <tex dpi="130">4, 5, 6, 7,</tex> нижние сегменты <tex dpi="130">8, 9, 10</tex> формируют <tex dpi="130">4</tex> новые задачи на разделение.<br />
<br />
<br />
<br />
Использование '''сортировки по ключу''' в данном алгоритме:<br />
<br />
Есть набор <tex dpi="130">T</tex> из <tex dpi="130">p</tex> чисел, которые отсортированы как <tex dpi="130">a_{1}, a_{2}, \ldots, a_{p}</tex>. Используем числа в <tex dpi="130">T</tex> для разделения набора <tex dpi="130">S</tex> из <tex dpi="130">q</tex> чисел <tex dpi="130">b_{1}, b_{2}, \ldots, b_{q}</tex> в <tex dpi="130">p + 1</tex> наборов <tex dpi="130">S_{0}, S_{1}, \ldots, S_{p}</tex>. Пусть <tex dpi="150">h = \frac{\log n}{c \log p}</tex> для константы <tex dpi="130">c > 1</tex>. (<tex dpi="150">\frac{h}{\log\log n \log p}</tex>)-битные числа могут храниться в одном контейнере, содержащим <tex dpi="150">\frac{\log n}{c \log\log n}</tex> бит. Сначала рассматриваем биты в каждом <tex dpi="130">a_{i}</tex> и каждом <tex dpi="130">b_{i}</tex> как сегменты одинаковой длины <tex dpi="150">\frac{h} {\log\log n}</tex>. Рассматриваем сегменты как числа. Чтобы получить неконсервативное преимущество для сортировки, числа в этих контейнерах (<tex dpi="130">a_{i}</tex>-ом и <tex dpi="130">b_{i}</tex>-ом) хешируются, и получается <tex dpi="150">\frac{h}{\log\log n}</tex> хешированных значений в одном контейнере. При вычислении хеш-значений сегменты не влияют друг на друга, можно даже отделить четные и нечетные сегменты в два контейнера. Не умаляя общности считаем, что хеш-значения считаются за константное время. Затем, посчитав значения, два контейнера объединяем в один. Пусть <tex dpi="130">a'_{i}</tex> {{---}} хеш-контейнер для <tex dpi="130">a_{i}</tex>, аналогично <tex dpi="130">b'_{i}</tex>. В сумме хеш-значения имеют <tex dpi="150">\frac{2 \log n}{c \log\log n}</tex> бит, хотя эти значения разделены на сегменты по <tex dpi="150">\frac{h}{ \log\log n}</tex> бит в каждом контейнере. Между сегментами получаются пустоты, которые забиваются нулями. Сначала упаковываются все сегменты в <tex dpi="150">\frac{2 \log n}{c \log\log n}</tex> бит. Потом рассматривается каждый хеш-контейнер как число, и эти хеш-контейнеры сортируются за линейное время (сортировка будет рассмотрена чуть позже). После этой сортировки биты в <tex dpi="130">a_{i}</tex> и <tex dpi="130">b_{i}</tex> разрезаны на <tex dpi="150">\frac{\log\log n}{h}</tex> сегментов. Таким образом, получилось дополнительное мультипликативное преимущество (англ. ''additional multiplicative advantage'') в <tex dpi="150">\frac{h} {\log\log n}</tex>.<br />
<br />
После того, как вышеописанный процесс повторится <tex dpi="130">g</tex> раз, получится неконсервативное преимущество в <tex dpi="150">(\frac{h} {\log\log n})^g</tex> раз, в то время как потрачено только <tex dpi="130">O(gqt)</tex> времени, так как каждое многократное деление происходит за линейное время <tex dpi="130">O(qt)</tex>.<br />
<br />
<br />
Хеш-функция, которая используется, находится следующим образом. Будут хешироватся сегменты, <tex dpi="150">\frac{\log\log n}{h}</tex>-ые, <tex dpi="150">(\frac{\log\log n}{h})^2</tex>-ые, <tex dpi="130">\ldots</tex> по счету в числе. Хеш-функцию для <tex dpi="150">(\frac{\log\log n}{h})^t</tex>-ых по счету сегментов, получаем нарезанием всех <tex dpi="130">p</tex> чисел на <tex dpi="150">(\frac{\log\log n}{h})^t</tex> сегментов. Рассматривая каждый сегмент как число, получаем <tex dpi="150">p(\frac{\log\log n}{h})^t</tex> чисел. Затем получаем одну хеш-функцию для этих чисел. Так как <tex dpi="130">t < \log n</tex>, то получится не более <tex dpi="130">\log n</tex> хеш-функций.<br />
<br />
<br />
Рассмотрим сортировку за линейное время, о которой было упомянуто ранее. Предполагается, что хешированные значения для каждого контейнера упакованы в <tex dpi="150">\frac{2 \log n}{c \log\log n}</tex> бит. Есть <tex dpi="130">t</tex> наборов, в каждом из которых <tex dpi="130">q + p</tex> хешированных контейнеров по <tex dpi="150">\frac{2 \log n}{c \log\log n}</tex> бит в каждом. Эти контейнеры должны быть отсортированы в каждом наборе. Комбинируя все хеш-контейнеры в один pool, сортируем следующим образом.<br />
<br />
<br />
Операция '''сортировки за линейное время''' (англ. ''Linear-Time-Sort'')<br />
<br />
Входные данные: <tex dpi="150">r > = n^{\frac{2}{5}}</tex> чисел <tex dpi="130">d_{i}</tex>, <tex dpi="130">d_{i}.value</tex> — значение числа <tex dpi="130">d_{i}</tex>, в котором <tex dpi="150">\frac{2 \log n}{c \log\log n}</tex> бит, <tex dpi="130">d_{i}.set</tex> — набор, в котором находится <tex dpi="130">d_{i}</tex>. Следует отметить, что всего есть <tex dpi="130">t</tex> наборов.<br />
<br />
# Сортируем все <tex dpi="130">d_{i}</tex> по <tex dpi="130">d_{i}.value</tex>, используя bucket sort. Пусть все отсортированные числа в <tex dpi="130">A[1..r]</tex>. Этот шаг занимает линейное время, так как сортируется не менее <tex dpi="150">n^{\frac{2}{5}}</tex> чисел.<br />
# Помещаем все <tex dpi="130">A[j]</tex> в <tex dpi="130">A[j].set</tex>.<br />
<br />
==Сортировка с использованием O(n log log n) времени и памяти==<br />
Для сортировки <tex dpi="130">n</tex> целых чисел в диапазоне <tex dpi="130">\{0, 1, \ldots, m - 1\}</tex> предполагается, что в нашем консервативном алгоритме используется контейнер длины <tex dpi="130">O(\log (m + n))</tex>. Далее везде считается, что все числа упакованы в контейнеры одинаковой длины. <br />
<br />
<br />
Берем <tex dpi="130">1/e = 5</tex> для ЭП-дерева Андерссона. Следовательно, у корня будет <tex dpi="150">n^{\frac{1}{5}}</tex> детей, и каждое ЭП-дерево в каждом ребенке будет иметь <tex dpi="150">n^{\frac{4}{5}}</tex> листьев. В отличие от оригинального дерева, за раз вставляется не один элемент, а <tex dpi="130">d^2</tex>, где <tex dpi="130">d</tex> — количество детей узла дерева, в котором числа должны спуститься вниз. Алгоритм полностью опускает все <tex dpi="130">d^2</tex> чисел на один уровень. В корне опускаются <tex dpi="150">n^{\frac{2}{5}}</tex> чисел на следующий уровень. После того, как все числа опустились на следующий уровень, они успешно разделились на <tex dpi="130">t_{1} = n^{1/5}</tex> наборов <tex dpi="130">S_{1}, S_{2}, \ldots, S_{t_{1}}</tex>, в каждом из которых <tex dpi="150">n^{\frac{4}{5}}</tex> чисел и <tex dpi="130">S_{i} < S_{j}, i < j</tex>. Затем, берутся <tex dpi="150">n^{\frac{8}{25}}</tex> чисел из <tex dpi="130">S_{i}</tex> и опускаются на следующий уровень ЭП-дерева. Это повторяется, пока все числа не опустятся на следующий уровень. На этом шаге числа разделены на <tex dpi="150">t_{2} = n^{\frac{1}{5}}n^{\frac{4}{25}} = n^{\frac{9}{25}}</tex> наборов <tex dpi="130">T_{1}, T_{2}, \ldots, T_{t_{2}}</tex>, аналогичных наборам <tex dpi="130">S_{i}</tex>, в каждом из которых <tex dpi="150">n^{\frac{16}{25}}</tex> чисел. Теперь числа опускаются дальше в ЭП-дереве.<br />
<br />
Нетрудно заметить, что перебалансирока занимает <tex dpi="130">O(n \log\log n)</tex> времени с <tex dpi="130">O(n)</tex> времени на уровень, аналогично стандартному ЭП-дереву Андерссона.<br />
<br />
<br />
Нам следует нумеровать уровни ЭП-дерева с корня, начиная с нуля. Рассмотрим спуск вниз на уровне <tex dpi="130">s</tex>. Имеется <tex dpi="150">t = n^{1 - (\frac{4}{5})^S}</tex> наборов по <tex dpi="150">n^{(\frac{4}{5})^S}</tex> чисел в каждом. Так как каждый узел на данном уровне имеет <tex dpi="150">p = n^{\frac{1}{5} \cdot (\frac{4}{5})^S}</tex> детей, то на <tex dpi="130">s + 1</tex> уровень опускаются <tex dpi="150">q = n^{\frac{2}{5} \cdot (\frac{4}{5})^S}</tex> чисел для каждого набора, или всего <tex dpi="150">qt \geqslant n^{\frac{2}{5}}</tex> чисел для всех наборов за один раз.<br />
<br />
<br />
Спуск вниз можно рассматривать как сортировку <tex dpi="130">q</tex> чисел в каждом наборе вместе с <tex dpi="130">p</tex> числами <tex dpi="130">a_{1}, a_{2}, \ldots, a_{p}</tex> из ЭП-дерева, так, что эти <tex dpi="130">q</tex> чисел разделены в <tex dpi="130">p + 1</tex> наборов <tex dpi="130">S_{0}, S_{1}, \ldots, S_{p}</tex> таких, что <tex dpi="130">S_{0} < a_{1} < \ldots < a_{p} < S_{p}</tex>.<br />
<br />
<br />
Так как <tex dpi="130">q</tex> чисел не надо полностью сортировать и <tex dpi="130">q = p^2</tex>, то можно использовать [[#lemma6|лемму №6]] для сортировки. Для этого необходимо неконсервативное преимущество, которое получается с помощью [[Сортировка Хана#Signature sorting|signature sorting]]. Для этого используется линейная техника многократного деления (англ. ''multi-dividing technique'').<br />
<br />
<br />
После <tex dpi="130">g</tex> сокращений бит в [[Сортировка Хана#Signature sorting|signature sorting]] получаем неконсервативное преимущество в <tex dpi="150">(\frac{h}{ \log\log n})^g</tex>. Мы не волнуемся об этих сокращениях до конца потому, что после получения неконсервативного преимущества мы можем переключиться на [[#lemma6|лемму №6]] для завершения разделения <tex dpi="130">q</tex> чисел с помощью <tex dpi="130">p</tex> чисел на наборы. Заметим, что по природе битового сокращения начальная задача разделения для каждого набора перешла в <tex dpi="130">w</tex> подзадач разделения на <tex dpi="130">w</tex> поднаборов для какого-то числа <tex dpi="130">w</tex>.<br />
<br />
<br />
Теперь для каждого набора все его поднаборы в подзадачах собираются в один набор. Затем, используя [[#lemma6|лемму №6]], делается разделение. Так как получено неконсервативное преимущество в <tex dpi="150">(\frac{h}{\log\log n})^g</tex> и работа происходит на уровнях не ниже, чем <tex dpi="130">2 \log\log\log n</tex>, то алгоритм занимает <tex dpi="150">O(\frac{qt \log\log n}{g(\log h - \log\log\log n) - \log\log\log n}) = O(\log\log n)</tex> времени.<br />
<br />
<br />
В итоге разделились <tex dpi="130">q</tex> чисел <tex dpi="130">p</tex> числами в каждый набор. То есть получилось, что <tex dpi="130">S_{0} < e_{1} < S_{1} < \ldots < e_{p} < S_{p}</tex>, где <tex dpi="130">e_{i}</tex> {{---}} сегмент <tex dpi="130">a_{i}</tex>, полученный с помощью битового сокращения. Такое разделение получилось комбинированием всех поднаборов в подзадачах. Предполагаем, что числа хранятся в массиве <tex dpi="130">B</tex> так, что числа в <tex dpi="130">S_{i}</tex> предшествуют числам в <tex dpi="130">S_{j}</tex> если <tex dpi="130">i < j</tex> и <tex dpi="130">e_{i}</tex> хранится после <tex dpi="130">S_{i - 1}</tex>, но до <tex dpi="130">S_{i}</tex>. <br />
<br />
<br />
Пусть <tex dpi="130">B[i]</tex> находится в поднаборе <tex dpi="130">B[i].subset</tex>. Чтобы позволить разделению выполниться, для каждого поднабора помещаем все <tex dpi="130">B[j]</tex> в <tex dpi="130">B[j].subset</tex>.<br />
<br />
На это потребуется линейное время и место.<br />
<br />
<br />
Теперь рассмотрим проблему упаковки, которая решается следующим образом. Считается, что число бит в контейнере <tex dpi="130">\log m \geqslant \log\log\log n</tex>, потому что в противном случае можно использовать radix sort для сортировки чисел. У контейнера есть <tex dpi="150">\frac{h}{\log\log n}</tex> хешированных значений (сегментов) в себе на уровне <tex dpi="130">\log h</tex> в ЭП-дереве. Полное число хешированных бит в контейнере равно <tex dpi="130">(2 \log n)(c \log\log n)</tex> бит. Хешированные биты в контейнере выглядят как <tex dpi="130">0^{i}t_{1}0^{i}t_{2} \ldots t</tex><tex dpi="150">_{\frac{h}{\log\log n}}</tex>, где <tex dpi="130">t_{k}</tex>-ые — хешированные биты, а нули {{---}} это просто нули. Сначала упаковываем <tex dpi="130">\log\log n</tex> контейнеров в один и получаем <tex dpi="130">w_{1} = 0^{j}t_{1, 1}t_{2, 1} \ldots t_{\log\log n, 1}0^{j}t_{1, 2} \ldots t_{\log\log n,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex>, где <tex dpi="130">t_{i, k}</tex>: элемент с номером <tex dpi="130">k = 1, 2, \ldots, </tex><tex dpi="150">\frac{h}{\log\log n}</tex> из <tex dpi="130">i</tex>-ого контейнера. Используем <tex dpi="130">O(\log\log n)</tex> шагов, чтобы упаковать <tex dpi="130">w_{1}</tex> в <tex dpi="130">w_{2} = 0</tex><tex dpi="150">^{\frac{jh}{\log\log n}}</tex><tex dpi="130">t_{1, 1}t_{2, 1} \ldots t_{\log\log n, 1}t_{1, 2}t_{2, 2} \ldots t_{1,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex><tex dpi="130">t_{2,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex><tex dpi="130">\ldots t_{\log\log n,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex>. Теперь упакованные хеш-биты занимают <tex dpi="130">2 \log</tex><tex dpi="150">\frac{n}{c}</tex> бит. Используем <tex dpi="130">O(\log\log n)</tex> времени чтобы распаковать <tex dpi="130">w_{2}</tex> в <tex dpi="130">\log\log n</tex> контейнеров <tex dpi="130">w_{3, k} = 0</tex><tex dpi="150">^{\frac{jh}{\log\log n}}</tex><tex dpi="130">0^{r}t_{k, 1}0^{r}t_{k, 2} \ldots t_{k,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex> <tex dpi="130">k = 1, 2, \ldots, \log\log n</tex>. Затем, используя <tex dpi="130">O(\log\log n)</tex> времени, упаковываем эти <tex dpi="130">\log\log n</tex> контейнеров в один <tex dpi="130">w_{4} = 0^{r}t_{1, 1}0^{r}t_{1, 2} \ldots t_{1,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex><tex dpi="130">0^{r}t_{2, 1} \ldots t_{\log\log n,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex>. Затем, используя <tex dpi="130">O(\log\log n)</tex> шагов, упаковываем <tex dpi="130">w_{4}</tex> в <tex dpi="130">w_{5} = 0^{s}t_{1, 1}t_{1, 2} \ldots t_{1,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex><tex dpi="130">t_{2, 1}t_{2, 2} \ldots t_{\log\log n,}</tex><tex dpi="150">_{ \frac{h}{\log\log n}}</tex>. В итоге используется <tex dpi="130">O(\log\log n)</tex> времени для упаковки <tex dpi="130">\log\log n</tex> контейнеров. Считаем, что время, потраченное на один контейнер — константа.<br />
<br />
==См. также==<br />
* [[Сортировка подсчетом]]<br />
* [[Цифровая сортировка]]<br />
<br />
==Источники информации==<br />
* [http://www.sciencedirect.com/science/article/pii/S019667740300155X Deterministic Sorting in O(n log log n) Time and Linear Space. Yijie Han.]<br />
* А. Андерссон. Fast deterministic sorting and searching in linear space. Proc. 1996 IEEE Symp. on Foundations of Computer Science. 135-141(1996)<br />
* [http://dl.acm.org/citation.cfm?id=1236460 A. Andersson, M. Thorup. Dynamic ordered sets with exponential search trees.]<br />
* [[wikipedia:en:Integer_sorting|Wikipedia {{---}} Integer sorting]]<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Сортировки]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B0%D0%B9%D0%BB:Han-example.png&diff=47948Файл:Han-example.png2015-06-07T09:16:43Z<p>6yry6e: </p>
<hr />
<div></div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A2%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0_%D0%B8%D0%BD%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D0%B9&diff=44387Таблица инверсий2015-01-13T13:25:36Z<p>6yry6e: </p>
<hr />
<div>Пусть <tex> P = (p_1,p_2,\dots,p_n)</tex> является [[Действие перестановки на набор из элементов, представление в виде циклов|перестановкой]] чисел <tex> 1, 2,\dots, n</tex>.<br />
<br />
{{Определение<br />
|definition = <br />
'''Инверсией''' (англ. ''inversion'') в перестановке <tex>P</tex> называется всякая пара индексов <tex>i, j</tex> такая, что <tex>1\leqslant i<j\leqslant n</tex> и <tex>P[i]>P[j]</tex>.<br />
}}<br />
{{Определение<br />
|definition = <br />
'''Таблицей инверсий''' (англ. ''inversion table'') перестановки <tex> P </tex> называют такую последовательность <tex> T = (t_1,t_2,\dots,t_n)</tex>, в которой <tex>t_i</tex> равно числу элементов перестановки <tex> P </tex>, стоящих в <tex> P </tex> левее числа <tex>i</tex> и больших <tex>i</tex>.<br />
}}<br />
<br />
== Алгоритм построения за O(N<sup>2</sup>) ==<br />
<br />
Таблицу инверсий тривиально построить по определению. Для каждого элемента перестановки считаем количество элементов, больших данного и стоящих в перестановке левее него.<br />
Алгоритм построения в псевдокоде выглядит так: <br />
T[1..n] = 0<br />
'''for''' i = 1..n<br />
'''for''' j = 1..(i - 1)<br />
'''if''' P[j] > P[i]<br />
T[P[i]] = T[P[i]]++<br />
Сложность данного алгоритма {{---}} <tex>O(n^2)</tex>. Уменьшить время работы можно используя алгоритм, похожий на [[Сортировка_слиянием |сортировку слиянием.]]<br />
<br />
== Алгоритм построения за O(N log N) ==<br />
<br />
Пусть дано разбиение перестановки на два списка, причём для каждого элемента дано число инверсий слева с элементами того же списка и известно, что все числа первого списка стоят левее всех чисел второго списка в исходной перестановке. Будем считать количество инверсий слева элементов обоих списков следующим образом: сливаем списки, аналогично [[Сортировка_слиянием |сортировке слиянием.]]<br />
<br />
Если в результат нужно записать элемент первого списка, то все нерассмотренные элементы второго списка больше, следовательно, количество инверсий для этого элемента не меняется. Если в результат нужно записать элемент второго списка, то все нерассмотренные элементы первого списка больше его и стоят левее. Следовательно, количество инверсий для этого элемента следует увеличить на количество нерассмотренных элементов второго списка.<br />
<br />
Описанный алгоритм записывается в псевдокод следующим образом:<br />
<font color=green>// ''inverses_merge'' {{---}} процедура, сливающая два списка пар</font><br />
<font color=green>// ''inverses_get'' {{---}} процедура, рекурсивно получающая таблицу инверсий для перестановки</font><br />
'''def''' inverses_merge(ls1, ls2):<br />
result = []<br />
it1, it2 = ''null''<br />
'''while''' (it1 < ls1.length) '''and''' (it2 < ls2.length)<br />
'''if''' ls1[it1].item < ls2[it2].item<br />
result.append(ls1[it1])<br />
it1++<br />
'''else'''<br />
result.append(item = ls2[it2].item, inverses = ls2[it2].inverses + ls1.length - it1)<br />
it2++<br />
'''while''' it1 < ls1.length<br />
result.append(ls1[it1])<br />
it1++<br />
'''while''' it2 < ls2.length<br />
result.append(ls2[it2])<br />
it2++<br />
'''return''' result<br />
<br />
'''def''' inverses_get(ls):<br />
'''if''' ls.length == 1<br />
'''return''' [(item = ls[0], inverses = 0)]<br />
'''else'''<br />
'''return''' inverses_merge(inverses_get(ls.first_half), inverses_get(ls.second_half))<br />
<br />
<br />
Сложность представленного алгоритма есть <tex>O(n\log n)</tex>. Алгоритм с такой же сложностью можно построить с помощью [[Дерево_отрезков._Построение | дерева отрезков.]]<br />
<br />
== Алгоритм восстановления ==<br />
<br />
Для восстановления перестановки по таблицы инверсий <tex>T</tex> воспользуемся следующим соображением: единица стоит в перестановке на <tex>T_0</tex>-ом месте (индексируем элементы с нуля), так как остальные числа в перестановке больше единицы. Далее, если известны расположения всех чисел <tex>1, \dots, k</tex>, то число <tex>k + 1</tex> стоит на <tex>T_{k + 1}</tex>-ой ещё не занятой позиции: все числа, меньшие <tex>k + 1</tex> уже расставлены. Это рассуждение напрямую переписывается в код следующим образом:<br />
<font color=green>// ''j'' {{---}} счётчик пропущенных свободных позиций</font><br />
<font color=green>// ''k'' {{---}} количество инверсий слева для элемента curr</font><br />
<font color=green>// ''result'' {{---}} массив, в который записывается перестановка. Равенство элемента массива нулю обозначает, что эта позиция свободна.</font><br />
'''def''' recover_straight(ls):<br />
n = ls.length<br />
result = array(0, n)<br />
curr = 1<br />
'''for''' k '''in''' ls<br />
j = 0<br />
'''for''' i = 0..(n - 1)<br />
'''if''' result[i] == 0<br />
'''if''' j == k<br />
result[i] = curr<br />
'''break'''<br />
'''else:'''<br />
j++<br />
curr++<br />
'''return''' result<br />
<br />
<br />
Этот простой алгоритм имеет сложность <tex>O(n^2)</tex> — внутренний цикл делает до <tex>n</tex> итераций, внешний — ровно <tex>n</tex> итераций.<br />
<br />
Видно, что для восстановления нужно узнавать <tex>k</tex>-ую свободную позицию. Это можно делать с помощью [[Дерево_отрезков._Построение | дерева отрезков]] следующим образом: построим дерево отрезков для суммы на массиве из единиц. Единица в позиции означает, что данная позиция свободна. Чтобы найти <tex>k</tex>-ую свободную позицию, нужно спускаться (начиная с корня) в левое поддерево если сумма в нём больше, чем <tex>k</tex>, и в правое дерево иначе.<br />
<br />
Данный алгоритм переписывается в код следующим образом:<br />
<br />
<font color=green>// ''build_segment_tree'' {{---}} строит дерево отрезков над массивом</font><br />
<font color=green>// ''node'' {{---}} вершина дерева</font><br />
<font color=green>// ''node.index'' {{---}} индекс соответствующего элемента в массиве для листа дерева</font><br />
'''def''' recover(inv):<br />
n = inv.length<br />
tree = build_segment_tree(array(n, 1))<br />
result = array(n)<br />
curr = 1<br />
'''for''' k '''in''' inv<br />
node = tree.root<br />
'''while''' !node.is_leaf<br />
'''if''' k < node.left.value<br />
node = node.left<br />
'''else'''<br />
k -= node.left.value<br />
node = node.right<br />
result[node.index] = curr<br />
node.add(-1)<br />
curr++<br />
'''return''' result<br />
<br />
<br />
Этот алгоритм имеет сложность <tex>O(n \log n)</tex>: делается <tex>n</tex> итераций цикла, в которой происходит спуск по дереву высоты <tex>O(\log n)</tex> и один запрос на дереве отрезков. Таким образом, время работы алгоритма на каждой итерации есть <tex>O(\log n)</tex>.<br />
<br />
== Пример ==<br />
<br />
Рассмотрим пример построения таблицы инверсий и восстановления перестановки по таблице инверсий. Пусть дана перестановка <tex>(5, 7, 1, 3, 4, 6, 8, 2)</tex>. Следующая таблица показывает работу алгоритма за <tex>O(n \log n)</tex>, на каждой строке один уровень рекурсии (на первой строке — самый глубокий). В скобках стоят пары: элемент перестановки, количество инверсий. Полужирным отмечены элементы, у которых обновилось значение количества инверсий на данном шаге.<br />
<br />
{| style = "border: 0px solid; background-color: gray; text-align: center; padding : 0" cellspacing = "2"<br />
| style = "background-color: white; padding: 3px 6px" |(5, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(7, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(1, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(3, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(4, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(6, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(8, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(2, 0)<br />
|-<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(5, 0), (7, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(1, 0), (3, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(4, 0), (6, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|'''(2, 1)''', (8, 0)<br />
|-<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(1, 2)''', '''(3, 2)''', (5, 0), (7, 0)<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(2, 3)''', (4, 0), (6, 0), (8, 0)<br />
|-<br />
|colspan = "8" style = "background-color: white; padding: 3px 6px"|(1, 2), '''(2, 6)''', (3, 2), '''(4, 2)''', (5, 0), '''(6, 1)''', (7, 0), (8, 0)<br />
|}<br />
<br />
Полученная таблица инверсий: <tex>(2, 6, 2, 2, 0, 1, 0, 0)</tex>. Восстановим перестановку по таблице инверсий, начиная с пустого массива.<br />
<br />
{| style = "border: 0px solid; background-color: grey; text-align: center; padding : 0;" cellspacing = "2"<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{1}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{1}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{2}</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем шесть свободных позиций и ставим <tex>\bf{2}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{3}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{3}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{4}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{4}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{5}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиции и ставим <tex>\bf{5}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{6}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем одну свободную позицию и ставим <tex>\bf{6}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{7}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{7}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>7</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{8}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{8}</tex><br />
|}<br />
<br />
== См. также ==<br />
* [[Матричное представление перестановок]]<br />
<br />
== Источники информации ==<br />
<br />
* [https://en.wikipedia.org/wiki/Permutation Wikipedia {{---}} Permutation]<br />
* Д. Кнут - Искусство программирования, том 3 {{---}} 29-31 с.<br />
<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Комбинаторика ]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A2%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0_%D0%B8%D0%BD%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D0%B9&diff=44386Таблица инверсий2015-01-13T13:24:39Z<p>6yry6e: </p>
<hr />
<div>Пусть <tex> P = (p_1,p_2,\dots,p_n)</tex> является [[Действие перестановки на набор из элементов, представление в виде циклов|перестановкой]] чисел <tex> 1, 2,\dots, n</tex>.<br />
<br />
{{Определение<br />
|definition = <br />
'''Инверсией''' (англ. ''inversion'') в перестановке <tex>P</tex> называется всякая пара индексов <tex>i, j</tex> такая, что <tex>1\leqslant i<j\leqslant n</tex> и <tex>P[i]>P[j]</tex>.<br />
}}<br />
{{Определение<br />
|definition = <br />
'''Таблицей инверсий''' (англ. ''inversion table'') перестановки <tex> P </tex> называют такую последовательность <tex> T = (t_1,t_2,\dots,t_n)</tex>, в которой <tex>t_i</tex> равно числу элементов перестановки <tex> P </tex>, стоящих в <tex> P </tex> левее числа <tex>i</tex> и больших <tex>i</tex>.<br />
}}<br />
<br />
== Алгоритм построения за O(N<sup>2</sup>) ==<br />
<br />
Таблицу инверсий тривиально построить по определению. Для каждого элемента перестановки считаем количество элементов, больших данного и стоящих в перестановке левее него.<br />
Алгоритм построения в псевдокоде выглядит так: <br />
T[1..n] = 0<br />
'''for''' i = 1..n<br />
'''for''' j = 1..(i - 1)<br />
'''if''' P[j] > P[i]<br />
T[P[i]] = T[P[i]]++<br />
Сложность данного алгоритма {{---}} <tex>O(n^2)</tex>. Уменьшить время работы можно используя алгоритм, похожий на [[Сортировка_слиянием |сортировку слиянием.]]<br />
<br />
== Алгоритм построения за O(N log N) ==<br />
<br />
Пусть дано разбиение перестановки на два списка, причём для каждого элемента дано число инверсий слева с элементами того же списка и известно, что все числа первого списка стоят левее всех чисел второго списка в исходной перестановке. Будем считать количество инверсий слева элементов обоих списков следующим образом: сливаем списки, аналогично [[Сортировка_слиянием |сортировке слиянием.]]<br />
<br />
Если в результат нужно записать элемент первого списка, то все нерассмотренные элементы второго списка больше, следовательно, количество инверсий для этого элемента не меняется. Если в результат нужно записать элемент второго списка, то все нерассмотренные элементы первого списка больше его и стоят левее. Следовательно, количество инверсий для этого элемента следует увеличить на количество нерассмотренных элементов второго списка.<br />
<br />
Описанный алгоритм записывается в псевдокод следующим образом:<br />
<font color=green>// ''inverses_merge'' {{---}} процедура, сливающая два списка пар</font><br />
<font color=green>// ''inverses_get'' {{---}} процедура, рекурсивно получающая таблицу инверсий для перестановки</font><br />
'''def''' inverses_merge(ls1, ls2):<br />
result = []<br />
it1, it2 = ''null''<br />
'''while''' (it1 < ls1.length) '''and''' (it2 < ls2.length):<br />
'''if''' ls1[it1].item < ls2[it2].item<br />
result.append(ls1[it1])<br />
it1++<br />
'''else'''<br />
result.append(item = ls2[it2].item, inverses = ls2[it2].inverses + ls1.length - it1)<br />
it2++<br />
'''while''' it1 < ls1.length<br />
result.append(ls1[it1])<br />
it1++<br />
'''while''' it2 < ls2.length<br />
result.append(ls2[it2])<br />
it2++<br />
'''return''' result<br />
<br />
'''def''' inverses_get(ls):<br />
'''if''' ls.length == 1<br />
'''return''' [(item = ls[0], inverses = 0)]<br />
'''else'''<br />
'''return''' inverses_merge(inverses_get(ls.first_half), inverses_get(ls.second_half))<br />
<br />
<br />
Сложность представленного алгоритма есть <tex>O(n\log n)</tex>. Алгоритм с такой же сложностью можно построить с помощью [[Дерево_отрезков._Построение | дерева отрезков.]]<br />
<br />
== Алгоритм восстановления ==<br />
<br />
Для восстановления перестановки по таблицы инверсий <tex>T</tex> воспользуемся следующим соображением: единица стоит в перестановке на <tex>T_0</tex>-ом месте (индексируем элементы с нуля), так как остальные числа в перестановке больше единицы. Далее, если известны расположения всех чисел <tex>1, \dots, k</tex>, то число <tex>k + 1</tex> стоит на <tex>T_{k + 1}</tex>-ой ещё не занятой позиции: все числа, меньшие <tex>k + 1</tex> уже расставлены. Это рассуждение напрямую переписывается в код следующим образом:<br />
<font color=green>// ''j'' {{---}} счётчик пропущенных свободных позиций</font><br />
<font color=green>// ''k'' {{---}} количество инверсий слева для элемента curr</font><br />
<font color=green>// ''result'' {{---}} массив, в который записывается перестановка. Равенство элемента массива нулю обозначает, что эта позиция свободна.</font><br />
'''def''' recover_straight(ls):<br />
n = ls.length<br />
result = array(0, n)<br />
curr = 1<br />
'''for''' k '''in''' ls<br />
j = 0<br />
'''for''' i = 0..(n - 1)<br />
'''if''' result[i] == 0<br />
'''if''' j == k<br />
result[i] = curr<br />
'''break'''<br />
'''else:'''<br />
j++<br />
curr++<br />
'''return''' result<br />
<br />
<br />
Этот простой алгоритм имеет сложность <tex>O(n^2)</tex> — внутренний цикл делает до <tex>n</tex> итераций, внешний — ровно <tex>n</tex> итераций.<br />
<br />
Видно, что для восстановления нужно узнавать <tex>k</tex>-ую свободную позицию. Это можно делать с помощью [[Дерево_отрезков._Построение | дерева отрезков]] следующим образом: построим дерево отрезков для суммы на массиве из единиц. Единица в позиции означает, что данная позиция свободна. Чтобы найти <tex>k</tex>-ую свободную позицию, нужно спускаться (начиная с корня) в левое поддерево если сумма в нём больше, чем <tex>k</tex>, и в правое дерево иначе.<br />
<br />
Данный алгоритм переписывается в код следующим образом:<br />
<br />
<font color=green>// ''build_segment_tree'' {{---}} строит дерево отрезков над массивом</font><br />
<font color=green>// ''node'' {{---}} вершина дерева</font><br />
<font color=green>// ''node.index'' {{---}} индекс соответствующего элемента в массиве для листа дерева</font><br />
'''def''' recover(inv):<br />
n = inv.length<br />
tree = build_segment_tree(array(n, 1))<br />
result = array(n)<br />
curr = 1<br />
'''for''' k '''in''' inv<br />
node = tree.root<br />
'''while''' !node.is_leaf<br />
'''if''' k < node.left.value<br />
node = node.left<br />
'''else'''<br />
k -= node.left.value<br />
node = node.right<br />
result[node.index] = curr<br />
node.add(-1)<br />
curr++<br />
'''return''' result<br />
<br />
<br />
Этот алгоритм имеет сложность <tex>O(n \log n)</tex>: делается <tex>n</tex> итераций цикла, в которой происходит спуск по дереву высоты <tex>O(\log n)</tex> и один запрос на дереве отрезков. Таким образом, время работы алгоритма на каждой итерации есть <tex>O(\log n)</tex>.<br />
<br />
== Пример ==<br />
<br />
Рассмотрим пример построения таблицы инверсий и восстановления перестановки по таблице инверсий. Пусть дана перестановка <tex>(5, 7, 1, 3, 4, 6, 8, 2)</tex>. Следующая таблица показывает работу алгоритма за <tex>O(n \log n)</tex>, на каждой строке один уровень рекурсии (на первой строке — самый глубокий). В скобках стоят пары: элемент перестановки, количество инверсий. Полужирным отмечены элементы, у которых обновилось значение количества инверсий на данном шаге.<br />
<br />
{| style = "border: 0px solid; background-color: gray; text-align: center; padding : 0" cellspacing = "2"<br />
| style = "background-color: white; padding: 3px 6px" |(5, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(7, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(1, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(3, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(4, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(6, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(8, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(2, 0)<br />
|-<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(5, 0), (7, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(1, 0), (3, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(4, 0), (6, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|'''(2, 1)''', (8, 0)<br />
|-<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(1, 2)''', '''(3, 2)''', (5, 0), (7, 0)<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(2, 3)''', (4, 0), (6, 0), (8, 0)<br />
|-<br />
|colspan = "8" style = "background-color: white; padding: 3px 6px"|(1, 2), '''(2, 6)''', (3, 2), '''(4, 2)''', (5, 0), '''(6, 1)''', (7, 0), (8, 0)<br />
|}<br />
<br />
Полученная таблица инверсий: <tex>(2, 6, 2, 2, 0, 1, 0, 0)</tex>. Восстановим перестановку по таблице инверсий, начиная с пустого массива.<br />
<br />
{| style = "border: 0px solid; background-color: grey; text-align: center; padding : 0;" cellspacing = "2"<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{1}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{1}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{2}</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем шесть свободных позиций и ставим <tex>\bf{2}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{3}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{3}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{4}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{4}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{5}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиции и ставим <tex>\bf{5}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{6}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем одну свободную позицию и ставим <tex>\bf{6}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{7}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{7}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>7</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{8}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{8}</tex><br />
|}<br />
<br />
== См. также ==<br />
* [[Матричное представление перестановок]]<br />
<br />
== Источники информации ==<br />
<br />
* [https://en.wikipedia.org/wiki/Permutation Wikipedia {{---}} Permutation]<br />
* Д. Кнут - Искусство программирования, том 3 {{---}} 29-31 с.<br />
<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Комбинаторика ]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A2%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0_%D0%B8%D0%BD%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D0%B9&diff=44384Таблица инверсий2015-01-13T13:05:29Z<p>6yry6e: </p>
<hr />
<div>Пусть <tex> P = (p_1,p_2,\dots,p_n)</tex> является [[Действие перестановки на набор из элементов, представление в виде циклов|перестановкой]] чисел <tex> 1, 2,\dots, n</tex>.<br />
<br />
{{Определение<br />
|definition = <br />
'''Инверсией''' (англ. ''inversion'') в перестановке <tex>P</tex> называется всякая пара индексов <tex>i, j</tex> такая, что <tex>1\leqslant i<j\leqslant n</tex> и <tex>P[i]>P[j]</tex>.<br />
}}<br />
{{Определение<br />
|definition = <br />
'''Таблицей инверсий''' (англ. ''inversion table'') перестановки <tex> P </tex> называют такую последовательность <tex> T = (t_1,t_2,\dots,t_n)</tex>, в которой <tex>t_i</tex> равно числу элементов перестановки <tex> P </tex>, стоящих в <tex> P </tex> левее числа <tex>i</tex> и больших <tex>i</tex>.<br />
}}<br />
<br />
== Алгоритм построения за O(N<sup>2</sup>) ==<br />
<br />
Таблицу инверсий тривиально построить по определению. Для каждого элемента перестановки считаем количество элементов, больших данного и стоящих в перестановке левее него.<br />
Алгоритм построения в псевдокоде выглядит так: <br />
T[1..n] = 0<br />
'''for''' i = 1..n<br />
'''for''' j = 1..(i - 1)<br />
'''if''' P}[j] > P}[i]<br />
T[P[i]] = T[P[i]]++<br />
Сложность данного алгоритма {{---}} <tex>O(n^2)</tex>. Уменьшить время работы можно используя алгоритм, похожий на [[Сортировка_слиянием |сортировку слиянием.]]<br />
<br />
== Алгоритм построения за O(N log N) ==<br />
<br />
Пусть дано разбиение перестановки на два списка, причём для каждого элемента дано число инверсий слева с элементами того же списка и известно, что все числа первого списка стоят левее всех чисел второго списка в исходной перестановке. Будем считать количество инверсий слева элементов обоих списков следующим образом: сливаем списки, аналогично [[Сортировка_слиянием |сортировке слиянием.]]<br />
<br />
Если в результат нужно записать элемент первого списка, то все нерассмотренные элементы второго списка больше, следовательно, количество инверсий для этого элемента не меняется. Если в результат нужно записать элемент второго списка, то все нерассмотренные элементы первого списка больше его и стоят левее. Следовательно, количество инверсий для этого элемента следует увеличить на количество нерассмотренных элементов второго списка.<br />
<br />
Описанный алгоритм записывается в псевдокод следующим образом:<br />
<font color=green>// ''inverses_merge'' {{---}} процедура, сливающая два списка пар</font><br />
<font color=green>// ''inverses_get'' {{---}} процедура, рекурсивно получающая таблицу инверсий для перестановки</font><br />
'''def''' inverses_merge(ls1, ls2)}:<br />
result = []<br />
it1, it2 = ''null''<br />
'''while''' (it1 < ls1.length) '''and''' (it2 < ls2.length):<br />
'''if''' ls1[it1}].item < ls2[it2].item:<br />
result.append(ls1[it1])<br />
it1++<br />
'''else:'''<br />
result.append(item = ls2[it2].item, inverses = ls2[it2].inverses + ls1.length - it1)<br />
it2++<br />
'''while''' it1 < ls1.length):<br />
result.append(ls1[it1])<br />
it1++<br />
'''while''' (it2 < ls2.length):<br />
result.append(ls2[it2])<br />
it2++<br />
'''return''' result<br />
<br />
'''def''' inverses_get(ls)}:<br />
'''if''' ls.length == 1<br />
'''return''' [(item = ls[0], inverses = 0)]<br />
'''else:'''<br />
'''return''' inverses_merge(inverses_get(ls.first_half), inverses_get(ls.second_half))<br />
<br />
<br />
Сложность представленного алгоритма есть <tex>O(n\log n)</tex>. Алгоритм с такой же сложностью можно построить с помощью [[Дерево_отрезков._Построение | дерева отрезков.]]<br />
<br />
== Алгоритм восстановления ==<br />
<br />
Для восстановления перестановки по таблицы инверсий <tex>T</tex> воспользуемся следующим соображением: единица стоит в перестановке на <tex>T_0</tex>-ом месте (индексируем элементы с нуля), так как остальные числа в перестановке больше единицы. Далее, если известны расположения всех чисел <tex>1, \dots, k</tex>, то число <tex>k + 1</tex> стоит на <tex>T_{k + 1}</tex>-ой ещё не занятой позиции: все числа, меньшие <tex>k + 1</tex> уже расставлены. Это рассуждение напрямую переписывается в код следующим образом:<br />
<font color=green>// ''j'' {{---}} счётчик пропущенных свободных позиций</font><br />
<font color=green>// ''k'' {{---}} количество инверсий слева для элемента curr</font><br />
<font color=green>// ''result'' {{---}} массив, в который записывается перестановка. Равенство элемента массива нулю обозначает, что эта позиция свободна.</font><br />
'''def''' recover_straight(ls):<br />
n = ls.length<br />
result = array(0, n)<br />
curr = 1<br />
'''for''' k ''in'' ls:<br />
j = 0<br />
'''for''' i..n<br />
'''if''' result[i] == 0<br />
'''if''' j == k<br />
result[i] = curr<br />
'''break'''<br />
'''else:'''<br />
j++<br />
curr++<br />
'''return''' result<br />
<br />
<br />
Этот простой алгоритм имеет сложность <tex>O(n^2)</tex> — внутренний цикл делает до <tex>n</tex> итераций, внешний — ровно <tex>n</tex> итераций.<br />
<br />
Видно, что для восстановления нужно узнавать <tex>k</tex>-ую свободную позицию. Это можно делать с помощью [[Дерево_отрезков._Построение | дерева отрезков]] следующим образом: построим дерево отрезков для суммы на массиве из единиц. Единица в позиции означает, что данная позиция свободна. Чтобы найти <tex>k</tex>-ую свободную позицию, нужно спускаться (начиная с корня) в левое поддерево если сумма в нём больше, чем <tex>k</tex>, и в правое дерево иначе.<br />
<br />
Данный алгоритм переписывается в код следующим образом:<br />
<br />
<font color=green>// ''build_segment_tree'' {{---}} строит дерево отрезков над массивом</font><br />
<font color=green>// ''node'' {{---}} вершина дерева</font><br />
<font color=green>// ''node.index'' {{---}} индекс соответствующего элемента в массиве для листа дерева</font><br />
'''def''' recover(inv):<br />
n = inv.length<br />
tree = build_segment_tree(array(n, 1))<br />
result = array(n)<br />
curr = 1<br />
'''for''' k ''in'' inv<br />
node = tree.root<br />
'''while''' !node.is_leaf<br />
'''if''' k < node.left.value<br />
node = node.left<br />
'''else:'''<br />
k -= node.left.value<br />
node = node.right<br />
result[node.index] = curr<br />
node.add(-1)<br />
curr++<br />
'''return''' result<br />
<br />
<br />
Этот алгоритм имеет сложность <tex>O(n \log n)</tex>: делается <tex>n</tex> итераций цикла, в которой происходит спуск по дереву высоты <tex>O(\log n)</tex> и один запрос на дереве отрезков. Таким образом, время работы алгоритма на каждой итерации есть <tex>O(\log n)</tex>.<br />
<br />
== Пример ==<br />
<br />
Рассмотрим пример построения таблицы инверсий и восстановления перестановки по таблице инверсий. Пусть дана перестановка <tex>(5, 7, 1, 3, 4, 6, 8, 2)</tex>. Следующая таблица показывает работу алгоритма за <tex>O(n \log n)</tex>, на каждой строке один уровень рекурсии (на первой строке — самый глубокий). В скобках стоят пары: элемент перестановки, количество инверсий. Полужирным отмечены элементы, у которых обновилось значение количества инверсий на данном шаге.<br />
<br />
{| style = "border: 0px solid; background-color: gray; text-align: center; padding : 0" cellspacing = "2"<br />
| style = "background-color: white; padding: 3px 6px" |(5, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(7, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(1, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(3, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(4, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(6, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(8, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(2, 0)<br />
|-<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(5, 0), (7, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(1, 0), (3, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(4, 0), (6, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|'''(2, 1)''', (8, 0)<br />
|-<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(1, 2)''', '''(3, 2)''', (5, 0), (7, 0)<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(2, 3)''', (4, 0), (6, 0), (8, 0)<br />
|-<br />
|colspan = "8" style = "background-color: white; padding: 3px 6px"|(1, 2), '''(2, 6)''', (3, 2), '''(4, 2)''', (5, 0), '''(6, 1)''', (7, 0), (8, 0)<br />
|}<br />
<br />
Полученная таблица инверсий: <tex>(2, 6, 2, 2, 0, 1, 0, 0)</tex>. Восстановим перестановку по таблице инверсий, начиная с пустого массива.<br />
<br />
{| style = "border: 0px solid; background-color: grey; text-align: center; padding : 0;" cellspacing = "2"<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{1}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{1}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{2}</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем шесть свободных позиций и ставим <tex>\bf{2}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{3}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{3}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{4}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{4}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{5}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиции и ставим <tex>\bf{5}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{6}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем одну свободную позицию и ставим <tex>\bf{6}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{7}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{7}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>7</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{8}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{8}</tex><br />
|}<br />
<br />
== См. также ==<br />
* [[Матричное представление перестановок]]<br />
<br />
== Источники информации ==<br />
<br />
* [https://en.wikipedia.org/wiki/Permutation Wikipedia {{---}} Permutation]<br />
* Д. Кнут - Искусство программирования, том 3 {{---}} 29-31 с.<br />
<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Комбинаторика ]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A2%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0_%D0%B8%D0%BD%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D0%B9&diff=44382Таблица инверсий2015-01-13T04:39:20Z<p>6yry6e: </p>
<hr />
<div>Пусть <tex> P = (p_1,p_2,\dots,p_n)</tex> является [[Действие перестановки на набор из элементов, представление в виде циклов|перестановкой]] чисел <tex> 1, 2,\dots, n</tex>.<br />
<br />
{{Определение<br />
|definition = <br />
'''Инверсией''' (англ. ''inversion'') в перестановке <tex>P</tex> называется всякая пара индексов <tex>i, j</tex> такая, что <tex>1\leqslant i<j\leqslant n</tex> и <tex>P[i]>P[j]</tex>.<br />
}}<br />
{{Определение<br />
|definition = <br />
'''Таблицей инверсий''' (англ. ''inversion table'') перестановки <tex> P </tex> называют такую последовательность <tex> T = (t_1,t_2,\dots,t_n)</tex>, в которой <tex>t_i</tex> равно числу элементов перестановки <tex> P </tex>, стоящих в <tex> P </tex> левее числа <tex>i</tex> и больших <tex>i</tex>.<br />
}}<br />
<br />
== Алгоритм построения за O(N<sup>2</sup>) ==<br />
<br />
Таблицу инверсий тривиально построить по определению. Для каждого элемента перестановки считаем количество элементов, больших данного и стоящих в перестановке левее него.<br />
Алгоритм построения в псевдокоде выглядит так: <br />
T[1..n] = 0<br />
'''for''' i = 1..n<br />
'''for''' j = 1..(i - 1)<br />
'''if''' P}[j] > P}[i]<br />
T[P[i]] = T[P[i]]++<br />
Сложность данного алгоритма {{---}} <tex>O(n^2)</tex>. Уменьшить время работы можно используя алгоритм, похожий на [[Сортировка_слиянием |сортировку слиянием.]]<br />
<br />
== Алгоритм построения за O(N log N) ==<br />
<br />
Пусть дано разбиение перестановки на два списка, причём для каждого элемента дано число инверсий слева с элементами того же списка и известно, что все числа первого списка стоят левее всех чисел второго списка в исходной перестановке. Будем считать количество инверсий слева элементов обоих списков следующим образом: сливаем списки, аналогично [[Сортировка_слиянием |сортировке слиянием.]]<br />
<br />
Если в результат нужно записать элемент первого списка, то все нерассмотренные элементы второго списка больше, следовательно, количество инверсий для этого элемента не меняется. Если в результат нужно записать элемент второго списка, то все нерассмотренные элементы первого списка больше его и стоят левее. Следовательно, количество инверсий для этого элемента следует увеличить на количество нерассмотренных элементов второго списка.<br />
<br />
Описанный алгоритм записывается в псевдокод следующим образом:<br />
<font color=green>// ''inverses_merge'' {{---}} процедура, сливающая два списка пар</font><br />
<font color=green>// ''inverses_get'' {{---}} процедура, рекурсивно получающая таблицу инверсий для перестановки</font><br />
'''def''' inverses_merge(ls1, ls2)}:<br />
result = []<br />
it1, it2 = ''null''<br />
'''while''' (it1 < ls1.length) '''and''' (it2 < ls2.length):<br />
'''if''' ls1[it1}].item < ls2[it2].item:<br />
result.append(ls1[it1])<br />
it1++<br />
'''else:'''<br />
result.append(item = ls2[it2].item, inverses = ls2[it2].inverses + ls1.length - it1)<br />
it2++<br />
'''while''' it1 < ls1.length):<br />
result.append(ls1[it1])<br />
it1++<br />
'''while''' (it2 < ls2.length):<br />
result.append(ls2[it2])<br />
it2++<br />
'''return''' result<br />
<br />
'''def''' inverses_get(ls)}:<br />
'''if''' ls.length == 1<br />
'''return''' [(item = ls[0], inverses = 0)]<br />
'''else:'''<br />
'''return''' inverses_merge(inverses_get(ls.first_half), inverses_get(ls.second_half))<br />
<br />
<br />
Сложность представленного алгоритма есть <tex>O(n\log n)</tex>. Алгоритм с такой же сложностью можно построить с помощью [[Дерево_отрезков._Построение | дерева отрезков.]]<br />
<br />
== Алгоритм восстановления ==<br />
<br />
Для восстановления перестановки по таблицы инверсий <tex>T</tex> воспользуемся следующим соображением: единица стоит в перестановке на <tex>T_0</tex>-ом месте (индексируем элементы с нуля), так как остальные числа в перестановке больше единицы. Далее, если известны расположения всех чисел <tex>1, \dots, k</tex>, то число <tex>k + 1</tex> стоит на <tex>T_{k + 1}</tex>-ой ещё не занятой позиции: все числа, меньшие <tex>k + 1</tex> уже расставлены. Это рассуждение напрямую переписывается в код следующим образом:<br />
<font color=green>// ''j'' {{---}} счётчик пропущенных свободных позиций</font><br />
<font color=green>// ''k'' {{---}} количество инверсий слева для элемента curr</font><br />
<font color=green>// ''result'' {{---}} массив, в который записывается перестановка. Равенство элемента массива нулю обозначает, что эта позиция свободна.</font><br />
'''def''' recover_straight(ls):<br />
n = ls.length<br />
result = array(0, n)<br />
curr = 1<br />
'''for''' k ''in'' ls:<br />
j = 0<br />
'''for''' i..n<br />
'''if''' result[i] == 0<br />
'''if''' j == k<br />
result[i] = curr<br />
'''break'''<br />
'''else:'''<br />
j++<br />
curr++<br />
'''return''' result<br />
<br />
<br />
Этот простой алгоритм имеет сложность <tex>O(n^2)</tex> — внутренний цикл делает до <tex>n</tex> итераций, внешний — ровно <tex>n</tex> итераций.<br />
<br />
Видно, что для восстановления нужно узнавать <tex>k</tex>-ую свободную позицию. Это можно делать с помощью [[Дерево_отрезков._Построение | дерева отрезков]] следующим образом: построим дерево отрезков для суммы на массиве из единиц. Единица в позиции означает, что данная позиция свободна. Чтобы найти <tex>k</tex>-ую свободную позицию, нужно спускаться (начиная с корня) в левое поддерево если сумма в нём больше, чем <tex>k</tex>, и в правое дерево иначе.<br />
<br />
Данный алгоритм переписывается в код следующим образом:<br />
<br />
<font color=green>// ''build_segment_tree'' {{---}} строит дерево отрезков над массивом</font><br />
<font color=green>// ''node'' {{---}} вершина дерева</font><br />
<font color=green>// ''node.index'' {{---}} индекс соответствующего элемента в массиве для листа дерева</font><br />
'''def''' recover(inv):<br />
n = inv.length<br />
tree = build_segment_tree(array(n, 1))<br />
result = array(n)<br />
curr = 1<br />
'''for''' k ''in'' inv<br />
node = tree.root<br />
'''while''' !node.is_leaf<br />
'''if''' k < node.left.value<br />
node = node.left<br />
'''else:'''<br />
k -= node.left.value<br />
node = node.right<br />
result[node.index] = curr<br />
node.add(-1)<br />
curr++<br />
'''return''' result<br />
<br />
<br />
Этот алгоритм имеет сложность <tex>O(n \log n)</tex>: делается <tex>n</tex> итераций цикла, в которой происходит спуск по дереву высоты <tex>O(\log n)</tex> и один запрос на дереве отрезков. Таким образом, время работы алгоритма на каждой итерации есть <tex>O(\log n)</tex>.<br />
<br />
== Пример ==<br />
<br />
Рассмотрим пример построения таблицы инверсий и восстановления перестановки по таблице инверсий. Пусть дана перестановка <tex>(5, 7, 1, 3, 4, 6, 8, 2)</tex>. Следующая таблица показывает работу алгоритма за <tex>O(n \log n)</tex>, на каждой строке один уровень рекурсии (на первой строке — самый глубокий). В скобках стоят пары: элемент перестановки, количество инверсий. Полужирным отмечены элементы, у которых обновилось значение количества инверсий на данном шаге.<br />
<br />
{| style = "border: 0px solid; background-color: gray; text-align: center; padding : 0" cellspacing = "2"<br />
| style = "background-color: white; padding: 3px 6px" |(5, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(7, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(1, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(3, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(4, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(6, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(8, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(2, 0)<br />
|-<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(5, 0), (7, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(1, 0), (3, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(4, 0), (6, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|'''(2, 1)''', (8, 0)<br />
|-<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(1, 2)''', '''(3, 2)''', (5, 0), (7, 0)<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(2, 3)''', (4, 0), (6, 0), (8, 0)<br />
|-<br />
|colspan = "8" style = "background-color: white; padding: 3px 6px"|(1, 2), '''(2, 6)''', (3, 2), '''(4, 2)''', (5, 0), '''(6, 1)''', (7, 0), (8, 0)<br />
|}<br />
<br />
Полученная таблица инверсий: <tex>(2, 6, 2, 2, 0, 1, 0, 0)</tex>. Восстановим перестановку по таблице инверсий, начиная с пустого массива.<br />
<br />
{| style = "border: 0px solid; background-color: grey; text-align: center; padding : 0;" cellspacing = "2"<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{1}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{1}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{2}</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем шесть свободных позиций и ставим <tex>\bf{2}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{3}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{3}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{4}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{4}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{5}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиции и ставим <tex>\bf{5}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{6}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем одну свободную позицию и ставим <tex>\bf{6}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{7}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{7}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>7</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{8}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{8}</tex><br />
|}<br />
<br />
== См. также ==<br />
* [[Матричное представление перестановок]]<br />
<br />
== Источники информации ==<br />
<br />
* [https://en.wikipedia.org/wiki/Permutation Wikipedia {{---}} Permutation]<br />
* Д. Кнут - Искусство программирования, том 3.<br />
<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Комбинаторика ]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A2%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0_%D0%B8%D0%BD%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D0%B9&diff=44381Таблица инверсий2015-01-13T04:37:32Z<p>6yry6e: </p>
<hr />
<div>Пусть <tex> P = (p_1,p_2,\dots,p_n)</tex> является [[Действие перестановки на набор из элементов, представление в виде циклов|перестановкой]] чисел <tex> 1, 2,\dots, n</tex>.<br />
<br />
{{Определение<br />
|definition = <br />
'''Инверсией''' (англ. ''inversion'') в перестановке <tex>P</tex> называется всякая пара индексов <tex>i, j</tex> такая, что <tex>1\leqslant i<j\leqslant n</tex> и <tex>P[i]>P[j]</tex>.<br />
}}<br />
{{Определение<br />
|definition = <br />
'''Таблицей инверсий''' (англ. ''inversion table'') перестановки <tex> P </tex> называют такую последовательность <tex> T = (t_1,t_2,\dots,t_n)</tex>, в которой <tex>t_i</tex> равно числу элементов перестановки <tex> P </tex>, стоящих в <tex> P </tex> левее числа <tex>i</tex> и больших <tex>i</tex>.<br />
}}<br />
<br />
== Алгоритм построения за O(N<sup>2</sup>) ==<br />
<br />
Таблицу инверсий тривиально построить по определению. Для каждого элемента перестановки считаем количество элементов, больших данного и стоящих в перестановке левее него.<br />
Алгоритм построения в псевдокоде выглядит так: <br />
T[1..n] = 0<br />
'''for''' i = 1..n<br />
'''for''' j = 1..(i - 1)<br />
'''if''' P}[j] > P}[i]<br />
T[P[i]] = T[P[i]]++<br />
Сложность данного алгоритма {{---}} <tex>O(n^2)</tex>. Уменьшить время работы можно используя алгоритм, похожий на [[Сортировка_слиянием |сортировку слиянием.]]<br />
<br />
== Алгоритм построения за O(N log N) ==<br />
<br />
Пусть дано разбиение перестановки на два списка, причём для каждого элемента дано число инверсий слева с элементами того же списка и известно, что все числа первого списка стоят левее всех чисел второго списка в исходной перестановке. Будем считать количество инверсий слева элементов обоих списков следующим образом: сливаем списки, аналогично [[Сортировка_слиянием |сортировке слиянием.]]<br />
<br />
Если в результат нужно записать элемент первого списка, то все нерассмотренные элементы второго списка больше, следовательно, количество инверсий для этого элемента не меняется. Если в результат нужно записать элемент второго списка, то все нерассмотренные элементы первого списка больше его и стоят левее. Следовательно, количество инверсий для этого элемента следует увеличить на количество нерассмотренных элементов второго списка.<br />
<br />
Описанный алгоритм записывается в псевдокод следующим образом:<br />
<font color=green>// ''inverses_merge'' {{---}} процедура, сливающая два списка пар</font><br />
<font color=green>// ''inverses_get'' {{---}} процедура, рекурсивно получающая таблицу инверсий для перестановки</font><br />
'''def''' inverses_merge(ls1, ls2)}:<br />
result = []<br />
it1, it2 = ''null''<br />
'''while''' (it1 < ls1.length) '''and''' (it2 < ls2.length):<br />
'''if''' ls1[it1}].item < ls2[it2].item:<br />
result.append(ls1[it1])<br />
it1++<br />
'''else:'''<br />
result.append(item = ls2[it2].item, inverses = ls2[it2].inverses + ls1.length - it1)<br />
it2++<br />
'''while''' it1 < ls1.length):<br />
result.append(ls1[it1])<br />
it1++<br />
'''while''' (it2 < ls2.length):<br />
result.append(ls2[it2])<br />
it2++<br />
'''return''' result<br />
<br />
'''def''' inverses_get(ls)}:<br />
'''if''' ls.length == 1<br />
'''return''' [(item = ls[0], inverses = 0)]<br />
'''else:'''<br />
'''return''' inverses_merge(inverses_get(ls.first_half), inverses_get(ls.second_half))<br />
<br />
<br />
Сложность представленного алгоритма есть <tex>O(n\log n)</tex>. Алгоритм с такой же сложностью можно построить с помощью [[Дерево_отрезков._Построение | дерева отрезков.]]<br />
<br />
== Алгоритм восстановления ==<br />
<br />
Для восстановления перестановки по таблицы инверсий <tex>T</tex> воспользуемся следующим соображением: единица стоит в перестановке на <tex>T_0</tex>-ом месте (индексируем элементы с нуля), так как остальные числа в перестановке больше единицы. Далее, если известны расположения всех чисел <tex>1, \dots, k</tex>, то число <tex>k + 1</tex> стоит на <tex>T_{k + 1}</tex>-ой ещё не занятой позиции: все числа, меньшие <tex>k + 1</tex> уже расставлены. Это рассуждение напрямую переписывается в код следующим образом:<br />
<font color=green>// ''j'' {{---}} счётчик пропущенных свободных позиций</font><br />
<font color=green>// ''k'' {{---}} количество инверсий слева для элемента curr</font><br />
<font color=green>// ''result'' {{---}} массив, в который записывается перестановка. Равенство элемента массива нулю обозначает, что эта позиция свободна.</font><br />
'''def''' recover_straight(ls):<br />
n = ls.length<br />
result = array(0, n)<br />
curr = 1<br />
'''for''' k ''in'' ls:<br />
j = 0<br />
'''for''' i..n<br />
'''if''' result[i] == 0<br />
'''if''' j == k<br />
result[i] = curr<br />
'''break'''<br />
'''else:'''<br />
j++<br />
curr++<br />
'''return''' result<br />
<br />
<br />
Этот простой алгоритм имеет сложность <tex>O(n^2)</tex> — внутренний цикл делает до <tex>n</tex> итераций, внешний — ровно <tex>n</tex> итераций.<br />
<br />
Видно, что для восстановления нужно узнавать <tex>k</tex>-ую свободную позицию. Это можно делать с помощью [[Дерево_отрезков._Построение | дерева отрезков]] следующим образом: построим дерево отрезков для суммы на массиве из единиц. Единица в позиции означает, что данная позиция свободна. Чтобы найти <tex>k</tex>-ую свободную позицию, нужно спускаться (начиная с корня) в левое поддерево если сумма в нём больше, чем <tex>k</tex>, и в правое дерево иначе.<br />
<br />
Данный алгоритм переписывается в код следующим образом:<br />
<br />
<font color=green>// ''build_segment_tree'' {{---}} строит дерево отрезков над массивом</font><br />
<font color=green>// <''node'' {{---}} вершина дерева</font><br />
<font color=green>// ''node.index'' {{---}} индекс соответствующего элемента в массиве для листа дерева</font><br />
'''def''' recover(inv):<br />
n = inv.length<br />
tree = build_segment_tree(array(n, 1))<br />
result = array(n)<br />
curr = 1<br />
'''for''' k ''in'' inv<br />
node = tree.root<br />
'''while''' !node.is_leaf<br />
'''if''' k < node.left.value<br />
node = node.left<br />
'''else:'''<br />
k -= node.left.value<br />
node = node.right<br />
result[node.index] = curr<br />
node.add(-1)<br />
curr++<br />
'''return''' result<br />
<br />
<br />
Этот алгоритм имеет сложность <tex>O(n \log n)</tex>: делается <tex>n</tex> итераций цикла, в которой происходит спуск по дереву высоты <tex>O(\log n)</tex> и один запрос на дереве отрезков. Таким образом, время работы алгоритма на каждой итерации есть <tex>O(\log n)</tex>.<br />
<br />
== Пример ==<br />
<br />
Рассмотрим пример построения таблицы инверсий и восстановления перестановки по таблице инверсий. Пусть дана перестановка <tex>(5, 7, 1, 3, 4, 6, 8, 2)</tex>. Следующая таблица показывает работу алгоритма за <tex>O(n \log n)</tex>, на каждой строке один уровень рекурсии (на первой строке — самый глубокий). В скобках стоят пары: элемент перестановки, количество инверсий. Полужирным отмечены элементы, у которых обновилось значение количества инверсий на данном шаге.<br />
<br />
{| style = "border: 0px solid; background-color: gray; text-align: center; padding : 0" cellspacing = "2"<br />
| style = "background-color: white; padding: 3px 6px" |(5, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(7, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(1, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(3, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(4, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(6, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(8, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(2, 0)<br />
|-<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(5, 0), (7, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(1, 0), (3, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(4, 0), (6, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|'''(2, 1)''', (8, 0)<br />
|-<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(1, 2)''', '''(3, 2)''', (5, 0), (7, 0)<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(2, 3)''', (4, 0), (6, 0), (8, 0)<br />
|-<br />
|colspan = "8" style = "background-color: white; padding: 3px 6px"|(1, 2), '''(2, 6)''', (3, 2), '''(4, 2)''', (5, 0), '''(6, 1)''', (7, 0), (8, 0)<br />
|}<br />
<br />
Полученная таблица инверсий: <tex>(2, 6, 2, 2, 0, 1, 0, 0)</tex>. Восстановим перестановку по таблице инверсий, начиная с пустого массива.<br />
<br />
{| style = "border: 0px solid; background-color: grey; text-align: center; padding : 0;" cellspacing = "2"<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{1}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{1}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{2}</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем шесть свободных позиций и ставим <tex>\bf{2}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{3}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{3}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{4}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{4}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{5}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиции и ставим <tex>\bf{5}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{6}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем одну свободную позицию и ставим <tex>\bf{6}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{7}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{7}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>7</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{8}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{8}</tex><br />
|}<br />
<br />
== См. также ==<br />
* [[Матричное представление перестановок]]<br />
<br />
== Источники информации ==<br />
<br />
* [https://en.wikipedia.org/wiki/Permutation Wikipedia {{---}} Permutation]<br />
* Д. Кнут - Искусство программирования, том 3.<br />
<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Комбинаторика ]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A2%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0_%D0%B8%D0%BD%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D0%B9&diff=44314Таблица инверсий2015-01-12T16:08:02Z<p>6yry6e: </p>
<hr />
<div>Пусть <tex> P = (p_1,p_2,\dots,p_n)</tex> является [[Действие перестановки на набор из элементов, представление в виде циклов|перестановкой]] чисел <tex> 1, 2,\dots, n</tex>.<br />
<br />
{{Определение<br />
|definition = <br />
'''Инверсией''' (англ. ''inversion'') в перестановке <tex>P</tex> называется всякая пара индексов <tex>i, j</tex> такая, что <tex>1\leqslant i<j\leqslant n</tex> и <tex>P[i]>P[j]</tex>.<br />
}}<br />
{{Определение<br />
|definition = <br />
'''Таблицей инверсий''' (англ. ''inversion table'') перестановки <tex> P </tex> называют такую последовательность <tex> T = (t_1,t_2,\dots,t_n)</tex>, в которой <tex>t_i</tex> равно числу элементов перестановки <tex> P </tex>, стоящих в <tex> P </tex> левее числа <tex>i</tex> и больших <tex>i</tex>.<br />
}}<br />
<br />
== Алгоритм построения за O(N<sup>2</sup>) ==<br />
<br />
Таблицу инверсий тривиально построить по определению. Для каждого элемента перестановки считаем количество элементов, больших данного и стоящих в перестановке левее него.<br />
Алгоритм построения в псевдокоде выглядит так: <br />
<tex>\mathtt{T}[1..n]\ =</tex> <tex>0</tex><br />
'''for''' <tex>i\ =</tex> <tex>1..n</tex><br />
'''for''' <tex>j\ =</tex> <tex>1..(i - 1)</tex><br />
'''if''' <tex>\mathtt{P}[j]</tex> <tex>></tex> <tex>\mathtt{P}[i]</tex><br />
<tex>\mathtt{T}[\mathtt{P}[i]]\ =</tex> <tex>\mathtt{T}[\mathtt{P}[i]]++</tex><br />
Сложность данного алгоритма {{---}} <tex>O(n^2)</tex>. Уменьшить время работы можно используя алгоритм, похожий на [[Сортировка_слиянием |сортировку слиянием.]]<br />
<br />
== Алгоритм построения за O(N log N) ==<br />
<br />
Пусть дано разбиение перестановки на два списка, причём для каждого элемента дано число инверсий слева с элементами того же списка и известно, что все числа первого списка стоят левее всех чисел второго списка в исходной перестановке. Будем считать количество инверсий слева элементов обоих списков следующим образом: сливаем списки, аналогично [[Сортировка_слиянием |сортировке слиянием.]]<br />
<br />
Если в результат нужно записать элемент первого списка, то все нерассмотренные элементы второго списка больше, следовательно, количество инверсий для этого элемента не меняется. Если в результат нужно записать элемент второго списка, то все нерассмотренные элементы первого списка больше его и стоят левее. Следовательно, количество инверсий для этого элемента следует увеличить на количество нерассмотренных элементов второго списка.<br />
<br />
Описанный алгоритм записывается в псевдокод следующим образом:<br />
<font color=green>// <tex>inverses\_merge</tex> {{---}} процедура, сливающая два списка пар</font><br />
<font color=green>// <tex>inverses\_get</tex> {{---}} процедура, рекурсивно получающая таблицу инверсий для перестановки</font><br />
'''def''' <tex>\mathtt{inverses\_merge(ls1, ls2)}:</tex><br />
<tex>\mathtt{result}\ = [ ]</tex><br />
<tex>it\textit{1}, it\textit{2}\ =</tex> ''null''<br />
'''while''' <tex>(it\textit{1}</tex> <tex><</tex> <tex>\mathtt{ls1.length})</tex> '''and''' <tex>(it\textit{2}</tex> <tex><</tex> <tex>\mathtt{ls2.length}):</tex><br />
'''if''' <tex>\mathtt{ls1}[it\textit{1}]\mathtt{.item}</tex> <tex><</tex> <tex>\mathtt{ls2}[it\textit{2}]\mathtt{.item}:</tex><br />
<tex>\mathtt{result.append}(\mathtt{ls1}[it\textit{1}])</tex><br />
<tex>it\textit{1}++</tex><br />
'''else:'''<br />
<tex>\mathtt{result.append}(item\ =</tex> <tex>\mathtt{ls2}[it\textit{2}]\mathtt{.item}, inverses\ =</tex> <tex>\mathtt{ls2}[it\textit{2}]\mathtt{.inverses}</tex> <tex>+</tex> <tex>\mathtt{ls1.length}</tex> <tex>-</tex> <tex>it\textit{1})</tex><br />
<tex>it\textit{2}++</tex><br />
'''while''' <tex>(it\textit{1}</tex> <tex><</tex> <tex>\mathtt{ls1.length}):</tex><br />
<tex>\mathtt{result.append}(\mathtt{ls1}[it\textit{1}])</tex><br />
<tex>it\textit{1}++</tex><br />
'''while''' <tex>(it\textit{2}</tex> <tex><</tex> <tex>\mathtt{ls2.length}):</tex><br />
<tex>\mathtt{result.append}(\mathtt{ls2}[it\textit{2}])</tex><br />
<tex>it\textit{2}++</tex><br />
'''return''' <tex>\mathtt{result}</tex><br />
<br />
'''def''' <tex>\mathtt{inverses\_get(ls)}:</tex><br />
'''if''' <tex>\mathtt{ls.length}\ == 1:</tex><br />
'''return''' <tex>[(item = \mathtt{ls[0]}, inverses = 0)]</tex><br />
'''else:'''<br />
'''return''' <tex>\mathtt{inverses\_merge(inverses\_get(ls.first\_half), inverses\_get(ls.second\_half))}</tex><br />
<br />
<br />
Сложность представленного алгоритма есть <tex>O(n\log n)</tex>. Алгоритм с такой же сложностью можно построить с помощью [[Дерево_отрезков._Построение | дерева отрезков.]]<br />
<br />
== Алгоритм восстановления ==<br />
<br />
Для восстановления перестановки по таблицы инверсий <tex>T</tex> воспользуемся следующим соображением: единица стоит в перестановке на <tex>T_0</tex>-ом месте (индексируем элементы с нуля), так как остальные числа в перестановке больше единицы. Далее, если известны расположения всех чисел <tex>1, \dots, k</tex>, то число <tex>k + 1</tex> стоит на <tex>T_{k + 1}</tex>-ой ещё не занятой позиции: все числа, меньшие <tex>k + 1</tex> уже расставлены. Это рассуждение напрямую переписывается в код следующим образом:<br />
<font color=green>// <tex>j</tex> {{---}} счётчик пропущенных свободных позиций</font><br />
<font color=green>// <tex>k</tex> {{---}} количество инверсий слева для элемента curr</font><br />
<font color=green>// <tex>result</tex> {{---}} массив, в который записывается перестановка. Равенство элемента массива нулю обозначает, что эта позиция свободна.</font><br />
'''def''' <tex>\mathtt{recover\_straight(ls)}:</tex><br />
<tex>n\ = \mathtt{ls.length}</tex><br />
<tex>\mathtt{result}\ = \mathtt{array}(0, n)</tex><br />
<tex>curr\ = 1</tex><br />
'''for''' <tex>k \in \mathtt{ls}:</tex><br />
<tex>j\ =</tex> <tex>0</tex><br />
'''for''' <tex>(i\ = 0, i < n, i++):</tex><br />
'''if''' <tex>\mathtt{result}[i]\ ==</tex> <tex>0:</tex><br />
'''if''' <tex>j\ ==</tex> <tex>k:</tex><br />
<tex>\mathtt{result}[i]\ =</tex> <tex>curr</tex><br />
'''break'''<br />
'''else:'''<br />
<tex>j++</tex><br />
<tex>curr++</tex><br />
'''return''' <tex>\mathtt{result}</tex><br />
<br />
<br />
Этот простой алгоритм имеет сложность <tex>O(n^2)</tex> — внутренний цикл делает до <tex>n</tex> итераций, внешний — ровно <tex>n</tex> итераций.<br />
<br />
Видно, что для восстановления нужно узнавать <tex>k</tex>-ую свободную позицию. Это можно делать с помощью [[Дерево_отрезков._Построение | дерева отрезков]] следующим образом: построим дерево отрезков для суммы на массиве из единиц. Единица в позиции означает, что данная позиция свободна. Чтобы найти <tex>k</tex>-ую свободную позицию, нужно спускаться (начиная с корня) в левое поддерево если сумма в нём больше, чем <tex>k</tex>, и в правое дерево иначе.<br />
<br />
Данный алгоритм переписывается в код следующим образом:<br />
<br />
<font color=green>// <tex>build\_segment\_tree</tex> {{---}} строит дерево отрезков над массивом</font><br />
<font color=green>// <tex>node</tex> {{---}} вершина дерева</font><br />
<font color=green>// <tex>node.index</tex> {{---}} индекс соответствующего элемента в массиве для листа дерева</font><br />
'''def''' <tex>\mathtt{recover(inv)}:</tex><br />
<tex>n\ = \mathtt{inv.length}</tex><br />
<tex>\mathtt{tree}\ = \mathtt{build\_segment\_tree}(\mathtt{array}(n, 1))</tex><br />
<tex>\mathtt{result}\ = \mathtt{array}(n)</tex><br />
<tex>curr\ = 1</tex><br />
'''for''' <tex>k \in \mathtt{inv}:</tex><br />
<tex>\mathtt{node}\ = \mathtt{tree.root}</tex><br />
'''while''' <tex>(!\mathtt{node.is\_leaf}):</tex><br />
'''if''' <tex>(k <\mathtt{node.left.value}):</tex><br />
<tex>\mathtt{node}\ = \mathtt{node.left}</tex><br />
'''else:'''<br />
<tex>k\ -= \mathtt{node.left.value}</tex><br />
<tex>\mathtt{node}\ = \mathtt{node.right}</tex><br />
<tex>\mathtt{result}[\mathtt{node.index}]\ = curr</tex><br />
<tex>\mathtt{node.add}(-1)</tex><br />
<tex>curr++</tex><br />
'''return''' <tex>\mathtt{result}</tex><br />
<br />
<br />
Этот алгоритм имеет сложность <tex>O(n \log n)</tex>: делается <tex>n</tex> итераций цикла, в которой происходит спуск по дереву высоты <tex>O(\log n)</tex> и один запрос на дереве отрезков. Таким образом, время работы алгоритма на каждой итерации есть <tex>O(\log n)</tex>.<br />
<br />
== Пример ==<br />
<br />
Рассмотрим пример построения таблицы инверсий и восстановления перестановки по таблице инверсий. Пусть дана перестановка <tex>(5, 7, 1, 3, 4, 6, 8, 2)</tex>. Следующая таблица показывает работу алгоритма за <tex>O(n \log n)</tex>, на каждой строке один уровень рекурсии (на первой строке — самый глубокий). В скобках стоят пары: элемент перестановки, количество инверсий. Полужирным отмечены элементы, у которых обновилось значение количества инверсий на данном шаге.<br />
<br />
{| style = "border: 0px solid; background-color: gray; text-align: center; padding : 0" cellspacing = "2"<br />
| style = "background-color: white; padding: 3px 6px" |(5, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(7, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(1, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(3, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(4, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(6, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(8, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(2, 0)<br />
|-<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(5, 0), (7, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(1, 0), (3, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(4, 0), (6, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|'''(2, 1)''', (8, 0)<br />
|-<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(1, 2)''', '''(3, 2)''', (5, 0), (7, 0)<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(2, 3)''', (4, 0), (6, 0), (8, 0)<br />
|-<br />
|colspan = "8" style = "background-color: white; padding: 3px 6px"|(1, 2), '''(2, 6)''', (3, 2), '''(4, 2)''', (5, 0), '''(6, 1)''', (7, 0), (8, 0)<br />
|}<br />
<br />
Полученная таблица инверсий: <tex>(2, 6, 2, 2, 0, 1, 0, 0)</tex>. Восстановим перестановку по таблице инверсий, начиная с пустого массива.<br />
<br />
{| style = "border: 0px solid; background-color: grey; text-align: center; padding : 0;" cellspacing = "2"<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{1}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{1}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{2}</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем шесть свободных позиций и ставим <tex>\bf{2}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{3}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{3}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{4}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{4}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{5}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиции и ставим <tex>\bf{5}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{6}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем одну свободную позицию и ставим <tex>\bf{6}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{7}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{7}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>7</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{8}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{8}</tex><br />
|}<br />
<br />
== См. также ==<br />
* [[Матричное представление перестановок]]<br />
<br />
== Источники информации ==<br />
<br />
* [https://en.wikipedia.org/wiki/Permutation Wikipedia {{---}} Permutation]<br />
* Д. Кнут - Искусство программирования, том 3.<br />
<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Комбинаторика ]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A2%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0_%D0%B8%D0%BD%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D0%B9&diff=44313Таблица инверсий2015-01-12T16:05:13Z<p>6yry6e: </p>
<hr />
<div>Пусть <tex> P = (p_1,p_2,\dots,p_n)</tex> является [[Действие перестановки на набор из элементов, представление в виде циклов|перестановкой]] чисел <tex> 1, 2,\dots, n</tex>.<br />
<br />
{{Определение<br />
|definition = <br />
'''Инверсией''' (англ. ''inversion'') в перестановке <tex>P</tex> называется всякая пара индексов <tex>i, j</tex> такая, что <tex>1\leqslant i<j\leqslant n</tex> и <tex>P[i]>P[j]</tex>.<br />
}}<br />
{{Определение<br />
|definition = <br />
'''Таблицей инверсий''' (англ. ''inversion table'') перестановки <tex> P </tex> называют такую последовательность <tex> T = (t_1,t_2,\dots,t_n)</tex>, в которой <tex>t_i</tex> равно числу элементов перестановки <tex> P </tex>, стоящих в <tex> P </tex> левее числа <tex>i</tex> и больших <tex>i</tex>.<br />
}}<br />
<br />
== Алгоритм построения за O(N<sup>2</sup>) ==<br />
<br />
Таблицу инверсий тривиально построить по определению. Для каждого элемента перестановки считаем количество элементов, больших данного и стоящих в перестановке левее него.<br />
Алгоритм построения в псевдокоде выглядит так: <br />
<tex>\mathtt{T}[1..n]\ =</tex> <tex>0</tex><br />
'''for''' <tex>i\ =</tex> <tex>1..n</tex><br />
'''for''' <tex>j\ =</tex> <tex>1..(i - 1)</tex><br />
'''if''' <tex>\mathtt{P}[j]</tex> <tex>></tex> <tex>\mathtt{P}[i]</tex><br />
<tex>\mathtt{T}[\mathtt{P}[i]]\ =</tex> <tex>\mathtt{T}[\mathtt{P}[i]]++</tex><br />
Сложность данного алгоритма {{---}} <tex>O(n^2)</tex>. Уменьшить время работы можно используя алгоритм, похожий на [[Сортировка_слиянием |сортировку слиянием.]]<br />
<br />
== Алгоритм построения за O(N log N) ==<br />
<br />
Пусть дано разбиение перестановки на два списка, причём для каждого элемента дано число инверсий слева с элементами того же списка и известно, что все числа первого списка стоят левее всех чисел второго списка в исходной перестановке. Будем считать количество инверсий слева элементов обоих списков следующим образом: сливаем списки, аналогично [[Сортировка_слиянием |сортировке слиянием.]]<br />
<br />
Если в результат нужно записать элемент первого списка, то все нерассмотренные элементы второго списка больше, следовательно, количество инверсий для этого элемента не меняется. Если в результат нужно записать элемент второго списка, то все нерассмотренные элементы первого списка больше его и стоят левее. Следовательно, количество инверсий для этого элемента следует увеличить на количество нерассмотренных элементов второго списка.<br />
<br />
Описанный алгоритм записывается в псевдокод следующим образом:<br />
<font color=green>// <tex>inverses\_merge</tex> {{---}} процедура, сливающая два списка пар</font><br />
<font color=green>// <tex>inverses\_get</tex> {{---}} процедура, рекурсивно получающая таблицу инверсий для перестановки</font><br />
'''def''' <tex>\mathtt{inverses\_merge(ls1, ls2)}:</tex><br />
<tex>\mathtt{result}\ = [ ]</tex><br />
<tex>it\textit{1}, it\textit{2}\ =</tex> ''null''<br />
'''while''' <tex>(it\textit{1}</tex> <tex><</tex> <tex>\mathtt{ls1.length})</tex> '''and''' <tex>(it\textit{2}</tex> <tex><</tex> <tex>\mathtt{ls2.length}):</tex><br />
'''if''' <tex>\mathtt{ls1}[it\textit{1}]\mathtt{.item}</tex> <tex><</tex> <tex>\mathtt{ls2}[it\textit{2}]\mathtt{.item}:</tex><br />
<tex>\mathtt{result.append}(\mathtt{ls1}[it\textit{1}])</tex><br />
<tex>it\textit{1}++</tex><br />
'''else:'''<br />
<tex>\mathtt{result.append}(item\ =</tex> <tex>\mathtt{ls2}[it\textit{2}]\mathtt{.item}, inverses\ =</tex> <tex>\mathtt{ls2}[it\textit{2}]\mathtt{.inverses}</tex> <tex>+</tex> <tex>\mathtt{ls1.length}</tex> <tex>-</tex> <tex>it\textit{1})</tex><br />
<tex>it\textit{2}++</tex><br />
'''while''' <tex>(it\textit{1}</tex> <tex><</tex> <tex>\mathtt{ls1.length}):</tex><br />
<tex>\mathtt{result.append}(\mathtt{ls1}[it\textit{1}])</tex><br />
<tex>it\textit{1}++</tex><br />
'''while''' <tex>(it\textit{2}</tex> <tex><</tex> <tex>\mathtt{ls2.length}):</tex><br />
<tex>\mathtt{result.append}(\mathtt{ls2}[it\textit{2}])</tex><br />
<tex>it\textit{2}++</tex><br />
'''return''' <tex>\mathtt{result}</tex><br />
<br />
'''def''' <tex>\mathtt{inverses\_get(ls)}:</tex><br />
'''if''' <tex>\mathtt{ls.length}\ == 1:</tex><br />
'''return''' <tex>[(item = \mathtt{ls[0]}, inverses = 0)]</tex><br />
'''else:'''<br />
'''return''' <tex>\mathtt{inverses\_merge(inverses\_get(ls.first\_half), inverses\_get(ls.second\_half))}</tex><br />
<br />
<br />
Сложность представленного алгоритма есть <tex>O(n\log n)</tex>. Алгоритм с такой же сложностью можно построить с помощью [[Дерево_отрезков._Построение | дерева отрезков.]]<br />
<br />
== Алгоритм восстановления ==<br />
<br />
Для восстановления перестановки по таблицы инверсий <tex>T</tex> воспользуемся следующим соображением: единица стоит в перестановке на <tex>T_0</tex>-ом месте (индексируем элементы с нуля), так как остальные числа в перестановке больше единицы. Далее, если известны расположения всех чисел <tex>1, \dots, k</tex>, то число <tex>k + 1</tex> стоит на <tex>T_{k + 1}</tex>-ой ещё не занятой позиции: все числа, меньшие <tex>k + 1</tex> уже расставлены. Это рассуждение напрямую переписывается в код следующим образом:<br />
<font color=green>// <tex>j</tex> {{---}} счётчик пропущенных свободных позиций</font><br />
<font color=green>// <tex>k</tex> {{---}} количество инверсий слева для элемента curr</font><br />
<font color=green>// <tex>result</tex> {{---}} массив, в который записывается перестановка. Равенство элемента массива нулю обозначает, что эта позиция свободна.</font><br />
'''def''' <tex>\mathtt{recover\_straight(ls)}:</tex><br />
<tex>n\ = \mathtt{ls.length}</tex><br />
<tex>\mathtt{result}\ = \mathtt{array}(0, n)</tex><br />
<tex>curr\ = 1</tex><br />
'''for''' <tex>k \in \mathtt{ls}:</tex><br />
<tex>j\ = 0</tex><br />
'''for''' <tex>(i\ = 0, i < n, i++):</tex><br />
'''if''' <tex>\mathtt{result}[i]\ == 0:</tex><br />
'''if''' <tex>j\ == k:</tex><br />
<tex>\mathtt{result}[i]\ = curr</tex><br />
'''break'''<br />
'''else:'''<br />
<tex>j++</tex><br />
<tex>curr++</tex><br />
'''return''' <tex>\mathtt{result}</tex><br />
<br />
<br />
Этот простой алгоритм имеет сложность <tex>O(n^2)</tex> — внутренний цикл делает до <tex>n</tex> итераций, внешний — ровно <tex>n</tex> итераций.<br />
<br />
Видно, что для восстановления нужно узнавать <tex>k</tex>-ую свободную позицию. Это можно делать с помощью [[Дерево_отрезков._Построение | дерева отрезков]] следующим образом: построим дерево отрезков для суммы на массиве из единиц. Единица в позиции означает, что данная позиция свободна. Чтобы найти <tex>k</tex>-ую свободную позицию, нужно спускаться (начиная с корня) в левое поддерево если сумма в нём больше, чем <tex>k</tex>, и в правое дерево иначе.<br />
<br />
Данный алгоритм переписывается в код следующим образом:<br />
<br />
<font color=green>// <tex>build\_segment\_tree</tex> {{---}} строит дерево отрезков над массивом</font><br />
<font color=green>// <tex>node</tex> {{---}} вершина дерева</font><br />
<font color=green>// <tex>node.index</tex> {{---}} индекс соответствующего элемента в массиве для листа дерева</font><br />
'''def''' <tex>\mathtt{recover(inv)}:</tex><br />
<tex>n\ = \mathtt{inv.length}</tex><br />
<tex>\mathtt{tree}\ = \mathtt{build\_segment\_tree}(\mathtt{array}(n, 1))</tex><br />
<tex>\mathtt{result}\ = \mathtt{array}(n)</tex><br />
<tex>curr\ = 1</tex><br />
'''for''' <tex>k \in \mathtt{inv}:</tex><br />
<tex>\mathtt{node}\ = \mathtt{tree.root}</tex><br />
'''while''' <tex>(!\mathtt{node.is\_leaf}):</tex><br />
'''if''' <tex>(k <\mathtt{node.left.value}):</tex><br />
<tex>\mathtt{node}\ = \mathtt{node.left}</tex><br />
'''else:'''<br />
<tex>k\ -= \mathtt{node.left.value}</tex><br />
<tex>\mathtt{node}\ = \mathtt{node.right}</tex><br />
<tex>\mathtt{result}[\mathtt{node.index}]\ = curr</tex><br />
<tex>\mathtt{node.add}(-1)</tex><br />
<tex>curr++</tex><br />
'''return''' <tex>\mathtt{result}</tex><br />
<br />
<br />
Этот алгоритм имеет сложность <tex>O(n \log n)</tex>: делается <tex>n</tex> итераций цикла, в которой происходит спуск по дереву высоты <tex>O(\log n)</tex> и один запрос на дереве отрезков. Таким образом, время работы алгоритма на каждой итерации есть <tex>O(\log n)</tex>.<br />
<br />
== Пример ==<br />
<br />
Рассмотрим пример построения таблицы инверсий и восстановления перестановки по таблице инверсий. Пусть дана перестановка <tex>(5, 7, 1, 3, 4, 6, 8, 2)</tex>. Следующая таблица показывает работу алгоритма за <tex>O(n \log n)</tex>, на каждой строке один уровень рекурсии (на первой строке — самый глубокий). В скобках стоят пары: элемент перестановки, количество инверсий. Полужирным отмечены элементы, у которых обновилось значение количества инверсий на данном шаге.<br />
<br />
{| style = "border: 0px solid; background-color: gray; text-align: center; padding : 0" cellspacing = "2"<br />
| style = "background-color: white; padding: 3px 6px" |(5, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(7, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(1, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(3, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(4, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(6, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(8, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(2, 0)<br />
|-<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(5, 0), (7, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(1, 0), (3, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(4, 0), (6, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|'''(2, 1)''', (8, 0)<br />
|-<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(1, 2)''', '''(3, 2)''', (5, 0), (7, 0)<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(2, 3)''', (4, 0), (6, 0), (8, 0)<br />
|-<br />
|colspan = "8" style = "background-color: white; padding: 3px 6px"|(1, 2), '''(2, 6)''', (3, 2), '''(4, 2)''', (5, 0), '''(6, 1)''', (7, 0), (8, 0)<br />
|}<br />
<br />
Полученная таблица инверсий: <tex>(2, 6, 2, 2, 0, 1, 0, 0)</tex>. Восстановим перестановку по таблице инверсий, начиная с пустого массива.<br />
<br />
{| style = "border: 0px solid; background-color: grey; text-align: center; padding : 0;" cellspacing = "2"<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{1}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{1}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{2}</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем шесть свободных позиций и ставим <tex>\bf{2}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{3}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{3}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{4}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{4}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{5}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиции и ставим <tex>\bf{5}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{6}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем одну свободную позицию и ставим <tex>\bf{6}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{7}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{7}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>7</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{8}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{8}</tex><br />
|}<br />
<br />
== См. также ==<br />
* [[Матричное представление перестановок]]<br />
<br />
== Источники информации ==<br />
<br />
* [https://en.wikipedia.org/wiki/Permutation Wikipedia {{---}} Permutation]<br />
* Д. Кнут - Искусство программирования, том 3.<br />
<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Комбинаторика ]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A2%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0_%D0%B8%D0%BD%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D0%B9&diff=44312Таблица инверсий2015-01-12T16:04:32Z<p>6yry6e: </p>
<hr />
<div>Пусть <tex> P = (p_1,p_2,\dots,p_n)</tex> является [[Действие перестановки на набор из элементов, представление в виде циклов|перестановкой]] чисел <tex> 1, 2,\dots, n</tex>.<br />
<br />
{{Определение<br />
|definition = <br />
'''Инверсией''' (англ. ''inversion'') в перестановке <tex>P</tex> называется всякая пара индексов <tex>i, j</tex> такая, что <tex>1\leqslant i<j\leqslant n</tex> и <tex>P[i]>P[j]</tex>.<br />
}}<br />
{{Определение<br />
|definition = <br />
'''Таблицей инверсий''' (англ. ''inversion table'') перестановки <tex> P </tex> называют такую последовательность <tex> T = (t_1,t_2,\dots,t_n)</tex>, в которой <tex>t_i</tex> равно числу элементов перестановки <tex> P </tex>, стоящих в <tex> P </tex> левее числа <tex>i</tex> и больших <tex>i</tex>.<br />
}}<br />
<br />
== Алгоритм построения за O(N<sup>2</sup>) ==<br />
<br />
Таблицу инверсий тривиально построить по определению. Для каждого элемента перестановки считаем количество элементов, больших данного и стоящих в перестановке левее него.<br />
Алгоритм построения в псевдокоде выглядит так: <br />
<tex>\mathtt{T}[1..n]\ =</tex> <tex>0</tex><br />
'''for''' <tex>i\ =</tex> <tex>1..n</tex><br />
'''for''' <tex>j\ =</tex> <tex>1..(i - 1)</tex><br />
'''if''' <tex>\mathtt{P}[j]</tex> <tex>></tex> <tex>\mathtt{P}[i]</tex><br />
<tex>\mathtt{T}[\mathtt{P}[i]]\ =</tex> <tex>\mathtt{T}[\mathtt{P}[i]]++</tex><br />
Сложность данного алгоритма {{---}} <tex>O(n^2)</tex>. Уменьшить время работы можно используя алгоритм, похожий на [[Сортировка_слиянием |сортировку слиянием.]]<br />
<br />
== Алгоритм построения за O(N log N) ==<br />
<br />
Пусть дано разбиение перестановки на два списка, причём для каждого элемента дано число инверсий слева с элементами того же списка и известно, что все числа первого списка стоят левее всех чисел второго списка в исходной перестановке. Будем считать количество инверсий слева элементов обоих списков следующим образом: сливаем списки, аналогично [[Сортировка_слиянием |сортировке слиянием.]]<br />
<br />
Если в результат нужно записать элемент первого списка, то все нерассмотренные элементы второго списка больше, следовательно, количество инверсий для этого элемента не меняется. Если в результат нужно записать элемент второго списка, то все нерассмотренные элементы первого списка больше его и стоят левее. Следовательно, количество инверсий для этого элемента следует увеличить на количество нерассмотренных элементов второго списка.<br />
<br />
Описанный алгоритм записывается в псевдокод следующим образом:<br />
<font color=green>// <tex>inverses\_merge</tex> {{---}} процедура, сливающая два списка пар</font><br />
<font color=green>// <tex>inverses\_get</tex> {{---}} процедура, рекурсивно получающая таблицу инверсий для перестановки</font><br />
'''def''' <tex>\mathtt{inverses\_merge(ls1, ls2)}:</tex><br />
<tex>\mathtt{result}\ = [ ]</tex><br />
<tex>it\textit{1}, it\textit{2}\ =</tex> ''null''<br />
'''while''' <tex>(it\textit{1}</tex> <tex><</tex> <tex>\mathtt{ls1.length})</tex> '''and''' <tex>(it\textit{2}</tex> <tex><</tex> <tex>\mathtt{ls2.length}):</tex><br />
'''if''' <tex>\mathtt{ls1}[it\textit{1}]\mathtt{.item}</tex> <tex><</tex> <tex>\mathtt{ls2}[it\textit{2}]\mathtt{.item}:</tex><br />
<tex>\mathtt{result.append}(\mathtt{ls1}[it\textit{1}])</tex><br />
<tex>it\textit{1}++</tex><br />
'''else:'''<br />
<tex>\mathtt{result.append}(item\ =</tex> <tex>\mathtt{ls2}[it\textit{2}]\mathtt{.item}, inverses\ =</tex> <tex>\mathtt{ls2}[it\textit{2}]\mathtt{.inverses}</tex> <tex>+</tex> <tex>\mathtt{ls1.length}</tex> <tex>-</tex> <tex>it\textit{1})</tex><br />
<tex>it\textit{2}++</tex><br />
'''while''' <tex>(it\textit{1}</tex> <tex><</tex> <tex>\mathtt{ls1.length}):</tex><br />
<tex>\mathtt{result.append}(\mathtt{ls1}[it\textit{1}])</tex><br />
<tex>it\textit{1}++</tex><br />
'''while''' <tex>(it\textit{2}</tex> <tex><</tex> <tex>\mathtt{ls2.length}):</tex><br />
<tex>\mathtt{result.append}(\mathtt{ls2}[it\textit{2}])</tex><br />
<tex>it\textit{2}++</tex><br />
'''return''' <tex>\mathtt{result}</tex><br />
<br />
'''def''' <tex>\mathtt{inverses\_get(ls)}:</tex><br />
'''if''' <tex>\mathtt{ls.length}\ == 1:</tex><br />
'''return''' <tex>[(item = \mathtt{ls[0]}, inverses = 0)]</tex><br />
'''else:'''<br />
'''return''' <tex>\mathtt{inverses\_merge(inverses\_get(ls.first\_half), inverses\_get(ls.second\_half))}</tex><br />
<br />
<br />
Сложность представленного алгоритма есть <tex>O(n\log n)</tex>. Алгоритм с такой же сложностью можно построить с помощью [[Дерево_отрезков._Построение | дерева отрезков.]]<br />
<br />
== Алгоритм восстановления ==<br />
<br />
Для восстановления перестановки по таблицы инверсий <tex>T</tex> воспользуемся следующим соображением: единица стоит в перестановке на <tex>T_0</tex>-ом месте (индексируем элементы с нуля), так как остальные числа в перестановке больше единицы. Далее, если известны расположения всех чисел <tex>1, \dots, k</tex>, то число <tex>k + 1</tex> стоит на <tex>T_{k + 1}</tex>-ой ещё не занятой позиции: все числа, меньшие <tex>k + 1</tex> уже расставлены. Это рассуждение напрямую переписывается в код следующим образом:<br />
<font color=green>// <tex>j</tex> {{---}} счётчик пропущенных свободных позиций</font><br />
<font color=green>// <tex>k</tex> {{---}} количество инверсий слева для элемента curr</font><br />
<font color=green>// <tex>result</tex> {{---}} массив, в который записывается перестановка. Равенство элемента массива нулю обозначает, что эта позиция свободна.</font><br />
'''def''' <tex>\mathtt{recover\_straight(ls)}:</tex><br />
<tex>n\ = \mathtt{ls.length}</tex><br />
<tex>\mathtt{result}\ = \mathtt{array}(0, n)</tex><br />
<tex>curr\ = 1</tex><br />
'''for''' <tex>k \in \mathtt{ls}:</tex><br />
<tex>j\ = 0</tex><br />
'''for''' <tex>(i\ = 0, i < n, i++):</tex><br />
'''if''' <tex>\mathtt{result}[i]\ == 0:</tex><br />
'''if''' <tex>j\ == k:</tex><br />
<tex>\mathtt{result}[i]\ = curr</tex><br />
'''break'''<br />
'''else:'''<br />
<tex>j++</tex><br />
<tex>curr++</tex><br />
'''return''' <tex>\mathtt{result}</tex><br />
<br />
<br />
Этот простой алгоритм имеет сложность <tex>O(n^2)</tex> — внутренний цикл делает до <tex>n</tex> итераций, внешний — ровно <tex>n</tex> итераций.<br />
<br />
Видно, что для восстановления нужно узнавать <tex>k</tex>-ую свободную позицию. Это можно делать с помощью [[Дерево_отрезков._Построение | дерева отрезков]] следующим образом: построим дерево отрезков для суммы на массиве из единиц. Единица в позиции означает, что данная позиция свободна. Чтобы найти <tex>k</tex>-ую свободную позицию, нужно спускаться (начиная с корня) в левое поддерево если сумма в нём больше, чем <tex>k</tex>, и в правое дерево иначе.<br />
<br />
Данный алгоритм переписывается в код следующим образом:<br />
<br />
<font color=green>// <tex>build\_segment\_tree</tex> {{---}} строит дерево отрезков над массивом</font><br />
<font color=green>// <tex>node</tex> {{---}} вершина дерева</font><br />
<font color=green>// <tex>node.index</tex> {{---}} индекс соответствующего элемента в массиве для листа дерева</font><br />
'''def''' <tex>\mathtt{recover(inv)}:</tex><br />
<tex>n\ = \mathtt{inv.length}</tex><br />
<tex>\mathtt{tree}\ = \mathtt{build\_segment\_tree}(\mathtt{array}(n, 1))</tex><br />
<tex>\mathtt{result}\ = \mathtt{array}(n)</tex><br />
<tex>curr\ = 1</tex><br />
'''for''' <tex>k \in \mathtt{inv}:</tex><br />
<tex>\mathtt{node}\ = \mathtt{tree.root}</tex><br />
'''while''' <tex>(!\mathtt{node.is\_leaf}):</tex><br />
'''if''' <tex>(k <\mathtt{node.left.value}):</tex><br />
<tex>\mathtt{node}\ = \mathtt{node.left}</tex><br />
'''else:'''<br />
<tex>k\ -= \mathtt{node.left.value}</tex><br />
<tex>\mathtt{node}\ = \mathtt{node.right}</tex><br />
<tex>\mathtt{result}[\mathtt{node.index}]\ = curr</tex><br />
<tex>\mathtt{node.add}(-1)</tex><br />
<tex>curr++</tex><br />
'''return''' <tex>\mathtt{result}</tex><br />
<br />
<br />
Этот алгоритм имеет сложность <tex>O(n \log n)</tex>: делается <tex>n</tex> итераций цикла, в которой происходит спуск по дереву высоты <tex>O(\log n)</tex> и один запрос на дереве отрезков. Таким образом, время работы алгоритма на каждой итерации есть <tex>O(\log n)</tex>.<br />
<br />
== Пример ==<br />
<br />
Рассмотрим пример построения таблицы инверсий и восстановления перестановки по таблице инверсий. Пусть дана перестановка <tex>(5, 7, 1, 3, 4, 6, 8, 2)</tex>. Следующая таблица показывает работу алгоритма за <tex>O(n \log n)</tex>, на каждой строке один уровень рекурсии (на первой строке — самый глубокий). В скобках стоят пары: элемент перестановки, количество инверсий. Полужирным отмечены элементы, у которых обновилось значение количества инверсий на данном шаге.<br />
<br />
{| style = "border: 0px solid; background-color: gray; text-align: center; padding : 0" cellspacing = "2"<br />
| style = "background-color: white; padding: 3px 6px" |(5, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(7, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(1, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(3, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(4, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(6, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(8, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(2, 0)<br />
|-<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(5, 0), (7, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(1, 0), (3, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(4, 0), (6, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|'''(2, 1)''', (8, 0)<br />
|-<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(1, 2)''', '''(3, 2)''', (5, 0), (7, 0)<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(2, 3)''', (4, 0), (6, 0), (8, 0)<br />
|-<br />
|colspan = "8" style = "background-color: white; padding: 3px 6px"|(1, 2), '''(2, 6)''', (3, 2), '''(4, 2)''', (5, 0), '''(6, 1)''', (7, 0), (8, 0)<br />
|}<br />
<br />
Полученная таблица инверсий: <tex>(2, 6, 2, 2, 0, 1, 0, 0)</tex>. Восстановим перестановку по таблице инверсий, начиная с пустого массива.<br />
<br />
{| style = "border: 0px solid; background-color: grey; text-align: center; padding : 0;" cellspacing = "2"<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{1}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{1}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{2}</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем шесть свободных позиций и ставим <tex>\bf{2}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{3}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{3}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{4}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{4}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{5}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиции и ставим <tex>\bf{5}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{6}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем одну свободную позицию и ставим <tex>\bf{6}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{7}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{7}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>7</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{8}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{8}</tex><br />
|}<br />
<br />
== См. также ==<br />
* [[Матричное представление перестановок]]<br />
<br />
<br />
== Источники информации ==<br />
<br />
* [https://en.wikipedia.org/wiki/Permutation Wikipedia {{---}} Permutation]<br />
* Д. Кнут - Искусство программирования, том 3.<br />
<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Комбинаторика ]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A2%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0_%D0%B8%D0%BD%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D0%B9&diff=44311Таблица инверсий2015-01-12T16:04:00Z<p>6yry6e: </p>
<hr />
<div>Пусть <tex> P = (p_1,p_2,\dots,p_n)</tex> является [[Действие перестановки на набор из элементов, представление в виде циклов|перестановкой]] чисел <tex> 1, 2,\dots, n</tex>.<br />
<br />
{{Определение<br />
|definition = <br />
'''Инверсией''' (англ. ''inversion'') в перестановке <tex>P</tex> называется всякая пара индексов <tex>i, j</tex> такая, что <tex>1\leqslant i<j\leqslant n</tex> и <tex>P[i]>P[j]</tex>.<br />
}}<br />
{{Определение<br />
|definition = <br />
'''Таблицей инверсий''' (англ. ''inversion table'') перестановки <tex> P </tex> называют такую последовательность <tex> T = (t_1,t_2,\dots,t_n)</tex>, в которой <tex>t_i</tex> равно числу элементов перестановки <tex> P </tex>, стоящих в <tex> P </tex> левее числа <tex>i</tex> и больших <tex>i</tex>.<br />
}}<br />
<br />
== Алгоритм построения за O(N<sup>2</sup>) ==<br />
<br />
Таблицу инверсий тривиально построить по определению. Для каждого элемента перестановки считаем количество элементов, больших данного и стоящих в перестановке левее него.<br />
Алгоритм построения в псевдокоде выглядит так: <br />
<tex>\mathtt{T}[1..n]\ =</tex> <tex>0</tex><br />
'''for''' <tex>i\ =</tex> <tex>1..n</tex><br />
'''for''' <tex>j\ =</tex> <tex>1..(i - 1)</tex><br />
'''if''' <tex>\mathtt{P}[j]</tex> <tex>></tex> <tex>\mathtt{P}[i]</tex><br />
<tex>\mathtt{T}[\mathtt{P}[i]]\ =</tex> <tex>\mathtt{T}[\mathtt{P}[i]]++</tex><br />
Сложность данного алгоритма {{---}} <tex>O(n^2)</tex>. Уменьшить время работы можно используя алгоритм, похожий на [[Сортировка_слиянием |сортировку слиянием.]]<br />
<br />
== Алгоритм построения за O(N log N) ==<br />
<br />
Пусть дано разбиение перестановки на два списка, причём для каждого элемента дано число инверсий слева с элементами того же списка и известно, что все числа первого списка стоят левее всех чисел второго списка в исходной перестановке. Будем считать количество инверсий слева элементов обоих списков следующим образом: сливаем списки, аналогично [[Сортировка_слиянием |сортировке слиянием.]]<br />
<br />
Если в результат нужно записать элемент первого списка, то все нерассмотренные элементы второго списка больше, следовательно, количество инверсий для этого элемента не меняется. Если в результат нужно записать элемент второго списка, то все нерассмотренные элементы первого списка больше его и стоят левее. Следовательно, количество инверсий для этого элемента следует увеличить на количество нерассмотренных элементов второго списка.<br />
<br />
Описанный алгоритм записывается в псевдокод следующим образом:<br />
<font color=green>// <tex>inverses\_merge</tex> {{---}} процедура, сливающая два списка пар</font><br />
<font color=green>// <tex>inverses\_get</tex> {{---}} процедура, рекурсивно получающая таблицу инверсий для перестановки</font><br />
'''def''' <tex>\mathtt{inverses\_merge(ls1, ls2)}:</tex><br />
<tex>\mathtt{result}\ = [ ]</tex><br />
<tex>it\textit{1}, it\textit{2}\ =</tex> ''null''<br />
'''while''' <tex>(it\textit{1}</tex> <tex><</tex> <tex>\mathtt{ls1.length})</tex> '''and''' <tex>(it\textit{2}</tex> <tex><</tex> <tex>\mathtt{ls2.length}):</tex><br />
'''if''' <tex>\mathtt{ls1}[it\textit{1}]\mathtt{.item}</tex> <tex><</tex> <tex>\mathtt{ls2}[it\textit{2}]\mathtt{.item}:</tex><br />
<tex>\mathtt{result.append}(\mathtt{ls1}[it\textit{1}])</tex><br />
<tex>it\textit{1}++</tex><br />
'''else:'''<br />
<tex>\mathtt{result.append}(item\ =</tex> <tex>\mathtt{ls2}[it\textit{2}]\mathtt{.item}, inverses\ =</tex> <tex>\mathtt{ls2}[it\textit{2}]\mathtt{.inverses}</tex> <tex>+</tex> <tex>\mathtt{ls1.length}</tex> <tex>-</tex> <tex>it\textit{1})</tex><br />
<tex>it\textit{2}++</tex><br />
'''while''' <tex>(it\textit{1}</tex> <tex><</tex> <tex>\mathtt{ls1.length}):</tex><br />
<tex>\mathtt{result.append}(\mathtt{ls1}[it\textit{1}])</tex><br />
<tex>it\textit{1}++</tex><br />
'''while''' <tex>(it\textit{2}</tex> <tex><</tex> <tex>\mathtt{ls2.length}):</tex><br />
<tex>\mathtt{result.append}(\mathtt{ls2}[it\textit{2}])</tex><br />
<tex>it\textit{2}++</tex><br />
'''return''' <tex>\mathtt{result}</tex><br />
<br />
'''def''' <tex>\mathtt{inverses\_get(ls)}:</tex><br />
'''if''' <tex>\mathtt{ls.length}\ == 1:</tex><br />
'''return''' <tex>[(item = \mathtt{ls[0]}, inverses = 0)]</tex><br />
'''else:'''<br />
'''return''' <tex>\mathtt{inverses\_merge(inverses\_get(ls.first\_half), inverses\_get(ls.second\_half))}</tex><br />
<br />
<br />
Сложность представленного алгоритма есть <tex>O(n\log n)</tex>. Алгоритм с такой же сложностью можно построить с помощью [[Дерево_отрезков._Построение | дерева отрезков.]]<br />
<br />
== Алгоритм восстановления ==<br />
<br />
Для восстановления перестановки по таблицы инверсий <tex>T</tex> воспользуемся следующим соображением: единица стоит в перестановке на <tex>T_0</tex>-ом месте (индексируем элементы с нуля), так как остальные числа в перестановке больше единицы. Далее, если известны расположения всех чисел <tex>1, \dots, k</tex>, то число <tex>k + 1</tex> стоит на <tex>T_{k + 1}</tex>-ой ещё не занятой позиции: все числа, меньшие <tex>k + 1</tex> уже расставлены. Это рассуждение напрямую переписывается в код следующим образом:<br />
<font color=green>// <tex>j</tex> {{---}} счётчик пропущенных свободных позиций</font><br />
<font color=green>// <tex>k</tex> {{---}} количество инверсий слева для элемента curr</font><br />
<font color=green>// <tex>result</tex> {{---}} массив, в который записывается перестановка. Равенство элемента массива нулю обозначает, что эта позиция свободна.</font><br />
'''def''' <tex>\mathtt{recover\_straight(ls)}:</tex><br />
<tex>n\ = \mathtt{ls.length}</tex><br />
<tex>\mathtt{result}\ = \mathtt{array}(0, n)</tex><br />
<tex>curr\ = 1</tex><br />
'''for''' <tex>k \in \mathtt{ls}:</tex><br />
<tex>j\ = 0</tex><br />
'''for''' <tex>(i\ = 0, i < n, i++):</tex><br />
'''if''' <tex>\mathtt{result}[i]\ == 0:</tex><br />
'''if''' <tex>j\ == k:</tex><br />
<tex>\mathtt{result}[i]\ = curr</tex><br />
'''break'''<br />
'''else:'''<br />
<tex>j++</tex><br />
<tex>curr++</tex><br />
'''return''' <tex>\mathtt{result}</tex><br />
<br />
<br />
Этот простой алгоритм имеет сложность <tex>O(n^2)</tex> — внутренний цикл делает до <tex>n</tex> итераций, внешний — ровно <tex>n</tex> итераций.<br />
<br />
Видно, что для восстановления нужно узнавать <tex>k</tex>-ую свободную позицию. Это можно делать с помощью [[Дерево_отрезков._Построение | дерева отрезков]] следующим образом: построим дерево отрезков для суммы на массиве из единиц. Единица в позиции означает, что данная позиция свободна. Чтобы найти <tex>k</tex>-ую свободную позицию, нужно спускаться (начиная с корня) в левое поддерево если сумма в нём больше, чем <tex>k</tex>, и в правое дерево иначе.<br />
<br />
Данный алгоритм переписывается в код следующим образом:<br />
<br />
<font color=green>// <tex>build\_segment\_tre</tex> {{---}} строит дерево отрезков над массивом</font><br />
<font color=green>// <tex>node</tex> {{---}} вершина дерева</font><br />
<font color=green>// <tex>node.index</tex> {{---}} индекс соответствующего элемента в массиве для листа дерева</font><br />
'''def''' <tex>\mathtt{recover(inv)}:</tex><br />
<tex>n\ = \mathtt{inv.length}</tex><br />
<tex>\mathtt{tree}\ = \mathtt{build\_segment\_tree}(\mathtt{array}(n, 1))</tex><br />
<tex>\mathtt{result}\ = \mathtt{array}(n)</tex><br />
<tex>curr\ = 1</tex><br />
'''for''' <tex>k \in \mathtt{inv}:</tex><br />
<tex>\mathtt{node}\ = \mathtt{tree.root}</tex><br />
'''while''' <tex>(!\mathtt{node.is\_leaf}):</tex><br />
'''if''' <tex>(k <\mathtt{node.left.value}):</tex><br />
<tex>\mathtt{node}\ = \mathtt{node.left}</tex><br />
'''else:'''<br />
<tex>k\ -= \mathtt{node.left.value}</tex><br />
<tex>\mathtt{node}\ = \mathtt{node.right}</tex><br />
<tex>\mathtt{result}[\mathtt{node.index}]\ = curr</tex><br />
<tex>\mathtt{node.add}(-1)</tex><br />
<tex>curr++</tex><br />
'''return''' <tex>\mathtt{result}</tex><br />
<br />
<br />
Этот алгоритм имеет сложность <tex>O(n \log n)</tex>: делается <tex>n</tex> итераций цикла, в которой происходит спуск по дереву высоты <tex>O(\log n)</tex> и один запрос на дереве отрезков. Таким образом, время работы алгоритма на каждой итерации есть <tex>O(\log n)</tex>.<br />
<br />
== Пример ==<br />
<br />
Рассмотрим пример построения таблицы инверсий и восстановления перестановки по таблице инверсий. Пусть дана перестановка <tex>(5, 7, 1, 3, 4, 6, 8, 2)</tex>. Следующая таблица показывает работу алгоритма за <tex>O(n \log n)</tex>, на каждой строке один уровень рекурсии (на первой строке — самый глубокий). В скобках стоят пары: элемент перестановки, количество инверсий. Полужирным отмечены элементы, у которых обновилось значение количества инверсий на данном шаге.<br />
<br />
{| style = "border: 0px solid; background-color: gray; text-align: center; padding : 0" cellspacing = "2"<br />
| style = "background-color: white; padding: 3px 6px" |(5, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(7, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(1, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(3, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(4, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(6, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(8, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(2, 0)<br />
|-<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(5, 0), (7, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(1, 0), (3, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(4, 0), (6, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|'''(2, 1)''', (8, 0)<br />
|-<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(1, 2)''', '''(3, 2)''', (5, 0), (7, 0)<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(2, 3)''', (4, 0), (6, 0), (8, 0)<br />
|-<br />
|colspan = "8" style = "background-color: white; padding: 3px 6px"|(1, 2), '''(2, 6)''', (3, 2), '''(4, 2)''', (5, 0), '''(6, 1)''', (7, 0), (8, 0)<br />
|}<br />
<br />
Полученная таблица инверсий: <tex>(2, 6, 2, 2, 0, 1, 0, 0)</tex>. Восстановим перестановку по таблице инверсий, начиная с пустого массива.<br />
<br />
{| style = "border: 0px solid; background-color: grey; text-align: center; padding : 0;" cellspacing = "2"<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{1}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{1}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{2}</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем шесть свободных позиций и ставим <tex>\bf{2}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{3}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{3}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{4}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{4}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{5}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиции и ставим <tex>\bf{5}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{6}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем одну свободную позицию и ставим <tex>\bf{6}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{7}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{7}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>7</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{8}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{8}</tex><br />
|}<br />
<br />
== См. также ==<br />
* [[Матричное представление перестановок]]<br />
<br />
<br />
== Источники информации ==<br />
<br />
* [https://en.wikipedia.org/wiki/Permutation Wikipedia {{---}} Permutation]<br />
* Д. Кнут - Искусство программирования, том 3.<br />
<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Комбинаторика ]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A2%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0_%D0%B8%D0%BD%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D0%B9&diff=44310Таблица инверсий2015-01-12T16:01:56Z<p>6yry6e: </p>
<hr />
<div>Пусть <tex> P = (p_1,p_2,\dots,p_n)</tex> является [[Действие перестановки на набор из элементов, представление в виде циклов|перестановкой]] чисел <tex> 1, 2,\dots, n</tex>.<br />
<br />
{{Определение<br />
|definition = <br />
'''Инверсией''' (англ. ''inversion'') в перестановке <tex>P</tex> называется всякая пара индексов <tex>i, j</tex> такая, что <tex>1\leqslant i<j\leqslant n</tex> и <tex>P[i]>P[j]</tex>.<br />
}}<br />
{{Определение<br />
|definition = <br />
'''Таблицей инверсий''' (англ. ''inversion table'') перестановки <tex> P </tex> называют такую последовательность <tex> T = (t_1,t_2,\dots,t_n)</tex>, в которой <tex>t_i</tex> равно числу элементов перестановки <tex> P </tex>, стоящих в <tex> P </tex> левее числа <tex>i</tex> и больших <tex>i</tex>.<br />
}}<br />
<br />
== Алгоритм построения за O(N<sup>2</sup>) ==<br />
<br />
Таблицу инверсий тривиально построить по определению. Для каждого элемента перестановки считаем количество элементов, больших данного и стоящих в перестановке левее него.<br />
Алгоритм построения в псевдокоде выглядит так: <br />
<tex>\mathtt{T}[1..n]\ =</tex> <tex>0</tex><br />
'''for''' <tex>i\ =</tex> <tex>1..n</tex><br />
'''for''' <tex>j\ =</tex> <tex>1..(i - 1)</tex><br />
'''if''' <tex>\mathtt{P}[j]</tex> <tex>></tex> <tex>\mathtt{P}[i]</tex><br />
<tex>\mathtt{T}[\mathtt{P}[i]]\ =</tex> <tex>\mathtt{T}[\mathtt{P}[i]]++</tex><br />
Сложность данного алгоритма {{---}} <tex>O(n^2)</tex>. Уменьшить время работы можно используя алгоритм, похожий на [[Сортировка_слиянием |сортировку слиянием.]]<br />
<br />
== Алгоритм построения за O(N log N) ==<br />
<br />
Пусть дано разбиение перестановки на два списка, причём для каждого элемента дано число инверсий слева с элементами того же списка и известно, что все числа первого списка стоят левее всех чисел второго списка в исходной перестановке. Будем считать количество инверсий слева элементов обоих списков следующим образом: сливаем списки, аналогично [[Сортировка_слиянием |сортировке слиянием.]]<br />
<br />
Если в результат нужно записать элемент первого списка, то все нерассмотренные элементы второго списка больше, следовательно, количество инверсий для этого элемента не меняется. Если в результат нужно записать элемент второго списка, то все нерассмотренные элементы первого списка больше его и стоят левее. Следовательно, количество инверсий для этого элемента следует увеличить на количество нерассмотренных элементов второго списка.<br />
<br />
Описанный алгоритм записывается в псевдокод следующим образом:<br />
<font color=green>// <tex>inverses\_merge</tex> {{---}} процедура, сливающая два списка пар</font><br />
<font color=green>// <tex>inverses\_get</tex> {{---}} процедура, рекурсивно получающая таблицу инверсий для перестановки</font><br />
'''def''' <tex>\mathtt{inverses\_merge(ls1, ls2)}:</tex><br />
<tex>\mathtt{result}\ = [ ]</tex><br />
<tex>it\textit{1}, it\textit{2}\ =</tex> ''null''<br />
'''while''' <tex>(it\textit{1}</tex> <tex><</tex> <tex>\mathtt{ls1.length})</tex> '''and''' <tex>(it\textit{2}</tex> <tex><</tex> <tex>\mathtt{ls2.length}):</tex><br />
'''if''' <tex>\mathtt{ls1}[it\textit{1}]\mathtt{.item}</tex> <tex><</tex> <tex>\mathtt{ls2}[it\textit{2}]\mathtt{.item}:</tex><br />
<tex>\mathtt{result.append}(\mathtt{ls1}[it\textit{1}])</tex><br />
<tex>it\textit{1}++</tex><br />
'''else:'''<br />
<tex>\mathtt{result.append}(item\ =</tex> <tex>\mathtt{ls2}[it\textit{2}]\mathtt{.item}, inverses\ =</tex> <tex>\mathtt{ls2}[it\textit{2}]\mathtt{.inverses}</tex> <tex>+</tex> <tex>\mathtt{ls1.length}</tex> <tex>-</tex> <tex>it\textit{1})</tex><br />
<tex>it\textit{2}++</tex><br />
'''while''' <tex>(it\textit{1}</tex> <tex><</tex> <tex>\mathtt{ls1.length}):</tex><br />
<tex>\mathtt{result.append}(\mathtt{ls1}[it\textit{1}])</tex><br />
<tex>it\textit{1}++</tex><br />
'''while''' <tex>(it\textit{2}</tex> <tex><</tex> <tex>\mathtt{ls2.length}):</tex><br />
<tex>\mathtt{result.append}(\mathtt{ls2}[it\textit{2}])</tex><br />
<tex>it\textit{2}++</tex><br />
'''return''' <tex>\mathtt{result}</tex><br />
<br />
'''def''' <tex>\mathtt{inverses\_get(ls)}:</tex><br />
'''if''' <tex>\mathtt{ls.length}\ == 1:</tex><br />
'''return''' <tex>[(item = \mathtt{ls[0]}, inverses = 0)]</tex><br />
'''else:'''<br />
'''return''' <tex>\mathtt{inverses\_merge(inverses\_get(ls.first\_half), inverses\_get(ls.second\_half))}</tex><br />
<br />
<br />
Сложность представленного алгоритма есть <tex>O(n\log n)</tex>. Алгоритм с такой же сложностью можно построить с помощью [[Дерево_отрезков._Построение | дерева отрезков.]]<br />
<br />
== Алгоритм восстановления ==<br />
<br />
Для восстановления перестановки по таблицы инверсий <tex>T</tex> воспользуемся следующим соображением: единица стоит в перестановке на <tex>T_0</tex>-ом месте (индексируем элементы с нуля), так как остальные числа в перестановке больше единицы. Далее, если известны расположения всех чисел <tex>1, \dots, k</tex>, то число <tex>k + 1</tex> стоит на <tex>T_{k + 1}</tex>-ой ещё не занятой позиции: все числа, меньшие <tex>k + 1</tex> уже расставлены. Это рассуждение напрямую переписывается в код следующим образом:<br />
<font color=green>// <tex>j</tex> {{---}} счётчик пропущенных свободных позиций</font><br />
<font color=green>// <tex>k</tex> {{---}} количество инверсий слева для элемента curr</font><br />
<font color=green>// <tex>result</tex> {{---}} массив, в который записывается перестановка. Равенство элемента массива нулю обозначает, что эта позиция свободна.</font><br />
'''def''' <tex>\mathtt{recover\_straight(ls)}:</tex><br />
<tex>n\ = \mathtt{ls.length}</tex><br />
<tex>\mathtt{result}\ = \mathtt{array}(0, n)</tex><br />
<tex>curr\ = 1</tex><br />
'''for''' <tex>k \in \mathtt{ls}:</tex><br />
<tex>j\ = 0</tex><br />
'''for''' <tex>(i\ = 0, i < n, i++):</tex><br />
'''if''' <tex>\mathtt{result}[i]\ == 0:</tex><br />
'''if''' <tex>j\ == k:</tex><br />
<tex>\mathtt{result}[i]\ = curr</tex><br />
'''break'''<br />
'''else:'''<br />
<tex>j++</tex><br />
<tex>curr++</tex><br />
'''return''' <tex>\mathtt{result}</tex><br />
<br />
<br />
Этот простой алгоритм имеет сложность <tex>O(n^2)</tex> — внутренний цикл делает до <tex>n</tex> итераций, внешний — ровно <tex>n</tex> итераций.<br />
<br />
Видно, что для восстановления нужно узнавать <tex>k</tex>-ую свободную позицию. Это можно делать с помощью [[Дерево_отрезков._Построение | дерева отрезков]] следующим образом: построим дерево отрезков для суммы на массиве из единиц. Единица в позиции означает, что данная позиция свободна. Чтобы найти <tex>k</tex>-ую свободную позицию, нужно спускаться (начиная с корня) в левое поддерево если сумма в нём больше, чем <tex>k</tex>, и в правое дерево иначе.<br />
<br />
Данный алгоритм переписывается в код следующим образом:<br />
<br />
<font color=green>// <tex>build_segment_tre</tex> {{---}} строит дерево отрезков над массивом</font><br />
<font color=green>// <tex>node</tex> {{---}} вершина дерева</font><br />
<font color=green>// <tex>node.index</tex> {{---}} индекс соответствующего элемента в массиве для листа дерева</font><br />
'''def''' <tex>\mathtt{recover(inv)}:</tex><br />
<tex>n\ = \mathtt{inv.length}</tex><br />
<tex>\mathtt{tree}\ = \mathtt{build\_segment\_tree}(\mathtt{array}(n, 1))</tex><br />
<tex>\mathtt{result}\ = \mathtt{array}(n)</tex><br />
<tex>curr\ = 1</tex><br />
'''for''' <tex>k \in \mathtt{inv}:</tex><br />
<tex>\mathtt{node}\ = \mathtt{tree.root}</tex><br />
'''while''' <tex>(!\mathtt{node.is\_leaf}):</tex><br />
'''if''' <tex>(k <\mathtt{node.left.value}):</tex><br />
<tex>\mathtt{node}\ = \mathtt{node.left}</tex><br />
'''else:'''<br />
<tex>k\ -= \mathtt{node.left.value}</tex><br />
<tex>\mathtt{node}\ = \mathtt{node.right}</tex><br />
<tex>\mathtt{result}[\mathtt{node.index}]\ = curr</tex><br />
<tex>\mathtt{node.add}(-1)</tex><br />
<tex>curr++</tex><br />
'''return''' <tex>\mathtt{result}</tex><br />
<br />
<br />
Этот алгоритм имеет сложность <tex>O(n \log n)</tex>: делается <tex>n</tex> итераций цикла, в которой происходит спуск по дереву высоты <tex>O(\log n)</tex> и один запрос на дереве отрезков. Таким образом, время работы алгоритма на каждой итерации есть <tex>O(\log n)</tex>.<br />
<br />
== Пример ==<br />
<br />
Рассмотрим пример построения таблицы инверсий и восстановления перестановки по таблице инверсий. Пусть дана перестановка <tex>(5, 7, 1, 3, 4, 6, 8, 2)</tex>. Следующая таблица показывает работу алгоритма за <tex>O(n \log n)</tex>, на каждой строке один уровень рекурсии (на первой строке — самый глубокий). В скобках стоят пары: элемент перестановки, количество инверсий. Полужирным отмечены элементы, у которых обновилось значение количества инверсий на данном шаге.<br />
<br />
{| style = "border: 0px solid; background-color: gray; text-align: center; padding : 0" cellspacing = "2"<br />
| style = "background-color: white; padding: 3px 6px" |(5, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(7, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(1, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(3, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(4, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(6, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(8, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(2, 0)<br />
|-<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(5, 0), (7, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(1, 0), (3, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(4, 0), (6, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|'''(2, 1)''', (8, 0)<br />
|-<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(1, 2)''', '''(3, 2)''', (5, 0), (7, 0)<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(2, 3)''', (4, 0), (6, 0), (8, 0)<br />
|-<br />
|colspan = "8" style = "background-color: white; padding: 3px 6px"|(1, 2), '''(2, 6)''', (3, 2), '''(4, 2)''', (5, 0), '''(6, 1)''', (7, 0), (8, 0)<br />
|}<br />
<br />
Полученная таблица инверсий: <tex>(2, 6, 2, 2, 0, 1, 0, 0)</tex>. Восстановим перестановку по таблице инверсий, начиная с пустого массива.<br />
<br />
{| style = "border: 0px solid; background-color: grey; text-align: center; padding : 0;" cellspacing = "2"<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{1}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{1}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{2}</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем шесть свободных позиций и ставим <tex>\bf{2}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{3}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{3}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{4}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{4}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{5}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиции и ставим <tex>\bf{5}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{6}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем одну свободную позицию и ставим <tex>\bf{6}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{7}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{7}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>7</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{8}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{8}</tex><br />
|}<br />
<br />
== См. также ==<br />
* [[Матричное представление перестановок]]<br />
<br />
<br />
== Источники информации ==<br />
<br />
* [https://en.wikipedia.org/wiki/Permutation Wikipedia {{---}} Permutation]<br />
* Д. Кнут - Искусство программирования, том 3.<br />
<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Комбинаторика ]]</div>6yry6ehttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A2%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0_%D0%B8%D0%BD%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D0%B9&diff=44306Таблица инверсий2015-01-12T15:48:56Z<p>6yry6e: </p>
<hr />
<div>Пусть <tex> P = (p_1,p_2,\dots,p_n)</tex> является [[Действие перестановки на набор из элементов, представление в виде циклов|перестановкой]] чисел <tex> 1, 2,\dots, n</tex>.<br />
<br />
{{Определение<br />
|definition = <br />
'''Инверсией''' (англ. ''inversion'') в перестановке <tex>P</tex> называется всякая пара индексов <tex>i, j</tex> такая, что <tex>1\leqslant i<j\leqslant n</tex> и <tex>P[i]>P[j]</tex>.<br />
}}<br />
{{Определение<br />
|definition = <br />
'''Таблицей инверсий''' (англ. ''inversion table'') перестановки <tex> P </tex> называют такую последовательность <tex> T = (t_1,t_2,\dots,t_n)</tex>, в которой <tex>t_i</tex> равно числу элементов перестановки <tex> P </tex>, стоящих в <tex> P </tex> левее числа <tex>i</tex> и больших <tex>i</tex>.<br />
}}<br />
<br />
== Алгоритм построения за O(N<sup>2</sup>) ==<br />
<br />
Таблицу инверсий тривиально построить по определению. Для каждого элемента перестановки считаем количество элементов, больших данного и стоящих в перестановке левее него.<br />
Алгоритм построения в псевдокоде выглядит так: <br />
T[1..n] = 0<br />
For i = 1..n<br />
For j = 1..(i - 1)<br />
if P[j] > P[i]<br />
T[P[i]] = T[P[i]] + 1<br />
Сложность данного алгоритма {{---}} <tex>O(n^2)</tex>. Уменьшить время работы можно используя алгоритм, похожий на [[Сортировка_слиянием |сортировку слиянием.]]<br />
<br />
== Алгоритм построения за O(N log N) ==<br />
<br />
Пусть дано разбиение перестановки на два списка, причём для каждого элемента дано число инверсий слева с элементами того же списка и известно, что все числа первого списка стоят левее всех чисел второго списка в исходной перестановке. Будем считать количество инверсий слева элементов обоих списков следующим образом: сливаем списки, аналогично [[Сортировка_слиянием |сортировке слиянием.]]<br />
<br />
Если в результат нужно записать элемент первого списка, то все нерассмотренные элементы второго списка больше, следовательно, количество инверсий для этого элемента не меняется. Если в результат нужно записать элемент второго списка, то все нерассмотренные элементы первого списка больше его и стоят левее. Следовательно, количество инверсий для этого элемента следует увеличить на количество нерассмотренных элементов второго списка.<br />
<br />
Описанный алгоритм записывается в псевдокод следующим образом:<br />
<font color=green>// <tex>inverses\_merge</tex> {{---}} процедура, сливающая два списка пар</font><br />
<font color=green>// <tex>inverses\_get</tex> {{---}} процедура, рекурсивно получающая таблицу инверсий для перестановки</font><br />
'''def''' <tex>\mathtt{inverses\_merge(ls1, ls2)}:</tex><br />
<tex>\mathtt{result}\ = [ ]</tex><br />
<tex>it\textit{1}, it\textit{2}\ =</tex> ''null''<br />
'''while''' <tex>(it\textit{1}</tex> <tex><</tex> <tex>\mathtt{ls1.length})</tex> '''and''' <tex>(it\textit{2}</tex> <tex><</tex> <tex>\mathtt{ls2.length}):</tex><br />
'''if''' <tex>\mathtt{ls1}[it\textit{1}]\mathtt{.item}</tex> <tex><</tex> <tex>\mathtt{ls2}[it\textit{2}]\mathtt{.item}:</tex><br />
<tex>\mathtt{result.append}(\mathtt{ls1}[it\textit{1}])</tex><br />
<tex>it\textit{1}++</tex><br />
'''else:'''<br />
<tex>\mathtt{result.append}(item\ =</tex> <tex>\mathtt{ls2}[it\textit{2}]\mathtt{.item}, inverses\ =</tex> <tex>\mathtt{ls2}[it\textit{2}]\mathtt{.inverses}</tex> <tex>+</tex> <tex>\mathtt{ls1.length}</tex> <tex>-</tex> <tex>it\textit{1})</tex><br />
<tex>it\textit{2}++</tex><br />
'''while''' <tex>(it\textit{1}</tex> <tex><</tex> <tex>\mathtt{ls1.length}):</tex><br />
<tex>\mathtt{result.append}(\mathtt{ls1}[it\textit{1}])</tex><br />
<tex>it\textit{1}++</tex><br />
'''while''' <tex>(it\textit{2}</tex> <tex><</tex> <tex>\mathtt{ls2.length}):</tex><br />
<tex>\mathtt{result.append}(\mathtt{ls2}[it\textit{2}])</tex><br />
<tex>it\textit{2}++</tex><br />
'''return''' <tex>\mathtt{result}</tex><br />
<br />
'''def''' <tex>\mathtt{inverses\_get(ls)}:</tex><br />
'''if''' <tex>\mathtt{ls.length}\ == 1:</tex><br />
'''return''' <tex>[(item = \mathtt{ls[0]}, inverses = 0)]</tex><br />
'''else:'''<br />
'''return''' <tex>\mathtt{inverses\_merge(inverses\_get(ls.first\_half), inverses\_get(ls.second\_half))}</tex><br />
<br />
<br />
Сложность представленного алгоритма есть <tex>O(n\log n)</tex>. Алгоритм с такой же сложностью можно построить с помощью [[Дерево_отрезков._Построение | дерева отрезков.]]<br />
<br />
== Алгоритм восстановления ==<br />
<br />
Для восстановления перестановки по таблицы инверсий <tex>T</tex> воспользуемся следующим соображением: единица стоит в перестановке на <tex>T_0</tex>-ом месте (индексируем элементы с нуля), так как остальные числа в перестановке больше единицы. Далее, если известны расположения всех чисел <tex>1, \dots, k</tex>, то число <tex>k + 1</tex> стоит на <tex>T_{k + 1}</tex>-ой ещё не занятой позиции: все числа, меньшие <tex>k + 1</tex> уже расставлены. Это рассуждение напрямую переписывается в код следующим образом:<br />
<font color=green>// <tex>j</tex> {{---}} счётчик пропущенных свободных позиций</font><br />
<font color=green>// <tex>k</tex> {{---}} количество инверсий слева для элемента curr</font><br />
<font color=green>// <tex>result</tex> {{---}} массив, в который записывается перестановка. Равенство элемента массива нулю обозначает, что эта позиция свободна.</font><br />
'''def''' <tex>\mathtt{recover\_straight(ls)}:</tex><br />
<tex>n\ = \mathtt{ls.length}</tex><br />
<tex>\mathtt{result}\ = \mathtt{array}(0, n)</tex><br />
<tex>curr\ = 1</tex><br />
'''for''' <tex>k \in \mathtt{ls}:</tex><br />
<tex>j\ = 0</tex><br />
'''for''' <tex>(i\ = 0, i < n, i++):</tex><br />
'''if''' <tex>\mathtt{result}[i]\ == 0:</tex><br />
'''if''' <tex>j\ == k:</tex><br />
<tex>\mathtt{result}[i]\ = curr</tex><br />
'''break'''<br />
'''else:'''<br />
<tex>j++</tex><br />
<tex>curr++</tex><br />
'''return''' <tex>\mathtt{result}</tex><br />
<br />
<br />
Этот простой алгоритм имеет сложность <tex>O(n^2)</tex> — внутренний цикл делает до <tex>n</tex> итераций, внешний — ровно <tex>n</tex> итераций.<br />
<br />
Видно, что для восстановления нужно узнавать <tex>k</tex>-ую свободную позицию. Это можно делать с помощью [[Дерево_отрезков._Построение | дерева отрезков]] следующим образом: построим дерево отрезков для суммы на массиве из единиц. Единица в позиции означает, что данная позиция свободна. Чтобы найти <tex>k</tex>-ую свободную позицию, нужно спускаться (начиная с корня) в левое поддерево если сумма в нём больше, чем <tex>k</tex>, и в правое дерево иначе.<br />
<br />
Данный алгоритм переписывается в код следующим образом:<br />
<br />
<font color=green>// <tex>build_segment_tre</tex> {{---}} строит дерево отрезков над массивом</font><br />
<font color=green>// <tex>node</tex> {{---}} вершина дерева</font><br />
<font color=green>// <tex>node.index</tex> {{---}} индекс соответствующего элемента в массиве для листа дерева</font><br />
'''def''' <tex>\mathtt{recover(inv)}:</tex><br />
<tex>n\ = \mathtt{inv.length}</tex><br />
<tex>\mathtt{tree}\ = \mathtt{build_segment_tree}(\mathtt{array}(n, 1))</tex><br />
<tex>\mathtt{result}\ = \mathtt{array}(n)</tex><br />
<tex>curr\ = 1</tex><br />
'''for''' <tex>k \in \mathtt{inv}:</tex><br />
<tex>\mathtt{node}\ = \mathtt{tree.root}</tex><br />
'''while''' <tex>(!\mathtt{node.is\_leaf}):</tex><br />
'''if''' <tex>(k <\mathtt{node.left.value}):</tex><br />
<tex>\mathtt{node}\ = \mathtt{node.left}</tex><br />
'''else:'''<br />
<tex>k\ -= \mathtt{node.left.value}</tex><br />
<tex>\mathtt{node}\ = \mathtt{node.right}</tex><br />
<tex>\mathtt{result}[\mathtt{node.index}]\ = curr</tex><br />
<tex>\mathtt{node.add}(-1)</tex><br />
<tex>curr++</tex><br />
'''return''' <tex>\mathtt{result}</tex><br />
<br />
<br />
Этот алгоритм имеет сложность <tex>O(n \log n)</tex>: делается <tex>n</tex> итераций цикла, в которой происходит спуск по дереву высоты <tex>O(\log n)</tex> и один запрос на дереве отрезков. Таким образом, время работы алгоритма на каждой итерации есть <tex>O(\log n)</tex>.<br />
<br />
== Пример ==<br />
<br />
Рассмотрим пример построения таблицы инверсий и восстановления перестановки по таблице инверсий. Пусть дана перестановка <tex>(5, 7, 1, 3, 4, 6, 8, 2)</tex>. Следующая таблица показывает работу алгоритма за <tex>O(n \log n)</tex>, на каждой строке один уровень рекурсии (на первой строке — самый глубокий). В скобках стоят пары: элемент перестановки, количество инверсий. Полужирным отмечены элементы, у которых обновилось значение количества инверсий на данном шаге.<br />
<br />
{| style = "border: 0px solid; background-color: gray; text-align: center; padding : 0" cellspacing = "2"<br />
| style = "background-color: white; padding: 3px 6px" |(5, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(7, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(1, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(3, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(4, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(6, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(8, 0)<br />
| style = "background-color: white; padding: 3px 6px" |(2, 0)<br />
|-<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(5, 0), (7, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(1, 0), (3, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|(4, 0), (6, 0)<br />
|colspan = "2" style = "background-color: white; padding: 3px 6px"|'''(2, 1)''', (8, 0)<br />
|-<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(1, 2)''', '''(3, 2)''', (5, 0), (7, 0)<br />
|colspan = "4" style = "background-color: white; padding: 3px 6px"|'''(2, 3)''', (4, 0), (6, 0), (8, 0)<br />
|-<br />
|colspan = "8" style = "background-color: white; padding: 3px 6px"|(1, 2), '''(2, 6)''', (3, 2), '''(4, 2)''', (5, 0), '''(6, 1)''', (7, 0), (8, 0)<br />
|}<br />
<br />
Полученная таблица инверсий: <tex>(2, 6, 2, 2, 0, 1, 0, 0)</tex>. Восстановим перестановку по таблице инверсий, начиная с пустого массива.<br />
<br />
{| style = "border: 0px solid; background-color: grey; text-align: center; padding : 0;" cellspacing = "2"<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{1}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{1}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{2}</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем шесть свободных позиций и ставим <tex>\bf{2}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{3}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{3}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{4}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем две свободных позиции и ставим <tex>\bf{4}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{5}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиции и ставим <tex>\bf{5}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{6}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|пропускаем одну свободную позицию и ставим <tex>\bf{6}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{7}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>0</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{7}</tex><br />
|-<br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>5</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>7</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>1</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>3</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>4</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>6</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>\bf{8}</tex><br />
|colspan = "1" style = "background-color: white; padding: 3px 6px"|<tex>2</tex><br />
|colspan = "1" style = "background-color: #EEF; text-align: left; padding: 3px 6px"|не пропускаем свободных позиций и ставим <tex>\bf{8}</tex><br />
|}<br />
<br />
== Источники информации ==<br />
<br />
* [https://en.wikipedia.org/wiki/Permutation Wikipedia {{---}} Permutation]<br />
* Д. Кнут - Искусство программирования, том 3.<br />
<br />
== См. также ==<br />
* [[Матричное представление перестановок]]<br />
<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
<br />
[[Категория: Комбинаторика ]]</div>6yry6e