27.2.1. Correctness of Dijkstra Algorithm

So, now let us analyze Dijkstra’s algorithm for the single source shortest path problem. Dijkstra's algorithms operate by burning vertices... So, we keep track of vertices which have burnt or... initially nothing is visited and initially we do not know any distance to any vertex.

In this introduction, we learn that Dijkstra's algorithm is used to find the shortest path from a source vertex to all other vertices in a graph. The algorithm keeps track of 'burnt' vertices, or those that have been settled with the shortest known distance, and relies on an initial assumption that all distances are set to infinity except for the source, which is set to zero.

Imagine a fire spreading in a forest from a single starting tree. The 'burnt' trees are those where the fire has spread and each tree keeps track of how far away they are from the source tree (the original tree on fire). The aim is to spread to all trees while minimizing the distance each tree has to cover.

Now, we need to justify that this order is actually correct... At each stage you make the next choice based on some local information... At this point, this looks like the best choice to make...

This chunk discusses the need to verify the correctness of Dijkstra’s algorithm. It introduces the concept of greedy algorithms, where decisions are made based on local information. Dijkstra's algorithm is justified as it follows a systematic method of choosing the next vertex based on the shortest current distance, ensuring that once a vertex is 'burnt', its shortest path to the source cannot be improved.

Consider a traveler trying to find the fastest route to reach a destination. Each time they reach a point or intersection, they pick the path that looks quickest based purely on the distance observed from their current position. Each step taken makes the route more optimal just as Dijkstra adds vertices based on minimum distance.

The key to establishing correctness in the Dijkstra algorithm is to establish what is called an invariant... the burnt vertices are correctly solved.

In this section, an invariant is introduced, which is a condition that must hold true throughout the algorithm's execution. It asserts that at any stage, the distances assigned to burnt vertices represent the shortest paths from the source. The correctness is proven by induction: starting with the source vertex, the property extends to all newly burnt vertices without contradiction.

Think of a treasure hunt where each found treasure represents a burnt vertex. After each discovery, you check that the distance to the next treasure (vertex) is indeed the shortest found so far. This confirms that your treasure map (the graph) accurately reflects the shortest paths.

Now, we want to add a new one... that if we now add this to our burnt set... the distance of v cannot be actually smaller than what we have computed now.

This chunk examines how new vertices are integrated into the burnt set. When a vertex is chosen based on the minimum distance, it is asserted that no shorter path to that vertex exists through other unburnt vertices. The reasoning solidifies the algorithm's correctness as it maintains the invariant established earlier.

As in a delivery route where you always choose the closest next delivery location based on the current distances, ensuring you never backtrack to a previous delivery if that new location is more optimal.

So, now having established that it is correct, let us look at the complexity... In each iteration, we burnt a vertex...

The complexity discussion involves understanding the time taken by Dijkstra's algorithm to execute. It mentions that finding the next vertex to burn takes time proportional to the number of vertices, as does scanning through edges. The overall time complexity is generally quadratic (O(n²)), but this can be optimized with better data structures.

Consider organizing a meeting where everyone must respond about their availability. If you email them one at a time, it takes longer (O(n²)). But if you use a group chat (a more efficient data structure), you can get quicker responses from everyone, reducing the coordination time significantly.

Dijkstra algorithm makes a very crucial assumption... if we choose v as the next neighbor to add to our burn set...

This chunk highlights an essential limitation of Dijkstra’s algorithm: it does not work with graphs that contain negative weight edges. It explains that if a graph contains negative cycles, the concept of shortest paths becomes meaningless, as paths can be shortened indefinitely by traversing the cycle.

Imagine a situation where you're driving along a route that loops back on itself but offers gas refunds at certain points (negative weight). Sometimes, you might go around the loop multiple times to minimize your overall costs, making it impossible to accurately determine the shortest path.

If I have negative cycles in a graph... it could have negative edges, but not negative cycle.

The conclusion summarizes that while negative edges can be present in a graph where Dijkstra is applied, the absence of negative cycles is essential for the algorithm's functionality. Algorithms like Bellman-Ford address the presence of negative weights while maintaining path integrity.

This is akin to budgeting where you can have expenses and rebates (negative weights). As long as there are no cycles where you can endlessly take rebates, you can maintain a valid financial plan.

--