2013-01-07 21 views
13

इस प्रकार मैं एक समस्या है जो सोचा:ढूँढना एक श्रेणी में निकटतम संख्या

हम आकार n का पूर्णांक की एक सरणी एक है, और हम परीक्षण मामलों टी है और हर परीक्षण मामलों में हम एक नंबर मीटर दिए गए हैं और एक सीमा [एस, ई] यानी हमें एस और ई दिया जाता है और हमें उस सरणी (ए [एस]-ए [ई]) की सीमा में एम की सबसे नज़दीकी संख्या मिलनी है।

आप मान सकते हैं कि अनुक्रमित सरणी 1 से n तक है।

उदाहरण के लिए:

A = {5, 12, 9, 18, 19} 
    m = 13 
    s = 4 and e = 5 

तो जवाब 18.

प्रतिबन्ध होना चाहिए:

n<=10^5 
t<=n 

सभी मैं सोचा एक हे (एन) हर परीक्षण मामले के लिए समाधान है कर सकते हैं, और मुझे लगता है कि एक बेहतर समाधान मौजूद है।

+2

यदि यह किसी भी तरह से क्रमबद्ध नहीं है, तो आपको ए [एस] और ए [ई] के बीच हर मूल्य का उपयोग करना होगा, इसलिए ओ (एन) यह है।या बल्कि ओ (ई-एस), मुझे लगता है। – femtoRgon

+0

@femtoRgon मुझे पता है, लेकिन किसी भी डेटा strucxture के उपयोग से मुझे लगता है कि यह संभव है (बस सोचो लेकिन यकीन नहीं)। –

+0

चूंकि आपने अधिकतम आकार सीमा (10^5) निर्दिष्ट की है, जटिलता ओ (1) नहीं है - यानी निरंतर समय? – Chris

उत्तर

9

यह एक मोटा स्केच है: डेटा से segment tree बनाएं। प्रत्येक नोड पर, बाएं और दाएं इंडेक्स जैसे सामान्य डेटा के अलावा, आप उस नोड पर रूट किए गए उप-पेड़ में पाए गए नंबरों को भी क्रमबद्ध क्रम में संग्रहीत करते हैं। जब आप नीचे-अप क्रम में सेगमेंट पेड़ बनाते हैं तो आप इसे प्राप्त कर सकते हैं। नोड में केवल पत्ते के ऊपर, आप दो पत्ते के मूल्य क्रमबद्ध क्रम में स्टोर करते हैं। एक मध्यवर्ती नोड में, आप संख्याओं को बाएं बच्चे में रखते हैं, और सही बच्चा, जिसे आप मानक विलय का उपयोग करके एक साथ विलय कर सकते हैं। पेड़ में ओ (एन) नोड्स हैं, और इस डेटा को समग्र ओ (एनएलओएल (एन)) लेना चाहिए।

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

ट्यूटोरियल जो मैं लिंक करता हूं, में अन्य डेटा संरचनाएं शामिल हैं, जैसे स्पार्स टेबल, जो कार्यान्वित करने में आसान हैं, और प्रति क्वेरी (एसकर्ट (एन)) देना चाहिए। लेकिन मैंने इसके बारे में बहुत कुछ नहीं सोचा है।

+0

आप कैसे तय करते हैं कि पेड़ में क्या नोड डालना है? आप सभी संभावित बाएं और दाएं सूचकांक नहीं जोड़ सकते हैं। – Chris

+0

एक सेगमेंट पेड़ सरणी के शीर्ष पर बनाया गया है (प्रत्येक सरणी तत्व एक पत्ता है) और प्रत्येक दो पत्ते नोड्स को अगले स्तर के नोड देने के लिए जोड़ा जाता है, और इसी तरह। ट्यूटोरियल में दिए गए सरणी पर आप पूरे पेड़ का निर्माण करते हैं। फिर, किसी दिए गए सीमा में कुल डेटा की खोज करने के लिए पेड़ में लगभग दो शाखाओं को घुमाने की आवश्यकता होती है। – mayank

+0

ठीक है, अब मिल गया। मुझे बुरा - मैंने सेगमेंट पेड़ों के साथ काम किया है, लेकिन किसी भी तरह से यह कल्पना नहीं कर सका कि उन्होंने इस समस्या को कैसे फिट किया। – Chris

-1

मुझे पूरा यकीन है कि कोई तेज समाधान मौजूद नहीं है। आपकी समस्या का मामूली बदलाव यह है:

कोई सरणी ए नहीं है, लेकिन प्रत्येक परीक्षण मामले में खोजने के लिए संख्याओं की एक अनारक्षित सरणी होती है। (ए से एस से ए के सरणी टुकड़ा)।

उस स्थिति में, प्रत्येक परीक्षण मामले के लिए रैखिक खोज से स्पष्ट रूप से कोई बेहतर तरीका नहीं है।

अब, आपकी मूल समस्या किस तरह से भिन्नता की तुलना में अधिक विशिष्ट है? केवल एक ही अतिरिक्त जानकारी यह है कि सभी स्लाइस एक ही सरणी से आते हैं। मुझे नहीं लगता कि इस अतिरिक्त बाधा का उपयोग एल्गोरिदमिक स्पीडअप के लिए किया जा सकता है।

संपादित करें: मैं सही खड़ा हूं। सेगमेंट पेड़ डेटा संरचना काम करना चाहिए।

+2

यह मामूली भिन्नता नहीं है, यह एक बड़ा अंतर है। जब आपके पास पहले से 'ए' है, तो आप प्रीप्रोकैसिंग के दौरान डेटा संरचना बनाने में सक्षम हो सकते हैं जो तेज खोजों की अनुमति देगा। – interjay

+0

मेरा तर्क था कि ऐसी डेटा संरचना मौजूद नहीं है, लेकिन एक अलग उत्तर में सेगमेंट ट्री विचार ने मुझे अन्यथा विश्वास दिलाया है। – Chris

-1

सरणी को सॉर्ट करें और बाइनरी खोज करें। जटिलता: ओ (nlogn + logn * t)

+1

काम नहीं करेगा - आपके पास क्वेरी के हिस्से के रूप में मूल सरणी में सूचकांक हैं। बयान फिर से पढ़ें। –

संबंधित मुद्दे