27.1. Design and Analysis of Algorithms, Chennai

So, now let us analyze Dijkstra’s algorithm for the single source shortest path problem. So, recall that Dijkstra's algorithms operate by burning vertices in the analogy we used.

Dijkstra's algorithm is used to solve the single source shortest path problem, which means it helps find the shortest path from a starting point (source vertex) to all other vertices in a graph. The term 'burning vertices' refers to marking a vertex as visited and finalizing its shortest path once it has been processed.

Imagine a firefighter in a building trying to find the shortest escape route. As they explore, they mark rooms they have already checked (burned vertices) to avoid going back. Dijkstra’s algorithm works similarly - it explores options in an organized manner to find the quickest route.

Initially nothing is visited and we do not know any distance to any vertex. So, we assume all distances at infinity. When we start at the source vertex, let us call it 1 by assumption. So, we set its distance to 0.

At the start, all vertices in the graph are unknown, meaning we cannot see how far away they are from the source vertex. Therefore, we assume that the distance to each vertex is infinity. The only exception is the source vertex itself, which we set to have a distance of zero since that's where we start from.

Think of a map where you're at your home (the source vertex). Initially, you don't know how far any other location is, so it's like saying all distances are infinite. However, since you are at home, the distance to your location is zero.

We repeatedly pick up the first vertex, which is not burnt and which has the minimum distance among those which are not burnt, visited and recomputed the distance to all its neighbors.

The algorithm works by continuously selecting the vertex that is closest to the source and has not yet been visited (or 'burned'). Once a vertex is chosen, the algorithm checks all of its neighboring vertices to see if the shortest path to them can be improved by going through the newly 'burned' vertex.

Imagine you are driving with a map, and you want to reach multiple destinations. Every time you reach a new location (burn a vertex), you check which neighboring locations can be accessed more quickly now that you've arrived at your current location. This is akin to reassessing your path based on that new information.

Before we look at the complexity of this algorithm, we actually first have to verify that it is correct. So, Dijkstra's algorithms now make these sequences of updates...

Before evaluating how efficient Dijkstra's algorithm is (its complexity), we must ensure that it produces correct results. The correctness can be verified through a concept called an 'invariant,' which helps us ascertain that once a vertex is burned, the shortest distance to it from the source vertex is indeed accurate.

Consider completing a jigsaw puzzle: once a piece has been correctly placed (burned), you can be confident that it fits without needing to change it again. Similarly, Dijkstra’s algorithm confirms each step is accurate before moving forward.

...this kind of strategy actually is correct. So, this is a general class of algorithms called greedy algorithms...

Dijkstra’s algorithm is categorized as a greedy algorithm. The fundamental principle of greedy algorithms is to make the best local choice at each step with the hope that these local choices will lead to a globally optimal solution.

Think of a person trying to gather a set of coins of varying values. A greedy approach would be to always pick the largest coin available. While this might lead to the highest total value in many cases, it's essential to analyze whether a combination of different lower-value coins might produce a better total later.

So, the key to establishing correctness in this particular case is which establishes what is called an invariant...

An invariant is a condition that remains true throughout the execution of the algorithm. In Dijkstra's algorithm, the invariant claims that at every point during the iterations, the distances assigned to all 'burned' vertices indeed represent the shortest distances from the source vertex.

Imagine you're tanking an investment by checking stock prices daily and noting when you sold a stock at a good price. You could rationalize that your records of historical prices represent the best times to sell. Maintaining this record (the invariant) helps you ensure accuracy in your investment strategy.

Now having established that it is correct, let us look at the complexity...

The complexity measures how the runtime of Dijkstra's algorithm scales with the number of vertices and edges in the graph. When implemented with an adjacency matrix, its time complexity is O(n^2). However, using more efficient data structures like adjacency lists with heaps can reduce the complexity to O(n log n), which is significantly more efficient as the size of the graph increases.

Think of searching for a book in a library. If books are organized randomly on shelves (adjacency matrix), you waste time looking for each book. If they are categorized clearly (adjacency list with heaps), finding a book becomes much faster, improving your efficiency considerably.

Dijkstra algorithm makes a very crucial assumption which underlies the correctness of its greedy step, and that is that there is no negative cost...

While Dijkstra's algorithm works well for graphs without negative edge weights, having such edges can lead to incorrect results. A negative edge means the algorithm might overlook shorter paths, as paths can become misleadingly shorter through negative weights.

Think of a situation where taking a detour might save time because part of the route has a toll refund (negative cost). If you're only considering how long the routes are without knowing about refunds, you might choose a longer route without realizing the detour would have been faster.

If instead of plus 1, I said that this was plus 7... there are other algorithms, other than Dijkstra's algorithm which can handle these...

In cases where negative edge weights exist but no negative cycles are present, alternative algorithms such as the Bellman-Ford algorithm can be employed to find the shortest path, as it accounts for negative weights effectively.

Similar to how some calculators provide different ways to evaluate equations, there are algorithms for different scenarios in graph theory. When specific conditions apply—like negative weights—a different tool (algorithm) might be more effective.

--