Dial's Algorithm (Optimized Dijkstra for small range weights)

Last Updated : 31 May, 2025

Given a weighted Graph and a source vertex, the task is to find the shortest paths from the source node to all other vertices.

Example:

Input : n = 9, src = 0
Output : 0 4 12 19 21 11 9 8 14

We have learned about how to find the shortest path from a given source vertex to all other vertex using Dijkstra's shortest path algorithm with the Time Complexity of O(E log V) in this article.

Can we optimize Dijkstra's shortest path algorithm to work better than O(E log V) if the maximum weight is small (or the range of edge weights is small)?

For example, in the above diagram, the maximum weight is 14. Many times the range of weights on edges is in a small range (i.e. all edge weights can be mapped to 0, 1, 2.. W where W is a small number). In that case, Dijkstra’s algorithm can be modified by using different data structures, and buckets, which is called dial implementation of Dijkstra's algorithm. time complexity is O(E + WV) where W is the maximum weight on any edge of the graph, so we can see that, if W is small then this implementation runs much faster than the traditional algorithm.

The following are important observations.

The maximum distance between any two nodes can be at max w(V – 1) (w is maximum edge weight and we can have at max V-1 edges between two vertices).
In the Dijkstra algorithm, distances are finalized in non-decreasing, i.e., the distance of the closer (to given source) vertices is finalized before the distant vertices.

Approach:

The idea is to use bucket based optimization for Dijkstra's algorithm when edge weights are small integers. Instead of using a priority queue, we create buckets for each possible distance value and process nodes in distance order by iterating through buckets sequentially.

Step by step approach:

Create buckets equal to maximum possible distance and initialize source distance as zero in first bucket.
Iterate through buckets sequentially and process all nodes in current bucket:
- For each node, examine all adjacent nodes and calculate new distance through current node.
- If shorter path found, remove node from its current bucket and place in bucket corresponding to new distance.

C++

// C++ program to find Shortest Path using Dial's Algorithm
#include <bits/stdc++.h>
using namespace std;

// Function to find Shortest Path
vector<int> shortestPath(int n, int src, vector<vector<int>> &edges) {
    vector<vector<vector<int>>> adj(n);
    int maxWeight = 0;
    
    // Build adjacency list and find maximum weight
    for (auto e: edges) {
        adj[e[0]].push_back({e[1], e[2]});
        adj[e[1]].push_back({e[0], e[2]});
        maxWeight = max(maxWeight, e[2]);
    }
    
    // Initialize distance array
    vector<int> dist(n, INT_MAX);
    dist[src] = 0;
    
    // Create buckets for distances
    int maxDist = (n - 1) * maxWeight;
    vector<unordered_set<int>> buckets(maxDist + 1);
    
    // Add source to bucket 0
    buckets[0].insert(src);
    
    // Process buckets in order
    for (int d = 0; d <= maxDist; d++) {
        
        // Process all nodes in current bucket
        while (!buckets[d].empty()) {
            int u = *buckets[d].begin();
            buckets[d].erase(buckets[d].begin());
            
            // Skip if we already found a better path
            if (d > dist[u]) continue;
            
            // Process all adjacent nodes
            for (auto& edge : adj[u]) {
                int v = edge[0];
                int weight = edge[1];
                int newDist = dist[u] + weight;
                
                // If shorter path found
                if (newDist < dist[v]) {
                    
                    // Remove from old bucket if it was there
                    if (dist[v] != INT_MAX) {
                        buckets[dist[v]].erase(v);
                    }
                    
                    // Update distance and add to new bucket
                    dist[v] = newDist;
                    buckets[newDist].insert(v);
                }
            }
        }
    }
    
    return dist;
}

int main() {
    int n = 9;
    int src = 0;
    vector<vector<int>> edges = {
        {0, 1, 4},
        {0, 7, 8},
        {1, 2, 8},
        {1, 7, 11},
        {2, 3, 7},
        {2, 8, 2},
        {3, 4, 9},
        {3, 5, 14},
        {4, 5, 10},
        {5, 6, 2},
        {6, 7, 1},
        {6, 8, 6},
        {7, 8, 7}
    };
    
    vector<int> res = shortestPath(n, src, edges);
    for (auto val : res) {
        cout << val << " ";
    }
    cout << endl;
    return 0;
}

Java

// Java program to find Shortest Path using Dial's Algorithm

import java.util.*;

class GfG {
    
    // Function to find Shortest Path
    static int[] shortestPath(int n, int src, int[][] edges) {
        ArrayList<ArrayList<ArrayList<Integer>>> adj = new ArrayList<>();
        int maxWeight = 0;
        
        // Build adjacency list and find maximum weight
        for (int i = 0; i < n; i++) {
            adj.add(new ArrayList<>());
        }
        for (int[] e : edges) {
            ArrayList<Integer> edge1 = new ArrayList<>();
            edge1.add(e[1]);
            edge1.add(e[2]);
            adj.get(e[0]).add(edge1);
            
            ArrayList<Integer> edge2 = new ArrayList<>();
            edge2.add(e[0]);
            edge2.add(e[2]);
            adj.get(e[1]).add(edge2);
            
            maxWeight = Math.max(maxWeight, e[2]);
        }
        
        // Initialize distance array
        int[] dist = new int[n];
        Arrays.fill(dist, Integer.MAX_VALUE);
        dist[src] = 0;
        
        // Create buckets for distances
        int maxDist = (n - 1) * maxWeight;
        ArrayList<HashSet<Integer>> buckets = new ArrayList<>(maxDist + 1);
        for (int i = 0; i <= maxDist; i++) {
            buckets.add(new HashSet<>());
        }
        
        // Add source to bucket 0
        buckets.get(0).add(src);
        
        // Process buckets in order
        for (int d = 0; d <= maxDist; d++) {
            
            // Process all nodes in current bucket
            while (!buckets.get(d).isEmpty()) {
                int u = buckets.get(d).iterator().next();
                buckets.get(d).remove(u);
                
                // Skip if we already found a better path
                if (d > dist[u]) continue;
                
                // Process all adjacent nodes
                for (ArrayList<Integer> edge : adj.get(u)) {
                    int v = edge.get(0);
                    int weight = edge.get(1);
                    int newDist = dist[u] + weight;
                    
                    // If shorter path found
                    if (newDist < dist[v]) {
                        
                        // Remove from old bucket if it was there
                        if (dist[v] != Integer.MAX_VALUE) {
                            buckets.get(dist[v]).remove(v);
                        }
                        
                        // Update distance and add to new bucket
                        dist[v] = newDist;
                        buckets.get(newDist).add(v);
                    }
                }
            }
        }
        
        return dist;
    }

    public static void main(String[] args) {
        int n = 9;
        int src = 0;
        int[][] edges = {
            {0, 1, 4},
            {0, 7, 8},
            {1, 2, 8},
            {1, 7, 11},
            {2, 3, 7},
            {2, 8, 2},
            {3, 4, 9},
            {3, 5, 14},
            {4, 5, 10},
            {5, 6, 2},
            {6, 7, 1},
            {6, 8, 6},
            {7, 8, 7}
        };
        
        int[] res = shortestPath(n, src, edges);
        for (int val : res) {
            System.out.print(val + " ");
        }
        System.out.println();
    }
}

Python

# Python program to find Shortest Path using Dial's Algorithm

import sys
from collections import defaultdict

def shortestPath(n, src, edges):
    adj = [[] for _ in range(n)]
    maxWeight = 0
    
    # Build adjacency list and find maximum weight
    for e in edges:
        adj[e[0]].append([e[1], e[2]])
        adj[e[1]].append([e[0], e[2]])
        maxWeight = max(maxWeight, e[2])
    
    # Initialize distance array
    dist = [sys.maxsize] * n
    dist[src] = 0
    
    # Create buckets for distances
    maxDist = (n - 1) * maxWeight
    buckets = defaultdict(set)
    
    # Add source to bucket 0
    buckets[0].add(src)
    
    # Process buckets in order
    for d in range(maxDist + 1):
        # Process all nodes in current bucket
        while d in buckets and buckets[d]:
            u = buckets[d].pop()
            
            # Skip if we already found a better path
            if d > dist[u]:
                continue
            
            # Process all adjacent nodes
            for edge in adj[u]:
                v, weight = edge[0], edge[1]
                newDist = dist[u] + weight
                
                # If shorter path found
                if newDist < dist[v]:
                    # Remove from old bucket if it was there
                    if dist[v] != sys.maxsize:
                        buckets[dist[v]].discard(v)
                    
                    # Update distance and add to new bucket
                    dist[v] = newDist
                    buckets[newDist].add(v)
    
    return dist

if __name__ == "__main__":
    n = 9
    src = 0
    edges = [
        [0, 1, 4],
        [0, 7, 8],
        [1, 2, 8],
        [1, 7, 11],
        [2, 3, 7],
        [2, 8, 2],
        [3, 4, 9],
        [3, 5, 14],
        [4, 5, 10],
        [5, 6, 2],
        [6, 7, 1],
        [6, 8, 6],
        [7, 8, 7]
    ]
    
    res = shortestPath(n, src, edges)
    for val in res:
        print(val, end=" ")
    print()

// C# program to find Shortest Path using Dial's Algorithm

using System;
using System.Collections.Generic;

class GfG {
    
    // Function to find Shortest Path
    static int[] shortestPath(int n, int src, int[][] edges) {
        List<List<List<int>>> adj = new List<List<List<int>>>();
        int maxWeight = 0;
        
        // Build adjacency list and find maximum weight
        for (int i = 0; i < n; i++) {
            adj.Add(new List<List<int>>());
        }
        foreach (int[] e in edges) {
            adj[e[0]].Add(new List<int> {e[1], e[2]});
            adj[e[1]].Add(new List<int> {e[0], e[2]});
            maxWeight = Math.Max(maxWeight, e[2]);
        }
        
        // Initialize distance array
        int[] dist = new int[n];
        Array.Fill(dist, int.MaxValue);
        dist[src] = 0;
        
        // Create buckets for distances
        int maxDist = (n - 1) * maxWeight;
        List<HashSet<int>> buckets = new List<HashSet<int>>(maxDist + 1);
        for (int i = 0; i <= maxDist; i++) {
            buckets.Add(new HashSet<int>());
        }
        
        // Add source to bucket 0
        buckets[0].Add(src);
        
        // Process buckets in order
        for (int d = 0; d <= maxDist; d++) {
            
            // Process all nodes in current bucket
            while (buckets[d].Count > 0) {
                int u = 0;
                foreach (int node in buckets[d]) {
                    u = node;
                    break;
                }
                buckets[d].Remove(u);
                
                // Skip if we already found a better path
                if (d > dist[u]) continue;
                
                // Process all adjacent nodes
                foreach (List<int> edge in adj[u]) {
                    int v = edge[0];
                    int weight = edge[1];
                    int newDist = dist[u] + weight;
                    
                    // If shorter path found
                    if (newDist < dist[v]) {
                        
                        // Remove from old bucket if it was there
                        if (dist[v] != int.MaxValue) {
                            buckets[dist[v]].Remove(v);
                        }
                        
                        // Update distance and add to new bucket
                        dist[v] = newDist;
                        buckets[newDist].Add(v);
                    }
                }
            }
        }
        
        return dist;
    }

    static void Main() {
        int n = 9;
        int src = 0;
        int[][] edges = new int[][] {
            new int[] {0, 1, 4},
            new int[] {0, 7, 8},
            new int[] {1, 2, 8},
            new int[] {1, 7, 11},
            new int[] {2, 3, 7},
            new int[] {2, 8, 2},
            new int[] {3, 4, 9},
            new int[] {3, 5, 14},
            new int[] {4, 5, 10},
            new int[] {5, 6, 2},
            new int[] {6, 7, 1},
            new int[] {6, 8, 6},
            new int[] {7, 8, 7}
        };
        
        int[] res = shortestPath(n, src, edges);
        foreach (int val in res) {
            Console.Write(val + " ");
        }
        Console.WriteLine();
    }
}

JavaScript

// Js program to find Shortest Path using Dial's Algorithm

function shortestPath(n, src, edges) {
    const adj = Array.from({length: n}, () => []);
    let maxWeight = 0;
    
    // Build adjacency list and find maximum weight
    for (const e of edges) {
        adj[e[0]].push([e[1], e[2]]);
        adj[e[1]].push([e[0], e[2]]);
        maxWeight = Math.max(maxWeight, e[2]);
    }
    
    // Initialize distance array
    const dist = new Array(n).fill(Infinity);
    dist[src] = 0;
    
    // Create buckets for distances
    const maxDist = (n - 1) * maxWeight;
    const buckets = Array.from({length: maxDist + 1}, () => new Set());
    
    // Add source to bucket 0
    buckets[0].add(src);
    
    // Process buckets in order
    for (let d = 0; d <= maxDist; d++) {
        
        // Process all nodes in current bucket
        while (buckets[d].size > 0) {
            const u = buckets[d].values().next().value;
            buckets[d].delete(u);
            
            // Skip if we already found a better path
            if (d > dist[u]) continue;
            
            // Process all adjacent nodes
            for (const edge of adj[u]) {
                const [v, weight] = edge;
                const newDist = dist[u] + weight;
                
                // If shorter path found
                if (newDist < dist[v]) {
                    
                    // Remove from old bucket if it was there
                    if (dist[v] !== Infinity) {
                        buckets[dist[v]].delete(v);
                    }
                    
                    // Update distance and add to new bucket
                    dist[v] = newDist;
                    buckets[newDist].add(v);
                }
            }
        }
    }
    
    return dist;
}

const n = 9;
const src = 0;
const edges = [
    [0, 1, 4],
    [0, 7, 8],
    [1, 2, 8],
    [1, 7, 11],
    [2, 3, 7],
    [2, 8, 2],
    [3, 4, 9],
    [3, 5, 14],
    [4, 5, 10],
    [5, 6, 2],
    [6, 7, 1],
    [6, 8, 6],
    [7, 8, 7]
];

const res = shortestPath(n, src, edges);
console.log(res.join(' '));

Output

0 4 12 19 21 11 9 8 14

Time Complexity: O(V + E + W×V), where W is the maximum weight of an edge.
Space Complexity: O(V + W×V) for storing buckets and adjacency list.

Advantages:

Dial's algorithm can be much faster than Dijkstra's algorithm for graphs with small range weights.
It is easy to implement and modify from Dijkstra's algorithm.

Disadvantages:

Dial's algorithm is only applicable when the range of the edge weights is small. For graphs with large range weights, Dijkstra's algorithm may be faster.

Minimum cost to connect all cities

Utkarsh Trivedi

Improve

Article Tags :

Practice Tags :

Dial's Algorithm (Optimized Dijkstra for small range weights)

Advantages:

Disadvantages:

Similar Reads

Standard Greedy algorithms

Greedy algorithm on Array

Greedy algorithm on Operating System

Greedy algorithm on Graph

Thank You!

What kind of Experience do you want to share?