कम्प्यूटिंग सेट दो बड़े सेटों के बीच अंतर करता है

Question

मेरे पास पूर्णांक और B के दो बड़े सेट हैं । प्रत्येक सेट में लगभग एक लाख प्रविष्टियाँ होती हैं, और प्रत्येक प्रविष्टि एक धनात्मक पूर्णांक होती है जो अधिकतम 10 अंकों की होती है। $A$$B$

सबसे अच्छा एल्गोरिथ्म गणना करने के लिए क्या है और बी ∖ एक ? दूसरे शब्दों में, मैं ए की प्रविष्टियों की सूची की कुशलता से गणना कैसे कर सकता हूं जो बी और इसके विपरीत नहीं हैं? इन ऑपरेशनों को कुशल बनाने के लिए इन दो सेटों का प्रतिनिधित्व करने के लिए सबसे अच्छी डेटा संरचना क्या होगी?$A\setminus B$$B\setminus A$$A$$B$

सबसे अच्छा तरीका मैं इन दो सेटों को क्रमबद्ध सूचियों के रूप में संग्रहीत कर सकता हूं, और के प्रत्येक तत्व की तुलना बी के प्रत्येक तत्व से कर सकता हूं।$A$$B$ एक रैखिक फैशन में करता है। क्या हम बेहतर कर सकते हैं?

Comments

यदि आप इसे अलग तरीके से संग्रहीत करने के लिए तैयार हैं, तो आप बेहतर परिणाम प्राप्त करने में सक्षम हो सकते हैं।

— रियलज़ स्लाव

इसके अलावा, यदि आप एक अंतर्निहित डेटा संरचना के रूप में परिणाम प्राप्त करने के लिए तैयार हैं; आप बस एक ऐसी संरचना बना सकते हैं, जो अपने प्रत्येक प्रश्न का उत्तर देने के लिए दो सेटों पर प्रश्न करती है।

— रियलज़ स्लाव

@ user917279 एक बड़ा बिंदु यह है: आप आमतौर पर एक दूसरे के साथ प्रीप्रोसेसिंग / निर्माण समय, क्वेरी समय और मेमोरी उपयोग को बंद कर सकते हैं। क्या आप संरचना को शायद ही कभी संपादित करते हैं, लेकिन क्वेरी बहुत करते हैं? विपरीत स्थिति? स्मृति एक चिंता है या नहीं? इस तरह के सवालों का व्यावहारिक दृष्टिकोण से उत्तर दिया जा सकता है, और "सही" "सैद्धांतिक" निर्माण की पसंद को सूचित कर सकते हैं।

— राफेल

@ राफेल क्या आप सुझाव देते हैं कि अधिक स्मृति और / या तैयारी पर अधिक समय खर्च करके आप लगातार चलने वाले सेट (जटिलता के संदर्भ में) से बेहतर कर सकते हैं। अगर आपको लगता है कि यह संभव है तो मैं उत्सुक हूं। मुझे इस आकार के इनपुट सेट के लिए लुकअप टेबल को एक विकल्प के रूप में नहीं दिखता है।

— स्मोसेन

@ user917279 यदि आप दो विशाल सेटों के उदाहरण पर विचार करते हैं जो समान हैं, तो हैश-कंसिंग का उपयोग करके बनाई गई कोई भी डेटा संरचना O (1) में समानता परीक्षण का समर्थन करेगी क्योंकि निर्मित होने पर समान संरचनाओं को मर्ज किया जाएगा और इस तरह एक ही मेमोरी स्थान साझा करें। दो संरचनाओं के लगभग बराबर होने पर भी लगातार सेट हैश-कंसिंग का लाभ उठाते हैं। जटिलता सबसे अच्छा है जिसे मैंने अब तक के सेट के लिए देखा है।

— स्मोसेन

Answer 1

यदि आप सेटों को एक विशेष डेटा-संरचना में संग्रहीत करने के लिए तैयार हैं, तो आप संभवतः कुछ दिलचस्प जटिलताएं प्राप्त कर सकते हैं।

चलो $I=\mathcal O\left(\min\left(|A|,|B|,|A\Delta B|\right)\right)$

तो फिर तुम सेट कार्य कर सकते हैं और एक Δ बी में, प्रत्येक हे ( मैं ⋅ लॉग इन करें | एक | + | बी $A\cup B, A\cap B,A\setminus B$$A\Delta B$$\mathcal O\left(I\cdot\log\frac{|A|+|B|}{I}\right)$ अपेक्षित समय। तो अनिवार्य रूप से, आपको दो सेटों का न्यूनतम आकार मिलता है, या, सममित अंतर का आकार, जो भी कम हो। यह रैखिक से बेहतर है, अगर सममित अंतर छोटा है; अर्थात। अगर उनके पास एक बड़ा चौराहा है। वास्तव में, आप जो दो सेट-अंतर ऑपरेशन चाहते हैं, यह व्यावहारिक रूप से आउटपुट-संवेदनशील है, क्योंकि एक साथ वे सममित अंतर का आकार बनाते हैं।

देखें Confluently लगातार सेट और नक्शे और जानकारी के लिए Olle Liljenzin (2013) से।

Comments

कागज में ट्रेप को खोजा गया पेड़ है। मैं उन्हें गैर-सॉर्ट किए गए डेटा-संरचनाओं के रूप में नहीं गिनूंगा।

— 8:14 बजे

@smossen काफी सच है, मैंने उसे संपादित किया।

— Realz Slaw

Answer 2

एक रेखीय स्कैन सबसे अच्छा है जो मुझे पता है कि कैसे करना है, अगर सेट को क्रमबद्ध लिंक्ड सूची के रूप में दर्शाया गया है। दौड़ने का समय ।$O(|A| + |B|)$

ध्यान दें कि आपको B के प्रत्येक तत्व के खिलाफ के प्रत्येक तत्व की तुलना करने की आवश्यकता नहीं है , जोड़ीदार। इस बात का एक क्रम का कारण बन हे ( | एक | × | बी $A$$B$$O(|A| \times |B|)$ , जो बहुत खराब है। इसके बजाय, इन दो सेटों के सममित अंतर की गणना करने के लिए, आप मर्जोर्ट में "मर्ज" ऑपरेशन के समान एक तकनीक का उपयोग कर सकते हैं, उपयुक्त रूप से उन मानों को छोड़ने के लिए संशोधित किया गया है जो दोनों सेटों के लिए सामान्य हैं।

अधिक विवरण में, आप गणना करने के लिए निम्न की तरह एक पुनरावर्ती एल्गोरिथ्म का निर्माण कर सकते हैं , यह मानते हुए कि A और B को क्रमबद्ध क्रम में उनके मूल्यों के साथ लिंक की गई सूचियों के रूप में दर्शाया गया है:$A \setminus B$$A$$B$

difference(A, B):
    if len(B)=0:
        return A # return the leftover list
    if len(A)=0:
        return B # return the leftover list
    if A[0] < B[0]:
        return [A[0]] + difference(A[1:], B)
    elsif A[0] = B[0]:
        return difference(A[1:], B[1:])  # omit the common element
    else:
        return [B[0]] + difference(A, B[1:])

मैंने इसे छद्म-पायथन में दर्शाया है। आप अजगर पढ़ा नहीं है, A[0]लिंक्ड सूची का सिर है A, A[1:]सूची में से बाकी है, और+ सूचियों के संयोजन का प्रतिनिधित्व करता है। दक्षता कारणों के लिए, यदि आप पायथन में काम कर रहे हैं, तो आप शायद इसे बिल्कुल ऊपर के रूप में लागू नहीं करना चाहेंगे - उदाहरण के लिए, जनरेटर का उपयोग करना बेहतर हो सकता है, कई अस्थायी सूचियों के निर्माण से बचने के लिए - लेकिन मैं चाहता था आपको सबसे सरल संभव रूप में विचार दिखाते हैं। इस छद्म कोड का उद्देश्य केवल एल्गोरिथ्म को चित्रित करना है, एक ठोस कार्यान्वयन का प्रस्ताव नहीं है।

$A$$B$$A$$B$

Comments

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

— user917279

Answer 3

यदि A और B समान आकार के हैं, तो असंतुष्ट और interleaved (जैसे A में विषम संख्या और B में भी संख्याएँ), तो रैखिक समय में वस्तुओं की जोड़ी की तुलना संभवतः इष्टतम है।

यदि A और B में ऐसी आइटमों के ब्लॉक हैं, जो A या B में से किसी एक में हैं, या उन दोनों में, उप-रेखीय समय में सेट अंतर, संघ और चौराहे की गणना करना संभव है। एक उदाहरण के रूप में, यदि A और B वास्तव में एक आइटम में भिन्न हैं, तो अंतर को O (लॉग एन) में गणना की जा सकती है।

http://arxiv.org/abs/1301.3388

Comments

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

— smossen

हे भगवान, आपने उसी कागज को I (I, समान रूप से, बल्कि) से जोड़ा ... अगली बार आपके लिंक को नाम दें: D

— Realz Slaw

मेरे पास जो कुछ भी ज्ञान (?) है, वह शानदार है, मैंने उन्हें क्रमबद्ध सूचियों के रूप में प्रस्तुत किया, लेकिन विनम्रतापूर्वक इन सुझावों का भी स्वागत करेंगे।

— user917279

Answer 4

एक विकल्प सेट (जहां) का प्रतिनिधित्व करने के लिए बिटवेक्टर का उपयोग करना है$n$वें स्थिति किसी वस्तु की उपस्थिति या अनुपस्थिति का प्रतिनिधित्व करती है) और सेट-प्रकार के संचालन फिर द्विआधारी संचालन को कम करते हैं जो डिजिटल कंप्यूटरों पर (और समानांतर में कई बिट्स पर) जल्दी से प्रदर्शन किया जा सकता है। इस मामले में$A-B$ = $a \wedge \overline b$ कहाँ पे $a,b$बिटवेक्टर हैं। अन्य तकनीकों की तुलना में इस तकनीक की सापेक्ष दक्षता भी विरलता पर निर्भर करती है। अधिक घने सेटों के लिए यह अन्य तरीकों की तुलना में अधिक कुशल हो सकता है। यह भी निश्चित रूप से पूरे ऑपरेशन शर्मनाक समानांतर है इसलिए सेट ऑपरेशन समानांतर में किया जा सकता है।

Comments

साथ में $10^{10}$संभव प्रविष्टियाँ, बिट वैक्टर बिल्कुल व्यावहारिक नहीं हैं।

— राफेल

आर।, की बात याद आती है। एक long32 तत्वों या 1 byte, 8 तत्वों को संग्रहीत कर सकता है । इसलिए 1M प्रविष्टियों को केवल ~ 125K RAM में संग्रहीत किया जा सकता है! स्टोरेज अन्य

— निरूपणों की

तो आपको ओपी में रुचि रखने वाले सेट के लिए 12 एमबी से अधिक की आवश्यकता होगी। यह सभी कैश (वर्तमान में) को उड़ा देता है और स्पाइस सेट के लिए भयानक होगा। विशेष रूप से, एक खाली सेट बनाने से अन्य सभी ऑपरेशन (विरल सेट के लिए) पर हावी हो जाते हैं। नथ इस तरह से TAoCP में इस मुद्दे को संबोधित करते हैं।

— राफेल

12MB? है ना? पोस्टर में कहा गया है कि उसके पास केवल 2 सेट हैं। पोस्टर ने अपने सेट की विरलता / घनत्व को निर्दिष्ट नहीं किया। यह मेरे उत्तर में बताया गया है। क्या आप मान रहे हैं कि वह विरल सेट है? कोई एक सही उत्तर नहीं है, दृष्टिकोण को एक वैकल्पिक विकल्प के रूप में इंगित किया गया है जो परिस्थितियों के आधार पर उपयोगी हो सकता है। यह इस संदर्भ में असामान्य रूप से उपयोग नहीं किया जाता है ...

— vzn

मेरा सुझाव है कि आप इस प्रश्न को फिर से पढ़ें: "प्रत्येक सेट में लगभग एक लाख प्रविष्टियाँ होती हैं, और प्रत्येक प्रविष्टि एक सकारात्मक पूर्णांक होती है जो अधिकतम 10 अंकों की होती है।" वहां$10^{10}$ विभिन्न संख्याएँ जो हो सकती हैं, और लगभग हैं $10^6$सूची में शामिल हैं। इसका मतलब है कि आपके बिट वेक्टर में सभी प्रविष्टियों में से केवल 0.01% ही 1 हैं - मैं वास्तव में बहुत विरल कहूंगा। (मेरे 12MB बहुत कम थे, आपको पाठ्यक्रम की आवश्यकता है$10^{10}\mathrm{b} \approx 1.15\mathrm{GB}$।)

— राफेल