Dial's Algorithm

Introduction

Dial's Algorithm is an optimization to Dijkstra's Algorithm, specifically targeting scenarios where edge weights fall within a small range. It was developed by Daniel Dial in 1970.

Dijkstra's algorithm works by maintaining a set of unvisited vertices and iteratively selecting the vertex with the smallest tentative distance to add to the visited set. In contrast, Dial's Algorithm works by maintaining a set of buckets, where each bucket contains vertices with a particular distance from the source vertex.

Algorithm

1. Initialize an array of buckets, where each bucket corresponds to a particular distance from the source vertex.
2. Insert the source vertex into the appropriate bucket based on its distance from the source vertex.
3. While there are buckets with vertices: a. Select the bucket with the smallest distance from the source vertex. b. Remove the vertex with the smallest tentative distance from the bucket and mark it as visited. c. For each neighbor of the selected vertex: i. If the neighbor has not been visited and its tentative distance is less than the upper bound of the current bucket, remove it from its current bucket and insert it into the appropriate bucket based on its distance from the source vertex.

Code

Here is an implementation of Dial's Algorithm in Python:

from collections import deque
from math import inf

def dijkstra_with_dials(adj_list, start):
    buckets = [deque() for _ in range(max(adj_list)+1)]  # Create buckets
    visited = set()  # Create visited set
    distances = {node: inf for node in adj_list}  # Create distances dict
    distances[start] = 0  # Initialize start distance
    buckets[0].append(start)  # Insert start node into bucket 0
    
    while any(buckets):
        bucket_idx = 0
        while not buckets[bucket_idx]:
            bucket_idx += 1  # Find first non-empty bucket
        
        vertex = buckets[bucket_idx].popleft()  # Remove vertex from bucket and mark as visited
        visited.add(vertex)
        
        for neighbor, weight in adj_list[vertex].items():
            if neighbor in visited:
                continue
                
            new_distance = distances[vertex] + weight
            if new_distance >= len(buckets):
                buckets += [deque() for _ in range(new_distance-len(adj_list)+1)]  # Extend bucket list if needed
                
            if new_distance < distances[neighbor]:
                old_bucket_idx = distances[neighbor]
                distances[neighbor] = new_distance
                new_bucket_idx = new_distance
                
                buckets[old_bucket_idx].remove(neighbor)  # Remove neighbor from old bucket
                buckets[new_bucket_idx].append(neighbor)  # Insert neighbor into new bucket
                
    return distances

Conclusion

Dial's Algorithm is an efficient optimization to Dijkstra's Algorithm that can significantly speed up shortest path calculations for scenarios where edge weights fall within a small range. By maintaining buckets of vertices based on their distance from the source vertex, Dial's Algorithm can avoid much of the unnecessary iteration that Dijkstra's Algorithm can encounter.