क्या तत्व विशिष्टता को नियतात्मक रैखिक समय में हल किया जा सकता है?

9

निम्नलिखित समस्या पर विचार करें:

इनपुट : सूचियां $X,Y$ पूर्णांकों की

लक्ष्य : निर्धारित करें कि क्या पूर्णांक मौजूद है $x$ वह दोनों सूची में है।

मान लीजिए दोनों सूची $X,Y$ आकार के हैं $n$ । क्या इस समस्या के लिए एक नियतात्मक, रैखिक-समय एल्गोरिथ्म है? दूसरे शब्दों में, क्या आप इस समस्या को हल कर सकते हैं $O(n)$ समय का निर्धारण, यादृच्छिकता का उपयोग किए बिना?

दुर्भाग्य से, आप यह नहीं मान सकते कि सूची तत्व सभी छोटे हैं।

मैं देख सकता हूं कि इसे कैसे हल किया जाए $O(n)$ एक यादृच्छिक एल्गोरिथ्म का उपयोग करके अपेक्षित समय: बेतरतीब ढंग से एक 2-सार्वभौमिक हैश फ़ंक्शन चुनें $h$ के तत्वों को संग्रहित करें $X$ एक हैशटेब में (उपयोग करके) $h$ हैश फ़ंक्शन के रूप में), और फिर प्रत्येक तत्व को देखें $Y$ देखना है कि क्या यह हैशटेबल में है। अपेक्षित रनिंग टाइम होगा $O(n)$ । हालाँकि, मैं यह नहीं देख सकता कि कैसे नियतात्मक एल्गोरिथ्म का पता लगाया जाए $O(n)$ कार्यकारी समय। यदि आप इसे डायग्राम करने और एक विशिष्ट हैश फ़ंक्शन को ठीक करने का प्रयास करते हैं, तो सबसे खराब स्थिति वाला इनपुट मौजूद होगा जो इस प्रक्रिया को चलाने का कारण बनता है $\Theta(n^2)$ समय। सबसे अच्छा निर्धारक एल्गोरिथ्म मैं पा सकता हूं जिसमें मूल्यों को क्रमबद्ध करना शामिल है, लेकिन यह रैखिक समय नहीं होगा। क्या हम रैखिक चलने का समय प्राप्त कर सकते हैं?

इसके अलावा, मैं यह देख सकता हूं कि इसे रैखिक समय में कैसे हल किया जाए यदि आप मानते हैं कि सभी सूची तत्व रेंज में पूर्णांक हैं $[1,n]$ (मूल रूप से, काउंटिंग सॉर्ट करें) - लेकिन मुझे इस बात में दिलचस्पी है कि जब हम ऐसा नहीं कर सकते तो सामान्य मामले में क्या होता है।

यदि उत्तर गणना के मॉडल पर निर्भर करता है, तो रैम मॉडल मन में कूद जाता है, लेकिन मैं गणना के किसी भी उचित मॉडल के लिए परिणामों में दिलचस्पी लेता हूं। मैं इससे अवगत हूँ $\Omega(n \log n)$ तत्व विशिष्टता के लिए निर्णय ट्री एल्गोरिदम के लिए कम सीमाएं , लेकिन यह निश्चित नहीं है, क्योंकि कभी-कभी हम रैखिक-समय के एल्गोरिदम भी पा सकते हैं $\Omega(n \log n)$ निर्णय-वृक्ष मॉडल में बंधे।

algorithms complexity-theory lower-bounds

— DW
स्रोत

Hashtables O हैं (n log n) क्योंकि आपको टकरावों से निपटने की आवश्यकता है।

— थोरबजोरन रावन एंडरसन

1

@ ThorbjørnRavnAndersen, मैं नहीं देख रहा हूँ कि आप कहाँ से प्राप्त कर रहे हैं। 2-सार्वभौमिक हैश फ़ंक्शन और एक उपयुक्त आकार की हैश तालिका का उपयोग करना सुनिश्चित करता है कि हैश टकराव की संख्या न्यूनतम है (उच्च संभावना के साथ), इसलिए मेरा मानना है कि

O (n)

$O(n)$ चलने का समय प्राप्त करने योग्य है। मुझे यकीन नहीं है कि तुम कहाँ हो

O (n \lg n)

$O(n \lg n)$ से; यदि आप कुछ विशेष नहीं करते हैं (जैसे 2-सार्वभौमिक हैशिंग का उपयोग करें), तो सबसे खराब स्थिति है

O (n^{2})

$O(n^2)$ , टक्करों के कारण।

— DW

शैतान विस्तार में है, यहां "उपयुक्त आकार का हैश-टेबल" है। यदि आप टकराव नहीं चाहते हैं, तो यह बहुत बड़ा हो सकता है। किसी सूची के साथ हैश फ़ंक्शन टकराव से निपटने के लिए सामान्य एन-लॉग-एन (यदि मुझे सही ढंग से याद है)।

— थोरबजोरन रेव एंडरसन

1

@ ThorbjørnRavnAndersen समान पते पर मैपिंग की जाने वाली चाबियों की अपेक्षित संख्या स्थिर है (तालिकाओं के लिए जो अतिभारित नहीं हैं), इसलिए इस तरह का टकराव रिज़ॉल्यूशन अप्रासंगिक है। यह भी देखें यहाँ ।

O (n \log n)

$O(n \log n)$ सबसे खराब स्थिति में फिट बैठता है यदि आप सूचियों के बजाय BSTs (बाहरी) का उपयोग करते हैं।

— राफेल

1

यदि आप X और Y में प्रत्येक संभावित मान के लिए थोड़ी मेमोरी रखना चाहते हैं, तो आप रैखिक समय में समस्या को हल कर सकते हैं। यह X और Y के आदेश के किसी भी प्रतिबंध को लागू नहीं करता है।

शुरू में सभी बिट्स परेशान हैं।
X को समान बिट पर सेट करें।
यदि इसी बिट को ऊपर सेट किया गया था, तो Y जाँच पर Iterate करें।

— थोरबजोरन रावन एंडरसन
स्रोत

2

दुर्भाग्य से, आप यह नहीं मान सकते कि सभी पूर्णांक छोटे हैं (आप यह नहीं मान सकते कि वे इतने छोटे हैं कि यह एल्गोरिथ्म काम करेगा)। सामान्य स्थिति में, इस एलिमेंट्री का रनिंग टाइम लिस्ट तत्वों की बिट-लेंथ में घातांक होगा। फिर भी आपका धन्यवाद!

— DW

चलो इसे "उपयुक्त आकार बिट-सरणी" नाम दें। बिट-लेंथ में भी रैखिक लॉग-एन के बराबर है। क्या आप इनपुट डेटा पर किसी प्रतिबंध या पूर्व शर्त के बिना लॉग-एन प्रदर्शन प्राप्त करने के बारे में गंभीर हैं?

— थोरबजोरन रेव एंडरसन

2

@ ThorbjørnRavnAndersen अंतरिक्ष थोड़ी लंबाई में घातांक है (आपको सभी संभावित मानों से मैप करने की आवश्यकता है), और कुल सूची आकार में समय रैखिक है (आपको दोनों सूची में सभी मूल्यों को देखने की आवश्यकता है)। बिट-लेंथ में कुछ भी रैखिक नहीं है।

— 3

0

चूंकि आप कह रहे हैं कि दो सूचियों में पूर्णांक होते हैं, इसलिए मुझे लगता है कि हम दो सूचियों पर एक मूलांक छांट सकते हैं और फिर समान वस्तुओं के लिए दो सूचियों की तुलना करते हुए एक रेखीय खोज करते हैं।

— अनिरुद्ध
स्रोत

4

यह केवल तभी काम करता है जब संख्याओं के परिमाण पर एक बाध्यता हो।

— ल्यूक मैथिसन

लेकिन मुझे लगा कि उच्च परिमाण केवल सॉर्ट गिनती के लिए और मूलांक सॉर्ट के लिए एक समस्या होगी, हम उस समस्या को हल करने के लिए एक उच्च पर्याप्त मूलांक का चयन कर सकते हैं ... कृपया मुझे बताएं कि मैं यहां क्या याद कर रहा हूं

— अनिरुद्ध

क्या होगा यदि संख्याओं में से 2 ^ (2 ^ 128) है?

— मिनीबिल

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

— ल्यूक मैथिसन

0

प्रत्येक सूची के पूर्णांकों को एक साधारण बिटवाइज़ ट्राई में क्यों न डालें? क्या यह इष्टतम नहीं होगा, इस अर्थ में कि यह है $\mathcal O\left(n\cdot \overline m\right)$ , कहाँ पे $\overline m$ पूर्णांकों का औसत बिट आकार है; विशेष रूप से, मैं यह नहीं देखता कि आप किस तरह से बेहतर कर सकते हैं, जैसा कि * दो सूचियों को पढ़ने * में इस समय लगेगा।

— Realz स्लाव
स्रोत

आपके नोट के लिए धन्यवाद। प्रश्न के अंतिम पैराग्राफ को देखें, जो इस बिंदु को संबोधित करता है। रैम मॉडल में, आप दो सूचियों को पढ़ सकते हैं

O (n)

$O(n)$ समय - यह नहीं लेता है

O (n \cdot \overbar m)

$O(n \cdot \overbar{m})$ समय। तो यह वह जगह है जहाँ गणना का मॉडल इसमें आता है - यह जवाब वास्तव में यह साबित नहीं करता है कि निर्धारक रैखिक समय असंभव है।

— डीडब्ल्यू

@DW रैम मॉडल में, एक शब्द का आकार होता है

w

$w$ जो एक स्थिर है, और यह सीमा है

m

$m$ और इस प्रकार भी

\bar{m}

$\overline{m}$ , जिसके परिणामस्वरूप एक रनटाइम होता है

O (n)

$\mathcal O\left(n\right)$ , या मैं गलत हूँ?

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

शायद हम्म

w

$w$ एक निरंतरता एक गलती है।

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

(

w

$w$ स्थिर नहीं माना जाता है, लेकिन निर्भर है

n

$n$ : आप इसे किसी भी लगातार कई हो सकते हैं

m

$m$ प्रतिनिधित्व करने के लिए क्या आवश्यक है

n

$n$ (पर्याप्त प्रतिनिधित्व करने के लिए

n^{m}

$n^m$ ), बस मनमाने ढंग से बड़े नहीं ।)

— ग्रेबर्ड

-1

यह एलिमेट यूनीकनेस समस्या के समान है, जहां आपके पास n संख्याओं का एक सेट है और आप यह निर्धारित करना चाहते हैं कि क्या सभी तत्व अलग हैं। समस्या का एक बीजगणितीय संगणना वृक्ष है जिसकी निचली सीमा है $O(n\log n)$ ।

— ओमर गोल्ड
स्रोत

1

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

— ईविल

1

क्या मतलब है आपका

Ω (n \log n)

$\Omega(n\log n)$ ? यदि हां, तो यह सुझाव दे सकता है कि प्रश्न में समस्या को रैखिक समय में हल नहीं किया जा सकता है। लेकिन सिर्फ यह कहना कि लॉग-लीनियर समय में संबंधित समस्या को हल किया जा सकता है, वास्तव में इस सवाल का जवाब नहीं देता है। (cc @EvilJS)

— डेविड रिचरबी

1

आपके नोट के लिए धन्यवाद। मुझे आश्चर्य है कि क्या आपने प्रश्न के अंतिम वाक्य को याद किया। मैं इसे यहाँ दोहराऊँगा: "मैं इससे अवगत हूँ

Ω (n \log n)

$\Omega(n \log n)$ तत्व विशिष्टता के लिए निर्णय ट्री एल्गोरिदम के लिए कम सीमाएं , लेकिन यह निश्चित नहीं है, क्योंकि कभी-कभी हम रैखिक-समय के एल्गोरिदम भी पा सकते हैं

Ω (n \log n)

$\Omega(n \log n)$ डिसीजन-ट्री मॉडल में बंधे। "दूसरे शब्दों में, यह जवाब सवाल का जवाब नहीं देता है; यह केवल कुछ दोहराता है जो मैंने पहले ही कहा था कि मैं इस सवाल से वाकिफ था, लेकिन जो सवाल हल नहीं करता है।

— DW

इसमें किया जा सकता है

O (n \log \log n)

$O(n \log \log n)$ समय जो दिए जाने से बेहतर है

O (n \log n)

$O(n \log n)$ , तो मुझे यकीन है कि यह नहीं था

Ω (n \log n)

$\Omega(n \log n)$ , लेकिन यह DW प्रश्न को हल नहीं करता है। तो बस यहाँ टिप्पणी करें।

— ईविल