Есть ли алгоритм «сортировки», который возвращает случайную перестановку при использовании компаратора с переворотом?

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

Существует ли алгоритм сортировки на основе сравнения, который в зависимости от нашей реализации компаратора будет:

1. возвращать элементы в отсортированном порядке при использовании истинного компаратора (то есть сравнение делает то, что мы ожидаем в стандартном алгоритме сортировки)
2. возвращать равномерно случайную перестановку элементов, когда компаратор заменяется честным подбрасыванием монеты (то есть возвращение x < y = trueс вероятностью 1/2, независимо от значений x и y)

Код для алгоритма сортировки должен быть таким же. Только код внутри «черного ящика» сравнения может быть изменен.

Следующий детерминированный (без компаратора) алгоритм работает для входного кортежа :$(a_1,\dots,a_n)$

1. Выполните Fisher-Yates перемешайте с помощью компаратора с некоторой статической парой (скажем , ) в качестве подбрасывания монеты (делают выборку приемо-отказ). Если компаратор выдает 1 в первый раз, используйте его инвертированным, чтобы избежать бесконечного цикла отклонения в детерминированном случае.$a_1 < a_2$$1$
2. (необязательное ускорение: попробуйте одну пару раз, где n - длина или ваш вход. Если какие-либо два выходных сигнала отличаются, возвращают перестановку, полученную в (1))$n$$n$
3. Сортируйте массив, используя сортировку слиянием.

При наличии детерминированного отношения порядка в качестве компаратора этот алгоритм сортирует массив за время поскольку перемешивание Фишера-Йейтса выполняется в O ( n ) с использованием максимального O ( log $\mathcal{O}(n \log n)$$\mathcal{O}(n)$случайная ) неслучайных «случайных битов» (например, вызовов вашего компаратора) ) в каждом шаге сортировка слиянием имеет одинаковую асимптотическую сложность. Результат (1) в этом случае совершенно бесполезен, но поскольку за ним следует реальная сортировка, это не вредит.$\mathcal{O}(\log n)$

Учитывая реальный бросок монеты, когда компаратор (1) переставляет массив с равной вероятностью для каждой перестановки, и если вам действительно нужно сделать (3) (вы пропустили (2) или (2) не смогли определить случайность), это не вред, потому что распределение его результата зависит только от порядка его ввода, который равномерно распределен среди всех перестановок из-за (1), поэтому результат всего алгоритма также равномерно распределен. Количество раз, которое каждая повторная выборка-приемка должна быть геометрически распределена (отклонение с вероятностью ) и, следовательно, имеет ожидаемое значение<2. Каждоеиспользует повторение в большинствелогапбит, поэтому анализ выполнения почти такие жекакв детерминированном случае, но мы получить толькоожидаемое время работыотO(павторизуйтесьп), с возможностью nontermination (только прекращает$< \frac{1}{2}$$< 2$$\log n$$\mathcal{O}(n \log n)$ почти наверное ).

---

Как Джо отметил: Если вам не нравится , тест на первый бит в (1), делать (3) , затем (1) и использовать , который всегда 0 , так как массив уже отсортирован в детерминированный случай. Кроме того, вы должны вычесть ваше случайное число из верхней границы диапазона в цикле, потому что верхняя граница для случайного числа дает идентичную перестановку. Но имейте в виду, что (2) тогда запрещено, потому что вы всегда должны делать случайные действия в случае выкупа.$a_n < a_1$$0$

---

Вы даже можете использовать те же вызовы для вашего компаратора для (1) и (3), но затем доказать, что результат распределен равномерно, как минимум, намного сложнее, если вообще возможно.

---

Следующий алгоритм не имеет отдельных фаз для перемешивания и сортировки, но асимптотически медленнее. Это по сути вставка сортировки с бинарным поиском . Я буду использовать для обозначения ввода, а b k = ( b k , 1 , … , b k , k ) для обозначения результата после k-го раунда:$a=(a_1,\dots,a_n)$$b_k=(b_{k,1},\dots,b_{k,k})$$k$

1. Установите $b_{1,1} = a_1$
2. Если то b 2 = ( a 2 , a 1 ) и ( c , d ) : = ( 2 , 1 ), иначе b 2 = ( a 1 , a 2 ) и ( c , d ) : = ( 1 , 2 ) . В любом случае a d$a_2 < a_1$$b_2 = (a_2,a_1)$$(c,d):= (2,1)$$b_2 = (a_1,a_2)$$(c,d):= (1,2)$ всегда будет 0 (т. е. false) для неслучайного компаратора.$a_d < a_c$$0$
3. Чтобы получить при k ≥ 3, сначала получим b k - 1 .$b_{k}$$k \geq 3$$b_{k-1}$
4. Пусть и k ′ = 2 l , т.е. k ′ - наименьшая степень 2, не меньшая, чем k .$l=\lceil log_2 k \rceil$$k' = 2^l$$k'$$2$$k$
5. Пусть . Для каждого j ∈ { 1 , … , l } пусть i j = { i j - 1 + 2 l - j i j - 1 + 2 l - j > k - 1 ∧ a d < a c i j - 1 i j - 1 + 2 л $i_0 = 0$$j \in \{1,\dots,l\}$ $$i_j = \begin{cases} i_{j-1} + 2^{l-j} & i_{j-1} + 2^{l-j} > k-1 \wedge a_d < a_c\\ i_{j-1} & i_{j-1} + 2^{l-j} > k-1 \wedge \neg (a_d < a_c)\\ i_{j-1} + 2^{l-j} & i_{j-1} + 2^{l-j} \leq k-1 \wedge b_{k-1,i_{j-1} + 2^{l-j}} < a_k \\ i_{j-1} & i_{j-1} + 2^{l-j} \leq k-1 \wedge \neg(b_{k-1,i_{j-1} + 2^{l-j}} < a_k) \\ \end{cases}$$
6. Если повторите (5.) иначе b k = ( b k - 1 , 1 , … , b k - 1 , i l - 1 , a k , b k - 1 , i l , … , b k - 1 , к - 1$i_l > k$$b_k=(b_{k-1,1},\dots,b_{k-1,i_l -1},a_k,b_{k-1,i_l},\dots,b_{k-1,k-1})$
7. Выход $b_n$

Случайный случай: 5 + условие if из 6 - это, по сути, выборка принятия-отклонения. Остальная часть алгоритма - наивный случайный порядок: перемешайте первые элементов и добавьте $k-1$$k$ элемент в каждую позицию с равной вероятностью. Если бы мы использовали обычную сортировку вставкой, мы бы получили вместо этого биномиальное распределение.

Обратите внимание, что этот алгоритм неэффективен в обоих режимах по сравнению со случайной сортировкой Фишера-Йейтса и сортировкой слиянием, поскольку вставка элемента в произвольную позицию является дорогой, если использование массива и бинарный поиск требуют линейного времени при использовании списка. Но, возможно, модификация сортировки кучи или сортировки дерева подобным образом может привести к более быстрому алгоритму.

$n \leq 2$$A/2^B$$1/n!$$n > 2$$1/n!$$A/2^B$