Module: फोर्ड-बेलमैन एल्गोरिथम


Problem

1/6

फोर्ड-बेलमैन: द बिगिनिंग (C++)

Theory Click to read/hide

फोर्ड-बेलमैन एल्गोरिदम
g को n कोने और m किनारों के साथ, और कुछ प्रारंभिक शीर्ष v के साथ एक निर्देशित भारित ग्राफ G दिया जाता है। > . शीर्ष v से अन्य सभी शीर्षों तक सबसे छोटे रास्तों की लंबाई ज्ञात करना आवश्यक है।

दिज्क्स्त्रा की तरह, Ford-Bellman शीर्ष 1 से अन्य सभी की दूरी की तलाश करता है, लेकिन नकारात्मक किनारों के साथ काम करता है< / मजबूत>।
 
Ford-Bellman एल्गोरिदम में ही कई चरण होते हैं (n-1)। प्रत्येक चरण में, ग्राफ़ के सभी किनारों की जांच की जाती है, और एल्गोरिद्म लागत c के प्रत्येक किनारे (a, b) के साथ आराम करने की कोशिश करता है। किनारे पर आराम — यह d[a]  मान d[b] + c। वास्तव में, इसका मतलब यह है कि हम किनारे  और शीर्ष के लिए वर्तमान उत्तर।

d सरणी प्रारंभिक शीर्ष से सबसे छोटी लंबाई की एक सरणी है, ठीक उसी तरह जैसे दिज्क्स्त्र में, हम शुरू में इसे यथासंभव बड़ी संख्या में भरते हैं, शुरुआती शीर्ष को छोड़कर, जिसमें आपको डालने की आवश्यकता होती है 0.
किनारों को संग्रहीत करने के लिए, आसन्न मैट्रिक्स या भार मैट्रिक्स का उपयोग नहीं किया जाता है, लेकिन एक सूची जो इंगित करती है कि किनारे किस नोड से निकलते हैं (<कोड>से), जिसके लिए यह आता है (to) कोड>) और उसका वजन (<कोड>लागत)।
  संरचना किनारा { int से, से, लागत; }; वेक्टर<किनारे> किनारों;
INF स्थिरांक "अनंत" संख्या दर्शाता है - इसे इस तरह से चुना जाना चाहिए कि यह स्पष्ट रूप से सभी संभावित पथ लंबाई से अधिक हो।

एल्गोरिथ्म का सबसे सरल कार्यान्वयन: डी [वी] = 0; के लिए (int i=0; i<n-1; ++i) के लिए (int j = 0; j<m; ++j)      अगर (डी[किनारे[जे].से] <आईएनएफ)        डी [किनारे [जे] .से] = न्यूनतम (डी [किनारे [जे] .से], डी [किनारे [जे]। से] + किनारों [जे]। लागत);

या सिंटैक्स C++11:
का उपयोग करके थोड़ा छोटा   डी [वी] = 0; के लिए (int i=0; i< n-1; ++i) के लिए (एज जे: किनारों) अगर (डी[जे.फ्रॉम] <INF) d[j.to] = min(d[j.to], d[j.from] + j.cost);

काम का उदाहरण


एक साधारण निर्देशित ग्राफ़ लें  5 नोड्स के साथ, 1 के बराबर वजन वाले 4 किनारे।

आइए इसी क्रम में किनारों की एक सूची पेश करते हैं।
4 5 1
3 4 1
2 3 1
1 2 1


सबसे कम लंबाई की सरणी में प्रारंभिक मान:
  <टेबल क्लास = "टेबल-एसएम टेबल-बॉर्डर टेबल-स्ट्राइप्ड टेबल-लिस्ट-टेस्ट"> <शरीर> 0 जानकारी जानकारी जानकारी जानकारी
जहां inf एक मेल खाने वाला पूर्णांक होना चाहिए जो हमेशा किनारे के भार से अधिक होता है।

पहली पास के बाद
  <टेबल क्लास = "टेबल-एसएम टेबल-बॉर्डर टेबल-स्ट्राइप्ड टेबल-लिस्ट-टेस्ट"> <शरीर> 0 1 जानकारी जानकारी जानकारी
दूसरे पास के बाद
  <टेबल क्लास = "टेबल-एसएम टेबल-बॉर्डर टेबल-स्ट्राइप्ड टेबल-लिस्ट-टेस्ट"> <शरीर> 0 1 2 जानकारी जानकारी
तीसरे पास के बाद
  <टेबल क्लास = "टेबल-एसएम टेबल-बॉर्डर टेबल-स्ट्राइप्ड टेबल-लिस्ट-टेस्ट"> <शरीर> 0 1 2 3 जानकारी

चौथी पास के बाद
  <टेबल क्लास = "टेबल-एसएम टेबल-बॉर्डर टेबल-स्ट्राइप्ड टेबल-लिस्ट-टेस्ट"> <शरीर> 0 1 2 3 4
यदि हम किनारों को 1 से अंत तक क्रम में खिलाते हैं, तो हम पहले पास के बाद सबसे कम लंबाई पा सकते हैं।

 

Problem

प्रोग्राम को पूरा करें ताकि यह निम्नलिखित समस्या को सही ढंग से हल कर सके।

एक निर्देशित ग्राफ दिया गया है जिसमें कई किनारे और लूप हो सकते हैं। प्रत्येक किनारे का वजन एक पूर्णांक (संभवतः नकारात्मक) के रूप में व्यक्त किया जाता है। यह गारंटी है कि कोई नकारात्मक भार चक्र नहीं है।
आपको शीर्ष संख्या 1 से अन्य सभी शीर्षों तक के सबसे छोटे रास्तों की लंबाई की गणना करने की आवश्यकता है।
 
इनपुट
प्रोग्राम पहले नंबर प्राप्त करता है N (1 <= N <= 100) – ग्राफ़ शीर्षों की संख्या और संख्या M (0 <= M <= 10000) – पसलियों की संख्या। निम्नलिखित पंक्तियों में किनारों का वर्णन करने वाली संख्याओं का M होता है: किनारे की शुरुआत, किनारे का अंत, और वजन (वजन -100 से 100 तक एक पूर्णांक है)।< /दिवि>
 
आउटपुट
प्रोग्राम को N नंबर – ग्राफ के शीर्ष संख्या 1 से सभी शीर्षों की दूरी। यदि संबंधित शीर्ष के लिए कोई पथ नहीं है, तो पथ की लंबाई के बजाय संख्या 30000 प्रिंट करें।
 
उदाहरण
<टेबल क्लास = "टेबल-एसएम टेबल-बॉर्डर टेबल-स्ट्राइप्ड टेबल-लिस्ट-टेस्ट"> <सिर> <वें># <वें>इनपुट <वें>आउटपुट <शरीर> 1 <टीडी>
6 4
1 2 10
2 3 10
1 3 100
4 5 -10
0 10 20 30000 30000 30000