Apakah ada algoritma "pengurutan" yang mengembalikan permutasi acak ketika menggunakan pembanding koin-balik?

Terinspirasi oleh pertanyaan ini di mana penanya ingin tahu apakah waktu berjalan berubah ketika pembanding yang digunakan dalam algoritma pencarian standar digantikan oleh flip koin yang adil, dan juga kegagalan Microsoft yang menonjol untuk menulis generator permutasi yang seragam, pertanyaan saya adalah demikian :

Apakah ada algoritma penyortiran berbasis perbandingan yang akan, tergantung pada implementasi kami dari pembanding:

kembalikan elemen dalam urutan yang diurutkan ketika menggunakan komparator sejati (yaitu, perbandingan melakukan apa yang kita harapkan dalam algoritma pengurutan standar)
mengembalikan permutasi acak seragam elemen ketika pembanding digantikan oleh flip koin yang adil (yaitu, kembali x < y = truedengan probabilitas 1/2, terlepas dari nilai x dan y)

Kode untuk algoritma pengurutan harus sama. Hanya kode di dalam "kotak hitam" perbandingan yang diizinkan untuk diubah.

sorting randomized-algorithms permutations

— Joe
sumber

Lihat juga pertanyaan ini .

— Raphael

Lihat juga pertanyaan menarik berikut: cstheory.stackexchange.com/questions/5321/… .

— Yuval Filmus

Apakah Anda ingin pembanding acak Anda berperilaku baik? Berikut adalah dua cara yang mungkin. (1) Setelah pembanding memutuskan bahwa

, maka

selalu, dan juga

. (2) Sama, tetapi jika lebih jauh pembanding memutuskan bahwa

dan

, maka berkomitmen untuk

(dan

). Dalam kedua kasus, setiap kueri yang tidak dibatasi masih sepenuhnya acak.

x < y

$x<y$

x < y

$x<y$

y > x

$y>x$

x < y

$x<y$

y < z

$y<z$

x < z

$x<z$

z > x

$z>x$

— Yuval Filmus

@YuvalFilmus Saya ingin dasarnya apa yang diminta dalam pertanyaan Anda yang ditautkan, kecuali bahwa sirkuit yang sama juga harus mengurutkan jika kita mengganti gerbang acak dengan gerbang pertukaran-tukar yang memesan sepasang elemen.

— Joe

Lihat di sini untuk visualisasi yang bagus.

— Raphael

Algoritma deterministik berikut (tanpa pembanding) bekerja untuk input tuple : $(a_1,\dots,a_n)$

Apakah yang Fisher-Yates mengocok menggunakan komparator Anda dengan beberapa pasangan statis (mengatakan ) sebagai flip koin (melakukan penerimaan-penolakan sampling). Jika komparator mengeluarkan pertama kali, gunakan itu terbalik untuk menghindari loop penolakan tanpa akhir dalam kasus deterministik. $a_1 < a_2$ $1$
(speedup opsional: Coba satu pasangan kali, di mana adalah panjang atau input Anda. Jika ada dua output yang berbeda, kembalikan permutasi yang diperoleh dalam (1)) $n$ $n$
Sortir array Anda menggunakan sortir gabungan.

Diberikan relasi urutan deterministik sebagai pembanding, algoritma ini mengurutkan array dalam waktu karena shuffle Fisher-Yates berjalan dalam menggunakan maksimal "acak bit" nonrandom (misalnya panggilan ke pembanding Anda ) pada setiap langkah dan gabungan, memiliki kompleksitas asimptotik yang sama. Hasil dari (1) sama sekali tidak berguna dalam kasus ini, tetapi karena diikuti oleh semacam nyata, ini tidak ada salahnya. $\mathcal{O}(n \log n)$ $\mathcal{O}(n)$ $\mathcal{O}(\log n)$

Diberikan flip koin nyata sebagai pembanding (1) memungkinkan array dengan probabilitas yang sama untuk setiap permutasi dan jika Anda benar-benar harus melakukan (3) (Anda ditinggalkan (2) atau (2) gagal menentukan keacakan), ini bukan salahnya karena distribusi hasil hanya tergantung pada urutan inputnya yang terdistribusi secara merata di antara semua permutasi karena (1), sehingga hasil dari seluruh algoritma juga terdistribusi secara seragam. Jumlah setiap pengambilan sampel penerimaan-penolakan harus diulang didistribusikan secara geometris (tolak dengan probabilitas ) dan karena itu memiliki nilai yang diharapkan. Setiap penggunaan pengulangan palingbit, sehingga analisis runtime hampir sama seperti dalam kasus deterministik, tetapi kami hanya mendapatkanruntime diharapkandari, dengan kemungkinan nontermination (Menghentikan hanyahampir pasti). $< \frac{1}{2}$ $< 2$ $\log n$ $\mathcal{O}(n \log n)$

Seperti Joe menunjukkan: Jika Anda tidak menyukai tes untuk bit pertama dalam (1), melakukan (3) maka (1) dan menggunakan yang selalu , karena array sudah diurutkan dalam kasus deterministik. Selain itu Anda harus mengurangi angka acak Anda dari batas atas pada rentang dalam loop, karena batas atas untuk angka acak menghasilkan permutasi yang sama. Namun ketahuilah bahwa (2) itu dilarang, karena Anda selalu harus melakukan shuffle dalam kasus tebusan. $a_n < a_1$ $0$

Anda bahkan dapat menggunakan panggilan yang sama ke komparator Anda untuk (1) dan (3), tetapi kemudian membuktikan bahwa hasilnya didistribusikan secara merata setidaknya jauh lebih sulit, jika mungkin sama sekali.

Algoritme berikut tidak memiliki fase berbeda untuk mengocok dan mengurutkan, tetapi secara asimptot lebih lambat. Ini pada dasarnya semacam penyisipan dengan pencarian biner . Saya akan menggunakan

untuk menunjukkan input dan

untuk menunjukkan hasil setelah putaran ke-

a = (a_{1}, \dots, a_{n})

$a=(a_1,\dots,a_n)$

b_{k} = (b_{k, 1}, \dots, b_{k, k})

$b_k=(b_{k,1},\dots,b_{k,k})$

k

$k$

Set $b_{1,1} = a_1$
Jika maka dan lain dan . Dalam kedua kasus $a_2 < a_1$ $b_2 = (a_2,a_1)$ $(c,d):= (2,1)$ $b_2 = (a_1,a_2)$ $(c,d):= (1,2)$ akan selalu menjadi (mis. salah) untuk pembanding nonrandom. $a_d < a_c$ $0$
Untuk mendapatkan untuk dapatkan terlebih dahulu. $b_{k}$ $k \geq 3$ $b_{k-1}$
Mari dan , yaitu adalah kekuatan paling tidak lebih kecil dari . $l=\lceil log_2 k \rceil$ $k' = 2^l$ $k'$ $2$ $k$
Biarkan . Untuk setiap biarkan $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 \land a_{d} < a_{c} \\ i_{j - 1} & i_{j - 1} + 2^{l - j} > k - 1 \land \neg (a_{d} < a_{c}) \\ i_{j - 1} + 2^{l - j} & i_{j - 1} + 2^{l - j} \leq k - 1 \land b_{k - 1, i_{j - 1} + 2^{l - j}} < a_{k} \\ i_{j - 1} & i_{j - 1} + 2^{l - j} \leq k - 1 \land \neg (b_{k - 1, i_{j - 1} + 2^{l - j}} < a_{k}) \end{cases}$ $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}$
$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})$
$b_n$

$k-1$ $k$

Perhatikan bahwa algoritma ini tidak efisien dalam kedua mode dibandingkan dengan pengocokan dan gabungan jenis Fisher-Yates karena memasukkan elemen ke posisi sewenang-wenang mahal jika menggunakan array dan pencarian biner membutuhkan waktu linier jika menggunakan daftar. Tapi mungkin modifikasi heap sort atau tree sort dengan cara yang sama dapat menghasilkan algoritma yang lebih cepat.

— frafl
sumber

@Jo, bisakah kamu menaruh semua poin kamu masih berlaku untuk posting dalam bentuk saat ini menjadi satu komentar dan menghapus sisanya?

— frafl

Saya berharap untuk algoritma yang tidak melakukan langkah-langkah berbeda tergantung pada komparator mana yang digunakan. Bisakah Anda menghindari loop penolakan tanpa batas tanpa memeriksa pembanding? Saya pikir Anda dapat menghindari penolakan dengan melakukan langkah (3) terlebih dahulu ...

— Joe

i

$i$

Komentar pertama: Perhatikan bahwa saya tidak membuang sedikit sampel pertama, itu "penggunaan ganda". Saya berpikir tentang membalikkan setiap bit ke-2, tetapi itu tidak akan mencegah loop tanpa akhir. Bahkan beberapa pola tidak teratur diperlukan dan bahkan dapat menolak lebih banyak entri. Tentu saja saya bisa XOR dua bit paling baru, bukan yang pertama dan yang terbaru, tapi itu tidak terlalu berbeda.

— frafl

i

$i$

a_{n} < a_{1}

$a_n < a_1$

0

$0$

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

— Yuval Filmus
sumber

Tetapi ini hanya berlaku, jika kita membutuhkan batasan deterministik pada runtime, yang tidak diminta dalam pertanyaan. Jika kita hanya membutuhkan runtime yang diharapkan menjadi terbatas, ini seharusnya tidak menjadi masalah.

— frafl

Apakah Anda mengetahui adanya algoritma penyortiran yang masuk akal yang tidak berakhir dalam waktu polinomial?

— Yuval Filmus

Anda mencampur kasus deterministik dan acak. Algoritma dapat berakhir dalam waktu polinom deterministik jika dipanggil dengan hubungan urutan deterministik dan dalam waktu polinomial yang diharapkan jika dipanggil dengan koin sebagai pembanding.

— frafl

2^{k}

$2^k$

k

$k$

A / 2^{k}

$A/2^k$