Saya memberi Anda daftar bitvektor dengan lebar . Tujuan Anda adalah mengembalikan dua vektor bit dari daftar yang tidak memiliki 1s sama, atau melaporkan bahwa tidak ada pasangan semacam itu.$n$$k$

Misalnya, jika saya memberi Anda maka satu-satunya solusi adalah . Atau, input tidak memiliki solusi. Dan daftar apa pun yang berisi bitvector semua-nol dan elemen lain memiliki solusi sepele .{ 00110 , 11000 } [ 111 , 011 , 110 , 101 ] 000 ... 0 e { e , 000 ... 0 $[00110, 01100, 11000]$$\{00110, 11000\}$$[111, 011, 110, 101]$$000...0$$e$$\{e, 000...0\}$

Berikut adalah contoh yang sedikit lebih sulit, tanpa solusi (setiap baris adalah vektor bit, kotak hitam adalah 1s dan kotak putih adalah 0s):

■ ■ ■ ■ □ □ □ □ □ □ □ □ □
■ □ □ □ ■ ■ ■ □ □ □ □ □ □ 
■ □ □ □ □ □ □ ■ ■ ■ □ □ □
■ □ □ □ □ □ □ □ □ □ ■ ■ ■
□ ■ □ □ □ ■ □ □ □ ■ ■ □ □
□ ■ □ □ ■ □ □ □ ■ □ □ □ ■
□ ■ □ □ □ □ ■ ■ □ □ □ ■ □ <-- All row pairs share a black square
□ □ ■ □ □ □ ■ □ ■ □ ■ □ □
□ □ ■ □ □ ■ □ ■ □ □ □ □ ■
□ □ ■ □ ■ □ □ □ □ ■ □ ■ □
□ □ □ ■ ■ □ □ ■ □ □ ■ □ □
□ □ □ ■ □ □ ■ □ □ ■ □ □ ■
□ □ □ ■ □ ■ □ □ ■ □ □ ■ □

Seberapa efisien dua bitvektor yang tidak tumpang tindih dapat ditemukan, atau ditunjukkan tidak ada?

Algoritma naif, di mana Anda hanya membandingkan setiap pasangan yang mungkin, adalah . Apakah mungkin melakukan lebih baik?$O(n^2 k)$

Pemanasan: bitvektor acak

Sebagai pemanasan, kita bisa mulai dengan kasus di mana setiap bitvector dipilih secara seragam secara acak. Kemudian ternyata masalah tersebut dapat diselesaikan dalam waktu (lebih tepatnya, dapat diganti dengan ).$O(n^{1.6} \min(k, \lg n))$$1.6$$\lg 3$

Kami akan mempertimbangkan varian dua set masalah berikut:

Set diberikan dari bitvectors, menentukan di mana terdapat non-tumpang tindih pasangan .$S,T \subseteq \{0,1\}^k$$s \in S, t \in T$

Teknik dasar untuk menyelesaikan ini adalah membagi-dan-taklukkan. Berikut ini adalah algoritma waktu menggunakan divide-and-conquer:$O(n^{1.6} k)$

1. Split dan berdasarkan posisi bit pertama. Dengan kata lain, bentuk , , , .$S$$T$$S_0 = \{s \in S : s_0=0\}$$S_1 = \{s \in S : s_0 = 1\}$$T_0 = \{t \in T : t_0 = 0\}$$T_1 = \{t \in T : t_0 = 1\}$

2. Sekarang cari secara rekursif untuk pasangan yang tidak tumpang tindih dari , dari , dan dari . Jika ada panggilan rekursif menemukan pasangan yang tidak tumpang tindih, output itu, jika tidak output "Tidak ada pasangan yang tumpang tindih".$S_0,T_0$$S_0,T_1$$T_1,S_0$

Karena semua bitvektor dipilih secara acak, kita dapat mengharapkan dan . Dengan demikian, kami memiliki tiga panggilan rekursif, dan kami telah mengurangi ukuran masalah dengan faktor dua (kedua set ukurannya dikurangi dengan faktor dua). Setelah terpecah, salah satu dari dua set turun ke ukuran 1, dan masalahnya dapat diselesaikan dalam waktu linier. Kami mendapatkan relasi berulang di sepanjang garis , yang solusinya adalah . Akuntansi untuk menjalankan waktu lebih tepatnya dalam kasus dua set, kita melihat waktu berjalan adalah .$|S_b| \approx |S|/2$$|T_b| \approx |T|/2$$\lg \min(|S|,|T|)$$T(n) = 3T(n/2) + O(nk)$$T(n) = O(n^{1.6} k)$$O(\min(|S|,|T|)^{0.6} \max(|S|,|T|) k)$

Ini dapat ditingkatkan lebih lanjut, dengan mencatat bahwa jika , maka probabilitas bahwa pasangan yang tidak tumpang tindih ada secara eksponensial kecil. Secara khusus, jika adalah dua vektor acak, probabilitas bahwa mereka tidak tumpang tindih adalah . Jika , ada pasangan demikian, maka dengan ikatan gabungan, probabilitas ada pasangan yang tidak tumpang tindih adalah paling banyak . Ketika , ini adalah . Jadi, sebagai langkah pra-pemrosesan, jika$k \ge 2.5\lg n+100$$x,y$$(3/4)^k$$|S|=|T|=n$$n^2$$n^2 (3/4)^k$$k \ge 2.5 \lg n+100$$\le 1/2^{100}$$k \ge 2.5 \lg n + 100$, maka kita dapat segera mengembalikan "Tidak ada pasangan yang tidak tumpang tindih" (probabilitas ini salah adalah sangat kecil), jika tidak kita jalankan algoritma di atas.

Dengan demikian kita mencapai waktu berjalan (atau untuk varian dua set yang diusulkan di atas), untuk kasus khusus di mana bitvektor dipilih secara seragam secara acak.$O(n^{1.6} \min(k, \lg n))$$O(\min(|S|,|T|)^{0.6} \max(|S|,|T|) \min(k, \lg n))$

Tentu saja, ini bukan analisis kasus terburuk. Bitvektor acak jauh lebih mudah daripada kasus terburuk - tetapi mari kita perlakukan itu sebagai pemanasan, untuk mendapatkan beberapa ide yang mungkin bisa kita terapkan pada kasus umum.

Pelajaran dari pemanasan

Kita bisa belajar beberapa pelajaran dari pemanasan di atas. Pertama, bagi-dan-taklukkan (pemisahan pada posisi bit) tampaknya membantu. Kedua, Anda ingin membagi pada posisi bit dengan sebanyak mungkin dalam posisi itu; semakin banyak ada, semakin sedikit pengurangan dalam ukuran subproblem yang Anda dapatkan.$1$$0$

Ketiga, ini menunjukkan bahwa masalahnya semakin sulit karena kepadatan semakin kecil - jika ada sangat sedikit di antara bitvectors (sebagian besar adalah 's), masalahnya terlihat cukup sulit, karena setiap split mengurangi ukuran subproblem sedikit. Jadi, tentukan densitas menjadi fraksi bit yang (yaitu, dari semua bit ), dan densitas posisi bit menjadi fraksi bitvektor yang pada posisi .$1$$1$$0$$\Delta$$1$$nk$$i$$1$$i$

Penanganan kepadatan sangat rendah

Sebagai langkah selanjutnya, kita mungkin bertanya-tanya apa yang terjadi jika kepadatannya sangat kecil. Ternyata jika kepadatan di setiap posisi bit lebih kecil dari , kami dijamin bahwa ada pasangan non-tumpang tindih: ada argumen keberadaan (non-konstruktif) yang menunjukkan bahwa beberapa non-tumpang tindih pasangan harus ada. Ini tidak membantu kami menemukannya, tetapi setidaknya kami tahu itu ada.$1/\sqrt{k}$

Mengapa demikian? Mari kita mengatakan bahwa sepasang bitvectors adalah ditutupi demi sedikit posisi jika . Perhatikan bahwa setiap pasangan bitvektor yang tumpang tindih harus dilindungi oleh beberapa posisi bit. Sekarang, jika kita memperbaiki posisi bit tertentu , jumlah pasangan yang dapat dicakup oleh posisi bit tersebut paling banyak . Menjumlahkan semua dari posisi bit, kami menemukan bahwa jumlah total pasangan yang dicakup oleh beberapa posisi bit adalah$x,y$$i$$x_i=y_i=1$$i$$(n \Delta(i))^2 < n^2/k$$k$$< n^2$. Ini berarti harus ada beberapa pasangan yang tidak dicakup oleh posisi bit apa pun, yang menyiratkan bahwa pasangan ini tidak tumpang tindih. Jadi jika kepadatan cukup rendah di setiap posisi bit, maka pasangan yang tidak tumpang tindih pasti ada.

Namun, saya bingung untuk mengidentifikasi algoritma cepat untuk menemukan pasangan yang tidak tumpang tindih, dalam rezim ini, meskipun satu dijamin ada. Saya tidak segera melihat teknik yang akan menghasilkan waktu berjalan yang memiliki ketergantungan sub-kuadrat pada . Jadi, ini adalah kasus khusus yang bagus untuk difokuskan, jika Anda ingin meluangkan waktu memikirkan masalah ini.$n$

Menuju algoritma kasus umum

Dalam kasus umum, heuristik alami tampaknya adalah: memilih posisi bit dengan jumlah paling banyak (yaitu, dengan kepadatan tertinggi), dan membaginya. Dengan kata lain:$i$$1$

1. Temukan posisi bit yang memaksimalkan .$i$$\Delta(i)$

2. Split dan berdasarkan posisi bit . Dengan kata lain, bentuk , , , .$S$$T$$i$$S_0 = \{s \in S : s_i=0\}$$S_1 = \{s \in S : s_i = 1\}$$T_0 = \{t \in T : t_i = 0\}$$T_1 = \{t \in T : t_i = 1\}$

3. Sekarang cari secara rekursif untuk pasangan yang tidak tumpang tindih dari , dari , dan dari . Jika ada panggilan rekursif menemukan pasangan yang tidak tumpang tindih, output itu, jika tidak output "Tidak ada pasangan yang tumpang tindih".$S_0,T_0$$S_0,T_1$$T_1,S_0$

Tantangannya adalah untuk menganalisis kinerjanya dalam kasus terburuk.

Mari kita asumsikan bahwa sebagai langkah pra-pemrosesan, pertama-tama kita menghitung kepadatan setiap posisi bit. Juga, jika untuk setiap , asumsikan bahwa langkah pra-pemrosesan menghasilkan "Pasangan yang tumpang tindih ada" (Saya menyadari bahwa ini tidak menunjukkan contoh pasangan yang tumpang tindih, tapi mari kita kesampingkan itu sebagai tantangan tersendiri). Semua ini dapat dilakukan dalam waktu . Informasi kepadatan dapat dipertahankan secara efisien karena kami melakukan panggilan rekursif; itu tidak akan menjadi kontributor dominan untuk waktu berjalan.$\Delta(i) < 1/\sqrt{k}$$i$$O(nk)$

Apa yang akan menjadi waktu berjalan dari prosedur ini? Saya tidak yakin, tapi di sini ada beberapa pengamatan yang mungkin bisa membantu. Setiap tingkat rekursi mengurangi ukuran masalah sekitar bitvectors (mis., Dari bitvectors ke bitvectors). Oleh karena itu, rekursi hanya dapat mencapai kedalaman . Namun, saya tidak segera yakin bagaimana cara menghitung jumlah daun di pohon rekursi (ada banyak kurang dari daun), jadi saya tidak yakin berapa lama waktu berjalan ini seharusnya mengarah untuk.$n/\sqrt{k}$$n$$n-n/\sqrt{k}$$\sqrt{k}$$3^{\sqrt{k}}$

Solusi lebih cepat saat , menggunakan perkalian matriks$n \approx k$

Misalkan . Tujuan kami adalah melakukan lebih baik daripada waktu berjalan .$n = k$$O(n^2k) = O(n^3)$

Kita dapat menganggap bitvektor dan posisi bit sebagai node dalam grafik. Ada tepi antara node bitvector dan node posisi bit ketika bitvector memiliki 1 di posisi itu. Grafik yang dihasilkan adalah bipartit (dengan node yang mewakili bitvector di satu sisi dan node yang mewakili bitposition di sisi lain), dan memiliki node.$n + k = 2n$

Dengan matriks adjacency dari sebuah grafik, kita dapat mengetahui apakah ada jalur dua hop antara dua simpul dengan mengkuadratkan dan memeriksa apakah matriks yang dihasilkan memiliki "tepi" antara dua simpul tersebut (yaitu entri tepi dalam matriks kuadrat tidak nol). Untuk tujuan kami, entri nol dalam matriks adjacency kuadrat sesuai dengan sepasang bitvektor yang tidak tumpang tindih (yaitu solusi). Kurangnya nol berarti tidak ada solusi.$M$ $M$

Mengkuadratkan matriks nxn dapat dilakukan dalam waktu , di mana diketahui berada di bawah dan dikira .$O(n^\omega)$$\omega$$2.373$$2$

Jadi algoritmanya adalah:

• Konversi bitvektor dan posisi bit menjadi grafik bipartit dengan node dan paling banyak edge. Ini membutuhkan waktu .$n+k$$nk$$O(nk)$
• Hitung matriks adjacency dari grafik. Ini membutuhkan waktu dan ruang .$O((n+k)^2)$
• Kuadratkan matriks adjacency. Ini membutuhkan waktu .$O((n+k)^\omega)$
• Cari bagian bitvector dari matriks adjacency untuk entri nol. Ini membutuhkan waktu .$O(n^2)$

Langkah paling mahal adalah mengkuadratkan adjacency matrix. Jika maka keseluruhan algoritma membutuhkan waktu , yang lebih baik daripada waktu naif .$n=k$$O((n+k)^\omega) = O(n^\omega)$$O(n^3)$

Solusi ini juga lebih cepat ketika tumbuh tidak terlalu banyak lebih lambat dan tidak terlalu banyak lebih cepat dari . Selama dan , maka lebih baik dari . Untuk yang diterjemahkan menjadi (asimtotik). Jika membatasi ke 2, maka batas melebar ke arah .$k$$n$$k \in \Omega(n^{\omega-2})$$k \in O(n^\frac{2}{\omega-1})$$(n+k)^\omega$$n^2 k$$w \approx 2.373$$n^{0.731} \leq k \leq n^{1.373}$$w$$n^\epsilon \leq k \leq n^{2-\epsilon}$

Ini setara dengan menemukan bit vektor yang merupakan bagian dari komplemen dari vektor lain; yaitu 1 nya hanya terjadi di mana 0's terjadi di yang lain.

Jika k (atau jumlah 1) kecil, Anda bisa mendapatkan waktu hanya dengan membuat semua himpunan bagian dari komplemen dari setiap bitvector dan menempatkannya dalam sebuah trie (menggunakan backtracking). Jika bitvector ditemukan dalam trie (kita dapat memeriksa masing-masing sebelum penyisipan komplemen-subset) maka kita memiliki pasangan yang tidak tumpang tindih.$O(n2^k)$

Jika angka 1 atau 0 dibatasi ke angka yang bahkan lebih rendah dari k, maka eksponen dapat diganti dengan itu. Subset-indexing bisa pada setiap vektor atau komplemennya, selama probing menggunakan yang sebaliknya.

Ada juga skema untuk superset-menemukan dalam sebuah trie yang hanya menyimpan masing-masing vektor hanya sekali, tetapi tidak melewatkan selama penyelidikan untuk apa yang saya percaya adalah kompleksitas agregat yang sama; yaitu ia memiliki penyisipan tetapi pencarian .$o(k)$$o(2^k)$

Mewakili vektor bit sebagai matriks . Ambil dan antara 1 dan .$n\times k$$M$$i$$j$$n$

$(MM^T)_{ij}$ , produk titik dari vektor ke - dan ke- , tidak-nol jika, dan hanya jika, vektor-vektor dan memiliki kesamaan 1. Jadi, untuk menemukan solusi, hitung dan kembalikan posisi entri nol, jika entri tersebut ada.$i$$j$$i$$j$$MM^T$

Kompleksitas

Menggunakan perkalian naif, ini membutuhkan operasi aritmatika . Jika , dibutuhkan operasi menggunakan algoritma Coppersmith-Winograd yang sama sekali tidak praktis, atau menggunakan algoritma Strassen. Jika , maka masalahnya dapat diselesaikan menggunakan operasi .$O(n^2k)$$n=k$$O(n^{2.37})$$O(n^{2.8})$$k=O(n^{0.302})$$n^{2 + o(1)}$