algorithm - एल्गोरिदम की समय जटिलता कैसे प्राप्त करें




time-complexity complexity-theory (9)

यहां से लिया गया - एक एल्गोरिदम की समय जटिलता का परिचय

1। परिचय

कंप्यूटर विज्ञान में, एल्गोरिदम की समय जटिलता इनपुट का प्रतिनिधित्व करने वाली स्ट्रिंग की लंबाई के फ़ंक्शन के रूप में चलाने के लिए एल्गोरिदम द्वारा उठाए गए समय की मात्रा को प्रमाणित करती है।

2. बिग ओ नोटेशन

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

उदाहरण के लिए, यदि आकार एन के सभी इनपुट पर एल्गोरिदम द्वारा आवश्यक समय अधिकतम 5 एन 3 + 3 एन पर है, तो एसिम्प्टोटिक समय जटिलता ओ (एन 3 ) है। उस पर और अधिक।

कुछ और उदाहरण:

  • 1 = ओ (एन)
  • एन = ओ (एन 2 )
  • लॉग (एन) = ओ (एन)
  • 2 एन + 1 = ओ (एन)

3. ओ (1) लगातार समय:

एक एल्गोरिदम को निरंतर समय में चलाने के लिए कहा जाता है यदि इनपुट आकार के बावजूद इसे एक ही समय की आवश्यकता होती है।

उदाहरण:

  • सरणी: किसी भी तत्व का उपयोग
  • निश्चित आकार का ढेर: पुश और पॉप विधियां
  • निश्चित आकार कतार: enqueue और dequeue विधियों

4. ओ (एन) रैखिक समय

एक एल्गोरिदम को रैखिक समय में चलाने के लिए कहा जाता है यदि इसका समय निष्पादन इनपुट आकार के लिए सीधे आनुपातिक होता है, यानी इनपुट आकार बढ़ने के साथ समय रेखा बढ़ता है।

निम्नलिखित उदाहरणों पर विचार करें, नीचे मैं एक तत्व की रैखिक रूप से खोज कर रहा हूं, इसमें ओ (एन) की समय जटिलता है।

int find = 66;
var numbers = new int[] { 33, 435, 36, 37, 43, 45, 66, 656, 2232 };
for (int i = 0; i < numbers.Length - 1; i++)
{
    if(find == numbers[i])
    {
        return;
    }
}

और ज्यादा उदाहरण:

  • ऐरे: रैखिक खोज, ट्रैवर्सिंग, न्यूनतम खोजें आदि
  • ArrayList: विधि शामिल है
  • कतार: विधि शामिल है

5. ओ (लॉग एन) लॉगरिदमिक समय:

एक एल्गोरिदम को लॉगरिदमिक समय में चलाने के लिए कहा जाता है यदि इसका समय निष्पादन इनपुट आकार के लॉगेरिथम के समान होता है।

उदाहरण: बाइनरी खोज

"बीस प्रश्न" खेल को याद करें - कार्य एक अंतराल में एक छिपे संख्या के मूल्य का अनुमान लगाना है। प्रत्येक बार जब आप अनुमान लगाते हैं, तो आपको बताया जाता है कि आपका अनुमान बहुत अधिक या बहुत कम है या नहीं। बीस प्रश्नों का खेल एक ऐसी रणनीति का तात्पर्य है जो अंतराल के आकार को कम करने के लिए आपके अनुमान संख्या का उपयोग करता है। यह बाइनरी खोज के रूप में जाने वाली सामान्य समस्या-समाधान विधि का एक उदाहरण है

6. ओ (एन 2) वर्गिक समय

एक एल्गोरिदम को चौकोर समय में चलाने के लिए कहा जाता है यदि इसका समय निष्पादन इनपुट आकार के वर्ग के समान होता है।

उदाहरण:

7. कुछ उपयोगी लिंक

प्रश्न

एल्गोरिदम की समय जटिलता कैसे प्राप्त करें?

एसओ पर एक प्रश्न पोस्ट करने से पहले मैंने क्या किया है?

मैं this और कई अन्य लिंक से गुजर चुका हूं

लेकिन समय जटिलता की गणना करने के लिए मैं स्पष्ट और सीधे आगे स्पष्टीकरण नहीं ढूंढ पाया।

मुझे क्या पता ?

नीचे दिए गए कोड के रूप में एक कोड के लिए कहें:

char h = 'y'; // This will be executed 1 time
int abc = 0; // This will be executed 1 time

नीचे दिए गए की तरह एक लूप के लिए कहें:

for (int i = 0; i < N; i++) {        
    Console.Write('Hello World !');
}

int i = 0; यह केवल एक बार निष्पादित किया जाएगा। समय वास्तव में i=0 गणना की जाती है और घोषणा नहीं होती है।

मैं <एन; इसे एन + 1 बार निष्पादित किया जाएगा

मैं ++; यह एन बार निष्पादित किया जाएगा

तो इस लूप द्वारा आवश्यक संचालन की संख्या हैं

{1+ (एन + 1) + एन} = 2 एन + 2

नोट: यह अभी भी गलत हो सकता है, क्योंकि मुझे समय जटिलता की गणना करने पर मेरी समझ के बारे में विश्वास नहीं है

मै क्या जानना चाहता हूँ ?

ठीक है, इसलिए मुझे लगता है कि ये छोटी बुनियादी गणना मुझे पता है, लेकिन ज्यादातर मामलों में मैंने समय जटिलता देखी है

ओ (एन), ओ (एन 2), ओ (लॉग एन), ओ (एन!) .... और कई other ,

क्या कोई मुझे समझने में मदद कर सकता है कि कोई एल्गोरिदम की समय जटिलता की गणना कैसे करता है? मुझे यकीन है कि मेरे जैसे बहुत सारे नए लोग इसे जानना चाहते हैं।


एल्गोरिदम की समय जटिलता कैसे प्राप्त करें

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

उदाहरण के लिए, देखते हैं कि हम 2N + 2 O(N) रूप में इसका वर्णन करने के लिए 2N + 2 मशीन निर्देशों को कैसे सरल बनाते हैं।

हम दो 2 एस क्यों हटाते हैं?

हम एल्गोरिदम के प्रदर्शन में रूचि रखते हैं क्योंकि एन बड़ा हो जाता है।

दो शर्तों 2 एन और 2 पर विचार करें।

इन दो शर्तों का सापेक्ष प्रभाव क्या है क्योंकि एन बड़ा हो जाता है? मान लीजिए एन एक लाख है।

फिर पहला शब्द 2 मिलियन है और दूसरा शब्द केवल 2 है।

इस कारण से, हम बड़े एन के लिए सबसे बड़ी शर्तों को छोड़कर सभी को छोड़ देते हैं।

तो, अब हम 2N + 2 से 2N + 2 तक चले गए हैं।

परंपरागत रूप से, हम केवल स्थिर कारकों तक प्रदर्शन में रूचि रखते हैं

इसका मतलब यह है कि जब हम बड़े होते हैं तो प्रदर्शन में अंतर के कुछ निरंतर एकाधिक होते हैं तो हम वास्तव में परवाह नहीं करते हैं। वैसे भी 2 एन की इकाई पहले स्थान पर अच्छी तरह से परिभाषित नहीं है। इसलिए हम सबसे सरल अभिव्यक्ति प्राप्त करने के लिए निरंतर कारक से गुणा या विभाजित कर सकते हैं।

तो 2N N सिर्फ N बन जाता है।


हालांकि इस सवाल के लिए कुछ अच्छे जवाब हैं। मैं loop कई उदाहरणों के साथ यहां एक और जवाब देना चाहता हूं।

  • ओ (एन) : लूप की समय जटिलता को ओ (एन) के रूप में माना जाता है यदि लूप वैरिएबल निरंतर मात्रा में वृद्धि / कमी हो जाती है। उदाहरण के लिए निम्नलिखित कार्यों में ओ (एन) समय जटिलता है।

    // Here c is a positive integer constant   
    for (int i = 1; i <= n; i += c) {  
        // some O(1) expressions
    }
    
    for (int i = n; i > 0; i -= c) {
        // some O(1) expressions
    }
    
  • ओ (एन ^ सी) : नेस्टेड लूप की समय जटिलता अंतर्निहित कथन निष्पादित होने की संख्या के बराबर होती है। उदाहरण के लिए निम्नलिखित नमूना loops ओ (एन ^ 2) समय जटिलता है

    for (int i = 1; i <=n; i += c) {
       for (int j = 1; j <=n; j += c) {
          // some O(1) expressions
       }
    }
    
    for (int i = n; i > 0; i += c) {
       for (int j = i+1; j <=n; j += c) {
          // some O(1) expressions
    }
    

    उदाहरण के लिए चयन क्रम और सम्मिलन क्रम में ओ (एन ^ 2) समय जटिलता है।

  • ओ (लॉगन) लूप की समय जटिलता को ओ (लॉगन) के रूप में माना जाता है यदि लूप चर को निरंतर राशि से विभाजित / गुणा किया जाता है।

    for (int i = 1; i <=n; i *= c) {
       // some O(1) expressions
    }
    for (int i = n; i > 0; i /= c) {
       // some O(1) expressions
    }
    

    उदाहरण के लिए बाइनरी सर्च में ओ (लॉगन) समय जटिलता है।

  • ओ (लॉगलोग्न) लूप की समय जटिलता को ओ (लॉगलोग्न) के रूप में माना जाता है यदि लूप वैरिएबल को निरंतर मात्रा में तेजी से बढ़ाया जाता है / बढ़ाया जाता है।

    // Here c is a constant greater than 1   
    for (int i = 2; i <=n; i = pow(i, c)) { 
       // some O(1) expressions
    }
    //Here fun is sqrt or cuberoot or any other constant root
    for (int i = n; i > 0; i = fun(i)) { 
       // some O(1) expressions
    }
    

समय जटिलता विश्लेषण का एक उदाहरण

int fun(int n)
{    
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j < n; j += i)
        {
            // Some O(1) task
        }
    }    
}

विश्लेषण :

For i = 1, the inner loop is executed n times. For i = 2, the inner loop is executed approximately n/2 times. For i = 3, the inner loop is executed approximately n/3 times. For i = 4, the inner loop is executed approximately n/4 times. ……………………………………………………. For i = n, the inner loop is executed approximately n/n times.

तो उपर्युक्त एल्गोरिदम की कुल समय जटिलता (n + n/2 + n/3 + … + n/n) , जो n * (1/1 + 1/2 + 1/3 + … + 1/n)

श्रृंखला के बारे में महत्वपूर्ण बात (1/1 + 1/2 + 1/3 + … + 1/n) ओ (लॉगन) के बराबर है। तो उपरोक्त कोड की समय जटिलता ओ (nLogn) है

रेफरी: 1 2 3


संक्षेप में बोलते हुए, समय जटिलता सारांश का एक तरीका है कि एल्गोरिदम के संचालन या रन-टाइम इनपुट आकार बढ़ने के साथ कैसे बढ़ता है।

जीवन में ज्यादातर चीजों की तरह, एक कॉकटेल पार्टी हमें समझने में मदद कर सकती है।

पर)

जब आप पार्टी में आते हैं, तो आपको हर किसी के हाथ को हिला देना पड़ता है (प्रत्येक आइटम पर एक ऑपरेशन करें)। चूंकि उपस्थित लोगों की संख्या बढ़ जाती है, समय / काम आपको O(N) रूप में हर किसी के हाथों को बढ़ाने के लिए ले जाएगा।

क्यों O(N) और cN नहीं?

लोगों के साथ हाथ हिलाते समय कितना समय लगता है इसमें भिन्नता है। आप इसे औसत कर सकते हैं और इसे निरंतर c में कैप्चर कर सकते हैं। लेकिन यहां मौलिक ऑपरेशन --- हर किसी के साथ हाथ मिलाकर --- हमेशा O(N) आनुपातिक होगा, इससे कोई फर्क नहीं पड़ता कि c क्या था। बहस करते समय कि हमें कॉकटेल पार्टी में जाना चाहिए, हम अक्सर इस तथ्य में अधिक रुचि रखते हैं कि हमें उन बैठकों के बारे में जानकारी के मिनटों के मुकाबले सभी को मिलना होगा।

हे (एन ^ 2)

कॉकटेल पार्टी का मेजबान चाहता है कि आप एक मूर्ख खेल खेलें जहां हर कोई हर किसी से मिल जाए। इसलिए, आपको N-1 अन्य लोगों से मिलना चाहिए और, क्योंकि अगला व्यक्ति पहले ही आपसे मिल चुका है, उन्हें N-2 लोगों से मिलना चाहिए, और इसी तरह। इस श्रृंखला का योग x^2/2+x/2 । चूंकि उपस्थित लोगों की संख्या बढ़ती है, इसलिए x^2 शब्द बड़ा तेज़ हो जाता है, इसलिए हम बाकी सब कुछ छोड़ देते हैं।

हे (एन ^ 3)

आपको हर किसी से मिलना है और, प्रत्येक मीटिंग के दौरान, आपको कमरे में हर किसी के बारे में बात करनी होगी।

हे (1)

मेजबान कुछ घोषणा करना चाहता है। वे एक वाइन ग्लास डिंग करते हैं और जोर से बोलते हैं। हर कोई उन्हें सुनता है। यह पता चला है कि इससे कोई फर्क नहीं पड़ता कि कितने उपस्थित लोग हैं, यह ऑपरेशन हमेशा एक ही समय लेता है।

हे (लॉग एन)

मेजबान ने तालिका में वर्णमाला क्रम में सभी को बाहर रखा है। दान कहाँ है? आप तर्क देते हैं कि वह आदम और मंडी के बीच कहीं होना चाहिए (निश्चित रूप से मंडी और जैच के बीच नहीं!)। यह देखते हुए, क्या वह जॉर्ज और मंडी के बीच है? नहीं। वह एडम और फ्रेड, और सिंडी और फ्रेड के बीच होना चाहिए। और इसी तरह ... हम आधा सेट और फिर उस सेट के आधा भाग देखकर दान का कुशलता से पता लगा सकते हैं। आखिरकार, हम ओ (लॉग_2 एन) व्यक्तियों को देखते हैं।

हे (एन लॉग एन)

आप उपरोक्त एल्गोरिदम का उपयोग कर तालिका में बैठे कहां मिल सकते हैं। यदि बड़ी संख्या में लोग टेबल पर आए, एक समय में, और यह सब किया, जो ओ (एन लॉग एन) समय लेगा। यह पता चलता है कि वस्तुओं की किसी भी संग्रह को तुलना करने के लिए कितना समय लगता है जब उनकी तुलना की जानी चाहिए।

सर्वश्रेष्ठ / सबसे खराब मामला

आप पार्टी में आते हैं और इनिगो को खोजने की ज़रूरत है - इसमें कितना समय लगेगा? यह तब पहुंचता है जब आप पहुंचते हैं। यदि हर कोई आपके आस-पास मिल रहा है तो आपने सबसे बुरी स्थिति को मारा है: इसमें O(N) समय लगेगा। हालांकि, अगर सब टेबल पर बैठे हैं, तो इसमें केवल O(log N) समय लगेगा। या हो सकता है कि आप मेजबान की वाइन ग्लास-चिल्लाने वाली शक्ति का लाभ उठा सकें और इसमें केवल O(1) समय लगेगा।

मेजबान मानना ​​अनुपलब्ध है, हम कह सकते हैं कि जब आप पहुंचते हैं तो पार्टी की स्थिति के आधार पर इनिगो-खोज एल्गोरिदम में O(log N) और ऊपरी-बाध्य O(N) निचली सीमा होती है।

अंतरिक्ष और संचार

एल्गोरिदम अंतरिक्ष या संचार का उपयोग करने के तरीके को समझने के लिए समान विचारों को लागू किया जा सकता है।

Knuth ने "द कॉम्प्लेक्सिटी ऑफ सॉन्ग" नामक पूर्व के बारे में एक अच्छा पेपर लिखा है।

प्रमेय 2: जटिलता ओ (1) के मनमाने ढंग से लंबे गीत मौजूद हैं।

सबूत: (केसी और सनशाइन बैंड के कारण)। गीत (15) द्वारा परिभाषित गीतों पर विचार करें, लेकिन साथ

V_k = 'That's the way,' U 'I like it, ' U
U   = 'uh huh,' 'uh huh'

सभी के लिए।


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

For i= 1 to n;
  j= 0;
while(j<=n);
  j=j+1;

यहां आंतरिक लूप के लिए निष्पादन की कुल संख्या एन + 1 है और बाहरी लूप के लिए निष्पादन की कुल संख्या एन (एन + 1) / 2 है, इसलिए पूरे एल्गोरिदम के लिए निष्पादन की कुल संख्या एन + 1 + एन (एन + 1/2) है ) = (एन ^ 2 + 3 एन) / 2। यहां एन ^ 2 हावी शब्द है इसलिए इस एल्गोरिदम के लिए समय जटिलता ओ (एन ^ 2) है


मुझे पता है कि यह सवाल एक रास्ता वापस चला गया है और यहां कुछ उत्कृष्ट उत्तर दिए गए हैं, फिर भी मैं गणितीय विचारधारा वाले लोगों के लिए एक और बिट साझा करना चाहता हूं जो इस पोस्ट में ठोकर खाएंगे। जटिलता का अध्ययन करते समय मास्टर प्रमेय जानना एक और उपयोगी बात है। मैंने इसे अन्य उत्तरों में उल्लिखित नहीं देखा।


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

सैद्धांतिक रूप से ऐसा करने के लिए, आपका दृष्टिकोण मेरे लिए सही लगता है: प्रोग्राम के माध्यम से चलें (हमेशा सबसे अधिक समय-जटिल पथ चुनना), अनिवार्य समय जोड़ें और सभी स्थिरांक / कारकों से छुटकारा पाएं। नेस्टेड लूप, कूदता इत्यादि यह काफी जटिल बना सकते हैं लेकिन मैं इसे हल करने के लिए चांदी की बुलेट के बारे में नहीं सोच सकता।

आप http://en.wikipedia.org/wiki/Big_O_notation में भी इंटरस्टेड हो सकते हैं, भले ही यह काफी गणितीय है।

मैंने अभी भी http://en.wikipedia.org/wiki/Analysis_of_algorithms पाया है


उदाहरण के साथ समय जटिलता

1 - मूल संचालन (अंकगणित, तुलना, सरणी के तत्वों का उपयोग, असाइनमेंट): चलने का समय हमेशा स्थिर रहता है ओ (1)

उदाहरण :

read(x)                               // O(1)
a = 10;                               // O(1)
a = 1.000.000.000.000.000.000         // O(1)

2 - यदि फिर और कथन: केवल दो या अधिक संभावित बयानों से अधिकतम चलने का समय लेना।

उदाहरण:

age = read(x)                               // (1+1) = 2
if age < 17 then begin                      // 1
      status = "Not allowed!";              // 1
end else begin
      status = "Welcome! Please come in";   // 1
      visitors = visitors + 1;              // 1+1 = 2
end;

तो, उपरोक्त छद्म कोड की जटिलता टी (एन) = 2 + 1 + अधिकतम (1, 1 + 2) = 6. है। इस प्रकार, इसका बड़ा ओह अभी भी निरंतर टी (एन) = ओ (1) है।

3 - लूपिंग (के लिए, जबकि, दोहराएं): इस कथन के लिए चलने का समय उस लूपिंग के अंदर संचालन की संख्या से गुणा करने वाली लूपिंग की संख्या है।

उदाहरण:

total = 0;                                  // 1
for i = 1 to n do begin                     // (1+1)*n = 2n
      total = total + i;                    // (1+1)*n = 2n
end;
writeln(total);                             // 1

तो, इसकी जटिलता टी (एन) = 1 + 4 एन + 1 = 4 एन + 2. है, इस प्रकार, टी (एन) = ओ (एन)।

4 - नेस्टेड लूप (लूपिंग के अंदर लूपिंग): चूंकि मुख्य लूपिंग के अंदर कम से कम एक लूपिंग है, इस कथन का चलने वाला समय O (n ^ 2) या O (n ^ 3) का उपयोग करता है।

उदाहरण:

for i = 1 to n do begin                     // (1+1)*n  = 2n
   for j = 1 to n do begin                  // (1+1)n*n = 2n^2
       x = x + 1;                           // (1+1)n*n = 2n^2
       print(x);                            // (n*n)    = n^2
   end;
end;

सामान्य चलने का समय

एल्गोरिदम का विश्लेषण करते समय कुछ सामान्य चलने वाले समय होते हैं:

  1. ओ (1) - निरंतर समय निरंतर समय का मतलब है कि चलने का समय स्थिर है, यह इनपुट आकार से प्रभावित नहीं है

  2. ओ (एन) - रैखिक समय जब एक एल्गोरिदम एन इनपुट आकार स्वीकार करता है, तो यह एन संचालन भी करेगा।

  3. ओ (लॉग एन) - लॉगरिदमिक टाइम एल्गोरिदम जिसमें चलने वाला समय ओ (लॉग एन) ओ (एन) से थोड़ा तेज है। आम तौर पर, एल्गोरिदम समस्या को उसी आकार के साथ उप समस्याओं में विभाजित करता है। उदाहरण: बाइनरी खोज एल्गोरिदम, बाइनरी रूपांतरण एल्गोरिदम।

  4. ओ (एन लॉग एन) - लिनियरिदमिक टाइम यह चलने वाला समय अक्सर "एल्गोरिदम को विभाजित और जीतने" में पाया जाता है जो समस्या को उप-समस्याओं में दोबारा विभाजित करता है और फिर उन्हें समय में विलय करता है। उदाहरण: क्रमबद्ध एल्गोरिदम मर्ज करें।

  5. ओ (एन 2 ) - क्वाड्रैटिक टाइम लुक बबल सॉर्ट एल्गोरिदम!

  6. ओ (एन 3 ) - घन समय यह ओ (एन 2 ) के साथ एक ही सिद्धांत है।

  7. ओ (2 एन ) - घातीय समय यह बहुत धीमा है क्योंकि इनपुट बड़ा हो जाता है, अगर एन = 1000.000, टी (एन) 21000.000 होगा। ब्रूट फोर्स एल्गोरिदम में यह चलने का समय है।

  8. हे (एन!) - सख्त फैक्टोरियल टाइम !!! उदाहरण: ट्रैवल सेल्समैन समस्या (टीएसपी)

इस लेख से लिया गया। बहुत अच्छी तरह से समझाया जाना चाहिए पढ़ना चाहिए।


कृपया ज़ेनडेक कलाल के शिकारी ट्रैकर पर एक नज़र डालें। इसके लिए कुछ प्रशिक्षण की आवश्यकता है, लेकिन यह सक्रिय रूप से सीख सकता है कि ट्रैक ऑब्जेक्ट अलग-अलग उन्मुखताओं और तराजू को कैसे देखता है और इसे रीयलटाइम में करता है!

स्रोत कोड उनकी साइट पर उपलब्ध है। यह MATLAB , लेकिन शायद एक समुदाय के सदस्य द्वारा पहले से ही जावा कार्यान्वयन किया गया है। मैंने सी # में टीएलडी के ट्रैकर हिस्से को सफलतापूर्वक दोबारा लागू किया है। अगर मुझे सही याद है, तो टीएलडी फर्नेस को मुख्य बिंदु डिटेक्टर के रूप में उपयोग कर रहा है। अगर ऑब्जेक्ट को पुनः प्राप्त करने के लिए ट्रैकर द्वारा खोया गया था तो मैं इसके बजाय या तो SURF या SIFT का उपयोग करता हूं (पहले से ही @stacker द्वारा सुझाया गया है)। ट्रैकर की फीडबैक समय के साथ सिफ्ट / सर्फ टेम्पलेट्स की एक गतिशील सूची बनाने में आसान बनाता है, जिसमें समय बहुत उच्च परिशुद्धता वाले ऑब्जेक्ट को पुनः प्राप्त करने में सक्षम बनाता है।

यदि आप ट्रैकर के मेरे सी # कार्यान्वयन में रूचि रखते हैं, तो बेझिझक पूछें।





algorithm time-complexity complexity-theory