पायथन ग्राफ एल्गोरिदम: लघुतम पथ समाधानों का कार्यान्वयन

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

ग्राफ को समझना

एल्गोरिदम में गोता लगाने से पहले, आइए परिभाषित करें कि ग्राफ क्या है:

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

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

पायथन में एक ग्राफ को आसन्न सूची के रूप में दर्शाने का उदाहरण:

            graph = {
 'A': [('B', 5), ('C', 2)],
 'B': [('D', 4)],
 'C': [('B', 8), ('D', 7)],
 'D': [('E', 6)],
 'E': []
}

            

              
                Copy
              
            
          

इस उदाहरण में, ग्राफ में नोड A, B, C, D और E हैं। प्रत्येक नोड से जुड़ा मान टुपल्स की एक सूची है, जहां प्रत्येक टुपल दूसरे नोड के लिए एक किनारे का प्रतिनिधित्व करता है और उस किनारे का भार।

डिज्क्स्ट्रा का एल्गोरिदम

परिचय

डिज्क्स्ट्रा का एल्गोरिदम गैर-नकारात्मक किनारे वाले भार के साथ एक ग्राफ में एक एकल स्रोत नोड से अन्य सभी नोड्स तक सबसे छोटा रास्ता खोजने के लिए एक क्लासिक एल्गोरिदम है। यह एक लालची एल्गोरिदम है जो पुनरावृत्त रूप से ग्राफ का पता लगाता है, हमेशा स्रोत से सबसे छोटी ज्ञात दूरी वाले नोड को चुनता है।

एल्गोरिदम चरण

1. प्रत्येक नोड के लिए स्रोत से सबसे छोटी दूरी को संग्रहीत करने के लिए एक शब्दकोश प्रारंभ करें। स्रोत नोड से दूरी को 0 पर और अन्य सभी नोड्स से दूरी को अनंत पर सेट करें।
2. देखे गए नोड्स के एक सेट को खाली होने के लिए प्रारंभ करें।
3. जब तक अनदेखे नोड हों:
   • स्रोत से सबसे छोटी ज्ञात दूरी के साथ अनदेखे नोड का चयन करें।
   • चयनित नोड को देखे गए के रूप में चिह्नित करें।
   • चयनित नोड के प्रत्येक पड़ोसी के लिए:
     • चयनित नोड के माध्यम से पड़ोसी के स्रोत से दूरी की गणना करें।
     • यदि यह दूरी पड़ोसी की वर्तमान ज्ञात दूरी से कम है, तो पड़ोसी की दूरी को अपडेट करें।
4. स्रोत से अन्य सभी नोड्स तक की सबसे छोटी दूरी अब ज्ञात है।

पायथन कार्यान्वयन

            import heapq

def dijkstra(graph, start):
 distances = {node: float('inf') for node in graph}
 distances[start] = 0
 priority_queue = [(0, start)] # (distance, node)

 while priority_queue:
 distance, node = heapq.heappop(priority_queue)

 if distance > distances[node]:
 continue # Already processed a shorter path to this node

 for neighbor, weight in graph[node]:
 new_distance = distance + weight
 if new_distance < distances[neighbor]:
 distances[neighbor] = new_distance
 heapq.heappush(priority_queue, (new_distance, neighbor))

 return distances

# Example usage:
graph = {
 'A': [('B', 5), ('C', 2)],
 'B': [('D', 4)],
 'C': [('B', 8), ('D', 7)],
 'D': [('E', 6)],
 'E': []
}

start_node = 'A'
shortest_distances = dijkstra(graph, start_node)
print(f"Shortest distances from {start_node}: {shortest_distances}")

            

              
                Copy
              
            
          

उदाहरण स्पष्टीकरण

कोड सबसे छोटी दूरी वाले अनदेखे नोड को कुशलतापूर्वक चुनने के लिए एक प्राथमिकता कतार (`heapq` के साथ कार्यान्वित) का उपयोग करता है। `distances` डिक्शनरी प्रत्येक अन्य नोड से स्टार्ट नोड की सबसे छोटी दूरी को संग्रहीत करती है। एल्गोरिथ्म इन दूरियों को तब तक पुनरावृत्त रूप से अपडेट करता है जब तक कि सभी नोड्स का दौरा नहीं किया जाता (या अप्राप्य नहीं हैं)।

जटिलता विश्लेषण

• समय जटिलता: O((V + E) log V), जहाँ V शिखर की संख्या है और E किनारों की संख्या है। Log V फैक्टर हीप संचालन से आता है।
• स्थान जटिलता: O(V), दूरियों और प्राथमिकता कतार को संग्रहीत करने के लिए।

बेलमैन-फोर्ड एल्गोरिदम

परिचय

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

एल्गोरिदम चरण

1. प्रत्येक नोड के लिए स्रोत से सबसे छोटी दूरी को संग्रहीत करने के लिए एक शब्दकोश प्रारंभ करें। स्रोत नोड से दूरी को 0 पर और अन्य सभी नोड्स से दूरी को अनंत पर सेट करें।
2. निम्नलिखित चरणों को V-1 बार दोहराएं, जहां V शिखर की संख्या है:
   • ग्राफ में प्रत्येक किनारे (u, v) के लिए:
     • यदि u की दूरी और किनारे (u, v) का भार v की वर्तमान दूरी से कम है, तो v की दूरी को अपडेट करें।
3. V-1 पुनरावृत्तियों के बाद, नकारात्मक चक्रों की जाँच करें। ग्राफ में प्रत्येक किनारे (u, v) के लिए:
   • यदि u की दूरी और किनारे (u, v) का भार v की वर्तमान दूरी से कम है, तो एक नकारात्मक चक्र है।
4. यदि एक नकारात्मक चक्र का पता चला है, तो एल्गोरिदम समाप्त हो जाता है और इसकी उपस्थिति की रिपोर्ट करता है। अन्यथा, स्रोत से अन्य सभी नोड्स तक की सबसे छोटी दूरी ज्ञात होती है।

पायथन कार्यान्वयन

            def bellman_ford(graph, start):
 distances = {node: float('inf') for node in graph}
 distances[start] = 0

 # Relax edges repeatedly
 for _ in range(len(graph) - 1):
 for node in graph:
 for neighbor, weight in graph[node]:
 if distances[node] != float('inf') and distances[node] + weight < distances[neighbor]:
 distances[neighbor] = distances[node] + weight

 # Check for negative cycles
 for node in graph:
 for neighbor, weight in graph[node]:
 if distances[node] != float('inf') and distances[node] + weight < distances[neighbor]:
 return "Negative cycle detected"

 return distances

# Example usage:
graph = {
 'A': [('B', -1), ('C', 4)],
 'B': [('C', 3), ('D', 2), ('E', 2)],
 'C': [],
 'D': [('B', 1), ('C', 5)],
 'E': [('D', -3)]
}

start_node = 'A'
shortest_distances = bellman_ford(graph, start_node)
print(f"Shortest distances from {start_node}: {shortest_distances}")

            

              
                Copy
              
            
          

उदाहरण स्पष्टीकरण

कोड V-1 बार ग्राफ में सभी किनारों के माध्यम से पुनरावृति करता है, उन्हें आराम देता है (दूरी को अपडेट करता है) यदि एक छोटा रास्ता पाया जाता है। V-1 पुनरावृत्तियों के बाद, यह किनारों के माध्यम से एक बार और पुनरावृति करके नकारात्मक चक्रों की जाँच करता है। यदि कोई भी दूरी अभी भी कम की जा सकती है, तो यह एक नकारात्मक चक्र की उपस्थिति को इंगित करता है।

जटिलता विश्लेषण

• समय जटिलता: O(V * E), जहाँ V शिखर की संख्या है और E किनारों की संख्या है।
• स्थान जटिलता: O(V), दूरियों को संग्रहीत करने के लिए।

ए* खोज एल्गोरिदम

परिचय

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

अनुमानित फलन

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

एल्गोरिदम चरण

1. स्टार्ट नोड युक्त एक खुला सेट प्रारंभ करें।
2. खाली होने के लिए एक बंद सेट प्रारंभ करें।
3. स्टार्ट नोड से प्रत्येक नोड (g(n)) तक की लागत को संग्रहीत करने के लिए एक शब्दकोश प्रारंभ करें। स्टार्ट नोड की लागत को 0 पर और अन्य सभी नोड्स की लागत को अनंत पर सेट करें।
4. प्रत्येक नोड (f(n) = g(n) + h(n)) के माध्यम से स्टार्ट नोड से लक्ष्य नोड तक की अनुमानित कुल लागत को संग्रहीत करने के लिए एक शब्दकोश प्रारंभ करें।
5. जबकि खुला सेट खाली नहीं है:
   • सबसे कम f(n) मान (सबसे आशाजनक नोड) के साथ खुले सेट में नोड का चयन करें।
   • यदि चयनित नोड लक्ष्य नोड है, तो पथ का पुनर्निर्माण और वापसी करें।
   • चयनित नोड को खुले सेट से बंद सेट में ले जाएँ।
   • चयनित नोड के प्रत्येक पड़ोसी के लिए:
     • यदि पड़ोसी बंद सेट में है, तो इसे छोड़ दें।
     • चयनित नोड के माध्यम से स्टार्ट नोड से पड़ोसी तक पहुंचने की लागत की गणना करें।
     • यदि पड़ोसी खुले सेट में नहीं है या नई लागत पड़ोसी की वर्तमान लागत से कम है:
       • पड़ोसी (g(n)) की लागत को अपडेट करें।
       • पड़ोसी (f(n)) के माध्यम से लक्ष्य तक की अनुमानित कुल लागत को अपडेट करें।
       • यदि पड़ोसी खुले सेट में नहीं है, तो इसे खुले सेट में जोड़ें।
6. यदि खुला सेट खाली हो जाता है और लक्ष्य नोड तक नहीं पहुंचा गया है, तो स्टार्ट नोड से लक्ष्य नोड तक कोई पथ नहीं है।

पायथन कार्यान्वयन

            import heapq

def a_star(graph, start, goal, heuristic):
 open_set = [(0, start)]  # (f_score, node)
 closed_set = set()

 g_score = {node: float('inf') for node in graph}
 g_score[start] = 0

 f_score = {node: float('inf') for node in graph}
 f_score[start] = heuristic(start, goal)

 came_from = {}

 while open_set:
 f, current_node = heapq.heappop(open_set)

 if current_node == goal:
 return reconstruct_path(came_from, current_node)

 closed_set.add(current_node)

 for neighbor, weight in graph[current_node]:
 if neighbor in closed_set:
 continue

 tentative_g_score = g_score[current_node] + weight

 if tentative_g_score < g_score[neighbor]:
 came_from[neighbor] = current_node
 g_score[neighbor] = tentative_g_score
 f_score[neighbor] = tentative_g_score + heuristic(neighbor, goal)
 if (f_score[neighbor], neighbor) not in open_set:
 heapq.heappush(open_set, (f_score[neighbor], neighbor))

 return None  # No path found


def reconstruct_path(came_from, current_node):
 path = [current_node]
 while current_node in came_from:
 current_node = came_from[current_node]
 path.append(current_node)
 path.reverse()
 return path

# Example Heuristic (Euclidean distance for demonstration, graph nodes should have x, y coords)
def euclidean_distance(node1, node2):
 # This example requires the graph to store coordinates with each node, such as:
 # graph = {
 #     'A': [('B', 5), ('C', 2)],
 #     'B': [('D', 4)],
 #     'C': [('B', 8), ('D', 7)],
 #     'D': [('E', 6)],
 #     'E': [],
 #     'coords': {
 #         'A': (0, 0),
 #         'B': (3, 4),
 #         'C': (1, 1),
 #         'D': (5, 2),
 #         'E': (7, 0)
 #     }
 # }
 #
 # Since we don't have coordinates in the default graph, we'll just return 0 (admissible)
 return 0
 # Replace this with your actual distance calculation if nodes have coordinates:
 # x1, y1 = graph['coords'][node1]
 # x2, y2 = graph['coords'][node2]
 # return ((x1 - x2)**2 + (y1 - y2)**2)**0.5

# Example Usage:
graph = {
 'A': [('B', 5), ('C', 2)],
 'B': [('D', 4)],
 'C': [('B', 8), ('D', 7)],
 'D': [('E', 6)],
 'E': []
}

start_node = 'A'
goal_node = 'E'

path = a_star(graph, start_node, goal_node, euclidean_distance)

if path:
 print(f"Shortest path from {start_node} to {goal_node}: {path}")
else:
 print(f"No path found from {start_node} to {goal_node}")

            

              
                Copy
              
            
          

उदाहरण स्पष्टीकरण

ए* एल्गोरिदम उन नोड्स को ट्रैक करने के लिए एक प्राथमिकता कतार (`open_set`) का उपयोग करता है, जिनकी खोज की जानी है, उन नोड्स को प्राथमिकता देना जिनकी अनुमानित कुल लागत सबसे कम है (f_score)। `g_score` डिक्शनरी प्रत्येक नोड से स्टार्ट नोड तक की लागत को संग्रहीत करती है, और `f_score` डिक्शनरी प्रत्येक नोड के माध्यम से लक्ष्य तक की अनुमानित कुल लागत को संग्रहीत करती है। लक्ष्य नोड तक पहुंचने के बाद सबसे छोटे पथ के पुनर्निर्माण के लिए `came_from` डिक्शनरी का उपयोग किया जाता है।

जटिलता विश्लेषण

• समय जटिलता: ए* खोज की समय जटिलता अनुमानित फलन पर बहुत अधिक निर्भर करती है। सबसे अच्छे मामले में, एक सही अनुमानित के साथ, ए* O(V + E) समय में सबसे छोटा पथ खोज सकता है। सबसे खराब स्थिति में, एक खराब अनुमानित के साथ, यह डिज्क्स्ट्रा के एल्गोरिदम में पतित हो सकता है, जिसकी समय जटिलता O((V + E) log V) है।
• स्थान जटिलता: खुले सेट, बंद सेट, g_score, f_score और came_from डिक्शनरी को संग्रहीत करने के लिए O(V)।

व्यावहारिक विचार और अनुकूलन

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

वास्तविक दुनिया के अनुप्रयोग

लघुतम पथ एल्गोरिदम में वास्तविक दुनिया के अनुप्रयोगों की एक विस्तृत श्रृंखला है:

• जीपीएस नेविगेशन: दूरी, यातायात और सड़क बंद होने जैसे कारकों पर विचार करते हुए, दो स्थानों के बीच सबसे छोटा मार्ग खोजना। Google मैप्स और वेज़ जैसी कंपनियां इन एल्गोरिदम पर बहुत अधिक निर्भर करती हैं। उदाहरण के लिए, कार से लंदन से एडिनबर्ग या टोक्यो से ओसाका तक का सबसे तेज़ मार्ग खोजना।
• नेटवर्क रूटिंग: डेटा पैकेट के लिए नेटवर्क पर यात्रा करने के लिए इष्टतम मार्ग निर्धारित करना। इंटरनेट सेवा प्रदाता कुशलतापूर्वक ट्रैफ़िक को रूट करने के लिए लघुतम पथ एल्गोरिदम का उपयोग करते हैं।
• लॉजिस्टिक्स और आपूर्ति श्रृंखला प्रबंधन: दूरी, लागत और समय की बाधाओं जैसे कारकों पर विचार करते हुए, ट्रकों या हवाई जहाजों के लिए डिलीवरी मार्गों को अनुकूलित करना। FedEx और UPS जैसी कंपनियां दक्षता में सुधार के लिए इन एल्गोरिदम का उपयोग करती हैं। उदाहरण के लिए, जर्मनी में एक गोदाम से विभिन्न यूरोपीय देशों में ग्राहकों तक माल के लिए सबसे अधिक लागत प्रभावी शिपिंग मार्ग की योजना बनाना।
• संसाधन आवंटन: लागत को कम करने या दक्षता को अधिकतम करने के तरीके से उपयोगकर्ताओं या कार्यों को संसाधन (जैसे, बैंडविड्थ, कंप्यूटिंग शक्ति) आवंटित करना। क्लाउड कंप्यूटिंग प्रदाता संसाधन प्रबंधन के लिए इन एल्गोरिदम का उपयोग करते हैं।
• गेम डेवलपमेंट: वीडियो गेम में पात्रों के लिए पथ खोजना। ए* खोज का उपयोग आमतौर पर इस उद्देश्य के लिए इसकी दक्षता और जटिल वातावरण को संभालने की क्षमता के कारण किया जाता है।
• सोशल नेटवर्क: एक सोशल नेटवर्क में दो उपयोगकर्ताओं के बीच सबसे छोटा रास्ता खोजना, उनके बीच अलगाव की डिग्री का प्रतिनिधित्व करना। उदाहरण के लिए, फेसबुक या लिंक्डइन पर किन्हीं दो लोगों के बीच "अलगाव की छह डिग्री" की गणना करना।

उन्नत विषय

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

निष्कर्ष

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

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