19.2.1. Dijkstra’s Algorithm

So, we have seen three algorithms so far which follow this 3D paradigm. The first was Dijkstra’s algorithm for the single source shortest path problem. So, recall that in this algorithm we kept burning vertices and at each stage we froze the distance to the nearest unburnt vertex and claim that this would in fact be the shortest distance to that vertex from the source.

Dijkstra's Algorithm is designed to solve the single-source shortest path problem, which means it finds the shortest path from a starting point (the source) to all other points in a graph. In the algorithm, we systematically explore the graph by 'burning' or marking vertices (nodes) as we find the shortest distances to them. Each time we mark a vertex as 'burnt', we lock in the shortest distance found to that vertex from the source. This process continues until all vertices have been burnt and their distances are finalized.

Imagine you are trying to deliver packages in a city. You start at your warehouse (source) and you want to find the most efficient routes to all the delivery addresses (vertices). As you plan your routes, you mark off each address you’ve delivered to. Once you find the quickest route to an address, you note it down and never go back to change it, even if you discover it may not always be the best option as you progress.

So, globally the optimum we achieved in this algorithm is that the distance assigned by this greedy strategy happens to be the shortest distance from the source.

The output of Dijkstra's Algorithm guarantees that the distance assigned to each vertex from the source node is the shortest possible distance. This is due to the nature of the algorithm, which follows a greedy approach. For every vertex, it only considers the most promising path based on the distances it has calculated up to that point and locks this distance in once it decides on it.

Think about using a GPS for navigation. Your GPS chooses the best route based on real-time traffic data and road conditions. Once it selects a route, it adjusts the plan as new information comes in, ensuring you are always on the optimal path to your destination.

A closely related algorithm is Prim’s algorithm for the minimum cost spanning tree. So, here we incrementally build up a tree and at each stage we add to this spanning tree, the nearest vertex that is not yet in the tree.

While Dijkstra’s Algorithm focuses on finding the shortest paths from a single source to all other vertices, Prim's Algorithm is about constructing a minimum spanning tree that connects all vertices with the least total edge weight. In each step of Prim’s Algorithm, it reinforces the growing tree by adding the nearest vertex not yet included, ensuring that at every stage, it minimizes the overall connection cost.

Imagine you are organizing a community park and trying to plant trees. You want the trees to be connected with the shortest distance possible using paths (edges). As you plant each tree (vertex), you look for the closest spot still available to maximize the park’s layout while minimizing walked distance.

This algorithm works by selecting the vertex with the smallest known distance, then examining its adjacent vertices to update their distances based on the shortest paths found so far.

In Dijkstra’s Algorithm, you start at the source vertex and keep updating the shortest distance to each neighboring vertex using a priority queue or similar structure to efficiently retrieve the next closest vertex. You repeat this process, updating distances and marking vertices as visited until all vertices have been accessed and the shortest paths are determined.

Consider a person navigating through a maze. The individual starts at the entrance and finds the shortest way to navigate to various exits using a map. They systematically check each path (vertex) from their current point, ensuring they always keep track of the shortest route they have found to each exit, continuously updating their route as they proceed.

--