प्राइम्स और दिज्क्स्ट्रा के एल्गोरिदम के बीच अंतर?

Question 1

दिजाकस्ट्रा और प्राइम के एल्गोरिदम के बीच सटीक अंतर क्या है? मुझे पता है कि प्राइम एक एमएसटी देगा, लेकिन दिजाक्षर द्वारा उत्पन्न पेड़ भी एमएसटी होगा। फिर सटीक अंतर क्या है?

Question 2

प्राइम का एल्गोरिथ्म ग्राफ के लिए एक न्यूनतम फैले हुए पेड़ का निर्माण करता है , जो कि एक ऐसा पेड़ है जो ग्राफ के सभी नोड्स को जोड़ता है और सभी नोड्स को जोड़ने वाले सभी पेड़ों के बीच कम से कम कुल लागत है। हालाँकि, MST में किन्हीं दो नोड्स के बीच एक पथ की लंबाई मूल ग्राफ़ में उन दो नोड्स के बीच सबसे छोटा रास्ता नहीं हो सकता है। उदाहरण के लिए, एमएसटी उपयोगी होते हैं, यदि आप कम से कम कुल लागत पर उन्हें बिजली प्रदान करने के लिए ग्राफ में नोड्स को भौतिक रूप से तार करना चाहते थे। इससे कोई फर्क नहीं पड़ता है कि दो नोड्स के बीच की पथ लंबाई इष्टतम नहीं हो सकती है, क्योंकि आप सभी के बारे में परवाह करते हैं कि वे जुड़े हुए हैं।

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

एक अन्य महत्वपूर्ण अंतर यह बताता है कि एल्गोरिदम किस प्रकार के ग्राफ़ पर काम करता है। प्राइम का एल्गोरिथ्म अप्रत्यक्ष ग्राफ़ पर ही काम करता है, क्योंकि MST की अवधारणा मानती है कि ग्राफ़ स्वाभाविक रूप से अप्रत्यक्ष हैं। (निर्देशित ग्राफ़ के लिए "न्यूनतम फैले हुए arborescence" नामक कुछ है, लेकिन उन्हें खोजने के लिए एल्गोरिदम बहुत अधिक जटिल हैं)। डायजेक्स्ट्रा का एल्गोरिदम निर्देशित ग्राफ़ पर ठीक काम करेगा, क्योंकि कम से कम पथ के पेड़ वास्तव में निर्देशित हो सकते हैं। इसके अतिरिक्त, डायजेक्स्ट्रा का एल्गोरिथ्म जरूरी नहीं कि नकारात्मक बढ़त भार वाले रेखांकन में सही समाधान प्राप्त करे , जबकि प्राइमर का एल्गोरिथ्म इसे संभाल सकता है।

उम्मीद है की यह मदद करेगा!

Question 3

डीजकस्ट्रा का एल्गोरिथ्म एक एमएसटी नहीं बनाता है, यह सबसे छोटा रास्ता खोजता है।

इस ग्राफ पर विचार करें

       5     5
  s *-----*-----* t
     \         /
       -------
         9

सबसे छोटा रास्ता 9 है, जबकि MST 10 पर एक अलग 'रास्ता' है।

Question 4

"आराम फ़ंक्शन" को छोड़कर, प्राइम और डीजकस्ट्रा एल्गोरिदम लगभग समान हैं।

रस्मी:

MST-PRIM (G, w, r) {
    for each key ∈ G.V
        u.key = ∞
        u.parent = NIL
    r.key = 0
    Q = G.V

    while (Q ≠ ø)
        u = Extract-Min(Q)
        for each v ∈ G.Adj[u]
            if (v ∈ Q)
                alt = w(u,v)    <== relax function, Pay attention here
                if alt < v.key
                    v.parent = u
                    v.key = alt
}

डिज्कस्ट्रा:

Dijkstra (G, w, r) {
    for each key ∈ G.V
        u.key = ∞
        u.parent = NIL
    r.key = 0
    Q = G.V

    while (Q ≠ ø)
        u = Extract-Min(Q)
        for each v ∈ G.Adj[u]
            if (v ∈ Q)
                alt = w(u,v) + u.key  <== relax function, Pay attention here
                if alt < v.key
                    v.parent = u
                    v.key = alt
}

एकमात्र अंतर तीर द्वारा इंगित किया गया है, जो कि आराम समारोह है।

प्राइम, जो न्यूनतम फैले हुए पेड़ की खोज करता है, केवल कुल किनारों के न्यूनतम के बारे में परवाह करता है सभी कोने को कवर करता है। आराम समारोह हैalt = w(u,v)
दिज्क्स्त्र, जो न्यूनतम पथ लंबाई की खोज करता है, इसलिए यह किनारे के संचय की परवाह करता है। आराम समारोह हैalt = w(u,v) + u.key

Question 5

डेज्स्ट्रेट का एल्गोरिदम नोड I से सभी नोड्स (आप निर्दिष्ट i) के लिए न्यूनतम दूरी पाता है । तो बदले में आपको नोड i से न्यूनतम दूरी का पेड़ मिलता है।

प्राइम्स एल्गोरिथ्म आपको दिए गए ग्राफ़ के लिए न्यूनतम फैले हुए पेड़ मिलता है । एक पेड़ जो सभी नोड्स को जोड़ता है जबकि सभी लागतों का योग न्यूनतम संभव है।

तो दिक्जस्त्र के साथ आप चयनित नोड से न्यूनतम लागत के साथ किसी अन्य पर जा सकते हैं , यह आपको प्राइम के साथ नहीं मिलता है

Question 6

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

दिज्क्स्त्र आपको स्रोत नोड से गंतव्य नोड तक का रास्ता देता है ताकि लागत न्यूनतम हो। हालाँकि प्राइम का एल्गोरिथ्म आपको एक न्यूनतम फैले हुए पेड़ देता है जैसे कि सभी नोड्स जुड़े हुए हैं और कुल लागत न्यूनतम है।

सरल शब्दों में:

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

Question 7

दोनों को बिल्कुल सामान्य जेनेरिक एल्गोरिथ्म का उपयोग करके लागू किया जा सकता है:

Inputs:
  G: Graph
  s: Starting vertex (any for Prim, source for Dijkstra)
  f: a function that takes vertices u and v, returns a number

Generic(G, s, f)
    Q = Enqueue all V with key = infinity, parent = null
    s.key = 0
    While Q is not empty
        u = dequeue Q
        For each v in adj(u)
            if v is in Q and v.key > f(u,v)
                v.key = f(u,v)
                v.parent = u

प्राइम के लिए, पास f = w(u, v)और दिज्क्स्ट्रा के लिए f = u.key + w(u, v)।

एक और दिलचस्प बात यह है कि ऊपर जेनेरिक भी चौड़ाई पहली खोज (बीएफएस) को लागू कर सकते हैं, हालांकि यह ओवरकिल होगा क्योंकि महंगी प्राथमिकता कतार वास्तव में आवश्यक नहीं है। जेएफएस में जेनेरिक अल्गोरिदम से ऊपर जाने के लिए, f = u.key + 1जो 1 से सभी भार को लागू करने के समान है (यानी बीएफएस बिंदु ए से बी तक पार करने के लिए आवश्यक किनारों की न्यूनतम संख्या देता है)।

सहज बोध

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

इस विचार को लागू करने के लिए एक क्रूर बल तरीका ए में कोने के लिए किनारों की एक प्राथमिकता कतार को बनाए रखना होगा जो कि बी को पार करता है। जाहिर है कि ग्राफ विरल नहीं था तो परेशानी होगी। तो सवाल यह होगा कि क्या हम वर्टीकल की प्राथमिकता कतार बनाए रख सकते हैं? यह वास्तव में हम अपने निर्णय के रूप में हो सकता है जो बी से लेने के लिए शीर्ष पर है।

ऐतिहासिक संदर्भ

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

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

इन सभी से स्वतंत्र, 1956 में एक संस्थान द्वारा विकसित एक नए कंप्यूटर की क्षमताओं को प्रदर्शित करने के लिए एक कार्यक्रम को लिखने के लिए डीजकस्ट्रा की आवश्यकता थी। उसने सोचा कि नीदरलैंड के दो शहरों के बीच यात्रा करने के लिए कंप्यूटर के कनेक्शन के लिए यह अच्छा होगा। उन्होंने एल्गोरिथ्म को 20 मिनट में डिज़ाइन किया। उन्होंने कुछ सरलीकरणों के साथ 64 शहरों का एक ग्राफ बनाया (क्योंकि उनका कंप्यूटर 6-बिट था) और इस 1956 के कंप्यूटर के लिए कोड लिखा था। हालाँकि उन्होंने अपना एल्गोरिथ्म प्रकाशित नहीं किया क्योंकि मुख्य रूप से कोई कंप्यूटर विज्ञान पत्रिका नहीं थी और उन्हें लगा कि यह बहुत महत्वपूर्ण नहीं हो सकता है। अगले वर्ष उन्होंने नए कंप्यूटरों के टर्मिनलों को जोड़ने की समस्या के बारे में सीखा, जैसे कि तारों की लंबाई कम से कम। उन्होंने इस समस्या के बारे में सोचा और Jarník / Prim की खोज की। एस एल्गोरिथ्म जो फिर से एक ही तकनीक का उपयोग करता है सबसे छोटा पथ एल्गोरिथम जो उसने एक साल पहले खोजा था। वहउल्लेख किया है कि उनके दोनों एल्गोरिदम कलम या कागज का उपयोग किए बिना डिजाइन किए गए थे। 1959 में उन्होंने दोनों एल्गोरिदम को एक पेपर में प्रकाशित किया जो सिर्फ ढाई पेज लंबा है।

Question 8

Dijkstra नोड और हर दूसरे नोड के बीच सबसे छोटा रास्ता खोजता है। तो बदले में आपको शुरुआती नोड से न्यूनतम दूरी का पेड़ मिलता है यानी आप हर दूसरे नोड तक कुशलता से पहुंच सकते हैं।

प्राइम्स अल्गोरिद्म आपको दिए गए ग्राफ यानी एक पेड़ के लिए MST देता है जो सभी नोड्स को जोड़ता है जबकि सभी लागतों का योग न्यूनतम संभव है।

यथार्थवादी उदाहरण के साथ कहानी को छोटा बनाने के लिए:

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

Question 9

सीधे दिक्जस्ट्रा के एल्गोरिथम के विकिपीडिया लेख से:

दिक्क्स्ट्रा के एल्गोरिथ्म को रेखांकित करने वाली प्रक्रिया प्राइम के एल्गोरिथ्म में उपयोग की जाने वाली लालची प्रक्रिया के समान है। प्राइम का उद्देश्य न्यूनतम फैले हुए पेड़ को खोजना है जो ग्राफ में सभी नोड्स को जोड़ता है; दिज्क्स्त्र का संबंध केवल दो नोड्स से है। प्राइम्स शुरुआती नोड से पथ के कुल वजन का मूल्यांकन नहीं करता है, केवल व्यक्तिगत पथ।

Question 10

मैं हाल ही में एक ही सवाल से परेशान था, और मुझे लगता है कि मैं अपनी समझ साझा कर सकता हूं ...

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

यह कहा जा रहा है, दिज्क्स्ट्रा हमें "शॉर्टकट लेने" की अनुमति देता है, इसलिए मैं लंबे समय से एस से टी तक प्राप्त कर सकता हूं , परिणाम की चिंता किए बिना - एक बार जब मैं टी में हो जाता हूं, तो मुझे किया जाता है! हालाँकि MST में s से t तक का एक मार्ग भी है , लेकिन यह s - t पथ सभी शेष नोड्स के विचारों के साथ बनाया गया है, इसलिए, यह पथ डिजस्ट्रॉर्मा के एल्गोरिथ्म द्वारा पाए गए s - t पथ से अधिक लंबा हो सकता है। नीचे 3 नोड्स के साथ एक त्वरित उदाहरण दिया गया है:

                                  2       2  
                          (s) o ----- o ----- o (t)     
                              |               |
                              -----------------
                                      3

मान लें कि प्रत्येक ऊपरी किनारे की लागत 2 है, और नीचे के किनारे की लागत 3 है, तो डेज्क्त्र हमें नीचे के रास्ते पर ले जाने के लिए कहेगा, क्योंकि हम मध्य नोड के बारे में परवाह नहीं करते हैं। दूसरी ओर, प्राइम हमें शीर्ष 2 किनारों के साथ एक एमएसटी लौटाएगा, जो निचले किनारे को छोड़ देगा।

कार्यान्वयन में सूक्ष्म अंतर से भी ऐसा ही अंतर परिलक्षित होता है: दिज्क्स्ट्रा के एल्गोरिथ्म में, किसी को नया नोड अवशोषित करने के बाद, एस से सबसे छोटे पथ को अद्यतन करने के लिए एक कदम रखने के लिए एक पुस्तक रखने की आवश्यकता होती है , जबकि प्राइमर एल्गोरिथ्म में, ऐसी कोई जरूरत नहीं है।

Question 11

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

def dijkstra(g, s):
    q <- make_priority_queue(VERTEX.distance)
    for each vertex v in g.vertex:
        v.distance <- infinite
        v.predecessor ~> nil
        q.add(v)
    s.distance <- 0
    while not q.is_empty:
        u <- q.extract_min()
        for each adjacent vertex v of u:
            ...

def prim(g, s):
    q <- make_priority_queue(VERTEX.distance)
    for each vertex v in g.vertex:
        v.distance <- infinite
        v.predecessor ~> nil
        q.add(v)
    s.distance <- 0
    while not q.is_empty:
        u <- q.extract_min()
        for each adjacent vertex v of u:
            if v in q and weight(u, v) < v.distance:// <-------selection--------
            ...

Vertex.distance की गणना दूसरा अलग बिंदु है।

Question 12

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

यदि आप इन धारणाओं की जाँच करते हैं, तो कृपया देखें

लालची एल्गोरिथ्म व्याख्यान नोट: http://jeffe.cs.illipedia.edu/teaching/algorithms/notes/07-greedy.pdf
न्यूनतम फैले हुए पेड़: http://jeffe.cs.illipedia.edu/teaching/al एल्गोरिदम / नोट / 20- mst.pdf
एकल स्रोत सबसे छोटा रास्ता: http://jeffe.cs.illipedia.edu/teaching/algorithms/notes/21-sssp.pdf

Question 13

Dijkstras एल्गोरिथ्म का उपयोग केवल सबसे छोटा रास्ता खोजने के लिए किया जाता है।

में न्यूनतम स्पैनिंग ट्री (रस्मी या Kruskal एल्गोरिथ्म) आप कम से कम बढ़त मूल्य के साथ न्यूनतम egdes मिलता है।

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

जबकि किसी भी नोड्स को एक दूसरे से जोड़ने के दौरान "डायजक्रस्टस एल्गोरिथ्म" का उपयोग दो नोड्स के बीच सबसे छोटा रास्ता पाने के लिए किया जाएगा।

Question 14

सरलतम विवरण है प्राइम्स में आप आरंभिक नोड को निर्दिष्ट नहीं करते हैं , लेकिन डायजेस्क्रा में आपको (एक प्रारंभिक नोड होने की आवश्यकता है) दिए गए नोड से अन्य सभी नोड्स के लिए सबसे छोटा रास्ता खोजना होगा।

Question 15

@templatetypedef ने MST और सबसे छोटे रास्ते के बीच अंतर को कवर किया है। मैंने एल्गोरिथ्म अंतर को दूसरे में कवर किया है इसलिए यह प्रदर्शित करके कि दोनों को एक ही सामान्य एल्गोरिदम का उपयोग करके लागू किया जा सकता है जो इनपुट के रूप में एक और पैरामीटर लेता है: फ़ंक्शन f(u,v)। प्राइम और डीजकस्ट्रा के एल्गोरिथ्म के बीच का अंतर केवल वह है जो f(u,v)आप उपयोग करते हैं।

Question 16

कोड स्तर पर, अन्य अंतर एपीआई है।

आप प्राइम को एक सोर्स वर्टेक्स, एस , यानी Prim.new(s); s कोई भी शीर्ष हो सकता है, और s की परवाह किए बिना , अंतिम परिणाम, जो कि न्यूनतम फैले हुए पेड़ (MST) के किनारे समान हैं। एमएसटी किनारों को प्राप्त करने के लिए, हम विधि कहते हैं edges()।

आप एक स्रोत शिखर, साथ डिज्कस्ट्रा प्रारंभ रों , यानी, Dijkstra.new(s)कि आप अन्य सभी कोने करने के लिए कम से कम पथ / दूरी प्राप्त करना चाहते हैं। अंतिम परिणाम, जो s से अन्य सभी चक्करों के लिए सबसे छोटा रास्ता / दूरी हैं ; एस के आधार पर भिन्न होते हैं । से कम से कम पथ / दूरी प्राप्त करने के लिए रों किसी शीर्ष, के वी , हम तरीकों कॉल distanceTo(v)और pathTo(v)क्रमशः।