क्या एक "छँटाई" एल्गोरिथ्म है जो एक सिक्का-फ्लिप तुलनित्र का उपयोग करते समय एक यादृच्छिक क्रमचय देता है?

इस प्रश्न से प्रेरित होकर , जो यह जानना चाहता है कि मानक खोज एल्गोरिथ्म में उपयोग किए जाने वाले तुलनित्र को फेयर कॉइन-फ्लिप द्वारा बदल दिया जाता है या नहीं, तो एक समान क्रमचय जनरेटर को लिखने में Microsoft की प्रमुख विफलता के कारण रनिंग टाइम बदल जाता है या नहीं , मेरा प्रश्न इस प्रकार है :

क्या तुलनाकर्ता के हमारे कार्यान्वयन के आधार पर एक तुलना आधारित छँटाई एल्गोरिथ्म है, जो:

एक सच्चे तुलनित्र का उपयोग करते समय क्रमबद्ध क्रम में तत्वों को लौटाएं (अर्थात्, एक मानक छँटाई एल्गोरिथ्म में हम जो अपेक्षा करते हैं वह तुलना करता है)
तत्वों का एक समान रूप से यादृच्छिक क्रमचय लौटाएं जब तुलनित्र को एक उचित सिक्का फ्लिप द्वारा प्रतिस्थापित किया जाता है (जो कि, x < y = truex और y के मूल्य की परवाह किए बिना, संभावना 1/2 के साथ वापसी करता है )

सॉर्टिंग एल्गोरिदम का कोड समान होना चाहिए। यह केवल तुलनात्मक "ब्लैक बॉक्स" के अंदर का कोड है जिसे बदलने की अनुमति है।

sorting randomized-algorithms permutations

— जो
स्रोत

यह प्रश्न भी देखें ।

— राफेल

निम्नलिखित दिलचस्प प्रश्न भी देखें: cstheory.stackexchange.com/questions/5321/… ।

— युवल फिल्मस

क्या आप चाहते हैं कि आपका यादृच्छिक तुलनित्र अच्छा व्यवहार करे? यहाँ दो संभावित तरीके हैं। (1) एक बार तुलनित्र अपना मन बना लेता है कि , तो हमेशा, और भी । (२) वही, लेकिन यदि तुलना करने वाला उस और का निर्णय लेता है , तो यह (और ) पर आ जाता है। दोनों मामलों में, प्रत्येक अप्रतिबंधित क्वेरी अभी भी पूरी तरह से यादृच्छिक है।

x < y

$x<y$

x < y

$x<y$

y > x

$y>x$

x < y

$x<y$

y < z

$y<z$

x < z

$x<z$

z > x

$z>x$

— युवल फिल्मस

@YuvalFilmus मैं आपके लिंक किए गए प्रश्न के लिए अनिवार्य रूप से क्या चाहता हूं, सिवाय इसके कि एक ही सर्किट को भी सॉर्ट करना चाहिए यदि हम यादृच्छिक गेट को एक तुलना-विनिमय गेट के साथ बदलते हैं जो तत्वों की जोड़ी का आदेश देता है।

— जो

अच्छा दृश्य के लिए यहाँ देखें ।

— राफेल

निम्नलिखित निर्धारक (तुलनित्र के बिना) एल्गोरिथ्म एक इनपुट ट्यूपल लिए काम करता है : $(a_1,\dots,a_n)$

है फिशर-येट्स शफ़ल कुछ स्थिर जोड़ी के साथ अपने तुलनित्र का उपयोग कर (कहना ) एक सिक्का फ्लिप के रूप में (कर स्वीकृति-अस्वीकृति नमूना)। तुलनित्र आउटपुट हैं पहली बार, का उपयोग यह नियतात्मक मामले में एक अंतहीन अस्वीकृति पाश से बचने के लिए उल्टे। $a_1 < a_2$ $1$
(वैकल्पिक स्पीडअप: एकल जोड़ी बार कोशिश करें , जहां लंबाई या आपका इनपुट है। यदि कोई भी दो आउटपुट अलग-अलग हो तो (1) में प्राप्त क्रमचय वापस आ सकता है) $n$ $n$
मर्ज सॉर्ट का उपयोग करके अपने सरणी को सॉर्ट करें।

तुलनित्र के रूप में एक नियतात्मक आदेश संबंध को देखते हुए, यह एल्गोरिथ्म समय- में एक सरणी सॉर्ट करता है, क्योंकि फिशर-येट्स फेरबदल में चलता है, जो कि का उपयोग करता है प्रत्येक चरण में गैर-यादृच्छिक "यादृच्छिक बिट्स" (जैसे आपके तुलनित्र को कॉल करता है) और मर्ज सॉर्ट में समान स्पर्शोन्मुख जटिलता होती है। (1) का परिणाम इस मामले में पूरी तरह से बेकार है, लेकिन चूंकि यह एक वास्तविक प्रकार का अनुसरण करता है, इसलिए इससे कोई नुकसान नहीं होता है। $\mathcal{O}(n \log n)$ $\mathcal{O}(n)$ $\mathcal{O}(\log n)$

तुलनित्र के रूप में एक वास्तविक सिक्के को फ्लिप करते हुए (1) प्रत्येक क्रमपरिवर्तन के लिए समान संभावना वाले सरणी की अनुमति देता है और यदि आपको वास्तव में करना है (3) (आपने छोड़ दिया (2) या (2) यादृच्छिकता निर्धारित करने में विफल रहा), यह नहीं है हानि क्योंकि इसके परिणाम का वितरण केवल इसके इनपुट के आदेश पर निर्भर करता है जो कि (1) के कारण सभी क्रमपरिवर्तन के बीच समान रूप से वितरित किया जाता है, इसलिए संपूर्ण एल्गोरिथ्म का परिणाम भी समान रूप से वितरित किया जाता है। प्रत्येक स्वीकृति-अस्वीकृति के नमूने को जितनी बार दोहराया जाना है, वह ज्यामितीय रूप से वितरित किया जाता है (संभावना के साथ अस्वीकार ) और इसलिए इसका एक अपेक्षित मूल्य है । प्रत्येक पुनरावृत्ति का उपयोग अधिकांश बिट्स पर किया जाता है, इसलिए रनटाइम विश्लेषण लगभग वैसा ही होता है जैसा निर्धारक मामले में होता है, लेकिन हमें केवल एक ही मिलता है $< \frac{1}{2}$ $< 2$ $\log n$ उम्मीद क्रम की , nontermination की संभावना (समाप्त के साथ ही लगभग निश्चित रूप से )। $\mathcal{O}(n \log n)$

जैसा कि जो बताया गया है: यदि आप पहले बिट में (1) के लिए परीक्षा पसंद नहीं करते हैं, तो (3) फिर (1) करें और उपयोग करें जो हमेशा , क्योंकि सरणी पहले से नियतात्मक मामले में क्रमबद्ध है । इसके अतिरिक्त आपको अपनी यादृच्छिक संख्या को लूप में सीमा पर ऊपरी सीमा से घटाना होगा, क्योंकि यादृच्छिक संख्या के लिए ऊपरी बाध्य समान क्रमपरिवर्तन देता है। लेकिन ध्यान रखें कि (2) तब मना किया जाता है, क्योंकि आपको हमेशा फेरबदल के मामले में फेरबदल करना पड़ता है। $a_n < a_1$ $0$

आप (1) और (3) के लिए अपने तुलनित्र को समान कॉल का उपयोग कर सकते हैं, लेकिन फिर यह साबित करना कि परिणाम समान रूप से वितरित किया गया है, कम से कम बहुत कठिन है, यदि संभव हो तो।

निम्नलिखित एल्गोरिथ्म में फेरबदल करने और क्रमबद्ध करने के लिए कोई अलग-अलग चरण नहीं हैं, लेकिन यह asymptotically धीमा है। यह अनिवार्य रूप से द्विआधारी खोज के साथ सम्मिलन प्रकार है । मैं का उपयोग करेगा इनपुट और निरूपित करने के लिए के बाद परिणाम को निरूपित करने के दौर मई:

a = (a_{1}, \dots, a_{n})

$a=(a_1,\dots,a_n)$

b_{k} = (b_{k, 1}, \dots, b_{k, k})

$b_k=(b_{k,1},\dots,b_{k,k})$

k

$k$

सेट करें $b_{1,1} = a_1$
यदि तो और अन्यथा और । या तो मामले में हमेशा तुलनित्र के लिए (यानी गलत) होगा। $a_2 < a_1$ $b_2 = (a_2,a_1)$ $(c,d):= (2,1)$ $b_2 = (a_1,a_2)$ $(c,d):= (1,2)$ $a_d < a_c$ $0$
प्राप्त करने के लिए के लिए प्राप्त पहले। $b_{k}$ $k \geq 3$ $b_{k-1}$
बता दें कि और , यानी की सबसे कम शक्ति है जो से छोटी नहीं है । $l=\lceil log_2 k \rceil$ $k' = 2^l$ $k'$ $2$ $k$
आज्ञा दें । प्रत्येक लिए $i_0 = 0$ $j \in \{1,\dots,l\}$ $i_{j} = {\begin{cases} i_{j - 1} + 2^{l - j} & i_{j - 1} + 2^{l - j} > k - 1 \land a_{d} < a_{c} \\ i_{j - 1} & i_{j - 1} + 2^{l - j} > k - 1 \land \neg (a_{d} < a_{c}) \\ i_{j - 1} + 2^{l - j} & i_{j - 1} + 2^{l - j} \leq k - 1 \land b_{k - 1, i_{j - 1} + 2^{l - j}} < a_{k} \\ i_{j - 1} & i_{j - 1} + 2^{l - j} \leq k - 1 \land \neg (b_{k - 1, i_{j - 1} + 2^{l - j}} < a_{k}) \end{cases}$ $i_j = \begin{cases} i_{j-1} + 2^{l-j} & i_{j-1} + 2^{l-j} > k-1 \wedge a_d < a_c\\ i_{j-1} & i_{j-1} + 2^{l-j} > k-1 \wedge \neg (a_d < a_c)\\ i_{j-1} + 2^{l-j} & i_{j-1} + 2^{l-j} \leq k-1 \wedge b_{k-1,i_{j-1} + 2^{l-j}} < a_k \\ i_{j-1} & i_{j-1} + 2^{l-j} \leq k-1 \wedge \neg(b_{k-1,i_{j-1} + 2^{l-j}} < a_k) \\ \end{cases}$
यदि रिपीट (5.) और $i_l > k$ $b_k=(b_{k-1,1},\dots,b_{k-1,i_l -1},a_k,b_{k-1,i_l},\dots,b_{k-1,k-1})$
आउटपुट $b_n$

यादृच्छिक मामले: 5 + यदि 6 का खंड अनिवार्य रूप से स्वीकृति-अस्वीकृति नमूना है। एल्गोरिथ्म के बाकी एक भोला-भाला है: पहले तत्वों को फेरबदल करें और प्रत्येक स्थिति में तत्व को समान संभावना के साथ जोड़ें । यदि हम सामान्य सम्मिलन प्रकार का उपयोग करते हैं, तो हमें इसके बजाय एक द्विपद वितरण मिलेगा। $k-1$ $k$

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

— frafl
स्रोत

@ जो आप अपने सभी बिंदुओं को अभी भी वर्तमान आकार में पोस्ट के लिए एक टिप्पणी में डाल सकते हैं और बाकी को हटा सकते हैं?

— फ्राफ्ल

मैं एक ऐसे एल्गोरिथ्म की उम्मीद कर रहा था जो अलग-अलग चरणों को नहीं करता है जिसके आधार पर तुलनित्र का उपयोग किया जाता है। आप तुलनित्र की जांच के बिना एक अनंत अस्वीकृति-लूप से बच सकते हैं? मुझे लगता है कि आप ... कदम (3) प्रदर्शन से अस्वीकृति से बचने के सकता है पहला

— जो

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

i

$i$

— जो

पहली टिप्पणी: ध्यान दें कि मैं उस पहले नमूने को फेंक नहीं देता, यह "दोहरी उपयोग" है। मैंने हर 2 बिट में इन्वर्ट करने के बारे में सोचा, लेकिन यह अंतहीन लूप को नहीं रोकेगा। वास्तव में कुछ अनियमित पैटर्न की आवश्यकता है और यहां तक कि बहुत अधिक प्रविष्टियों को अस्वीकार कर सकते हैं। बेशक मैं पहले और सबसे हालिया के बजाय दो सबसे हालिया बिट्स XOR कर सकता था, लेकिन यह वास्तव में अलग नहीं है।

— फ्राफेल

दूसरी टिप्पणी: आदेश (1) बनाम (3) केवल महत्वपूर्ण है यदि आप चरण (2) का उपयोग करते हैं, क्योंकि यादृच्छिक मामले में आपको आश्वस्त करना होगा कि फेरबदल संभावना 1 के साथ किया जाता है अन्यथा वर्दी वितरण का उल्लंघन होगा। इस पर निर्भर क्यों होना चाहिए ? इस स्थिति में हमेशा उत्तर देगा , जिसकी हमें आवश्यकता है।

i

$i$

a_{n} < a_{1}

$a_n < a_1$

0

$0$

— फ्राफेल

नहीं, यह असंभव है जब तक कि । संभावना है कि एक यादृच्छिक तुलनित्र का उपयोग करके आपके एल्गोरिथ्म द्वारा एक क्रमपरिवर्तन उत्पन्न किया जाता है, वह है फॉर्म , अर्थात , संभावना होनी चाहिए। जब , लिखने का कोई तरीका नहीं हैके रूप में । $n \leq 2$ $A/2^B$ $1/n!$ $n > 2$ $1/n!$ $A/2^B$

— युवल फिल्मस
स्रोत

लेकिन यह केवल धारण करता है, अगर हमें रनटाइम पर एक नियतात्मक बाध्यता की आवश्यकता होती है, जो प्रश्न में नहीं किया गया था। यदि हमें केवल परिमित होने के लिए अपेक्षित रनटाइम की आवश्यकता है, तो यह कोई समस्या नहीं होनी चाहिए।

— फ्राफ्ल

क्या आप किसी भी उचित छँटाई एल्गोरिथ्म के बारे में जानते हैं जो बहुपद समय में समाप्त नहीं होता है?

— युवल फिल्मस

आप निर्धारक और यादृच्छिक मामले को मिलाते हैं। एल्गोरिथ्म नियतात्मक बहुपद समय में समाप्त हो सकता है यदि एक नियतात्मक आदेश संबंध के साथ और अपेक्षित बहुपद समय में कहा जाता है यदि एक सिक्का के साथ तुलनित्र के रूप में कहा जाता है।

— फ्राफ्ल

@YuvalFilmus निर्णय वृक्ष के पास पत्ते क्यों होते हैं?

2^{k}

$2^k$

— जो

यदि आप कर रहे हैं

k

$k$ कुल में तुलना करें, तो किसी भी घटना की संभावना फॉर्म की होने वाली है

A / 2^{k}

$A/2^k$ । यह पत्तियों की संख्या के बारे में नहीं है। एकमात्र तरीका यह है कि जैसा कि पता चलता है, तुलनाओं की एक बिना संख्या वाली संख्या होती है।

— युवल फिल्मस २२'१३