ಪೈಥಾನ್ ಗ್ರಾಫ್ ಅಲ್ಗಾರಿದಮ್‌ಗಳು: ಕಡಿಮೆ ದೂರದ ಪಥ ಪರಿಹಾರಗಳನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸುವುದು

ಗ್ರಾಫ್‌ಗಳು ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದಲ್ಲಿ ಮೂಲಭೂತ ದತ್ತಾಂಶ ರಚನೆಗಳಾಗಿವೆ, ಇವು ವಸ್ತುಗಳ ನಡುವಿನ ಸಂಬಂಧಗಳನ್ನು ಮಾದರಿಯಾಗಿಸಲು ಬಳಸಲ್ಪಡುತ್ತವೆ. ಗ್ರಾಫ್‌ನಲ್ಲಿ ಎರಡು ಬಿಂದುಗಳ ನಡುವಿನ ಕಡಿಮೆ ದೂರದ ಪಥವನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಜಿಪಿಎಸ್ ನ್ಯಾವಿಗೇಶನ್‌ನಿಂದ ಹಿಡಿದು ನೆಟ್‌ವರ್ಕ್ ರೂಟಿಂಗ್ ಮತ್ತು ಸಂಪನ್ಮೂಲ ಹಂಚಿಕೆವರೆಗೆ ವ್ಯಾಪಕವಾದ ಅನ್ವಯಿಕೆಗಳನ್ನು ಹೊಂದಿರುವ ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಯಾಗಿದೆ. ಪೈಥಾನ್, ಅದರ ಶ್ರೀಮಂತ ಲೈಬ್ರರಿಗಳು ಮತ್ತು ಸ್ಪಷ್ಟ ಸಿಂಟ್ಯಾಕ್ಸ್‌ನೊಂದಿಗೆ, ಗ್ರಾಫ್ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಲು ಅತ್ಯುತ್ತಮ ಭಾಷೆಯಾಗಿದೆ. ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ ವಿವಿಧ ಕಡಿಮೆ ದೂರದ ಪಥ ಅಲ್ಗಾರಿದಮ್‌ಗಳು ಮತ್ತು ಅವುಗಳ ಪೈಥಾನ್ ಅನುಷ್ಠಾನಗಳನ್ನು ಅನ್ವೇಷಿಸುತ್ತದೆ.

ಗ್ರಾಫ್‌ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಅಲ್ಗಾರಿದಮ್‌ಗಳಿಗೆ ಧುಮುಕುವ ಮೊದಲು, ಗ್ರಾಫ್ ಎಂದರೇನು ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸೋಣ:

• ನೋಡ್‌ಗಳು (ಶೃಂಗಗಳು): ವಸ್ತುಗಳು ಅಥವಾ ಘಟಕಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ.
• ಅಂಚುಗಳು: ನೋಡ್‌ಗಳನ್ನು ಸಂಪರ್ಕಿಸುತ್ತವೆ, ಅವುಗಳ ನಡುವಿನ ಸಂಬಂಧಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ. ಅಂಚುಗಳು ನಿರ್ದೇಶಿತವಾಗಿರಬಹುದು (ಏಕಮುಖ) ಅಥವಾ ನಿರ್ದೇಶಿತವಲ್ಲದವು (ದ್ವಿಮುಖ).
• ತೂಕಗಳು: ಅಂಚುಗಳು ತೂಕವನ್ನು ಹೊಂದಿರಬಹುದು, ಇದು ವೆಚ್ಚ, ದೂರ ಅಥವಾ ಯಾವುದೇ ಸಂಬಂಧಿತ ಮೆಟ್ರಿಕ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಯಾವುದೇ ತೂಕವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದರೆ, ಅದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ 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 ಅಂಚುಗಳ ಸಂಖ್ಯೆ. ಲಾಗ್ 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).

ಪ್ರಾಯೋಗಿಕ ಪರಿಗಣನೆಗಳು ಮತ್ತು ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಳು

• ಸರಿಯಾದ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಆರಿಸುವುದು: ಡೈಕ್‌ಸ್ಟ್ರಾಸ್ ಅಲ್ಗಾರಿದಮ್ ಸಾಮಾನ್ಯವಾಗಿ ಧನಾತ್ಮಕವಲ್ಲದ ಅಂಚಿನ ತೂಕಗಳನ್ನು ಹೊಂದಿರುವ ಗ್ರಾಫ್‌ಗಳಿಗೆ ವೇಗವಾಗಿರುತ್ತದೆ. ಋಣಾತ್ಮಕ ಅಂಚಿನ ತೂಕಗಳು ಇದ್ದಾಗ ಬೆಲ್‌ಮನ್-ಫೋರ್ಡ್ ಅಗತ್ಯವಿದೆ, ಆದರೆ ಅದು ನಿಧಾನವಾಗಿರುತ್ತದೆ. ಉತ್ತಮ ಹ್ಯೂರಿಸ್ಟಿಕ್ ಲಭ್ಯವಿದ್ದರೆ ಎ* ಹುಡುಕಾಟವು ಡೈಕ್‌ಸ್ಟ್ರಾಸ್‌ಗಿಂತ ವೇಗವಾಗಿರುತ್ತದೆ.
• ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್‌ಗಳು: ಆದ್ಯತೆಯ ಸರತಿ ಸಾಲುಗಳು (ರಾಶಿಗಳು) ರೀತಿಯ ಪರಿಣಾಮಕಾರಿ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್‌ಗಳನ್ನು ಬಳಸುವುದು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸುಧಾರಿಸುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಗ್ರಾಫ್‌ಗಳಿಗೆ.
• ಗ್ರಾಫ್ ಪ್ರಾತಿನಿಧ್ಯ: ಗ್ರಾಫ್ ಪ್ರಾತಿನಿಧ್ಯದ ಆಯ್ಕೆ (ಅಡ್ಜಸೆನ್ಸಿ ಲಿಸ್ಟ್ ವಿರುದ್ಧ ಅಡ್ಜಸೆನ್ಸಿ ಮ್ಯಾಟ್ರಿಕ್ಸ್) ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರಬಹುದು. ವಿರಳವಾದ ಗ್ರಾಫ್‌ಗಳಿಗೆ ಅಡ್ಜಸೆನ್ಸಿ ಲಿಸ್ಟ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿರುತ್ತವೆ.
• ಹ್ಯೂರಿಸ್ಟಿಕ್ ಡಿಸೈನ್ (ಎ* ಗಾಗಿ): ಹ್ಯೂರಿಸ್ಟಿಕ್ ಕಾರ್ಯದ ಗುಣಮಟ್ಟವು ಎ* ನ ಕಾರ್ಯಕ್ಷಮತೆಗೆ ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಉತ್ತಮ ಹ್ಯೂರಿಸ್ಟಿಕ್ ಸ್ವೀಕಾರಾರ್ಹವಾಗಿರಬೇಕು (ಎಂದಿಗೂ ಅಂದಾಜು ಮಾಡಬಾರದು) ಮತ್ತು ಸಾಧ್ಯವಾದಷ್ಟು ನಿಖರವಾಗಿರಬೇಕು.
• ಮೆಮೊರಿ ಬಳಕೆ: ದೊಡ್ಡ ಗ್ರಾಫ್‌ಗಳಿಗೆ, ಮೆಮೊರಿ ಬಳಕೆ ಕಾಳಜಿಗೆ ಕಾರಣವಾಗಬಹುದು. ಚಂಕ್‌ಗಳಲ್ಲಿ ಗ್ರಾಫ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಇಟರೇಟರ್‌ಗಳು ಅಥವಾ ಜನರೇಟರ್‌ಗಳನ್ನು ಬಳಸುವಂತಹ ತಂತ್ರಗಳು ಮೆಮೊರಿ ಹೆಜ್ಜೆಗುರುತನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

ನೈಜ-ಪ್ರಪಂಚದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು

ಕಡಿಮೆ ದೂರದ ಪಥ ಅಲ್ಗಾರಿದಮ್‌ಗಳು ನೈಜ-ಪ್ರಪಂಚದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ವ್ಯಾಪಕ ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿವೆ:

• ಜಿಪಿಎಸ್ ನ್ಯಾವಿಗೇಶನ್: ದೂರ, ಟ್ರಾಫಿಕ್ ಮತ್ತು ರಸ್ತೆ ಮುಚ್ಚುವಿಕೆಗಳಂತಹ ಅಂಶಗಳನ್ನು ಪರಿಗಣಿಸಿ ಎರಡು ಸ್ಥಳಗಳ ನಡುವಿನ ಕಡಿಮೆ ಮಾರ್ಗವನ್ನು ಕಂಡುಹಿಡಿಯುವುದು. ಗೂಗಲ್ ನಕ್ಷೆಗಳು ಮತ್ತು ವೇಜ್‌ನಂತಹ ಕಂಪನಿಗಳು ಈ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಹೆಚ್ಚು ಅವಲಂಬಿಸಿವೆ. ಉದಾಹರಣೆಗೆ, ಲಂಡನ್‌ನಿಂದ ಎಡಿನ್‌ಬರ್ಗ್‌ಗೆ ಅಥವಾ ಟೋಕಿಯೊದಿಂದ ಒಸಾಕಾಗೆ ಕಾರಿನ ಮೂಲಕ ವೇಗವಾದ ಮಾರ್ಗವನ್ನು ಕಂಡುಹಿಡಿಯುವುದು.
• ನೆಟ್‌ವರ್ಕ್ ರೂಟಿಂಗ್: ಡೇಟಾ ಪ್ಯಾಕೆಟ್‌ಗಳು ನೆಟ್‌ವರ್ಕ್‌ನಾದ್ಯಂತ ಪ್ರಯಾಣಿಸಲು ಸೂಕ್ತವಾದ ಮಾರ್ಗವನ್ನು ನಿರ್ಧರಿಸುವುದು. ಇಂಟರ್ನೆಟ್ ಸೇವಾ ಪೂರೈಕೆದಾರರು ದಟ್ಟಣೆಯನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ರೂಟ್ ಮಾಡಲು ಕಡಿಮೆ ದೂರದ ಪಥ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಬಳಸುತ್ತಾರೆ.
• ಲಾಜಿಸ್ಟಿಕ್ಸ್ ಮತ್ತು ಸಪ್ಲೈ ಚೈನ್ ಮ್ಯಾನೇಜ್‌ಮೆಂಟ್: ಟ್ರಕ್‌ಗಳು ಅಥವಾ ವಿಮಾನಗಳಿಗೆ ವಿತರಣಾ ಮಾರ್ಗಗಳನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವುದು, ದೂರ, ವೆಚ್ಚ ಮತ್ತು ಸಮಯದ ನಿರ್ಬಂಧಗಳಂತಹ ಅಂಶಗಳನ್ನು ಪರಿಗಣಿಸುವುದು. ಫೆಡ್‌ಎಕ್ಸ್ ಮತ್ತು ಯುಪಿಎಸ್‌ನಂತಹ ಕಂಪನಿಗಳು ದಕ್ಷತೆಯನ್ನು ಸುಧಾರಿಸಲು ಈ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಬಳಸುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, ಜರ್ಮನಿಯ ಗೋದಾಮಿನಿಂದ ವಿವಿಧ ಯುರೋಪಿಯನ್ ದೇಶಗಳಲ್ಲಿ ಗ್ರಾಹಕರಿಗೆ ಸರಕುಗಳ ಸಾಗಣೆಗೆ ಹೆಚ್ಚು ವೆಚ್ಚ-ಪರಿಣಾಮಕಾರಿ ಮಾರ್ಗವನ್ನು ಯೋಜಿಸುವುದು.
• ಸಂಪನ್ಮೂಲ ಹಂಚಿಕೆ: ವೆಚ್ಚವನ್ನು ಕಡಿಮೆ ಮಾಡುವ ಅಥವಾ ದಕ್ಷತೆಯನ್ನು ಹೆಚ್ಚಿಸುವ ರೀತಿಯಲ್ಲಿ ಬಳಕೆದಾರರು ಅಥವಾ ಕಾರ್ಯಗಳಿಗೆ ಸಂಪನ್ಮೂಲಗಳನ್ನು (ಉದಾಹರಣೆಗೆ, ಬ್ಯಾಂಡ್‌ವಿಡ್ತ್, ಕಂಪ್ಯೂಟಿಂಗ್ ಪವರ್) ಹಂಚಿಕೆ ಮಾಡುವುದು. ಕ್ಲೌಡ್ ಕಂಪ್ಯೂಟಿಂಗ್ ಪೂರೈಕೆದಾರರು ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆಗಾಗಿ ಈ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಬಳಸುತ್ತಾರೆ.
• ಗೇಮ್ ಡೆವಲಪ್‌ಮೆಂಟ್: ವೀಡಿಯೊ ಗೇಮ್‌ಗಳಲ್ಲಿನ ಪಾತ್ರಗಳಿಗೆ ಪಥವನ್ನು ಕಂಡುಹಿಡಿಯುವುದು. ಎ* ಹುಡುಕಾಟವನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ, ಅದರ ದಕ್ಷತೆ ಮತ್ತು ಸಂಕೀರ್ಣ ಪರಿಸರಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಸಾಮರ್ಥ್ಯದಿಂದಾಗಿ.
• ಸಾಮಾಜಿಕ ನೆಟ್‌ವರ್ಕ್‌ಗಳು: ಸಾಮಾಜಿಕ ನೆಟ್‌ವರ್ಕ್‌ನಲ್ಲಿ ಇಬ್ಬರು ಬಳಕೆದಾರರ ನಡುವಿನ ಕಡಿಮೆ ದೂರದ ಪಥವನ್ನು ಕಂಡುಹಿಡಿಯುವುದು, ಅವುಗಳ ನಡುವಿನ ಪ್ರತ್ಯೇಕತೆಯ ಮಟ್ಟವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಫೇಸ್‌ಬುಕ್ ಅಥವಾ ಲಿಂಕ್ಡ್‌ಇನ್‌ನಲ್ಲಿರುವ ಯಾವುದೇ ಇಬ್ಬರು ವ್ಯಕ್ತಿಗಳ ನಡುವಿನ "ಆರು ಡಿಗ್ರಿಗಳ ಪ್ರತ್ಯೇಕತೆ" ಅನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು.

ಸುಧಾರಿತ ವಿಷಯಗಳು

• ದ್ವಿಮುಖ ಹುಡುಕಾಟ: ಪ್ರಾರಂಭದ ಮತ್ತು ಗುರಿ ನೋಡ್‌ಗಳಿಂದ ಏಕಕಾಲದಲ್ಲಿ ಹುಡುಕುವುದು, ಮಧ್ಯದಲ್ಲಿ ಭೇಟಿಯಾಗುವುದು. ಇದು ಹುಡುಕಾಟ ಜಾಗವನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಮಾಡಬಹುದು.
• ಸಂಕೋಚನ ಶ್ರೇಣಿಗಳು: ನೋಡ್‌ಗಳು ಮತ್ತು ಅಂಚುಗಳ ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುವ ಪೂರ್ವ-ಸಂಸ್ಕರಣಾ ತಂತ್ರ, ಇದು ಕಡಿಮೆ ದೂರದ ಪಥ ಪ್ರಶ್ನೆಗಳಿಗೆ ಬಹಳ ವೇಗವಾಗಿ ಅನುಮತಿಸುತ್ತದೆ.
• ALT (A*, ಲ್ಯಾಂಡ್‌ಮಾರ್ಕ್‌ಗಳು, ತ್ರಿಕೋನ ಅಸಮಾನತೆ): ಹ್ಯೂರಿಸ್ಟಿಕ್ ಅಂದಾಜನ್ನು ಸುಧಾರಿಸಲು ಲ್ಯಾಂಡ್‌ಮಾರ್ಕ್‌ಗಳು ಮತ್ತು ತ್ರಿಕೋನ ಅಸಮಾನತೆಯನ್ನು ಬಳಸುವ ಎ*-ಆಧಾರಿತ ಅಲ್ಗಾರಿದಮ್‌ಗಳ ಕುಟುಂಬ.
• ಸಮಾನಾಂತರ ಕಡಿಮೆ ದೂರದ ಪಥ ಅಲ್ಗಾರಿದಮ್‌ಗಳು: ಕಡಿಮೆ ದೂರದ ಪಥದ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ವೇಗಗೊಳಿಸಲು ಅನೇಕ ಪ್ರೊಸೆಸರ್‌ಗಳು ಅಥವಾ ಥ್ರೆಡ್‌ಗಳನ್ನು ಬಳಸುವುದು, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಗ್ರಾಫ್‌ಗಳಿಗೆ.

ತೀರ್ಮಾನ

ಕಡಿಮೆ ದೂರದ ಪಥ ಅಲ್ಗಾರಿದಮ್‌ಗಳು ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದಲ್ಲಿ ಮತ್ತು ಅದರಾಚೆಗಿನ ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಪ್ರಬಲ ಸಾಧನಗಳಾಗಿವೆ. ಪೈಥಾನ್, ಅದರ ಬಹುಮುಖತೆ ಮತ್ತು ವ್ಯಾಪಕ ಲೈಬ್ರರಿಗಳೊಂದಿಗೆ, ಈ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸಲು ಮತ್ತು ಪ್ರಯೋಗಿಸಲು ಅತ್ಯುತ್ತಮ ವೇದಿಕೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಡೈಕ್‌ಸ್ಟ್ರಾಸ್, ಬೆಲ್‌ಮನ್-ಫೋರ್ಡ್ ಮತ್ತು ಎ* ಹುಡುಕಾಟದ ಹಿಂದಿನ ತತ್ವಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ಪಥವನ್ನು ಕಂಡುಹಿಡಿಯುವುದು, ರೂಟಿಂಗ್ ಮತ್ತು ಆಪ್ಟಿಮೈಸೇಶನ್ ಒಳಗೊಂಡ ನೈಜ-ಪ್ರಪಂಚದ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಪರಿಹರಿಸಬಹುದು.

ನಿಮ್ಮ ಗ್ರಾಫ್‌ನ ಗುಣಲಕ್ಷಣಗಳ ಆಧಾರದ ಮೇಲೆ ನಿಮ್ಮ ಅಗತ್ಯಗಳಿಗೆ ಸೂಕ್ತವಾದ ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಮರೆಯದಿರಿ (ಉದಾಹರಣೆಗೆ, ಅಂಚಿನ ತೂಕಗಳು, ಗಾತ್ರ, ಸಾಂದ್ರತೆ) ಮತ್ತು ಹ್ಯೂರಿಸ್ಟಿಕ್ ಮಾಹಿತಿಯ ಲಭ್ಯತೆ. ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಲು ವಿಭಿನ್ನ ಡೇಟಾ ಸ್ಟ್ರಕ್ಚರ್‌ಗಳು ಮತ್ತು ಆಪ್ಟಿಮೈಸೇಶನ್ ತಂತ್ರಗಳೊಂದಿಗೆ ಪ್ರಯೋಗಿಸಿ. ಈ ಪರಿಕಲ್ಪನೆಗಳ ಬಗ್ಗೆ ಗಟ್ಟಿಯಾದ ತಿಳುವಳಿಕೆಯೊಂದಿಗೆ, ನೀವು ವಿವಿಧ ಕಡಿಮೆ ದೂರದ ಪಥ ಸವಾಲುಗಳನ್ನು ಎದುರಿಸಲು ಉತ್ತಮವಾಗಿ ಸಜ್ಜುಗೊಂಡಿರುತ್ತೀರಿ.