हटाने डुप्लिकेट कुशलता से और कम स्मृति उपरि के साथ

Question

मैं डुप्लिकेट के लिए पूर्णांकों की एक सूची को कुशलतापूर्वक फ़िल्टर करना चाहता हूं जो केवल परिणामी सेट को संग्रहीत करने की आवश्यकता है।

इसे देखा जा सकता है:

• हमारे पास बड़े के साथ पूर्णांक एक श्रृंखला है ( )$S = \{1, \dots{}, N\}$$N$$2^{40}$
• हमारे पास एक फ़ंक्शन माना जाता है कि , माना जाता है, कई टकराव (चित्र समान रूप से में वितरित किए गए हैं )$f : S \to S$$S$
• हमें फिर को स्टोर करना होगा , वह है$f[S]$$\{f(x) | x \in S\}$

मेरे पास काफी सटीक (संभाव्य) अनुमान है कि क्याहै, और इसलिए अग्रिम में डेटा संरचनाओं को आवंटित कर सकते हैं (कहते हैं )।$|f[S]|$$|f[S]| \approx 2^{30}$

मेरे पास कुछ विचार हैं, लेकिन मुझे यकीन नहीं है कि सबसे अच्छा तरीका क्या होगा:

• एक बिटसेट प्रश्न से बाहर है क्योंकि इनपुट सेट मेमोरी में फिट नहीं होता है।
• हैश टेबल, लेकिन (1) इसके लिए कुछ मेमोरी ओवरहेड की आवश्यकता होती है, 150% का कहना हैऔर (2) तालिका का निर्माण तब किया जाना चाहिए जब मेमोरी ओवरहेड के कारण अतिरिक्त समय की आवश्यकता हो।$|f[S]|$
• ए "फ्लाई पर" सॉर्ट, अधिमानतः जटिलता (गैर-तुलना सॉर्ट) के साथ। इस बारे में, मुझे यकीन नहीं है कि बाल्टी सॉर्ट और फ्लैशसॉर्ट के बीच मुख्य अंतर क्या है ।$O(N)$
• द्विआधारी खोज ट्री के साथ एक सरल सरणी, लेकिन इसके लिए समय की आवश्यकता होती है।$O(N \log |f[S]|)$
• हो सकता है कि ब्लूम फ़िल्टर या इसी तरह की डेटा संरचना का उपयोग करने से समस्या के विश्राम (झूठी सकारात्मक) के साथ उपयोगी हो।

स्टैकओवरफ्लो पर कुछ प्रश्न इस प्रकार की चीजों से निपटने के लिए प्रतीत होते हैं ( /programming/12240997/sorting-array-in-on-run-time , https://stackoverflow.com/questions-3951547/java -रे-फाइंड-डुप्लिकेट ), लेकिन कोई भी मेरी आवश्यकताओं से मेल नहीं खाता।

Comments

क्या आपको f [S] (जो कुछ भी है) की गणना करने की आवश्यकता है, या जल्दी से यह बताने में सक्षम होना चाहिए कि क्या इसमें कुछ x है?

— गाइल्स का एसओ- बुराई को रोकना '

@ गिल्स: मेरा मानना ​​है कि, चूंकि कोई स्पष्ट संरचना f [S] में नहीं मिल सकती है, दो समाधान समतुल्य हैं।

— doc

आपके नंबर नहीं जुड़ते हैं। के आकार के डोमेन पर एक यादृच्छिक फ़ंक्शन की अपेक्षित छवि लगभग । एक और मुद्दा यह है कि से गुजर रहा है जब तक कि आपके पास एक सुपर कंप्यूटर या आपके निपटान में एक बड़ा क्लस्टर न हो। $N$$(1-1/e)N$$2^{56}$

— युवल फिल्मस

बाइनरी सर्च ट्री का समय , जो व्यवहार में करीब हो सकता है या नहीं लेकिन फिर भी अधिक सटीक है। $O(N \log |f[S]|)$$O(N\log N)$

— जम्मूद

साथ , एक रेखीय समय एल्गोरिथ्म निषेधात्मक भी नहीं होगा? (मेरी गणना से, भले ही आप 1 नैनो सेकेंड में एक तत्व पर विचार करें , यह आपको 2 साल अच्छा लगेगा!)। $N \sim 2^{56}$$S$

— आर्यभट्ट

Answer 1

बिन और चेन क्यों नहीं?

यह विचार सकारात्मक पूर्णांक को द्वारा संग्रहित करना है$n = k+m$ एक सरणी में बिट$A$ का $2^k$ मानों की श्रेणियों का प्रतिनिधित्व करने वाली प्रविष्टियाँ: प्रविष्टि $A[y]$, $y \ge 0$सीमा का प्रतिनिधित्व करता है $[2^m y, 2^m(y+1)-1]$। किसी के लिए$1 \le x \lt 2^n$ हम लिख सकते हैं $x = 2^m y + z$ कहाँ पे $y$ है $k$ बिट्स और $z$ है $m$बिट्स। स्टोर करने का प्रयास करें$z$ (नहीं $x$!) स्थान पर $y$:

• कब $A[y]=z$ पहले से, कुछ भी न करें: $x$ एक डुप्लिकेट है।

• कब $A[y]$ अनधिकृत है, स्टोर है $z$ पर $A[y]$।

• अन्यथा, एक इंडेक्स को चेन करने के लिए उपयोग किए जाने वाले एक अलग एरे में स्टोर करें $z$की (जो टकरा गए हैं) $y$) जुड़ी हुई सूचियों में। आप की अध्यक्षता में सूची के माध्यम से रैखिक खोज करनी होगी$A[y]$ और, यह पता लगाने पर निर्भर करता है कि खोज क्या संभव है, संभावित रूप से सम्मिलित करें $z$ सूची में।

अतं मै, $f(S)$ की आरंभिक प्रविष्टियों के माध्यम से लूपिंग द्वारा पुनर्प्राप्त करना आसान है $A$ और - केवल दो बिटस्ट्रिंग को समेटकर - प्रत्येक को पुनः प्राप्त करना $z$ स्थान पर पाया गया $y$ (या तो सीधे या एक श्रृंखला के भीतर संदर्भित) मूल मूल्य में $x = 2^m y + z$।

जब वितरण समान और के करीब है $2^k$ से अधिक है $N$, वहाँ बहुत अधिक जंजीर नहीं होगी (इसका सामान्य तरीकों से मूल्यांकन किया जा सकता है) और जंजीरें छोटी होंगी। जब वितरण गैर-समान होता है, तो एल्गोरिथ्म अभी भी काम करता है, लेकिन द्विघात समय पर पहुंच सकता है। यदि यह संभावना है, तो जंजीरों की तुलना में कुछ अधिक कुशल का उपयोग करें (और भंडारण के लिए थोड़ा उपरि का भुगतान करें)।

सबसे ज्यादा जरूरत स्टोरेज की है $2^n$ के लिए बिट्स $A$ तथा $2^{2k}$ जंजीरों के लिए बिट्स (ग्रहण करना $m \le k$)। यह वास्तव में स्टोर करने के लिए आवश्यक स्थान है$2^k$ के मान $n$प्रत्येक बिट। यदि आप एकरूपता में आश्वस्त हैं, तो आप जंजीरों के भंडारण को कम कर सकते हैं। यदि गैर-समरूपता एक संभावना है, तो आप बढ़ाना चाह सकते हैं$k$ और पूरी तरह से चेन स्टोरेज की वकालत करते हैं।

इस समाधान के बारे में सोच का एक वैकल्पिक तरीका है कि यह है है एक विशेष रूप से अच्छा हैश समारोह के साथ एक हैश तालिका (ले$k$ सबसे महत्वपूर्ण बिट्स) और, इस वजह से, हमें केवल कम से कम महत्वपूर्ण स्टोर करने की आवश्यकता है $m=n-k$ तालिका में बिट्स।

भंडारण के लिए जंजीरों के लिए भंडारण को ओवरले करने के तरीके हैं $A$ लेकिन यह परेशान होने के लायक नहीं है, क्योंकि यह ज्यादा बचत नहीं करेगा $m$ से बहुत छोटा है $k$) स्थान और कोड को विकसित करने, डिबग करने और बनाए रखने के लिए कठिन बना देगा।

Comments

मुझे लगता है कि दूसरा-से-अंतिम पैराग्राफ यहां केंद्रीय है, और संभवतः शीर्ष पर होना चाहिए (विचार के रूप में)। मैं "बिन और चेन" शब्द नहीं जानता (हालांकि यह पोस्ट पढ़ने के बाद समझ में आता है)। इस विचार को कोशिशों तक बढ़ाया जा सकता है ।

— राफेल

तो यह है $\Theta(n^2)$खराब वितरित इनपुट पर। मैं यह नहीं देखता कि यह कैसे कुशल है।

— ईनपोकलूम

@einpoklum यह उत्तर स्पष्ट रूप से उन स्थितियों का वर्णन करता है जिनमें समाधान कुशल है।

— व्ह्यूकर