Temukan sudut

Bagaimana seseorang dapat menemukan sudut dari unit cube di terdekat dengan titik di dalam kubus? Gunakan metrik L1, sehingga dalam 4d | - 0000 | = , | - 0001 | = ( di sebelah kanan) dan seterusnya.d + 1 R d x x ∑ x i x x 3 + x 2 + x 1 + ( 1 - x 0 ) x $d+1$$\mathbb{R}^d$$x$
$x$$\sum {x_i}$$x$$x_3 + x_2 + x_1 + (1 - x_0)$
$x_0$

Untuk formulasi alternatif, flip pertama > 1/2 dan urutkan, sehingga 1/2; dengan simetri, suatu algoritma untuk kasus ini dapat melakukan di dalam kubus. Tentukan , . Lalu kami ingin sudut dengan sudut terkecil .x i 0 ≤ x d - 1 ≤ … x 1 ≤ $x_i$  0 ≤ x c ≡ 1 - 2 x 1 ≥ c d - 1 ≥ … c 1 ≥ c 0 ≥ 0 d + 1 c $0 \leq x_{d-1} \leq \dots\ x_1 \leq x_0 \leq$$x$
$c \equiv 1 - 2x$$1\geq c_{d-1} \geq \dots\ c_1 \geq c_0 \geq 0$
$d+1$$c \cdot$

Dalam 4d misalnya, dengan $x_i$ berkurang 1/2 .. 0 seperti di atas, 5 sudut terdekat bisa

    0 0 0 0
    0 0 0 1
    0 0 1 0

    0 1 0 0  or  0 0 1 1
                 0 1 * *

    1 0 0 0
 or 0 1 0 1

Namun dalam 5d, 6d ... pohon-pohon di sudut yang meningkat terlihat (bagi saya) semakin berantakan.
Heuristik untuk perkiraan-terdekat akan baik-baik saja.

Waktu $O(d^3\log d)$

lemma: Perbaiki x ∈ [ 0 , 1 ] d . Lalu ada himpunan S yang berisi d + 1 sudut { 0 , 1 } d yang paling dekat dengan x dan sedemikian sehingga S terhubung (artinya subgraf dari hypercube yang diinduksi oleh S terhubung).$x\in[0,1]^d$$S$$d+1$$\{0,1\}^d$$x$$S$$S$

Bukti. Pertama mempertimbangkan kasus yang x memiliki koordinat sama untuk 1 / 2 .$x$$1/2$

Mengingat setiap sudut sebuah di S , membalik koordinat suatu j dari suatu tidak akan meningkatkan jarak dari suatu ke x jika | a j - x j | ≥ 1 / 2 . $a$$S$$a_j$$a$$a$$x$$|a_j - x_j| \ge 1/2$

Pertimbangkan dua sudut a , b dalam S yang berbeda setidaknya dalam satu koordinat j , dan asumsikan WLOG bahwa a j = 0 dan b j = 1 . Jika x j < 1 / 2 kemudian membalik b j di b memberikan titik lain di S (karena mengurangi jarak dari b ke x ). Atau, jika x j > 1 / 2 kemudian membalik sebuah $a,b$$S$$j$$a_j=0$$b_j=1$$x_j<1/2$$b_j$$b$$S$$b$$x$$x_j>1/2$$a_j$di sebuah memberikan titik di S . Mengulangi proses ini untuk setiap berbeda koordinat dalam sebuah dan b memberikan jalan yang menghubungkan suatu dan b dalam S .$a$$S$$a$$b$$a$$b$$S$

Jika x memiliki koordinat sama untuk 1 / 2 , kemudian, dalam memilih S , ikatan istirahat antara titik yang berjarak sama dengan mendahulukan mereka dengan lebih nol koordinat. Maka argumen yang sama akan berhasil. QED$x$$1/2$$S$

Oleh lemma, Anda dapat menggunakan Dijkstra seperti algoritma untuk menemukan S . Mulailah dengan sudut yang paling dekat dengan x ( a dengan a j = 0 jika x j ≤ 1 / 2 ). Kemudian berulang kali menambah S sudut yang terdekat dengan x antara mereka yang berdekatan dengan beberapa titik dalam S . Berhenti ketika d + 1 poin telah ditambahkan. $S$$x$$a$$a_j = 0$$x_j \le 1/2$$S$$x$$S$$d+1$

Naif (menggunakan min-heap untuk menemukan titik terdekat di samping x di setiap iterasi), saya kira ada d + 1 iterasi, dan setiap iterasi membutuhkan O ( d 2 ) bekerja untuk menghasilkan d tetangga dari node ditambahkan (masing-masing yang memiliki representasi ukuran d ), memberikan run time O ( d 3 log d ) .$x$$d+1$$O(d^2)$$d$$d$$O(d^3\log d)$

Waktu $O(d^2\log d)$

Mewakili setiap sudut sebuah implisit sebagai pasangan ( h , d ) , di mana h adalah hash dari himpunan indeks i sehingga sebuah i = 1 , dan d adalah jarak dari x ke sebuah . Dari sudut tertentu a , pasangan untuk semua sudut tetangga dapat dihasilkan dalam waktu O ( d ) (total). Ini membawa run time ke O ( d 2 log d ) .$a$$(h, d)$$h$$i$$a_i=1$$d$$x$$a$$a$$O(d)$$O(d^2\log d)$

Lebih cepat?

Untuk mempermudah diskusi, mari kita ulangi masalahnya sebagai berikut. Dengan urutan d angka non-negatif y 1 ≤ y 2 ≤ ⋯ ≤ y d , cari himpunan himpunan biaya minimum d + 1 , di mana biaya himpunan bagian adalah jumlah dari angka-angka di dalamnya. $d$$y_1 \le y_2 \le \cdots \le y_d$$d+1$ (Untuk melihat hubungan dengan masalah sebelumnya, mengambil y i = | x i - 1 / 2 | ; maka setiap bagian Y dari y i 's berkorespondensi ke sudut $y_i = |x_i - 1/2|$$Y$$y_i$( Y ) dari hypercube, di mana sebuah i ( y ) adalah 1 jika ( x i ≤ 1 / 2 dan y i ∈ Y ) atau ( x i > 1 / 2 dan y i ∉ Y ); dan biaya Y adalah jarak dari x ke a ( y ) .)$a(y)$$a_i(y)$$x_i \le 1/2$$y_i\in Y$$x_i>1/2$$y_i\not\in Y$$Y$$x$$a(y)$

Inilah ide umum untuk algoritma yang lebih cepat. Mungkin seseorang bisa mengetahui cara membuatnya bekerja.

Tentukan grafik yang diarahkan implisit di mana setiap node adalah subset Y dari y i 's. Node mulai adalah set kosong. Mewakili node secara implisit sebagai pasangan ( h , c ) di mana h adalah hash dari subset dan c adalah biayanya. Untuk setiap himpunan bagian Y , tentukan himpunan bagian himpunan tetangga entah bagaimana sehingga (i) jika Y → Y ′ adalah tepi terarah maka biaya ( Y ′ ) ≥ biaya ( Y ) , dan (ii) untuk setiap himpunan bagian Y ′ , ada tepi diarahkan$Y$$y_i$$(h, c)$$h$$c$$Y$$Y\rightarrow Y'$$(Y') \ge$$(Y)$$Y'$Y → Y ′ dari beberapa himpunan bagian Y di mana biaya ( Y ) ≤ biaya ( Y ′ ) . Kemudian jalankan Dijkstra pada grafik implisit ini mulai dari simpul awal.$Y\rightarrow Y'$$Y$$(Y) \le$$(Y')$

Pilih ujung-ujungnya (entah bagaimana) sehingga (i) dan (ii) keduanya bertahan, dan jumlah derajat dari simpul d + 1 termurah adalah O ( d ) . (Ini selalu mungkin, misalnya, mengambil sisi-sisinya menjadi pohon-pohon di jalur pohon terpendek yang berakar di awal). Tetapi bisakah seseorang mendefinisikan grafik semacam itu tanpa pengetahuan a-priori tentang pohon jalur terpendek? Jika demikian, ini dapat menyebabkan algoritma O ( d log d ) -time (?).$d+1$$O(d)$$O(d\log d)$

Ini sama dengan bertanya, di antara sekumpulan item d non-negatif berbobot, untuk himpunan bagian d + 1 dari berat total minimum. Seseorang dapat membentuk semua himpunan bagian dari item menjadi pohon, di mana induk dari subset dibentuk dengan menghapus item terberatnya (dengan ikatan yang diputus secara sewenang-wenang tetapi konsisten); solusi d + 1 akan membentuk subtree dari pohon ini yang terhubung pada akarnya (set kosong).$d$$d+1$$d+1$

Jadi, seseorang dapat mencari pohon ini untuk item d + 1 terkecil dengan bentuk algoritma Dijkstra di mana kami mempertahankan antrian subset prioritas dan menghapusnya dalam urutan prioritas. Kami mulai dengan item yang dipilih pertama menjadi set kosong. Kemudian, pada setiap langkah, kami mempertahankan sebagai antrian algoritma sebagai antrian prioritas yang berisi anak berikutnya yang tidak dipilih untuk setiap subset yang sudah dipilih. Ketika kami memilih himpunan S , kami menghapusnya dari antrian prioritas, dan kami menambahkan ke antrian prioritas dua himpunan bagian baru: anak pertamanya (himpunan dibentuk dengan menambahkan elemen lebih berat berikutnya daripada elemen terberat di S ) dan saudara kandung berikutnya (himpunan dibentuk dengan menghapus elemen terberat dalam S dan menambahkan elemen lebih berat berikutnya yang sama).$d+1$$S$$S$$S$

Setelah mengurutkan item berdasarkan bobotnya, mudah untuk mewakili setiap set secara implisit (sebagai elemen terberatnya ditambah pointer ke set induknya), menjaga berat total dari setiap set, dan menemukan anak pertama dan saudara kandung berikutnya yang dibutuhkan oleh algoritma dalam waktu konstan per set. Oleh karena itu total waktu didominasi oleh penyortiran awal dan oleh operasi antrian prioritas, yang mengambil total waktu O ( d log d ) .$O(d\log d)$

Bahkan ini dapat ditingkatkan, jika barang sudah diurutkan berdasarkan bobotnya. Lihat hubungan "anak pertama" dan "saudara berikutnya" dari algoritma sebelumnya sebagai anak-anak kiri dan kanan dalam pohon biner himpunan bagian. Pohon ini adalah heap-ordered (total berat meningkat dari induk ke anak) sehingga kami dapat menerapkan algoritma untuk menemukan node bobot minimum d + 1 dalam pohon biner yang di-heap [GN Frederickson. Algoritma yang optimal untuk seleksi dalam min-heap. Informasi dan Komputasi, 104: 197–214, 1993]. Total waktu, setelah langkah penyortiran, adalah O ( d ) .$d+1$$O(d)$

Dalam praktiknya, bobot sering didistribusikan secara seragam, kira-kira ~ 1 2 3 ... Kemudian heuristik sederhana dimulai dengan:$\dots$

$\qquad$yang d bit tunggal, misalnya 10000000 01000000 ... 00000001$d$$\dots$
$\qquad$ ⌈ l n 2 d ⌉ kombinasi bit-rendah 00000011 00000101 00000110 00000111$\lceil ln_2 d\rceil$
$\qquad$kombinasi beberapa bit dari ⌈ l n 2 d ⌉ berikutnya , mis. 00001001 00001010 00001100. Yang terbaik d + 1 dari kandidat ini bekerja cukup baik dalam praktiknya, setidaknya untuk yang kecil d .$\lceil ln_2 d\rceil$
$d+1$$d$