क्या कोई 'स्ट्रिंग स्टैक' डेटा संरचना है जो इन स्ट्रिंग संचालन का समर्थन करता है?

Question

मैं एक डेटा संरचना की तलाश कर रहा हूं, जो एक वर्ण सेट पर स्ट्रिंग्स का एक सेट संग्रहीत करता है , जो निम्न संचालन करने में सक्षम है। हम को दर्शाते हैं क्योंकि डेटा संरचना स्ट्रिंग्स के सेट को संग्रहीत करती है ।$\Sigma$$\mathcal{D}(S)$$S$

• Add-Prefix-Seton : दिए गए कुछ सेट (संभवतः खाली) स्ट्रिंग्स, जिसका आकार एक स्थिरांक से घिरा होता है और जिसकी स्ट्रिंग लंबाई एक निरंतर, बाउंड । ये दोनों सीमावर्ती स्थिरांक वैश्विक हैं: वे सभी इनपुट लिए समान हैं ।$\mathcal{D}(S)$$T$$\mathcal{D}( \{ t s\ |\ t \in T, s \in S\} )$$T$
• Get-Prefixeson : return । ध्यान दें कि मैं वास्तव में इस सेट के लिए किस संरचना का उपयोग नहीं करता हूं, जब तक कि मैं समय में इसकी सामग्री की गणना कर सकता हूं ।$\mathcal{D}(S)$$\{ a \ | \ as \in S, a \in \Sigma \}$$O(|\Sigma|)$
• Remove-Prefixeson : return ।$\mathcal{D}(S)$$\mathcal{D}( \{ s \ | \ as \in S, a \in \Sigma \} )$
• Merge: और , लौटाएं ।$\mathcal{D}(S)$$\mathcal{D}(T)$$\mathcal{D}(S \cup T)$

अब, मैं वास्तव में समय में इन सभी ऑपरेशनों को करना चाहूंगा , लेकिन मैं एक संरचना के साथ ठीक हूं जो इन सभी ऑपरेशनों को समय में करता है, जहां सबसे लंबे स्ट्रिंग की लंबाई है संरचना। मर्ज के मामले में, मैं एक चाहते हैं चलने का समय, जहां है पहले के लिए और दूसरी संरचना के लिए।$O(1)$$o(n)$$n$$o(n_1+n_2)$$n_1$$n$$n_2$$n$

एक अतिरिक्त आवश्यकता यह है कि संरचना अपरिवर्तनीय है, या कम से कम उपरोक्त ऑपरेशन 'नई' संरचनाएं लौटाते हैं जैसे कि पुराने के लिए संकेत अभी भी पहले की तरह कार्य करते हैं।

परिशोधन के बारे में एक नोट: यह ठीक है, लेकिन आपको दृढ़ता के लिए बाहर देखना होगा। जैसा कि मैं हर समय पुरानी संरचनाओं का फिर से उपयोग करता हूं, अगर मैं एक ही संरचना पर कुछ विशेष कार्यों के संचालन के साथ सबसे खराब स्थिति में हूं, तो मैं मुश्किल में पड़ जाऊंगा (इसलिए नई संरचनाओं की उपेक्षा करता है)।

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

मैंने पहले ही एक ट्राइ का उपयोग करने पर विचार किया है , लेकिन मुख्य समस्या यह है कि मुझे नहीं पता कि कैसे मर्ज करने की कुशलता से कोशिश करता है। यदि स्ट्रिंग्स के सेट में Add-Prefix-Setकेवल एकल-वर्ण स्ट्रिंग्स होते हैं, तो आप इन सेटों को एक स्टैक में संग्रहीत कर सकते हैं, जो आपको पहले तीन ऑपरेशनों के लिए रनिंग टाइम देगा। हालाँकि, यह दृष्टिकोण विलय के लिए काम नहीं करता है।$O(1)$

अंत में, ध्यान दें कि मुझे कारकों में कोई दिलचस्पी नहीं है: यह मेरी देखभाल के लिए निरंतर है।$|\Sigma|$

Comments

क्या स्ट्रिंग्स केवल ऑपरेशन द्वारा निर्मित हैं Add-Prefix-Setया आप स्ट्रिंग्स के एक मनमाने सेट के साथ शुरू करते हैं?

— जो

मान लीजिए कि एक मर्ज ऑपरेशन से पहले, और दोनों में लंबाई की एक स्ट्रिंग है । आप संभवतः यह कैसे पता लगा सकते हैं कि यह स्ट्रिंग समय में डुप्लिकेट है या नहीं ? $n_1 = n_2$$S$$T$$o(n_1 + n_2)$

— जो

आप इसमें एक सिंगल-चार स्ट्रिंग के साथ एक सेट के साथ शुरू करते हैं, लेकिन एक खाली स्ट्रिंग ठीक है (आप इसे बस में कर सकते हैं Add-Prefix-Set)

— एलेक्स दस कगार

@ जो: यह एक अच्छा सवाल है - मैं मर्ज ऑपरेशन को पूरा करने के लिए शुरू कर रहा हूँ बहुत ज्यादा इस तरह की संरचना प्राप्त करने का कोई भी मौका टूट जाता है ...

— एलेक्स दस ब्रिंक

यदि आप अपने "स्टैक ऑफ सेट्स" प्रतिनिधित्व का उपयोग करते हैं, तो आप मिनट में दो स्टैक विलय कर सकते हैं$(n_1, n_2)$

— जो

Answer 1

मैंने कुछ समय के लिए सोचा था, लेकिन अपने सभी ऑपरेशनों को ट्राई-डेग संरचना में सबसे बेवकूफ संभव तरीके से करने में समस्या नहीं आई:

ऐड-उपसर्ग सेट

से स्ट्रिंग्स का एक त्रिभुज बनाएं । प्रत्येक पत्ती के नोड को पुराने ट्राइ की जड़ से कनेक्ट करें।$T$

जटिलता:$O(|T|)$

मर्ज

दो संरचनाओं की एकजुट जड़ें: सभी बच्चों को पहली नोड के दूसरे मूल बच्चों के नोड बनाते हैं। अब आपके पास एक ही नोड से जाने वाले एक से अधिक किनारों को चिह्नित किया जा सकता है।

जटिलता:$O(1)$

जड़ का आलसी अद्यतन

1. प्रत्येक चरित्र के लिए इस चरित्र के साथ चिह्नित किनारों द्वारा सुलभ रूट के सभी बच्चों को एकजुट करें। ( _ + प्रवर्धित प्रत्येक किनारे के लिए कभी जोड़ा गया)$O(|\Sigma|)$$O(1)$
2. ऊपर से रूट में जाने वाले सभी किनारों को हटा दें। (हटाए गए उपसर्गों के बाद भी हो सकता है, प्रत्येक किनारे के लिए amortized कभी जोड़ा गया)$O(1)$

Get-उपसर्गों

आलसी जड़ को अपडेट करें। अब रूट के सभी बच्चों को ढूंढें और उन्हें जाने वाले किनारों पर अक्षरों के सेट की रिपोर्ट करें।

जटिलता:$O(|\Sigma|)$

निकालें-उपसर्गों

आलसी जड़ को अपडेट करें। रूट के सभी बच्चों को एकजुट करें और इस एकजुट होने के परिणाम के लिए रूट पॉइंटर सेट करें। आलसी नई जड़ को अपडेट करें।

जटिलता: + आलसी अद्यतन$O(|\Sigma|)$

हठ

इस डेटा संरचना के बारे में सभी जानकारी के साथ सरणियों में बचाया जा सकता है नोड प्लस प्रति जानकारी नोड के प्रत्येक बच्चे के लिए जानकारी। प्रत्येक ऑपरेशन को इन सरणियों में असाइनमेंट के सेट के रूप में आयोजित किया जा सकता है। निरंतर श्रेणी के पेड़ या किसी अन्य डेटा संरचना का उपयोग करें जिसे लगातार सरणी के रूप में देखा जा सकता है। मेमोरी और स्पेस जटिलता लिए अतिरिक्त गुणक , जहां सभी प्रश्नों में वर्णों की कुल संख्या है।$O(1)$$O(|\Sigma|)$$O(log N)$$N$