गैर-अतिव्यापी बिट वैक्टर की एक जोड़ी ढूँढना

Question

मैं आपको चौड़ाई k के $n$ bitvectors की एक सूची देता हूं । आपका लक्ष्य उस सूची से दो बिटवेक्टरों को वापस करना है जिनका कोई 1s आम नहीं है, या फिर यह रिपोर्ट करें कि ऐसी कोई जोड़ी मौजूद नहीं है।$k$

उदाहरण के लिए, यदि मैं आपको $[00110, 01100, 11000]$ तो एकमात्र समाधान $\{00110, 11000\}$ । वैकल्पिक रूप से, इनपुट $[111, 011, 110, 101]$ का कोई हल नहीं है। और कोई भी सूची जिसमें ऑल-जीरो बिटवेक्टर $000...0$ और एक अन्य तत्व $e$ का एक तुच्छ समाधान $\{e, 000...0\}$ ।

इसका थोड़ा कठिन उदाहरण है, जिसका कोई हल नहीं है (प्रत्येक पंक्ति थोड़ी वेक्टर है, काले वर्ग 1s हैं और सफेद वर्ग 0 वर्ग हैं):

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

कितनी कुशलता से दो गैर-अतिव्यापी बिटवेक्टर पाए जा सकते हैं, या अस्तित्व में नहीं दिखाए जा सकते हैं?

भोली एल्गोरिथ्म, जहाँ आप हर संभावित जोड़ी की तुलना करते हैं, $O(n^2 k)$ । क्या बेहतर करना संभव है?

Comments

एक संभावित कमी: आपके पास प्रत्येक वेक्टर के लिए एक शीर्ष के साथ एक ग्राफ और दो कोने के बीच एक किनारे है यदि दो संबंधित वैक्टर में 1 सामान्य है। आप जानना चाहते हैं कि ग्राफ व्यास चाहते ≥ 2 । लेकिन ओ ( एन 2 के ) की तुलना में तेजी से जाना मुश्किल लगता है । $G$$\geq 2$$O(n^2k)$

— फ्रांस्वा

@ फ़्राँस्वागोदी तीन नोड्स और एक लापता किनारे के साथ किसी भी जुड़े ग्राफ घटक में कम से कम दो व्यास हैं। आसन्न सूची प्रतिनिधित्व के साथ, इसे जांचने के लिए समय लगता है। $O(V)$

— क्रेग गिदनी

@Strilanc ज़रूर, अगर कोई समाधान नहीं है तो ग्राफ पूरा हो गया है (व्यास = 1 की तुलना में अधिक स्पष्ट है, आप सही हैं), लेकिन आसन्न सूची प्रतिनिधित्व की गणना लंबी हो सकती है।

— फ्रांस्वा

क्या आपकी मशीन की शब्द चौड़ाई से छोटा है? $k$

— राफेल

@TomvanderZanden ऐसा लगता है कि यह इनवेटर्स का उल्लंघन करेगा कि डेटा संरचना संभवतः पर निर्भर करती है। विशेष रूप से, वह समानता सकर्मक होनी चाहिए। मैं पहले से ही एक ट्राई का उपयोग करने के बारे में सोच रहा था और मैं यह नहीं देखता कि कैसे एक कारक -२

— ब्लूपअप

Answer 1

वार्मअप: यादृच्छिक बिटवेक्टर

वार्म-अप के रूप में, हम उस मामले से शुरू कर सकते हैं जहां प्रत्येक बिटवेक्टर को यादृच्छिक रूप से समान रूप से iid चुना जाता है। तब यह पता चलता है कि समस्या को समय में हल किया जा सकता है (अधिक सटीक रूप से, 1.6 को lg 3 से बदला जा सकता है )।$O(n^{1.6} \min(k, \lg n))$$1.6$$\lg 3$

हम समस्या के निम्नलिखित दो-सेट प्रकारों पर विचार करेंगे:

यह देखते हुए सेट bitvectors की, निर्धारित जहां वहां मौजूद एक गैर-अतिव्यापी जोड़ी रों ∈ एस , टी ∈ टी ।$S,T \subseteq \{0,1\}^k$$s \in S, t \in T$

इसे हल करने की मूल तकनीक फूट डालो-जीतो है। यहाँ एक टाइम अल्गोरिद्म है जो डिवाइड-एंड-कॉनकेयर का उपयोग करता है:$O(n^{1.6} k)$

1. स्प्लिट और टी पहले बिट स्थिति पर आधारित है। दूसरे शब्दों में, प्रपत्र एस 0 = { रों ∈ एस : एस 0 = 0 } , एस 1 = { रों ∈ एस : एस 0 = 1 } , टी 0 = { टी ∈ टी : टी 0 = 0 } , टी 1 = { टी ∈ टी : $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. अब , एस 0 , टी 1 , और टी 1 , एस 0 से एक गैर-अतिव्यापी जोड़ी के लिए पुन: खोज करें । यदि कोई पुनरावर्ती कॉल एक गैर-अतिव्यापी जोड़ी पाता है, तो इसे आउटपुट करें, अन्यथा आउटपुट "कोई अतिव्यापी जोड़ी मौजूद नहीं है"।$S_0,T_0$$S_0,T_1$$T_1,S_0$

चूँकि सभी bitvectors यादृच्छिक पर चुने जाते हैं, हम उम्मीद कर सकते हैं और | टी बी | ≈ | टी | / २ । इस प्रकार, हमारे पास तीन पुनरावर्ती कॉल हैं, और हमने समस्या के आकार को दो के कारक से घटा दिया है (दोनों सेट दो के कारक से कम हो जाते हैं)। बाद एलजी मिनट ( | एस | , | टी | ) विभाजन, दो सेट में से एक नीचे आकार 1 करने के लिए है, और समस्या रैखिक समय में हल किया जा सकता। की तर्ज पर हमें एक पुनरावृत्ति संबंध मिलता है$|S_b| \approx |S|/2$$|T_b| \approx |T|/2$$\lg \min(|S|,|T|)$ , जिसका समाधान T ( n ) = O ( n 1.6 k ) है । दो सेट के मामले में अधिक सटीक समय चल रहा है के लिए लेखांकन, तो हम समय देखने है हे ( मिनट ( | एस | , | टी | ) 0.6 अधिकतम ( | एस | , |$T(n) = 3T(n/2) + O(nk)$$T(n) = O(n^{1.6} k)$ ।$O(\min(|S|,|T|)^{0.6} \max(|S|,|T|) k)$

इसे और बेहतर बनाया जा सकता है, यह देखते हुए कि यदि , तो गैर-अतिव्यापी जोड़ी मौजूद होने की संभावना बहुत कम है। विशेष रूप से, अगर एक्स , वाई दो यादृच्छिक वैक्टर, संभावना है कि वे गैर-अतिव्यापी है ( 3 / 4 ) कश्मीर । अगर | एस | = | टी | = N , देखते हैं n 2 ऐसे जोड़े, तो एक संघ बाध्य द्वारा, संभावना एक गैर-अतिव्यापी जोड़ी मौजूद है ज्यादा से ज्यादा है n 2 ( $k \ge 2.5\lg n+100$$x,y$$(3/4)^k$$|S|=|T|=n$$n^2$ । जब कश्मीर ≥ 2.5 एलजी n + 100 , यह है ≤ 1 / 2 100 । इसलिए, एक पूर्व-प्रसंस्करण कदम के रूप में, यदि k g 2.5 lg n + 100 है , तो हम तुरंत "कोई गैर-अतिव्यापी जोड़ी मौजूद नहीं है" (संभावना है कि यह गलत है लापरवाही से छोटा है), अन्यथा हम उपरोक्त एल्गोरिथ्म चलाते हैं।$n^2 (3/4)^k$$k \ge 2.5 \lg n+100$$\le 1/2^{100}$$k \ge 2.5 \lg n + 100$

इस प्रकार हम के चल रहे समय को प्राप्त (या हे ( मिनट ( | एस | , | टी | ) 0.6 अधिकतम ( | एस | , | टी | ) मिनट ( कश्मीर , एलजी n ) ) दो-सेट संस्करण के लिए ऊपर प्रस्तावित), उस विशेष मामले के लिए जहां बिटवेक्टर को यादृच्छिक रूप से समान रूप से चुना जाता है।$O(n^{1.6} \min(k, \lg n))$$O(\min(|S|,|T|)^{0.6} \max(|S|,|T|) \min(k, \lg n))$

बेशक, यह सबसे खराब स्थिति का विश्लेषण नहीं है। रैंडम बिटवेक्टर सबसे खराब स्थिति की तुलना में काफी आसान होते हैं - लेकिन चलो इसे वार्मअप मानते हैं, कुछ विचार प्राप्त करने के लिए जो शायद हम सामान्य मामले पर लागू कर सकते हैं।

वार्मअप से सबक

हम वार्मअप से कुछ सबक सीख सकते हैं। सबसे पहले, फूट डालो और जीतो (थोड़ा स्थान पर विभाजित) मददगार लगता है। दूसरा, आप उस स्थिति में संभव के रूप में कई साथ एक बिट स्थिति पर विभाजित करना चाहते हैं; जितने अधिक 0 होते हैं, उतने ही कम उप-आकार के आकार में कमी होती है।$1$$0$

तीसरा, इससे यह पता चलता है कि समस्या कठिन हो जाती है क्योंकि का घनत्व छोटा हो जाता है - अगर बिटवॉकरों में बहुत कम 1 है (वे ज्यादातर 0 हैं ), तो समस्या काफी कठिन दिखती है, क्योंकि प्रत्येक विभाजन कम हो जाता है उपप्रकारों का आकार थोड़ा छोटा है। तो, घनत्व को परिभाषित Δ बिट्स कि कर रहे हैं के अंश होने के लिए 1 (यानी, सब से बाहर n कश्मीर बिट्स), और बिट स्थिति का घनत्व मैं bitvectors के अंश होने के लिए कर रहे हैं 1 की स्थिति में मैं ।$1$$1$$0$$\Delta$$1$$nk$$i$$1$$i$

बहुत कम घनत्व को संभालना

अगले चरण के रूप में, हमें आश्चर्य हो सकता है कि यदि घनत्व बहुत छोटा है तो क्या होगा। ऐसा लगता है कि अगर हर बिट स्थिति में घनत्व से छोटा होता है , हम गारंटी देते हैं कि एक गैर-अतिव्यापी जोड़ी मौजूद है: एक (गैर-रचनात्मक) अस्तित्व तर्क है जो दिखा रहा है कि कुछ गैर-अतिव्यापी जोड़ी मौजूद होनी चाहिए। यह हमें इसे खोजने में मदद नहीं करता है, लेकिन कम से कम हमें पता है कि यह मौजूद है।$1/\sqrt{k}$

यह एक केस क्यों है? चलो का कहना है कि bitvectors की एक जोड़ी है कवर बिट स्थिति से मैं अगर एक्स मैं = y मैं = 1 । ध्यान दें कि ओवरलैपिंग बिटवेक्टरों की प्रत्येक जोड़ी को किसी न किसी स्थिति से कवर किया जाना चाहिए। अब, अगर हम एक विशेष बिट स्थिति को ठीक मैं , जोड़े कि कि बिट स्थिति से कवर किया जा सकता की संख्या अधिक से अधिक है ( एन Δ ( मैं ) ) 2 < n 2 / कश्मीर । सभी के बीच $x,y$$i$$x_i=y_i=1$$i$$(n \Delta(i))^2 < n^2/k$$k$बिट स्थिति के अनुसार, हम पाते हैं कि कुछ बिट स्थिति से आच्छादित जोड़े की कुल संख्या । इसका मतलब यह है कि कुछ ऐसी जोड़ी होनी चाहिए जो किसी भी बिट स्थिति से आच्छादित न हो, जिसका अर्थ है कि यह जोड़ी गैर-अतिव्यापी है। इसलिए यदि घनत्व प्रत्येक बिट स्थिति में पर्याप्त रूप से कम है, तो एक गैर-अतिव्यापी जोड़ी निश्चित रूप से मौजूद है।$< n^2$

हालाँकि, मैं इस तरह के एक गैर-अतिव्यापी जोड़ी को खोजने के लिए एक तेज एल्गोरिदम की पहचान करने के लिए नुकसान में हूं, इन शासन में, भले ही किसी के अस्तित्व की गारंटी हो। मैं तुरंत ऐसी कोई तकनीक नहीं देखता, जो चल रहे समय की उपज हो, जिसमें पर एक उप-द्विघात निर्भरता हो । इसलिए, यदि आप इस समस्या के बारे में सोचने के लिए कुछ समय बिताना चाहते हैं, तो यह एक अच्छा विशेष मामला है।$n$

एक सामान्य-केस एल्गोरिथ्म की ओर

सामान्य स्थिति में, एक प्राकृतिक हेयुरिस्टिक लगता है: बिट स्थिति को सबसे अधिक 1 's (यानी उच्चतम घनत्व के साथ) के साथ उठाता हूं , और उस पर विभाजित होता हूं । दूसरे शब्दों में:$i$$1$

1. थोड़ा स्थिति का पता लगाएं कि अधिकतम Δ ( मैं ) ।$i$$\Delta(i)$

2. स्प्लिट और टी बिट स्थिति पर आधारित है i । दूसरे शब्दों में, प्रपत्र एस 0 = { रों ∈ एस : एस मैं = 0 } , एस 1 = { रों ∈ एस : एस मैं = 1 } , टी 0 = { टी ∈ टी : टी मैं = 0 } , टी 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. अब , एस 0 , टी 1 , और टी 1 , एस 0 से एक गैर-अतिव्यापी जोड़ी के लिए पुन: खोज करें । यदि कोई पुनरावर्ती कॉल एक गैर-अतिव्यापी जोड़ी पाता है, तो इसे आउटपुट करें, अन्यथा आउटपुट "कोई अतिव्यापी जोड़ी मौजूद नहीं है"।$S_0,T_0$$S_0,T_1$$T_1,S_0$

चुनौती सबसे खराब स्थिति में अपने प्रदर्शन का विश्लेषण करना है।

मान लेते हैं कि पूर्व-प्रसंस्करण कदम के रूप में हम पहले हर बिट स्थिति के घनत्व की गणना करते हैं। इसके अलावा, अगर हर के लिएमैं, मान लेते हैं कि पूर्व प्रसंस्करण कदम आउटपुट "एक ओवरलैपिंग जोड़ी मौजूद है" (मुझे पता है कि यह एक ओवरलैपिंग जोड़ी का एक उदाहरण का प्रदर्शन नहीं करता है, लेकिन सेट है कि एक तरफ एक अलग चुनौती के रूप में करते हैं)। यह सबO(nk)समयमें किया जा सकता है। घनत्व सूचना को कुशलता से बनाए रखा जा सकता है क्योंकि हम पुनरावर्ती कॉल करते हैं; यह समय को चलाने में प्रमुख योगदानकर्ता नहीं होगा।$\Delta(i) < 1/\sqrt{k}$$i$$O(nk)$

इस प्रक्रिया का चलने का समय क्या होगा? मुझे यकीन नहीं है, लेकिन यहां कुछ अवलोकन हैं जो मदद कर सकते हैं। प्रत्यावर्तन के प्रत्येक स्तर पर के बारे में द्वारा समस्या आकार कम कर देता bitvectors (जैसे, सेnbitvectors लिएn-n/$n/\sqrt{k}$$n$ बिटवेक्टर)। इसलिए, प्रत्यावर्तन ही के बारे में जा सकते हैं$n-n/\sqrt{k}$ स्तर गहरा। हालांकि, मैं तुरंत यकीन है कि कैसे प्रत्यावर्तन पेड़ में पत्तियों की संख्या की गणना करने के लिए नहीं कर रहा हूँ (वहाँ एक बहुत की तुलना में कम कर रहे हैं3$\sqrt{k}$ पत्ते), तो मुझे यकीन नहीं है कि यह किस समय चलना चाहिए।$3^{\sqrt{k}}$

Comments

विज्ञापन कम घनत्व: यह कुछ प्रकार के कबूतर-छेद तर्क लगता है। हो सकता है कि यदि हम आपके सामान्य विचार (सबसे अधिक लोगों के साथ स्तंभ को विभाजित करें) का उपयोग करते हैं, तो हमें बेहतर सीमाएं मिलती हैं क्योंकि -केस (हम पुन: प्राप्त नहीं करते हैं) पहले से ही "सबसे" से छुटकारा पा लेते हैं? $(S_1, T_1)$

— राफेल

लोगों की कुल संख्या एक उपयोगी पैरामीटर हो सकती है। आपने पहले ही एक निचली सीमा दिखाई है जिसका उपयोग हम पेड़ काटने के लिए कर सकते हैं; क्या हम ऊपरी सीमा भी दिखा सकते हैं? उदाहरण के लिए, यदि से अधिक हैं, तो हमारे पास कम से कम c ओवरलैप्स हैं। $ck$$c$

— राफेल

वैसे, आप कैसे प्रस्ताव करते हैं कि हम पहला विभाजन करें; मनमाने ढंग से? क्यों न सिर्फ पूरे इनपुट सेट को कुछ कॉलम विभाजित किया जाए ? हमें केवल 0 -केस में पुनरावृत्ति करने की आवश्यकता है (उन लोगों के बीच कोई समाधान नहीं है जो मुझे एक साझा करते हैं )। अपेक्षा यह है कि के माध्यम से देता है टी ( एन ) = टी ( एन / 2 ) + हे ( एन कश्मीर ) के एक बाध्य हे ( एन कश्मीर ) (यदि कश्मीर निर्धारित)। एक सामान्य बाध्यता के लिए, आपने दिखाया है कि हम (निचले-कट-कटऑफ को आप प्रस्तावित करते हैं) मान सकते हैं कि हम कम से कम छुटकारा पाते हैं$i$$0$$i$$T(n) = T(n/2) + O(nk)$$O(nk)$$k$हर विभाजन के साथ k तत्व, जो एकO(nk) कोसबसे खराब स्थिति के लिए बाध्य करता है। या क्या मैं कुछ न कुछ भूल रहा हूं? $n/\sqrt{k}$$O(nk)$

— राफेल

आह, यह गलत है, ज़ाहिर है, क्योंकि यह 0-1-बेमेल नहीं मानता है। मुझे लगता है कि नाश्ते से पहले सोचने की कोशिश करने के लिए मुझे क्या मिलता है।

— राफेल

@ राफेल, दो मुद्दे हैं: (ए) वैक्टर ज्यादातर शून्य हो सकते हैं, इसलिए आप 50-50 के विभाजन पर भरोसा नहीं कर सकते हैं; पुनरावृत्ति कुछ और होगी जैसे , (b) अधिक महत्वपूर्ण बात, यह केवल 0-सबसेट पर पुनरावृत्ति करने के लिए पर्याप्त नहीं है; आपको 0-सबसेट से एक वेक्टर के बीच युग्मन की जांच करने की आवश्यकता है और 1-सब्मिट से एक वेक्टर है, इसलिए एक अतिरिक्त पुनरावृत्ति या दो करना है। (मुझे लगता है कि मुझे आशा है कि मुझे लगता है कि सही है?।)$T(n) = T((n-n/\sqrt{k})k)+O(nk)$

— DW

Answer 2

तेजी से समाधान जब , मैट्रिक्स गुणन का उपयोग$n \approx k$

मान लीजिए कि । हमारा लक्ष्य एक O ( n 2 k ) = O ( n 3 ) रनिंग टाइम से बेहतर करना है।$n = k$$O(n^2k) = O(n^3)$

हम बिटवेक्टर और बिट पदों को एक ग्राफ में नोड के रूप में सोच सकते हैं। बिटवेक्टर नोड और बिट स्थिति नोड के बीच एक किनारे होता है जब बिटवेक्टर में उस स्थिति में 1 होता है। परिणामी ग्राफ द्विअर्थी है (एक तरफ बिटवेक्टर-निरूपण नोड्स के साथ और दूसरी तरफ बिटपोजिट-प्रतिनिधित्व नोड्स), और नोड्स हैं।$n + k = 2n$

ग्राफ के समीपवर्ती मैट्रिक्स को देखते हुए , हम बता सकते हैं कि क्या स्क्वेरिंग M द्वारा दो कोने के बीच एक दो-हॉप पथ है और यह जाँचने पर कि परिणामी मैट्रिक्स में उन दो कोने के बीच "बढ़त" है (यानी धार मैट्रिक्स में किनारे की प्रविष्टि) गैर शून्य है)। हमारे उद्देश्यों के लिए, वर्ग आसन्न मैट्रिक्स में एक शून्य प्रविष्टि बिटवेक्टरों की एक गैर-अतिव्यापी जोड़ी (यानी एक समाधान) से मेल खाती है। किसी भी शून्य की कमी का मतलब है कि कोई समाधान नहीं है।$M$ $M$

एक NxN मैट्रिक्स के वर्ग में किया जा सकता समय है, जहां ω के तहत माना जाता है 2.373 और होने की अनुमान लगाया 2 ।$O(n^\omega)$$\omega$$2.373$$2$

तो एल्गोरिथ्म है:

• बिटवेक्टर और बिट पोज़िशन को नोड्स और अधिकांश n k किनारों के साथ एक द्विदलीय ग्राफ में परिवर्तित करें । इसमें O ( n k ) समय लगता है।$n+k$$nk$$O(nk)$
• ग्राफ के आसन्न मैट्रिक्स की गणना करें। इसमें समय और स्थान लगता है।$O((n+k)^2)$
• आसन्न मैट्रिक्स को स्क्वायर करें। यह लेता है समय।$O((n+k)^\omega)$
• शून्य प्रविष्टियों के लिए आसन्न मैट्रिक्स के बिटवेक्टर अनुभाग को खोजें। इसमें समय लगता है।$O(n^2)$

सबसे महंगा कदम आसन्न मैट्रिक्स को चुकता करना है। यदि फिर समग्र एल्गोरिथ्म लेता हे ( ( n + कश्मीर ) ω ) = हे ( एन ω ) समय है, जो अनुभवहीन से बेहतर है हे ( एन 3 ) समय।$n=k$$O((n+k)^\omega) = O(n^\omega)$$O(n^3)$

यह समाधान तब भी तेज होता है जब बहुत ज्यादा धीमा हो जाता है और n की तुलना में बहुत ज्यादा तेज नहीं होता है । लंबे समय के रूप के रूप में कश्मीर ∈ Ω ( एन ω - 2 ) और कश्मीर ∈ हे ( एन $k$$n$$k \in \Omega(n^{\omega-2})$, तो(n+कश्मीर)ωसे बेहतर हैn2कश्मीर। के लिएडब्ल्यू≈2.373कि करने के लिए अनुवादn0.731≤कश्मीर≤n1.373(asymptotically)। अगरडब्ल्यू2 करने के लिए सीमा है, तो सीमा की ओर चौड़ाnε≤कश्मीर≤n2-ε।$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}$

Comments

1. This is also better than the naive solution if $k=\Omega(n)$ but $k=o(n^{1.457})$. 2. If $k \ge n$, a heuristic could be: pick a random subset of $n$ bit positions, restrict to those bit positions and use matrix multiplication to enumerate all pairs that don't overlap in those $n$ bit positions; for each such pair, check if it solves the original problem. If there aren't many pairs that don't overlap in those $n$ bit positions, this provides a speedup over the naive algorithm. However I don't know a good upper bound on the number of such pairs.

— D.W.

Answer 3

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.

यदि 1 या 0 की संख्या k से भी कम संख्या के लिए बाध्य है, तो प्रतिपादक को उसके द्वारा प्रतिस्थापित किया जा सकता है। सबसेट-इंडेक्सिंग या तो प्रत्येक वेक्टर या इसके पूरक पर हो सकती है, इसलिए जब तक प्रोबिंग विपरीत का उपयोग करता है।

$o(k)$$o(2^k)$ searches.

Comments

thanks. The complexity of your solution is $\sim n 2^{(1-p)k}$, where $p$ is the probability of 1's in the bitvector. A couple of implementation details: though this is a slight improvement, there's no need to compute and store the complements in the trie. Just following the complementary branches when checking for a non-overlapping match is enough. And, taking the 0's directly as wildcards, no special wildcard is needed, either.

— Mauro Lacy

Answer 4

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

$$\begin{align} (MM^T)_{ij} = \sum_l M_{il}M_{jl} \end{align}.$$

$(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.

Comments

How is this different from Strilanc's answer?

— D.W.

@D.W. Using an $n$-by-$k$ matrix instead of an $(n+k)$-by-$(n+k)$ matrix is an improvement. Also it mentions a way to cut off the factor of k when k << n, so that might be useful.

— Craig Gidney