Computer >> कंप्यूटर >  >> प्रोग्रामिंग >> प्रोग्रामिंग

निकटता सूची प्रतिनिधित्व के लिए प्राइम का एमएसटी


यह पिछले एल्गोरिथम के समान है। यहाँ केवल अंतर है, ग्राफ G(V, E) को एक आसन्न सूची द्वारा दर्शाया जाता है।

समय जटिलता आसन्नता सूची प्रतिनिधित्व ओ (ई लॉग वी) है।

इनपुट और आउटपुट

<पूर्व>इनपुट:लागत मैट्रिक्स:निकटता सूची प्रतिनिधित्व के लिए प्राइम का एमएसटी आउटपुट:एज:A--B और लागत:1Edge:B--E और लागत:2Edge:A --C और लागत:3Edge:A--D और लागत:4Edge:E--F और लागत:2Edge:F--G और लागत:3कुल लागत:15

एल्गोरिदम

प्राइम्स(g:ग्राफ़, स्टार्ट)

इनपुट - ग्राफ़ g और बीज शीर्ष को 'प्रारंभ' नाम दिया गया है

आउटपुट - किनारों को जोड़ने के बाद पेड़।

दो सेट बी बनाना शुरू करें, एन बी सेट में स्टार्ट नोड जोड़ें। ग्राफ़ g में सभी शीर्षों के लिए u को सेट N में जोड़ें जबकि B ≠ N न्यूनतम करें:=ग्राफ़ g में सभी शीर्षों के लिए u यदि u सेट B में है तो सभी शीर्षों के लिए v जो u से सटे हुए हैं अगर वी अंदर है (एन - बी) तो अगर न्यूनतम> यूवी एज की लागत तो न्यूनतम:=यूवी एज पैरेंट की लागत:=यू नोड:=वी किया गया बी सेट में नोड डालें, पैरेंट से नोड तक किनारे को जोड़ें ट्री कर दिया ट्री को वापस कर देता हैअंत

उदाहरण

#शामिल करें#शामिल करें int लागत;}नोड;वर्ग ग्राफ़ { int n; सूची <नोड> * adjList; निजी:शून्य शोलिस्ट (इंट स्रोत, सूची <नोड> लेफ्टिनेंट) {सूची <नोड> ::पुनरावर्तक i; नोड टेम्पनोड; for(i =lt.begin(); i!=lt.end(); i++) {tempNode =*i; cout <<"(" < [एन]; } शून्य ऐडएज (इंट सोर्स, इंट डेस्ट, इंट कॉस्ट) {नोड न्यूनोड; newNode.dest =नियति; newNode.cost =लागत; adjList [स्रोत]। पुश_बैक (नया नोड); } शून्य डिस्प्लेएज () {के लिए (int i =0; i tempList =adjList[i]; शोलिस्ट (मैं, अस्थायी सूची); } } दोस्त ग्राफ प्राइम्सएमएसटी (ग्राफ जी, इंट स्टार्ट);}; सेट  अंतर (सेट  पहले, सेट  दूसरा) {सेट  ::iterator it; सेट  रेस; for(it =first.begin(); it!=first.end(); it++) { if(second.find(*it) ==second.end ()) res.insert(*it); // उन वस्तुओं को जोड़ें जो दूसरी सूची में नहीं हैं} वापसी रेस; // सेट (प्रथम-सेकंड)}ग्राफ प्राइम्सएमएसटी (ग्राफ जी, इंट स्टार्ट) {इंट एन =जीएन; सेट बी, एन, अंतर; ग्राफ ट्री (एन); // ग्राफ B.insert (प्रारंभ) के समान नोड के साथ पेड़ बनाएं; // बी सेट में प्रारंभ नोड डालें (int u =0; u ::iterator it; for(it =g.adjList[u].begin(); it !=g.adjList[u].end(); it++) { if(diff.find(it->dest) !=diff.end() ) {अगर (मिनट> यह-> लागत) {मिनट =यह-> लागत; // अद्यतन लागत बराबर =यू; वी =यह-> गंतव्य; } } } } } B.insert(v); tree.addEdge (बराबर, वी, मिनट); tree.addEdge(v, par, min); } रिटर्न ट्री;} मुख्य () {ग्राफ जी (7), ट्री (7); g.addEdge(0, 1, 1); g.addEdge(0, 2, 3); g.addEdge(0, 3, 4); g.addEdge(0, 5, 5); g.addEdge(1, 0, 1); g.addEdge(1, 3, 7); g.addEdge(1, 4, 2); g.addEdge(2, 0, 3); g.addEdge(2, 4, 8); g.addEdge(3, 0, 4); g.addEdge(3, 1, 7); g.addEdge(4, 1, 2); g.addEdge(4, 2, 8); g.addEdge(4, 5, 2); g.addEdge(4, 6, 4); g.addEdge(5, 0, 5); g.addEdge(5, 4, 2); g.addEdge(5, 6, 3); g.addEdge(6, 4, 4); g.addEdge(6, 5, 3); पेड़ =प्राइम्सएमएसटी (जी, 0); tree.displayEdges();}

आउटपुट

एज:ए--बी और लागत:1एज:बी--ई और लागत:2एज:ए--सी और लागत:3एज:ए--डी और लागत:4एज:ई--एफ और लागत:2एज:एफ--जी और लागत:3कुल लागत:15

  1. आर्मस्ट्रांग नंबरों के लिए सी प्रोग्राम

    हमें एक टास्क दिया जाता है जहां हमें उपयोगकर्ता द्वारा दर्ज किए गए नंबर n की जांच करनी होती है, चाहे वह आर्मस्ट्रांग हो या नहीं। एक आर्मस्ट्रांग संख्या तब होती है जब अंकों की संख्या से सभी अंकों की शक्ति का योग होता है या हम कह सकते हैं कि अंकों का क्रम अंक के समान है। तो आर्मस्ट्रांग नंबर कैसे पत

  1. सी++ प्रोग्राम एडजेंसी लिस्ट को लागू करने के लिए

    एक ग्राफ की आसन्न सूची प्रतिनिधित्व लिंक्ड सूची प्रतिनिधित्व है। इस निरूपण में हमारे पास सूचियों की एक सरणी है सरणी का आकार V है। यहाँ V शीर्षों की संख्या है। दूसरे शब्दों में, हम कह सकते हैं कि हमारे पास विभिन्न सूचियों के V नंबर को संग्रहीत करने के लिए एक सरणी है। यदि कोई सूची शीर्षलेख u वर्टेक्स

  1. डेटा संरचनाओं में निकटता सूचियाँ

    ग्राफ एक गैर-रेखीय डेटा संरचना है। यह नोड्स का उपयोग करके डेटा का प्रतिनिधित्व करता है, और किनारों का उपयोग करके उनके संबंध। एक ग्राफ G में दो खंड होते हैं। कोने, और किनारे। सेट वी का उपयोग करके वर्टिस का प्रतिनिधित्व किया जाता है, और किनारों को सेट ई के रूप में दर्शाया जाता है। इसलिए ग्राफ नोटेशन ज