27.1.6. Lecture - 26

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. We keep track of vertices which have burnt or initially nothing is visited and initially we do not know any distance to any vertex. So, we have assumes all distances that at infinity. When we start at the source vertex, let us call it 1 by assumption. So, we set its distance to 0. Then, 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.

Dijkstra's algorithm is designed to find the shortest path from a source vertex to all other vertices in a graph. Initially, no vertices are visited and their distances are set to infinity, indicating that they cannot be reached yet. The algorithm starts at a source vertex (which we can label as '1') and sets its distance to 0 because no distance is needed to reach itself. The algorithm then continuously selects the unvisited vertex with the smallest distance and updates the distances of its neighboring vertices based on the shortest path found so far. This process is akin to 'burning' or finalizing the shortest distance for that vertex before moving on to the next one. Essentially, it uses a greedy approach to make local optimal choices to eventually reach a global optimum.

Imagine you are on a hiking trail. At the start, you know your current location (the source) and can see some distances to nearby campsites (neighbors). Your goal is to determine the shortest path to reach each campsite. Initially, you only have your current campsite (source) marked. As you explore, you repeatedly look around (pick an unburnt vertex) and see which campsite is closest (minimum distance). Each time you reach a new campsite, you calculate how long it would take to other campsites from here, helping you discover the quickest routes along the way.

So, before we look at the complexity of these algorithms, we actually first have to verify that it is correct. Dijkstra's algorithms now make these sequences of updates. It is a bit analysis to BFS and DFS, because it keeps visiting vertices and it visits every vertex only once. Now, its visits vertices in a particular order which is different from breadth-first or the depth-first, and we need to justify that this order is actually correct. So, at every point, breadth-first search looks at all its neighbors and visits them in the order of their vertex number... So, this is a way to show that Dijkstra's greedy strategy actually solves this problem correctly.

To ensure that Dijkstra's algorithm is correct, we must establish that the distances assigned to the 'burnt' vertices represent the shortest paths from the source. The algorithm leverages an enduring property called an invariant, which asserts that every time a vertex is ‘burnt’, its distance is indeed the shortest from the source. Even though other paths might lead to this vertex later, the choice of the next vertex to burn is dictated by having the smallest known distance, checked against all potential vertices, which guarantees that no shorter path exists once a vertex is burnt. Hence, this ‘greedy’ approach—selecting the immediate best option—brings forth the globally best solution for all vertices.

Think of assembling a team for a project. Each member has specific skills, and your goal is to form the best team. Each time you select a member (burn a vertex), you ensure they are the most skilled for the role based on current understanding (minimum distance). After selection, you assign them tasks (update neighboring vertices). Once picked, that choice is final, and you can’t go back to consider them for a different task; hence, the skill set they brought ensures that the team's progress remains optimal. Similarly, Dijkstra’s guarantee that the choices made lead to the best overall outcome.

So, now having established that it is correct, let us look at the complexity. ... So overall its order n square. ... So, activate to get around this bottleneck, we need to maintain the burnt times in a most sophisticated data structure, ... this can be done using a tree-like structure... show that finding the minimum burn time takes log n time...

Once we confirm that Dijkstra's algorithm works correctly, we must analyze its performance. The algorithm features two main loops. Initially, there’s a linear loop to set all vertices as unvisited and their distances to infinity. After establishing the unvisited set, repeatedly selecting the vertex with the smallest distance leads to scanning all unvisited vertices. This process, combined with updating the distances to neighboring vertices, contributes to a complexity of O(n^2) due to the nested loops. To improve this, instead of simple lists, we can utilize more efficient data structures like heaps, which reduce the time complexity to O(n log n) by allowing us to quickly retrieve and update vertices' distances, significantly enhancing algorithm performance.

Comparing this to managing tasks or appointments—if you use a simple list, checking through each task to find the most urgent one can be cumbersome and time-consuming (O(n^2)). However, if you use a smart digital organizer with filters (heaps), you can quickly find the most urgent tasks and modify them easily (O(n log n)). This efficiency means you can handle more work in less time, just like Dijkstra’s algorithm becomes more efficient with better structures.

So, Dijkstra algorithm makes a very crucial assumption which underlies the correctness of its greedy step, and that is that there is no negative cost associated to the nature... So, now of course you might want to ask why you want to put a negative ways in a graph at all. ... So, what do we do here negative edge weights?

Dijkstra’s algorithm assumes that the edge costs—usability relevant to the paths—are non-negative. This assumption ensures that once a vertex is visited (burnt), any further paths calculated cannot yield a shorter distance. However, negative edges lead to scenarios where a previously visited vertex could suddenly have a shorter path introduced later, invalidating the algorithm’s outcomes. This means that if negative weights are present, we need alternate algorithms, such as the Bellman-Ford algorithm, which can effectively handle these cases without negative cycles.

Imagine planning a budget for a trip whereby some chosen routes incur costs while certain detours save you money (negative edges). Dijkstra’s algorithm would fail if it assumed all travel costs were strictly additive since new savings could make previous routes non-optimal. Just like in budgeting, knowing when to change strategies (to another algorithm like Bellman-Ford) is crucial to managing costs wisely.

--