University Institute of Engineering Department of

Computer Science & Engineering

CASE STUDY

UNIVERSITY INSTITUTE OF ENGINEERING

SUBJECT NAME-DATASTRUCTURES

SUBJECT CODE - 22CSH-211

DIJKSTRA ALGORITHM FOR NEGATIVE EDGE WEIGHTS

SUBMITTED TO: MS. KAMNA SHARMA NAME: PARSANT VARDHAN

SUBMITTED BY: PARSHANT VARDHAN UID: 22BCS12914

FACULTYNAME: MS. KAMNA SHARMA SECTION:22BCS-706

GROUP: B
 University Institute of Engineering Department of
Computer Science & Engineering

Abstract

Dijkstra's algorithm is a renowned method for finding the shortest path in weighted
graphs, but its traditional version is limited by its inability to handle negative edge
weights. In this abstract, we explore adaptations and extensions of Dijkstra's
algorithm that allow it to address graphs containing negative edge weights, an
important consideration for real-world applications. Various techniques, including
the use of Bellman-Ford algorithm, graph transformations, weight restrictions, and
specialized algorithms, are discussed to mitigate the challenges posed by negative
weights. By providing an overview of these approaches, this abstract shed light on
the strategies that enable Dijkstra's algorithm to effectively navigate the
complexities of graphs with negative edge weights, ultimately expanding its utility
in solving optimization problems in diverse fields.
 University Institute of Engineering Department of
Computer Science & Engineering

Problem Statements: Dijkstra algorithm for Negative Edge Weights

Dijkstra's algorithm assumes that all edge weights in the graph are non-negative. This assumption is
fundamental to the algorithm's correctness. If there are negative edge weights in the graph, Dijkstra's
algorithm can produce incorrect results. The reason for this limitation is rooted in the algorithm's greedy
nature. It continually selects the node with the smallest tentative distance from the source node and
relaxes its neighboring nodes. When negative edge weights are present, it becomes possible for the
algorithm to get caught in a cycle with negative weight, causing it to produce incorrect, often negative,
distances. Such cycles are known as "negative weight cycles."

Objectives:

1. To demonstrate how Dijkstra's algorithm can be applied to optimize route planning in a

transportation network.

2. To illustrate the algorithm's efficiency in finding the shortest path.

3. To evaluate the impact of changing parameters (e.g., traffic conditions) on route

planning.

Figure 1
 University Institute of Engineering Department of
Computer Science & Engineering

Introduction

Dijkstra's algorithm is a fundamental and widely used method in computer science and
mathematics for finding the shortest path between nodes in a weighted graph. Named after its
inventor, Dutch computer scientist Edsger W. Dijkstra, the algorithm was first introduced in 1956
and has since become a cornerstone of various applications, ranging from transportation network
optimization to computer networking and robotics.
The core objective of Dijkstra's algorithm is to determine the most efficient path from a starting
node to all other nodes in a graph, considering the associated weights or costs of traversing edges
between nodes. Unlike some other path-finding algorithms, such as breadth-first search (BFS) or
depth-first search (DFS), Dijkstra's algorithm can handle graphs with weighted edges, making it
particularly suitable for solving real-world routing and optimization problems.

When applied to navigation services like Google Maps, Dijkstra's algorithm enables users to find
optimal routes for various modes of transportation, including driving, walking, cycling, and public
transit. It considers factors such as road lengths, speed limits, turn restrictions, real-time traffic
data, and elevation changes to provide accurate and up-to-date route recommendations.

The algorithm's versatility and efficiency have made it a vital component in modern navigation
systems, computer networks, and various logistical applications. Its impact extends beyond
computer science and mathematics, with practical applications in transportation planning, logistics
optimization, and even biology, where it is used to model processes like neuronal connectivity and
disease spread.
 University Institute of Engineering Department of
Computer Science & Engineering

Background
Dijkstra's algorithm, named after Dutch computer scientist Edsger W. Dijkstra, is a foundational
algorithm in the field of graph theory and computer science. It originated in 1956 while Dijkstra
was working at the Mathematical Center in Amsterdam, initially conceived to solve the problem
of finding the shortest route on a map of the Dutch road network. The algorithm was purpose-built
to address the single-source shortest path problem within weighted graphs, where edges between
nodes carry non-negative weights, representing distances, costs, or time. Its remarkable feature is
its ability to guarantee the discovery of the shortest path, making it highly reliable for route
planning and optimization across diverse applications, including road networks, computer
networks, and more.

Current Implementation of Dijkstra's Algorithm:

Dijkstra's algorithm maintains its significance in contemporary contexts, with various
implementations tailored to specific applications and programming languages. While the
fundamental steps remain consistent, modern adaptations incorporate optimizations and data
structures for efficient execution. Implementations rely on data structures to represent the graph,
often employing adjacency lists or matrices. The algorithm begins by initializing data structures
to track distances and visited nodes, with the distance to the source node set at zero and all others
at infinity. A priority queue, often implemented as a min-heap, facilitates selecting nodes with the
shortest distance. Termination occurs when all nodes are visited, or the destination is reached.
Post-completion, path reconstruction allows users to find the shortest route between nodes.

Current Use Cases:

Dijkstra's algorithm finds application across an array of modern scenarios. In navigation services
like Google Maps, it powers route optimization for driving, walking, cycling, and public transit,
considering factors such as distance, time, and real-time traffic data. In computer networking, it
underpins routing protocols like OSPF, facilitating efficient data transmission paths. Furthermore,
transportation and logistics companies employ it for delivery route optimization and airline
scheduling. Dijkstra's algorithm is also instrumental in analyzing social networks and making
recommendations based on shortest paths, and in game development, it helps characters or units
navigate virtual worlds. Robotics benefits from the algorithm for path planning and real-world
navigation. Overall, Dijkstra's algorithm continues to be a versatile and essential tool in computer
science, addressing complex optimization problems where finding the shortest path is of utmost
importance.
 University Institute of Engineering Department of
Computer Science & Engineering

Methodology
1. Algorithm Overview:
Dijkstra's algorithm is a versatile and widely-used approach for solving the single-source shortest
path problem in weighted graphs. Its core objective is to find the shortest path from a specified
source node to all other nodes in the graph, considering the weights associated with each edge.
The algorithm operates by iteratively exploring neighboring nodes, gradually building up the
shortest paths to those nodes.
At the beginning of the algorithm, all nodes are assigned a tentative distance value from the source
node, typically initialized to infinity. The source node itself is given a distance of zero. The
algorithm then repeatedly selects the node with the smallest tentative distance (usually done using
a priority queue or min-heap) as the current node. It explores its neighboring nodes, calculating
their tentative distances through the current node. If a shorter path is found, the distance and
predecessor for that node are updated. This process continues until all nodes have been visited or
until the shortest path to a specific destination node is found.

2. Data Structures Used:

Dijkstra's algorithm relies on several data structures to efficiently perform its operations. One of
the key data structures is the priority queue or min-heap, which enables the algorithm to select
nodes with the smallest tentative distances efficiently. Additionally, an array or data structure is
used to maintain and update the tentative distances and predecessors for each node. In most
implementations, an adjacency list or matrix represents the graph's structure and weights, allowing
for efficient access to neighboring nodes and edge weights during exploration. This data structure
choice impacts the algorithm's efficiency, with adjacency lists being more space-efficient for
sparse graphs and adjacency matrices more suitable for dense graphs.

3. Implementation:
To implement Dijkstra's algorithm, you need to set up the graph, initialize data structures, and
execute the algorithm's steps. The algorithm starts by initializing the distance values, typically
using an array or data structure where each node's distance is initially set to infinity, except for the
source node, which is set to zero. It then utilizes a priority queue or min-heap to select the node
with the smallest tentative distance as the current node. For each neighboring node of the current
node, it calculates a tentative distance through the current node, updates the distance if a shorter
path is found, and adds the node to the priority queue for further exploration. This process
continues until all nodes are visited or, if you're interested in finding the shortest path to a specific
destination, until that destination is reached. The efficiency and correctness of the implementation
are essential, especially for large graphs, as the algorithm's runtime depends on the chosen data
structures and optimizations.
 University Institute of Engineering Department of
Computer Science & Engineering

Analysis:

1. Time Complexity:
In the worst-case scenario, where all nodes and edges are considered, Dijkstra's algorithm
has a time complexity of O(|n|^2), where |n| is the number of nodes in the graph. In this
scenario, the algorithm is relatively slow and becomes impractical for large graphs.
However, when a suitable data structure like a priority queue or min-heap is employed to
efficiently select the node with the smallest tentative distance, the time complexity
improves significantly. Using a binary heap, for instance, reduces the time complexity to
O(|E| + |n| * log(|n|)), where |E| is the number of edges. This is a more manageable
complexity for practical purposes.

2. Space Complexity:
The space complexity of Dijkstra's algorithm is O(|n|) for storing distances and
predecessor information. This is because it maintains distance values for all nodes and
predecessor nodes for path reconstruction.

3. Dijkstra's algorithm guarantees finding the shortest path from a single source node to all
other nodes in a graph, provided that the graph has non-negative edge weights. This
makes it a reliable choice for problems where finding the shortest path is essential, such
as route planning and network optimization.

4. Greedy Approach: Dijkstra's algorithm employs a greedy strategy by always selecting the
node with the smallest tentative distance as the current node for exploration. This greedy
choice ensures that the algorithm builds the shortest path incrementally, ultimately
leading to the optimal solution.

5. Applications in Navigation: Dijkstra's algorithm forms the basis of modern navigation

and mapping services like Google Maps. It is used to provide users with optimal routes
for driving, walking, cycling, and public transit, considering factors like distance, travel
time, and real-time traffic data.

6. While it's commonly used for route planning, Dijkstra's algorithm is versatile and can be
applied to various domains beyond transportation. It has applications in computer
networking, robotics, logistics, and more, where finding the shortest path is a critical
optimization task.
 University Institute of Engineering Department of
Computer Science & Engineering

Key Issues and Challenges:

Dijkstra's algorithm is a widely used and effective method for finding the shortest path from a
single source node to all other nodes in a weighted graph. However, it has a notable limitation
related to its applicability for the Single Source Shortest Path problem:
Non-Negative Edge Weights Requirement:
Dijkstra's algorithm assumes that all edge weights in the graph are non-negative. This assumption
is fundamental to the algorithm's correctness. If there are negative edge weights in the graph,
Dijkstra's algorithm can produce incorrect results.
The reason for this limitation is rooted in the algorithm's greedy nature. It continually selects the
node with the smallest tentative distance from the source node and relaxes its neighboring nodes.
When negative edge weights are present, it becomes possible for the algorithm to get caught in a
cycle with negative weight, causing it to produce incorrect, often negative, distances. Such cycles
are known as "negative weight cycles."
Negative weight cycles can lead to two issues

Incorrect Shortest Path: The algorithm may produce a path with a shorter length than the true
shortest path due to the influence of the negative weight cycle.

Infinite Loop: Dijkstra's algorithm may get stuck in an infinite loop when a negative weight cycle
is reachable from the source node. This can prevent the algorithm from terminating.

To address the limitation of negative edge weights, there are alternative algorithms, such as the
Bellman-Ford algorithm, that can handle graphs with both positive and negative weights. Bellman-
Ford detects negative weight cycles and ensures correct results even in the presence of such cycles.
However, it typically has higher time complexity compared to Dijkstra's algorithm, making it less
efficient for graphs with non-negative weights.

Figure 2
 University Institute of Engineering Department of
Computer Science & Engineering

Solutions and Recommendations

Handling negative edge weights in Dijkstra's algorithm is a significant limitation because the
algorithm assumes that all edge weights are non-negative. When negative edge weights are present
in the graph, it can lead to incorrect results and potentially cause the algorithm to enter an infinite
loop. To address this limitation, several solutions and recommendations can be considered:

Using Bellman-Ford Algorithm: The Bellman-Ford algorithm is a versatile and widely used algorithm
for finding the shortest paths in weighted graphs, including those with negative edge weights and the
presence of negative weight cycles. Developed by Richard Bellman and Lester Ford in the 1950s, this
algorithm addresses a critical limitation of Dijkstra's algorithm by handling graphs where edges can have
non-positive weights.

The algorithm iteratively relaxes edges in the graph, repeatedly considering all edges and relaxing them to
improve distance estimates. It can detect negative weight cycles, a feature that makes it suitable for cases
where Dijkstra's algorithm would produce incorrect results. When used to find the shortest path from a
single source node to all other nodes, Bellman-Ford guarantees that the shortest paths are correctly
computed, provided there are no negative weight cycles reachable from the source node.

In some cases, you can preprocess the graph to transform it into an equivalent form that removes
negative weights or converts them into non-negative values. This preprocessing can involve
techniques like Johnson's algorithm, which reweights the edges to eliminate negative weights
without altering the shortest paths.

Before applying Dijkstra's algorithm, consider whether preprocessing the graph to eliminate
negative weights is feasible and practical. This approach allows you to continue using Dijkstra's
algorithm while avoiding the negative weight issue.

In summary, handling negative edge weights in Dijkstra's algorithm requires careful consideration
of the problem context and graph characteristics. The recommended approach often depends on
the frequency of negative weights, the complexity of the graph, and the trade-offs between
computational resources and accuracy. By implementing suitable solutions and recommendations,
you can effectively address this limitation and ensure robust path-finding in graphs with negative
edge weights.
 University Institute of Engineering Department of
Computer Science & Engineering

CONCLUSION

Dijkstra's algorithm is a cornerstone in graph theory and optimization, renowned for its ability to
find the shortest path between nodes in weighted graphs. Over the years, it has been an
invaluable tool for solving real-world problems, from route planning in transportation networks
to optimizing data transmission in computer networks in this comprehensive conclusion, we
delve into the significance of overcoming this limitation, the strategies employed to do so, and
the broader implications for practical applications.

The central challenge with Dijkstra's algorithm lies in its original design, which assumes non-
negative edge weights. This assumption holds for many scenarios, but it does not reflect the
complexities of real-world networks. Negative edge weights can represent various phenomena,
such as downhill slopes, financial incentives, or reduced travel times under specific conditions.
Failing to account for these negative weights can lead to erroneous results and render Dijkstra's
algorithm unsuitable for certain applications.

To address this limitation, several solutions and adaptations have been proposed, each offering a
unique approach to handling negative edge weights:
Bellman-Ford Algorithm: One of the most direct solutions is to switch to the Bellman-Ford
algorithm, which can accommodate graphs with negative edge weights and even detect negative
weight cycles. This algorithm's flexibility comes at the cost of increased time complexity, but it
provides correctness and robustness, particularly when the presence of negative weights is
uncertain.
Graph Transformations: Preprocessing techniques and graph transformations offer another
avenue. These methods involve modifying the graph to eliminate or neutralize negative weights.
For example, Johnson's algorithm reweights edges to ensure non-negative weights, allowing
Dijkstra's algorithm to operate without modification.

In conclusion, Dijkstra's algorithm's ability to adapt to negative edge weights signifies its
resilience and continued relevance in the ever-evolving landscape of optimization and graph
theory. Through careful consideration of the strategies presented, practitioners and researchers
can harness the algorithm's power, extend its applicability, and solve real-world problems with
increased accuracy and efficiency. The journey to overcome the limitation of negative edge
weights has not only enhanced Dijkstra's algorithm but has also enriched the field of graph
algorithms, contributing to a deeper understanding of their practical significance and broader
utility.