Size k genişliği $n$ bitvector'larının bir listesini veriyorum . Amacınız, listeden ortak 1'si olmayan iki bitvector döndürmek veya böyle bir çiftin olmadığını bildirmektir.$k$

Örneğin, size verirsem $[00110, 01100, 11000]$tek çözüm $\{00110, 11000\}$ . Alternatif olarak, girişin $[111, 011, 110, 101]$ çözümü yoktur. Ve tamamen sıfır bitvector $000...0$ ve başka bir elemanını içeren herhangi bir liste $e$önemsiz bir çözüme sahiptir $\{e, 000...0\}$ .

İşte biraz daha zor bir örnek, çözüm yok (her satır biraz vektör, siyah kareler 1s ve beyaz kareler 0s):

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

Çakışan olmayan iki bitvektör ne kadar verimli bulunabilir veya var olmadığı gösterilebilir?

Sadece olası her çifti karşılaştırdığınız saf algoritma $O(n^2 k)$ . Daha iyisini yapmak mümkün mü?

Isınma: rastgele bitvektörler

Bir ısınma olarak, her bir bitvektörün rasgele olarak eşit olarak seçildiği durumla başlayabiliriz. Sonra sorunun O ( n 1,6 dk. ( K , lg n) olarak çözülebileceği ortaya çıktı. sürede(daha kesin olarak, 1.6 lg 3 ile değiştirilebilir).$O(n^{1.6} \min(k, \lg n))$$1.6$$\lg 3$

Sorunun aşağıdaki iki kümesi varyantını ele alacağız:

Verilen kümeler $S,T \subseteq \{0,1\}^k$ olmayan bir üst üste binen çifte vardır burada bitvectors bölgesinin belirlenmesi .$s \in S, t \in T$

Bunu çözmenin temel tekniği böl ve ele geçir. Burada birbölme ve fethetme kullanan O ( n 1.6 k ) zaman algoritması:$O(n^{1.6} k)$

1. Bölünmüş ve T birinci bit konumuna göre. Başka bir deyişle, form S 0 = { s ∈ S : s 0 = 0 } , S 1 = { s ∈ S : s 0 = 1 } , T 0 = { t ∈ T : t 0 = 0 } , T 1 = { t ∈ T : $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. Şimdi, , S 0 , T 1 ve T 1 , S 0'dan üst üste binmeyen bir çifti tekrarlayın . Herhangi bir özyinelemeli çağrı çakışan olmayan bir çift bulursa, çıktıyı verin, aksi takdirde "Çakışan çift yok" çıktısını alın.$S_0,T_0$$S_0,T_1$$T_1,S_0$

Tüm bitvektörler rastgele seçildiği için ve | T b | ≈ | T | / 2 . Böylece, üç özyinelemeli çağrı var ve sorunun boyutunu iki faktör azalttık (her iki kümenin boyutu da iki faktör azaltılır). Lg dakika sonra ( |$|S_b| \approx |S|/2$$|T_b| \approx |T|/2$$\lg \min(|S|,|T|)$ böler, iki set bir boyutu 1 aşağı ve sorun lineer zamanda çözülebilir. Biz çizgileri boyunca bir nüks ilişkisi elde | T , ki bu çözeltisi T ( n ) = O ( n 1.6 k ) . İki setli durumda çalışma süresi daha kesin olarak hesaplandığında, çalışma süresinin O ( dk ( | S | , | T | ) 0,6 maks ( | S | , | ) k ) olduğunu görüyoruz$T(n) = 3T(n/2) + O(nk)$$T(n) = O(n^{1.6} k)$$O(\min(|S|,|T|)^{0.6} \max(|S|,|T|) k)$ .

Bu, olduğunda, üst üste binmeyen bir çiftin var olma olasılığının katlanarak küçük olduğuna dikkat çekerek daha da geliştirilebilir . Özel olarak, X , Y , iki rasgele vektörler, onlardır örtüşmeyen bu olasılık vardır ( 3 / 4 ) k . Eğer | S | = | T | = N , orada , n 2 , böylece bağlanmış bir birlik bu tür çift, bir üst üste çifti mevcut ihtimali en fazla olan n- 2 ( $k \ge 2.5\lg n+100$$x,y$$(3/4)^k$$|S|=|T|=n$$n^2$, hemen "Çakışan çift yoktur" (bu yanlış olma olasılığı ihmal edilebilir derecede küçüktür) derhal dönebiliriz, aksi takdirde yukarıdaki algoritmayı çalıştırırız. . Zaman k ≥ 2.5 lg , n + 100 , bu ≤ ≥ 2,5 lg n + $n^2 (3/4)^k$$k \ge 2.5 \lg n+100$ . Yani, bir ön işleme adımı olarak, eğer$\le 1/2^{100}$$k \ge 2.5 \lg n + 100$

Böylece (veya O ( dk ( | S | , | T | ) 0.6 max ( | S | , | T | ) min $O(n^{1.6} \min(k, \lg n))$ yukarıda önerilen iki-grup varyant için), bitvektörlerin rastgele düzgün bir şekilde seçildiği özel durum için.$O(\min(|S|,|T|)^{0.6} \max(|S|,|T|) \min(k, \lg n))$

Tabii ki, bu en kötü durum analizi değil. Rastgele bitvektörler en kötü durumdan çok daha kolaydır - ama belki de genel duruma uygulayabileceğimiz bazı fikirler almak için bir ısınma olarak ele alalım.

Isınma dersleri

Yukarıdaki ısınmadan birkaç ders öğrenebiliriz. İlk olarak, böl ve fethet (biraz pozisyonda bölme) yararlı görünüyor. İkincisi, bir bit pozisyonunao konumda olabildiğince fazla 1 '; 0 ne kadar fazlaolursa, alt sorun boyutunda o kadar az azalma olur.$1$$0$

Üçüncüsü, bu, 'in yoğunluğu küçüldükçe sorunun daha da zorlaştığını gösterir - bitvektörler arasında çok az 1 ' varsa (çoğunlukla 0 'lar), her bölünme azaldıkça problem oldukça zor görünüyor alt problemlerin boyutu biraz. Bu yüzden, yoğunluk tanımlamak Í olan bit ondalık sayı 1 (yani, tüm üzerinden n- k bit) ve bit pozisyonunun yoğunluğu I olan bitvectors fraksiyonu olduğu 1 pozisyonunda $1$$1$$0$$\Delta$$1$$nk$$i$$1$$i$ .

Çok düşük yoğunlukta kullanım

Bir sonraki adım olarak, yoğunluk çok küçükse ne olacağını merak edebiliriz. Her bit pozisyonundaki yoğunluk 1 / than'dan küçükse, , örtüşmeyen bir çiftin var olduğu garanti edilir: örtüşmeyen bir çiftin var olması gerektiğini gösteren (yapıcı olmayan) bir varlık argümanı vardır. Bu onu bulmamıza yardımcı olmaz, ama en azından var olduğunu biliyoruz.$1/\sqrt{k}$

Neden böyle? Diyelim ki bir çift bitvector , eğer x i = y i = 1 ise , bit konumu i ile kaplıdır . Çakışan her bitvektör çiftinin bir bit konumu ile kaplanması gerektiğini unutmayın. Şimdi, belirli bir bit konumunu i sabitlersek, o bit konumu tarafından kaplanabilecek çift sayısı en fazla ( n Δ ( i ) ) 2 < n 2 / k olur . Tüm k boyunca toplama$x,y$$i$$x_i=y_i=1$$i$$(n \Delta(i))^2 < n^2/k$$k$Bit pozisyonlarında, bir bit pozisyonu tarafından kapsanan toplam çift sayısının $< n^2$ . Bu, herhangi bir bit konumu tarafından kapsanmayan bir çiftin olması gerektiği anlamına gelir, bu da bu çiftin çakışmasız olduğunu ima eder. Bu nedenle, yoğunluk her bit pozisyonunda yeterince düşükse, örtüşmeyen bir çift mutlaka vardır.

Ancak, böyle bir örtüşmeyen çifti bulmak için hızlı bir algoritma tanımlamakta bir kayıp var, bu rejimde, bir kişinin var olduğu garanti edilmesine rağmen. Ben hemen bir alt karesel bir bağımlılığı olan çalışma süresi doğuracak herhangi bir teknik görmüyorum $n$ . Yani, bu sorunu düşünmek için biraz zaman harcamak istiyorsanız, bu odaklanmak için güzel bir özel durum.

Genel durum algoritmasına doğru

Genel durumda, doğal bir sezgisel tarama şöyle görünmektedir: en fazla 1 '(yani, en yüksek yoğunlukta) olan bit konumunu seçin ve üzerine bölün. Diğer bir deyişle:$i$$1$

1. Δ ( i ) değerini maksimize eden bir bit konumu bulun .$i$$\Delta(i)$

2. Bölünmüş ve T bit pozisyonu dayalı i . Başka bir deyişle, form S 0 = { s ∈ S : s i = 0 } , S 1 = { s ∈ S : s i = 1 } , T 0 = { t ∈ T : t i = 0 } , T 1 = { $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. Şimdi, , S 0 , T 1 ve T 1 , S 0'dan üst üste binmeyen bir çifti tekrarlayın$S_0,T_0$$S_0,T_1$$T_1,S_0$. Herhangi bir özyinelemeli çağrı çakışan olmayan bir çift bulursa, çıktıyı verin, aksi takdirde "Çakışan çift yok" çıktısını alın.

Zorluk en kötü durumda performansını analiz etmektir.

Bir ön işleme adımı olarak, önce her bit konumunun yoğunluğunu hesapladığımızı varsayalım. Ayrıca, eğer , heri için, ön işleme adımının "Çakışan bir çift var" olduğunu varsayın (bunun örtüşen bir çifte bir örnek sergilemediğinin farkındayım, ama bunu ayrı bir meydan okuma olarak bir kenara bırakalım). Bütün bunlarO(nk) 'da yapılabilir$\Delta(i) < 1/\sqrt{k}$$i$$O(nk)$ zamanında yapılabilir. Yoğunluk bilgisi, yinelemeli çağrılar yaptığımız gibi verimli bir şekilde muhafaza edilebilir; çalışma süresine baskın katkıda bulunmayacaktır.

Bu prosedürün çalışma süresi ne olacak? Emin değilim, ama burada yardımcı olabilecek birkaç gözlem var. Yineleme her seviyesi ile sorun boyutunu azaltır bitvektörler (örneğin,nbitvektörlerdenn-n$n/\sqrt{k}$$n$ bitvektörler). Bu nedenle, özyineleme sadece$n-n/\sqrt{k}$ derin seviyeler. Ancak, ben özyineleme ağacında yaprakların sayısını saymak için nasıl hemen emin değilim (az bir sürü vardır$\sqrt{k}$ ayrılır), bu yüzden bunun hangi çalışma süresine yol açacağından emin değilim.$3^{\sqrt{k}}$

Matris çarpımı kullanarak olduğunda daha hızlı çözüm$n \approx k$

Diyelim ki . Amacımız O ( n 2 k ) = O ( n 3 ) çalışma süresinden daha iyisini yapmaktır .$n = k$$O(n^2k) = O(n^3)$

Bitvektörleri ve bit konumlarını bir grafikteki düğümler olarak düşünebiliriz. Bitvector bu konumda bir 1 olduğunda, bir bitvector düğümü ile bir bit konumu düğümü arasında bir kenar vardır. Elde edilen grafik (bir tarafta bitvector-temsil düğümleri ve diğer bitposition-temsil düğümleri) ikili olup, sahip düğümleri.$n + k = 2n$

Komşuluk matrisi verilen iki köşe arasında iki atlama yol varsa bir grafik, söyleyebileceğimiz karesi alınarak M ve elde edilen matris, bu iki köşe arasında bir "kenar" (kare matris içinde kenarın girişi yani var olmadığını kontrol sıfırdan farklıdır). Bizim amacımız için, kare bitişiklik matrisine sıfır girişi örtüşmeyen bir çift bitvektöre (yani bir çözüme) karşılık gelir. Herhangi bir sıfır olmaması çözüm olmadığı anlamına gelir.$M$ $M$

Bir nxn matrisinin karesi zamanında yapılabilir, burada ω , 2.373'ün altındadır ve 2 olarak tahmin edilir .$O(n^\omega)$$\omega$$2.373$$2$

Yani algoritma:

• Convert the bitvectors and bit positions into a bipartite graph with $n+k$ nodes and at most $nk$ edges. This takes $O(nk)$ time.
• Compute the adjacency matrix of the graph. This takes $O((n+k)^2)$ time and space.
• Square the adjacency matrix. This takes $O((n+k)^\omega)$ time.
• Search the bitvector section of the adjacency matrix for zero entries. This takes $O(n^2)$ time.

$n=k$$O((n+k)^\omega) = O(n^\omega)$$O(n^3)$

$k$$n$. As long as $k \in \Omega(n^{\omega-2})$ and $k \in O(n^\frac{2}{\omega-1})$, then $(n+k)^\omega$ is better than $n^2 k$. For $w \approx 2.373$ that translates to $n^{0.731} \leq k \leq n^{1.373}$ (asymptotically). If $w$ limits to 2, then the bounds widen towards $n^\epsilon \leq k \leq n^{2-\epsilon}$.

This is equivalent to finding a bit vector which is a subset of the complement of another vector; ie its 1's occur only where 0's occur in the other.

If k (or the number of 1's) is small, you can get $O(n2^k)$ time by simply generating all the subsets of the complement of each bitvector and putting them in a trie (using backtracking). If a bitvector is found in the trie (we can check each before complement-subset insertion) then we have a non-overlapping pair.

If the number of 1's or 0's is bounded to an even lower number than k, then the exponent can be replaced by that. The subset-indexing can be on either each vector or its complement, so long as probing uses the opposite.

There's also a scheme for superset-finding in a trie that only stores each vector only once, but does bit-skipping during probes for what I believe is similar aggregate complexity; ie it has $o(k)$ insertion but $o(2^k)$ searches.

Represent the bit vectors as an $n\times k$ matrix $M$. Take $i$ and $j$ between 1 and $n$.

$(MM^T)_{ij}$, the dot product of the $i$th and $j$th vector, is non-zero if, and only if, vectors $i$ and $j$ share a common 1. So, to find a solution, compute $MM^T$ and return the position of a zero entry, if such an entry exists.

Complexity

Using naive multiplication, this requires $O(n^2k)$ arithmetic operations. If $n=k$, it takes $O(n^{2.37})$ operations using the utterly impractical Coppersmith-Winograd algorithm, or $O(n^{2.8})$ using the Strassen algorithm. If $k=O(n^{0.302})$, then the problem may be solved using $n^{2 + o(1)}$ operations.