Scribd
Upload
4 views3 pages

Shortest patha algorithms explained

The document discusses the shortest path problem in graph theory, outlining its significance and various types, including Single-Source and All-Pairs Shortest Path. It details popular algorithms such as Dijkstra’s, Bellman-Ford, Floyd-Warshall, and A* Algorithm, along with their use cases, approaches, and time complexities. Additionally, Python implementations for Dijkstra’s and Bellman-Ford algorithms are provided to illustrate their functionality.

Uploaded by

sdas.cse21
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
Download as pdf or txt
4 views3 pages

Shortest patha algorithms explained

The document discusses the shortest path problem in graph theory, outlining its significance and various types, including Single-Source and All-Pairs Shortest Path. It details popular algorithms such as Dijkstra’s, Bellman-Ford, Floyd-Warshall, and A* Algorithm, along with their use cases, approaches, and time complexities. Additionally, Python implementations for Dijkstra’s and Bellman-Ford algorithms are provided to illustrate their functionality.

Uploaded by

sdas.cse21
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
Download as pdf or txt
Download as pdf or txt
You are on page 1/ 3

Shortest Path Algorithm

Introduction
The shortest path problem is a fundamental problem in graph theory and computer science. It
involves finding the shortest possible path between two vertices (nodes) in a weighted or unweighted
graph. Shortest path algorithms are widely used in navigation systems, computer networks, robotics,
artificial intelligence, and social networks.

Types of Shortest Path Problems


1. Single-Source Shortest Path (SSSP): Find the shortest paths from a given source node to all
other nodes in the graph.
2. Single-Pair Shortest Path: Find the shortest path between two specific nodes.
3. All-Pairs Shortest Path: Find the shortest paths between every pair of nodes in the graph.
4. K-Shortest Paths: Find the k-shortest paths between two nodes.

Popular Shortest Path Algorithms


1. Dijkstra’s Algorithm (Greedy Approach)
• Use Case: Finds the shortest path from a single source to all other nodes in a graph with non-
negative weights.
• Approach:
• Start from the source node.
• Use a priority queue (min-heap) to repeatedly pick the node with the smallest known
distance.
• Update distances to neighboring nodes.
• Repeat until all nodes are visited.
• Time Complexity: O((V+E)logV), where V is the number of vertices and E is the number of
edges.
• Example Usage: GPS navigation, network routing.

Python Implementation
python
CopyEdit
import heapq

def dijkstra(graph, start):


pq = [(0, start)] # Min-heap of (distance, node)
distances = {node: float('inf') for node in graph}
distances[start] = 0
while pq:
current_distance, node = heapq.heappop(pq)
if current_distance > distances[node]:
continue

for neighbor, weight in graph[node].items():


distance = current_distance + weight
if distance < distances[neighbor]:
distances[neighbor] = distance
heapq.heappush(pq, (distance, neighbor))

return distances

# Graph represented as an adjacency list


graph = {
'A': {'B': 1, 'C': 4},
'B': {'A': 1, 'C': 2, 'D': 5},
'C': {'A': 4, 'B': 2, 'D': 1},
'D': {'B': 5, 'C': 1}
}

print(dijkstra(graph, 'A'))

2. Bellman-Ford Algorithm (Dynamic Programming)


• Use Case: Works with graphs that have negative weights but no negative weight cycles.
• Approach:
• Initialize distances.
• Relax all edges (V-1) times, updating shortest paths.
• Detect negative weight cycles.
• Time Complexity: O(VE)
• Example Usage: Currency exchange (arbitrage), network protocols.

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

for _ in range(len(graph) - 1):


for node in graph:
for neighbor, weight in graph[node].items():
if distances[node] + weight < distances[neighbor]:
distances[neighbor] = distances[node] + weight

return distances

graph = {
'A': {'B': 1, 'C': 4},
'B': {'C': 2, 'D': 5},
'C': {'D': -3},
'D': {}
}

print(bellman_ford(graph, 'A'))

3. Floyd-Warshall Algorithm (All-Pairs Shortest Path)


• Use Case: Finds the shortest path between all pairs of nodes.
• Approach:
• Use dynamic programming to iteratively update a matrix of shortest paths.
• Time Complexity: O(V3)
• Example Usage: Network latency analysis, routing tables.

Python Implementation
python
CopyEdit
def floyd_warshall(graph):
nodes = list(graph.keys())
dist = {node: {neighbor: float('inf') for neighbor in nodes} for node in nodes}

for node in nodes:


dist[node][node] = 0
for neighbor, weight in graph[node].items():
dist[node][neighbor] = weight

for k in nodes:
for i in nodes:
for j in nodes:
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])

return dist

graph = {
'A': {'B': 3, 'C': 8},
'B': {'A': 3, 'C': 2},
'C': {'A': 8, 'B': 2}
}

print(floyd_warshall(graph))

4. A Algorithm (Heuristic Search)*


• Use Case: Optimized shortest path search in large graphs (e.g., game AI, GPS routing).
• Approach:
• Uses Dijkstra’s Algorithm with a heuristic (e.g., Euclidean distance).
• Prioritizes paths more likely to reach the goal faster.
• Time Complexity: O((V+E)logV) (similar to Dijkstra’s but often faster in practice).

You might also like