सभी चक्रों का पता लगाना

Question

मेरे पास एक परिमित सेट है $S$, एक समारोह $f:S\to S$, और कुल आदेश $<$ पर $S$। मैं अलग-अलग चक्रों की संख्या का पता लगाना चाहता हूं$S$।

किसी दिए गए तत्व के लिए $s\in S$ मैं फ़्लॉइड के एल्गोरिथ्म (या ब्रेंट का, आदि) का उपयोग कर सकता हूं ताकि उस चक्र की लंबाई का पता लगाया जा सके जिसके बार-बार अनुप्रयोग $f$ भेजता है $s$सेवा; थोड़े और प्रयास से मैं इस चक्र को पहचान सकता हूं (जैसे इसके द्वारा$<$(न्यूनतम तत्व)। समस्या को हल करने के लिए एक बुरा तरीका यह होगा कि यह प्रत्येक तत्व को दोहराए, जिसके परिणामस्वरूप न्यूनतम डुप्लिकेट को छोड़ने वाले तत्वों को सॉर्ट करें, और गिनती वापस करें। लेकिन इस संभावित में समान तत्वों और बड़े स्थान की आवश्यकताओं के लिए कई पास शामिल हैं।

बेहतर समय और अंतरिक्ष प्रदर्शन के लिए क्या तरीके हैं? मुझे यह भी निश्चित नहीं है कि आवश्यक स्थान को मापने का सबसे अच्छा तरीका क्या है - यदि$f$ पहचान फ़ंक्शन तब किसी भी विधि को संग्रहीत करता है जो सभी चक्रों का उपयोग करेगा $\Omega(n)$ अंतरिक्ष।

Comments

अंतरिक्ष को मापने के प्राकृतिक तरीकों में से एक एस को एन-बिट स्ट्रिंग्स के सेट के रूप में माना जाता है और एक ओरेकल के रूप में एफ। फिर आपके द्वारा वर्णित भोली एल्गोरिथ्म में घातीय स्थान की आवश्यकता होती है। एक एल्गोरिथ्म की तलाश हो सकती है जो केवल बहुपद स्थान का उपयोग करता है, लेकिन यह मेरे लिए संभव होने की संभावना नहीं है।

— त्सुयोशी इतो

यही मेरा मतलब है "मुझे नहीं पता कि अंतरिक्ष को मापने का सबसे अच्छा तरीका क्या है"। संभवतः मुझे O (पाली (n) + y) को लक्षित करना चाहिए जहां y आउटपुट है, ताकि उपयोग किया जाने वाला स्थान बहुपद हो जब तक y पर्याप्त रूप से छोटा हो।

— चार्ल्स

क्या आपके फ़ंक्शन f में कोई उपयोग करने योग्य गुण हैं? एल्गोरिथ्म बहुपद या घातीय है या नहीं इनपुट आकार को व्यक्त करने के आपके पसंदीदा तरीके में कुछ हद तक लूट होगी यदि व्यावहारिक उत्तर यह है कि एल्गोरिथ्म एस के कार्डिनिटी के आदेश पर समय और स्थान दोनों लेगा ।

— नील डी बेउड्राप

@ नील डी ब्यूड्रैप: मुझे यकीन नहीं है कि क्या गुण उपयोगी होंगे। मुझे उम्मीद है कि अलग-अलग चक्रों की संख्या कम है, हालांकि, शायद$O(\sqrt[3]n)$; इसलिए मैंने एक समारोह का सुझाव दिया$y$ तथा $n$ इसके बजाय बस $n$। यदि आवश्यक हो तो मैं आउटपुट के बिट्स की संख्या में अंतरिक्ष घातीय का उपयोग करने के लिए तैयार हूं।

— चार्ल्स

Answer 1

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

एक सरणी के साथ शुरू करें एक भंडारण पूर्णांक {0,1,2} - एस का एक तत्व - शून्य से आरंभीकृत; हम इन के रूप में इंगित करेंगे (unexplored), (partially explored)और (fully explored)। एक चक्र काउंटर को शून्य पर प्रारंभ करें। प्रत्येक तत्व के लिए रों  ∈  एस क्रम में, निम्न कार्य करें:

1. यदि A [ s ] =  (fully explored), चरण 6 पर जाएं।
2. सेट एक [ रों ] ←  (partially explored), और पुनरावर्तक सेट जे  ←  च (रों) ।
3. जबकि एक [ जे ] =  (unexplored), सेट एक [ जे ] ←  (partially explored), और सेट जे  ←  च (जे) ।
4. यदि ए [ जे ] =  (partially explored), हमने एक नया चक्र बंद कर दिया है; 1 से वृद्धि c । (यदि आप इस चक्र के कुछ प्रतिनिधि का रिकॉर्ड रखना चाहते हैं, तो j का वर्तमान मान एक मनमानी विकल्प के रूप में करेगा; निश्चित रूप से, यह आपकी पसंद के तहत चक्र में न्यूनतम तत्व नहीं होगा। आदेश <।) अन्यथा, हमारे पास ए [ जे ] = है  (fully explored), जिसका अर्थ है कि हमने एक पूर्व-खोजी कक्षा की खोज की है जो पहले से ही गिने चक्र में समाप्त होती है; वेतन वृद्धि नहीं ग ।
5. यह इंगित करने के लिए कि s पर शुरू होने वाली कक्षा अब पूरी तरह से खोजी गई है, j  ←  s सेट करें ।
   जबकि ए [ जे ] =  (partially explored), ए [ जे सेट करें ] ←  (fully explored)और सेट जे  ←  च (जे) ।
6. अगले तत्व के लिए आगे बढ़ें रों  ∈  एस ।

इस प्रकार, एफ द्वारा प्रेरित कक्षाओं के बीच प्रत्येक चक्र एक बार गिना जाएगा; और प्रतिनिधि के रूप में आपके द्वारा रिकॉर्ड किए गए कोई भी तत्व अलग चक्र के तत्व होंगे। स्मृति आवश्यकताएँ 2 हैं | एस | ए के लिए, ए, ओ (लॉग | एस |) चक्र गणना के लिए, और अन्य बाधाओं और समाप्त होता है।

प्रत्येक तत्व रों  ∈  एस दो बार कम से कम का दौरा किया किया जाएगा: एक बार जब एक के मूल्य [ रों ] से बदल दिया गया है (unexplored)करने के लिए (partially explored), और करने के लिए बदलाव के लिए एक बार (fully explored)। किसी भी नोड्स की कुल संख्या का पुनरीक्षण होने के बाद, (fully explored)नए चक्रों को खोजने के प्रयासों की संख्या से ऊपर होने के बाद , जो ऐसा करने में विफल रहता है, जो कि सबसे अधिक है। एस | - एस के सभी तत्वों के माध्यम से चलने वाले मुख्य लूप से उत्पन्न । इस प्रकार, हम इस प्रक्रिया को अधिकतम 3 में शामिल करने की उम्मीद कर सकते हैं एस | नोड-ट्रैवर्सल्स, हर समय गिना जाता है कि नोड्स का दौरा किया गया है या फिर से देखा गया है।

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

Comments

बहुत बढ़िया, यह मूर्खता पर सुधार करता है $O(|S|\log|S|)$अंतरिक्ष एल्गोरिथ्म मेरे मन में था। मुझे वास्तव में प्रतिनिधियों की आवश्यकता नहीं है; मैंने मिलाया$<$बस कुछ एल्गोरिदम के लिए यह उपयोगी होगा।

— चार्ल्स

मुझे आश्चर्य है कि अगर मामले में बहुत कम जगह का उपयोग करने का कोई तरीका है जहां बहुपद स्थान से अधिक का उपयोग किए बिना कुछ कुल चक्र हैं। आह, कोई बात नहीं; यह मेरी जरूरतों के लिए करेगा।

— चार्ल्स

यह मुझे लगता है कि यह # एल (मैट्रिक्स पॉवरिंग का उपयोग करके) में होना चाहिए। क्या यह # एल-हार्ड हो सकता है?

— केवह

@Charles: मेरे और हालिया उत्तर को देखें जो आपको सुधार देगा यदि आप जानते हैं कि # चक्र (o ( | S | ) | यह बहुवचन से अधिक उपयोग करता है | S | अंतरिक्ष, लेकिन अगर आप अंतरिक्ष और समय के लिए व्यापार करना चाहते हैं तो यह आपके लिए बेहतर हो सकता है।

— निल डे ब्यूड्रैप

@ नील डी ब्यूड्रैप: धन्यवाद! दोनों के लिए +1। जब तक डेटा इन-मेमोरी में फिट बैठता है तब तक यह एल्गोरिथ्म सबसे अच्छा लगता है; एक बार जब यह बाहर निकलता है तो मैं दूसरे का उपयोग करके देखूंगा। (यह संभव है कि दूसरा बेहतर होगा अगर मैं कैश में सब कुछ फिट कर सकता हूं, लेकिन यह बहुत अधिक परेशानी हो सकती है।)

— चार्ल्स

Answer 2

यदि आपके पास बहुत कम चक्र हैं, तो यहां एक एल्गोरिथ्म है जो कम जगह का उपयोग करेगा, लेकिन समाप्त करने के लिए काफी अधिक समय लेता है।

[संपादित करें।] मेरे पिछले रन-टाइम विश्लेषण ने यह निर्धारित करने की महत्वपूर्ण लागत को याद किया कि क्या हम जिन नोड्स पर जाते हैं, वे पहले से नमूना हैं; इस उत्तर को सुधारने के लिए इसे कुछ हद तक संशोधित किया गया है।

हम फिर से एस के सभी तत्वों के माध्यम से पुनरावृति करते हैं । हम तत्वों की कक्षाओं का पता लगाने के रूप में रों  ∈  एस , हम नोड्स है कि हम विज़िट कर चुके हैं नमूना है, ताकि अगर हम उन्हें भर में फिर से आना जांच करने के लिए सक्षम होने के लिए। हम 'घटकों' के नमूनों की एक सूची भी बनाए रखते हैं - कक्षाओं के संघ जो एक सामान्य चक्र में समाप्त होते हैं (और जो चक्र के लिए समान हैं) - जो पहले देखे गए हैं।

घटकों की एक खाली सूची को आरम्भ करें complist। प्रत्येक घटक को उस घटक से नमूनों के संग्रह द्वारा दर्शाया जाता है; हम एक खोज ट्री भी बनाए रखते हैं samplesजो उन सभी तत्वों को संग्रहीत करता है जिन्हें कुछ घटक या अन्य के लिए नमूने के रूप में चुना गया है। आज्ञा देना जी अनुक्रम के पूर्णांक तक है n , जिसके लिए सदस्यता कुशलता से कुछ बूलियन विधेय कंप्यूटिंग द्वारा निर्धार्य है; उदाहरण के लिए, कुछ पूर्णांक p के लिए 2 या पूर्ण p ^वें शक्तियों की शक्तियाँ । प्रत्येक के लिए रों  ∈  एस , निम्न कार्य करें:

1. यदि s में हैsamples , तो # 5 चरण पर जाएं।
2. एक खाली सूची cursample, एक पुनरावृत्त j s  f ( s ), और एक काउंटर t  । 1 को प्रारंभ करें ।
3. जबकि जे में नहीं है samples:
   - अगर टी  ∈  जी , सम्मिलित जे दोनों में cursampleऔर samples।
   - बढ़ते क्रम में टी और सेट जे  ←  च (जे) ।
4. यह देखने के लिए जांचें कि क्या j अंदर है cursample। यदि नहीं, तो हमें पहले से खोजे गए घटक का सामना करना पड़ा है: हम जाँचते हैं कि कौन सा घटक जे है, और इसे बढ़ाने cursampleके complistलिए उपयुक्त तत्व के सभी तत्वों को सम्मिलित करें । अन्यथा, हमने वर्तमान कक्षा से एक तत्व का फिर से सामना किया है, जिसका अर्थ है कि हमने पहले से खोजे गए चक्रों के किसी भी प्रतिनिधि का सामना किए बिना कम से कम एक बार एक चक्र का पता लगाया है: हम cursampleएक नए पाए गए घटक से नमूनों के संग्रह के रूप में सम्मिलित करते हैं,complist ।
5. अगले तत्व के लिए आगे बढ़ें रों  ∈  एस ।

के लिए n  = | S |, X (n) चक्रों की अपेक्षित संख्या ( उदाहरण  X (n) =  n ^1/3 ) का वर्णन करने वाला एक मोनोटोन बढ़ाने वाला कार्य है , और Y (n) = y (n)  लॉग ( n ) Ω ( एक्स (एन)  लॉग ( एन )) एक लय बढ़ा हुआ कार्य स्मृति के उपयोग के लिए एक लक्ष्य (निर्धारित करने होना जैसे  y (एन) =  n ^1/2 )। हमें y (n)  ∈ Ω ( X (n) ) की आवश्यकता है क्योंकि प्रत्येक घटक से एक नमूने को संग्रहीत करने में कम से कम X (n)  लॉग ( n ) स्थान लगेगा ।

• एक कक्षा के जितने तत्व हम नमूना करते हैं, उतनी ही जल्दी हम कक्षा के अंत में चक्र में एक नमूने का चयन करते हैं, और इस तरह जल्दी से उस चक्र का पता लगा लेते हैं। एक स्पर्शोन्मुख दृष्टिकोण से, यह तब हमारी स्मृति सीमा के रूप में कई नमूने प्राप्त करने के लिए समझ में आता है: हम एक अपेक्षित y (n) तत्वों के लिए G सेट कर सकते हैं जो n से कम हैं । - यदि S की कक्षा में अधिकतम लंबाई L होने की उम्मीद है , तो हम G को L  /  y (n) का पूर्णांक गुणक मान सकते हैं । - अगर कोई अपेक्षित लंबाई नहीं है, तो हम हर बार एक बार n  /  प्रति नमूना ले सकते हैं।
  
  y (n)तत्वों; यह किसी भी मामले में नमूनों के बीच अंतराल पर एक ऊपरी बाध्य है।

• यदि, एक नए घटक की तलाश में, हम S के उन तत्वों को पीछे छोड़ना शुरू कर देते हैं, जिन्हें हमने पहले देखा है (या तो खोजे जा रहे नए घटक से या पुराने से जिसका टर्मिनल चक्र पहले ही मिल चुका है), यह अधिकांश n  /  y पर लगेगा ( एन) पूर्व नमूना तत्व का सामना करने के लिए पुनरावृत्तियों; यह तब की संख्या पर एक ऊपरी बाध्य होता है, एक नया घटक खोजने के प्रत्येक प्रयास के लिए, हम निरर्थक नोड्स का पता लगाते हैं। क्योंकि हम कर n ऐसे प्रयासों, हम तो प्रचुरता से के तत्वों का दौरा करेंगे एस ज्यादा से ज्यादा n ²  /  y (एन) में कुल बार।

• सदस्यता के लिए परीक्षण करने के लिए आवश्यक कार्य samplesहे ( y (n)  लॉग  y (n) ) है, जिसे हम हर मुलाक़ात में दोहराते हैं: इस जाँच की संचयी लागत O ( n ²  log  y (n) ) है। नमूनों को उनके संबंधित संग्रहों में जोड़ने की लागत भी है, जो संचयी रूप से O ( y (n)  log  y (n) ) है। अंत में, हर बार जब हम पहले से खोजे गए घटक का पुन: सामना करते हैं, तो हमें यह पता लगाने के लिए एक्स (एन)  लॉग *  वाई (एन) समय तक खर्च करना चाहिए कि हमने किस घटक को फिर से खोजा; जैसा कि n बार तक हो सकता है , इसमें शामिल संचयी कार्य n x (n)  लॉग  द्वारा बाउंड किए गए हैं y (n) ।

इस प्रकार, संचयी कार्य यह जाँचने में किया जाता है कि क्या हम जिन नोड्स पर जाते हैं, वे रन-टाइम में नमूनों पर हावी हैं: यह लागत O ( n ²  log  y (n) ) है। फिर हमें y (n) जितना संभव हो उतना छोटा करना चाहिए , जिसे O ( X (n) कहना है ) ।

इस प्रकार, कोई ओ ( एक्स (एन)  लॉग ( एन ) स्पेस में ओ ( एन ²  लॉग  एक्स (एन) ले ) चक्रों की संख्या (जो उन चक्रों में समाप्त होने वाले घटकों की संख्या के समान है ) को शामिल कर सकता है ऐसा करने का समय, जहां एक्स (एन) चक्रों की अपेक्षित संख्या है।

Answer 3

आप एक संघ सेट डेटा-संरचना का उपयोग करके एक ही तत्वों पर कई पास से बच सकते हैं । प्रत्येक तत्व पर एक पास$s$ सेट युक्त संघ $s$ युक्त सेट के साथ $f(s)$। यह अभी भी बहुत सारी मेमोरी का उपयोग करता है।