5

ternary search एल्गोरिथ्म न्यूनतम या unimodal function की अधिकतम एक समारोह है कि या तो बढ़ जाती है और उसके बाद कम हो जाती है या कम हो जाती है और उसके बाद बढ़ जाती है को खोजने के लिए एक तेजी से एल्गोरिथ्म है। मान लें कि हम एक ऐसे फ़ंक्शन से निपट रहे हैं जो घटता है, फिर बढ़ता है, और हम न्यूनतम मान खोजना चाहते हैं। टर्नरी सर्च निम्नलिखित रिकर्सन का उपयोग करके काम करता है:क्या इस संबंधित एल्गोरिदम से टर्नरी खोज कम कुशल है?

  • यदि खिड़की का आकार "छोटा छोटा" है, तो बस अपना मध्यबिंदु वापस कर दें।
  • अन्यथा:
    • छोड़ दिया और सही सीमा पर कार्यप्रणाली का मूल्यांकन; मूल्य एल और आर कॉल करें।
    • 1/3 और 2/3 अंक पर फ़ंक्शन का मूल्यांकन करें; फोन मूल्यों हूँ और मीटर मीटर < मीटर , तो हम समारोह के बढ़ते क्षेत्र में कर रहे हैं और कम से कम मीटर और आर के बीच नहीं किया जा सकता 2
    • हैं ।
    • मीटर > मीटर , तो हम समारोह के घटते क्षेत्र में हैं, तो कम से कम मैं और मीटर के बीच नहीं किया जा सकता कर सकते हैं
    • रिकर्सिवली खोज 2/3 कि नहीं थे ' टी त्याग दिया।

इस एल्गोरिथ्म जल्दी से काम करता है, क्योंकि यह प्रत्येक यात्रा पर मूल्यों का 1/3 बाहर घालना रख सकते हैं।

हालांकि, मुझे लगता है कि मुझे कुछ याद आ रहा है क्योंकि मुझे विश्वास है कि हम इस एल्गोरिदम को बहुत तेजी से चला सकते हैं। विशेष रूप से, ध्यान दें कि हम हमेशा एक सीमा और जांच बिंदुओं के बीच सीमा के तीसरे भाग में से एक को फेंक रहे हैं। इसका मतलब है कि हम जांच बिंदु और दूसरी सीमा के बीच क्षेत्र को बनाए रखते हैं। चूंकि टर्नरी खोज 1/3 अंक पर जांच बिंदु चुनती है, इसका मतलब है कि हम प्रत्येक बिंदु पर मानों के 2/3 बनाए रखते हैं। क्या होगा यदि 1/3 और 2/3 अंक पर जांच करने की बजाय, हमने 1/2 - और ईपीएसलॉन पर जांच की; और 1/2 + और ईपीएसलॉन; एक बेहद छोटे और ईपीएसलॉन के लिए अंक ;? इसका मतलब यह होगा कि हम 1/2 - और ईपीएसलॉन फेंक देंगे; प्रत्येक चरण पर सीमा का, जिसका मतलब है कि सीमा का आकार बहुत तेज़ हो जाएगा, अगर हम हर बार तत्वों के 1/3 को फेंक रहे थे।

उदाहरण के तौर पर, यदि मैं चुनता हूं और ईपीएसलॉन करता हूं; = 1/1000, हम प्रत्येक पुनरावृत्ति पर खोजने के लिए 999/2000 रेंज को टॉस आउट करते हैं। पुनरावृत्तियों की कुछ संख्या के बाद शेष अंश यहाँ दिखाया गया है (त्रिगुट खोज बाईं तरफ है, मेरे एल्गोरिथ्म सही पर है :)

1 :    1.0 >=    1.0 
2 :  0.666666666667 >=    0.5005 
3 :  0.444444444444 >=   0.25050025 
4 :  0.296296296296 >=  0.125375375125 
5 :  0.197530864198 >= 0.0627503752501 
6 :  0.131687242798 >= 0.0314065628127 
7 : 0.0877914951989 >= 0.0157189846877 
8 : 0.0585276634659 >= 0.00786735183621 
9 : 0.0390184423106 >= 0.00393760959402 
10 : 0.0260122948737 >= 0.00197077360181 
11 : 0.0173415299158 >= 0.000986372187705 
12 : 0.0115610199439 >= 0.000493679279947 
13 : 0.00770734662926 >= 0.000247086479613 
14 : 0.00513823108617 >= 0.00
15 : 0.00342548739078 >= 6.18952249147e-05 
16 : 0.00228365826052 >= 3.09785600698e-05 
17 : 0.00152243884035 >= 1.55047693149e-05 
18 : 0.00101495922690 >= 7.76013704213e-06 
19 : 0.000676639484599 >= 3.88394858959e-06 

एल्गोरिथ्म के इस संशोधित संस्करण है सिर्फ "बेहतर" मूल संस्करण की तुलना में? या क्या मैं यहां कुछ खो रहा हूं जिसका मतलब यह होगा कि मुझे जांच बिंदु चुनने के लिए संशोधित रणनीति का उपयोग नहीं करना चाहिए?

उत्तर

3

यह संस्करण निश्चित रूप से तेज़ी से एकत्रित होगा, लेकिन हो सकता है कि फ़्लोटिंग-पॉइंट परिशुद्धता के मुद्दों के लिए अधिक प्रवण हो। उदाहरण के लिए, यदि आप m + eps = m प्राप्त करते हैं तो क्या होगा? यह एक वास्तविक संभावना है अगर एम बड़ा है, तो कहें। तो अभिसरण की सटीकता और दर के बीच एक व्यापार है।इस वर्ग का सबसे अच्छा एल्गोरिदम तर्कसंगत रूप से Golden Section Search है, जो तेज़ और सटीक दोनों है।

+1

मेरी समझ से, सुनहरा अनुभाग खोज का लाभ यह है समारोह का मूल्यांकन करता है कम बार क्योंकि यह, पुनरावृत्तियों भर में जांच का पुन: उपयोग नहीं कर सकते हैं क्योंकि यह अधिक संख्यानुसार स्थिर है। क्या मैं इसके बारे में गलत हूं? – templatetypedef

+0

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

1

एक समारोह unimodal, ग्राम (y) = एफ (y + ε) की तुलना में कम है - एफ (y) शून्य पार करती है केवल एक बार, जब सही सीमा बाएं से y बढ़ रही है।

असल में, क्या आप अपने दूसरे/बेहतर एल्गोरिथ्म में प्रस्ताव जी (y) की शून्य को पार (रूट) के लिए एक द्विआधारी खोज है। मान लें कि आप कम से कम कर रहे हैं, इसलिए एफ (वाई) में न्यूनतम न्यूनतम है। फिर जी (वाई) थोड़ी देर के लिए नकारात्मक है, और फिर सकारात्मक है। इस प्रकार, यदि जी (x) < 0, तो रूट x (या अधिक सटीक: x + ε) से बड़ा है, और यदि जी (x)> 0 है, तो रूट x से छोटा है।

इसका कारण यह है क्षेत्र में, जहां कम से कम स्थित है हर कदम को आधा कर दिया जाता है, बजाय के 2/3 से गुणा, अपने पहले/मूल एल्गोरिथ्म की तुलना में तेजी (सबसे खराब स्थिति) है।

+0

वास्तव में, वास्तव में अंतर्ज्ञान मेरे पास इस एल्गोरिदम के साथ आने पर था और वास्तव में मैं टर्नरी खोज से इतनी उलझन में क्यों हूं। :-) – templatetypedef

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