🍙 🔛 🤴🏼 हम कक्षा को ग्राफ बूस्ट के तहत मुखौटा करते हैं। भाग 3: रास्ता खोजना 👨‍👨‍👦 👏 👩‍🚀

प्रस्तावना: बूस्ट कॉन्सेप्ट्स
भाग 1: स्रोत वर्ग इंटरफ़ेस के साथ जुड़े बिना संबद्ध प्रकार को जोड़ना
भाग 2: अवधारणा समर्थन के कार्यान्वयन को पूरा करना

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

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

struct EdgeWeightMap { typedef double value_type; typedef value_type reference; typedef Edge key_type; typedef boost::readable_property_map_tag category; reference operator[](key_type e) const { return 1; } };

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

अगला, आपको अवधारणा द्वारा आवश्यक फ़ंक्शन को लागू करने की आवश्यकता है। लेकिन पहले, आइए छोटे प्रकार के उपनामों का परिचय दें (अपने लिए)

 typedef boost::property_map<GameField, boost::edge_weight_t>::const_type EdgeWeightMapConst; typedef boost::property_traits<EdgeWeightMapConst>::reference EdgeWeightMapValueType; typedef boost::property_traits<EdgeWeightMapConst>::key_type EdgeWeightMapKey;

फ़ंक्शन को कुंजी से मानचित्र से मान वापस करना चाहिए

 EdgeWeightMapValueType get(EdgeWeightMapConst pMap, EdgeWeightMapKey pKey) { return pMap[pKey]; }

अब आप पसलियों के वजन का एक नक्शा निर्दिष्ट कर सकते हैं। ध्यान दें कि घोषणा को बूस्ट नेमस्पेस में बनाया गया है।

 namespace boost { template<> struct property_map< GameField, edge_weight_t > { typedef EdgeWeightMap type; typedef EdgeWeightMap const_type; }; }

अवधारणा की जाँच

 boost::function_requires<boost::ReadablePropertyMapConcept<EdgeWeightMap, Edge> >();

आप शीर्षकों के गुण भी निर्धारित कर सकते हैं - हम ऐसा नहीं करेंगे, लेकिन हमें एक स्टब बनाना होगा ताकि बढ़ावा डिफ़ॉल्ट रूप से कोने के लिए एक मानचित्र उत्पन्न कर सके। ऐसा करने के लिए, बस वर्टेक्स गुणों के प्रकार को निर्दिष्ट करें, इसे वर्टेक्स इंडेक्स का प्रकार होने दें

 namespace boost { template <> struct vertex_property_type<GameField> { typedef boost::graph_traits<GameField>::vertex_descriptor type; }; }

यह परिभाषा बूस्ट नेमस्पेस में भी होनी चाहिए।

हम एक और अवधारणा के लिए अपने ग्राफ द्वारा समर्थन को लागू करते हैं - पठनीयप्रक्रियाग्राफकंसेप्ट , अर्थात। "गुणों के साथ ग्राफ़।" ऐसा करने के लिए, आपको दो फ़ंक्शन सेट करने की आवश्यकता है। पहले एक ग्राफ संपत्ति का नक्शा बनाता है

 EdgeWeightMapConst get(boost::edge_weight_t, const GameField& graph) { return EdgeWeightMapConst(); }

कृपया ध्यान दें कि इस लेख में किनारों के वजन की गणना नहीं की गई है (1 के बराबर), इसलिए इसमें क्रमशः ग्राफ़ को सूचक को सहेजने की आवश्यकता नहीं है, और ग्राफ़ पैरामीटर का उपयोग नहीं किया जाता है। हम एक बढ़त के वजन को निर्धारित करने के लिए एक फ़ंक्शन को भी परिभाषित करते हैं

 EdgeWeightMapValueType get(boost::edge_weight_t tag, const GameField& g, EdgeWeightMapKey e) { return get(tag, g)[e]; }

इस पर अगली अवधारणा के साथ, आप देख सकते हैं

 boost::function_requires<boost::ReadablePropertyGraphConcept<GameField, Edge, boost::edge_weight_t> >();

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

 class GameFieldHeuristic: public boost::astar_heuristic<GameField, int> { public: GameFieldHeuristic(const GameField& gameField, Vertex goal) : mGameField(&gameField) { std::pair<int, int> goalPosition = getCoordinates(goal, gameField); mGoalX = goalPosition.first; mGoalY = goalPosition.second; }; int operator()(Vertex v) { std::pair<int, int> position = getCoordinates(v, *mGameField); int dx = mGoalX - position.first; int dy = mGoalY - position.second; int result =dx * dx + dy * dy; return result; } private: int mGoalX; int mGoalY; const GameField* mGameField; };

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

और अंत में, एक वर्ग बनाएं जो पाए गए समाधान का संकेत दे सकता है। हम एक फाउंडहाउस अपवाद को बढ़ाकर संकेत देंगे।

 struct FoundGoal {};

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

 struct AstarGoalVisitor : public boost::default_astar_visitor { AstarGoalVisitor(Vertex goal) : mGoal(goal) { } void examine_vertex(Vertex u, const GameField&) { if (u == mGoal) { throw FoundGoal(); } } private: Vertex mGoal; };

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

 typedef std::list<NextStep> StepsList; StepsList findPath(int sourceX, int sourceY, int targetX, int targetY, const GameFieldMap& graph) { GraphVertex source = getVertex(sourceX, sourceY, graph); GraphVertex destination = getVertex(targetX, targetY, graph); std::vector<GraphVertex> predecessor(num_vertices(graph)); std::vector<edge_weight_map_value_type> dist(num_vertices(graph)); StepsList result; try { astar_search(graph, source, GameFieldHeuristic(graph, destination), boost::visitor(AstarGoalVisitor(destination)). predecessor_map(&predecessor[0]). distance_map(&dist[0])); } catch (FoundGoal f) { for (int i = destination; i != source; i = predecessor[i]) { std::pair<int, int> coordinates = getCoordinates(i, graph); result.push_front(NextStep(coordinates.first, coordinates.second)); } } return result; }

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

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

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

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

हम कक्षा को ग्राफ बूस्ट के तहत मुखौटा करते हैं। भाग 3: रास्ता खोजना

More articles: