CASE STUDY: IMPLEMENTING DIJKSTRA'S ALGORITHM WITH A

PRIORITY QUEUE

Introduction

In this case study, we explore the implementation of Dijkstra's algorithm using a priority queue
(min-heap) in C. Dijkstra's algorithm is widely used to find the shortest path in a graph with
non-negative edge weights. The algorithm is especially relevant in fields like network routing,
geographical mapping, and robot navigation. Here, the graph is represented as a 2D matrix,
where each cell contains a cost, and the goal is to find the minimum cost path from the top-left
corner to the bottom-right corner of the matrix.

Problem Statement

Given a 3X3 matrix where each element represents the cost to traverse that cell, the task is to
determine the minimum cost to move from the top-left corner (0,0) to the bottom-right corner
(2,2), with movements allowed in four directions: up, down, left, and right.

Example Matrix:

1 3 1

1 5 1

4 2 1

Objective:

● Calculate the minimum cost required to move from the top-left corner (0,0) to the
bottom-right corner (2,2).

Purpose

The primary purpose of this case study is to:

1. Demonstrate the Implementation: Show how Dijkstra's algorithm can be implemented

using a priority queue (min-heap) to solve a grid-based shortest path problem.
 2. Optimize Pathfinding: Illustrate the advantages of using a min-heap to improve the
efficiency of Dijkstra's algorithm, making it more suitable for larger or more complex
grids.
3. Educational Insight: Provide a clear understanding of how Dijkstra’s algorithm
operates, particularly in grid environments, and the role of a priority queue in enhancing
its performance.

Approach

Data Structures

To efficiently implement Dijkstra's algorithm, the following data structures are used:

● Node Structure: A structure that represents each cell in the matrix, storing the
cumulative cost to reach that cell, as well as its coordinates (x, y) in the matrix.
● Min-Heap (Priority Queue): A min-heap is used to prioritize nodes based on their
cumulative cost. The node with the lowest cost is always extracted first, ensuring that the
algorithm always extends the least-cost path.

Algorithm Design

The algorithm begins by initializing a minCost matrix, where each cell is set to infinity
(INT_MAX) to indicate that the minimum cost to reach that cell is initially unknown. The cost of
the starting cell (top-left corner) is set to the value of the matrix at that position.

A priority queue (min-heap) is initialized, and the starting node is inserted into the heap with its
cost as the priority. The algorithm then enters a loop where it continuously extracts the node with
the minimum cost from the heap and explores its neighbors.

For each neighboring cell, the algorithm calculates the new cost of reaching that cell by adding
the cost of the current cell to the cost of the neighboring cell. If this new cost is lower than the
previously recorded cost for the neighboring cell, the algorithm updates the cost and inserts the
neighboring cell into the heap.

This process continues until the destination cell (bottom-right corner) is reached. At this point,
the minimum cost to reach the destination is returned.
Algorithm Execution

1. Initialization:
○ The minCost matrix is initialized with infinity for all cells except the starting cell,
which is set to the cost of the matrix at that position.
○ A priority queue is initialized, and the starting cell is added to the queue.
2. Main Loop:
○ The algorithm repeatedly extracts the node with the smallest cost from the priority
queue.
○ It then explores the neighboring cells in the four possible directions: right, down,
left, and up.
○ For each valid neighboring cell, the algorithm calculates the new cost of reaching
that cell and updates the minCost matrix if the new cost is lower than the
previously recorded cost.
3. Termination:
○ The algorithm terminates when the destination cell is reached, at which point the
minimum cost is returned.
4. Edge Cases:
○ If there is no valid path to the destination, the algorithm would return a specific
indicator, such as -1, to signify that the destination is unreachable.

Source code:

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

#define ROWS 3
#define COLS 3
#define INF INT_MAX

typedef struct {
int cost, x, y;
} Node;

typedef struct {
Node *arr;
int size;
} MinHeap;
MinHeap* createMinHeap(int capacity) {
MinHeap* heap = (MinHeap*)malloc(sizeof(MinHeap));
heap->arr = (Node*)malloc(capacity * sizeof(Node));
heap->size = 0;
return heap;
}

void swap(Node* a, Node* b) {

Node temp = *a;
*a = *b;
*b = temp;
}

void minHeapify(MinHeap* heap, int idx) {

int smallest = idx;
int left = 2 * idx + 1;
int right = 2 * idx + 2;

if (left < heap->size && heap->arr[left].cost < heap->arr[smallest].cost)

smallest = left;
if (right < heap->size && heap->arr[right].cost < heap->arr[smallest].cost)
smallest = right;
if (smallest != idx) {
swap(&heap->arr[smallest], &heap->arr[idx]);
minHeapify(heap, smallest);
}
}

Node extractMin(MinHeap* heap) {

if (heap->size == 0) {
Node node = {INF, -1, -1};
return node;
}
Node root = heap->arr[0];
Node lastNode = heap->arr[heap->size - 1];
heap->arr[0] = lastNode;
heap->size--;
minHeapify(heap, 0);
return root;
}

void insertMinHeap(MinHeap* heap, Node node) {

heap->size++;
int i = heap->size - 1;
heap->arr[i] = node;
while (i && heap->arr[i].cost < heap->arr[(i - 1) / 2].cost) {
swap(&heap->arr[i], &heap->arr[(i - 1) / 2]);
i = (i - 1) / 2;
}
}

int dijkstra(int matrix[ROWS][COLS]) {

int minCost[ROWS][COLS];
for (int i = 0; i < ROWS; i++)
for (int j = 0; j < COLS; j++)
minCost[i][j] = INF;
minCost[0][0] = matrix[0][0];

MinHeap* heap = createMinHeap(ROWS * COLS);

insertMinHeap(heap, (Node){matrix[0][0], 0, 0});

int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

while (heap->size) {
Node current = extractMin(heap);

if (current.x == ROWS - 1 && current.y == COLS - 1)

return current.cost;

for (int i = 0; i < 4; i++) {

int nx = current.x + directions[i][0];
int ny = current.y + directions[i][1];

if (nx >= 0 && nx < ROWS && ny >= 0 && ny < COLS) {
int newCost = current.cost + matrix[nx][ny];
if (newCost < minCost[nx][ny]) {
minCost[nx][ny] = newCost;
insertMinHeap(heap, (Node){newCost, nx, ny});
}
 }
}
}

return -1; // If there's no valid path

}

int main() {
int matrix[ROWS][COLS] = {
{1, 3, 1},
{1, 5, 1},
{4, 2, 1}
};
printf("Dijkstra's algorithm with Priority Queue\n");
for(int i=0;i<ROWS;i++)
{
for(int j=0;j<COLS;j++)
{
printf("%d ",matrix[i][j]);
}
printf("\n");
}
printf("Minimum cost: %d\n", dijkstra(matrix));
return 0;
}

Output and Results

Upon executing the algorithm on the given 3x3 matrix, the matrix is printed, followed by the
minimum cost required to traverse from the top-left to the bottom-right corner. In this specific
example, the algorithm determines that the minimum cost is 7.
Advantages

1. Efficiency:
○ Faster Computation: The use of a min-heap allows for efficient retrieval of the
minimum cost node, reducing the overall time complexity of Dijkstra's algorithm.
○ Scalability: This approach is particularly beneficial in larger grids or graphs,
where the number of nodes is significant.
2. Optimal Path:
○ Guaranteed Shortest Path: Dijkstra's algorithm guarantees finding the shortest
path in graphs with non-negative weights, making it reliable for applications like
navigation and network routing.
3. Flexibility:
○ Versatile Application: The algorithm can be applied to various types of grids,
including non-uniform grids where the cost of traversal varies across cells.
4. Deterministic:
○ Predictable Behavior: The algorithm always produces the same result for the
same input, ensuring consistency in applications requiring reliable outputs.

Disadvantages

1. Memory Usage:
 ○ Space Complexity: The use of a priority queue requires additional memory,
which can be a limitation in environments with constrained resources.
2. Limited to Non-Negative Weights:
○ Restriction: Dijkstra's algorithm does not handle graphs with negative weights.
For such scenarios, alternative algorithms like the Bellman-Ford algorithm are
required.
3. Complexity in Implementation:
○ Programming Overhead: Implementing the min-heap and integrating it with
Dijkstra's algorithm adds complexity to the code, which might be challenging for
beginners.
4. Not Always the Fastest:
○ Comparative Speed: While Dijkstra’s algorithm is efficient, other algorithms
like A* (with an appropriate heuristic) can be faster for specific pathfinding
problems.

Conclusion

This implementation demonstrates an efficient approach to solving the shortest path problem
using Dijkstra's algorithm with a priority queue. The algorithm's time complexity is significantly
improved using a min-heap, making it suitable for larger matrices or graphs. The case study
provides a clear understanding of how to manage and optimize pathfinding in grid-based
problems.
CASE STUDY: IMPLEMENTING BELLMAN-FORD ALGORITHM FOR
GRID-BASED PATH FINDING

Introduction

The Bellman-Ford algorithm is a fundamental algorithm used for finding the shortest path in a
graph, particularly in scenarios where edge weights can be negative. Unlike Dijkstra's algorithm,
which requires non-negative edge weights, Bellman-Ford can handle negative weights, making it
more versatile. This case study explores the implementation of the Bellman-Ford algorithm to
solve a shortest path problem in a 2D grid.

In this grid, each cell has a cost associated with moving into it, and the goal is to find the
minimum cost path from the top-left corner to the bottom-right corner of the matrix.

Problem Statement

Given a 3x3 matrix, where each element represents the cost to traverse that cell, the objective is
to determine the minimum cost path from the top-left corner (0,0) to the bottom-right corner
(2,2). Movements are allowed in four directions: up, down, left, and right.

Example Matrix:

1 8 1

1 5 1

9 3 1

Objective:

● Calculate the minimum cost to move from the top-left corner to the bottom-right corner
of the matrix.
Purpose

The purpose of this case study is to:

1. Demonstrate Implementation: Show how the Bellman-Ford algorithm can be adapted

for use in a grid-based environment to find the shortest path from the top-left corner to
the bottom-right corner.
2. Handle Negative Weights: Illustrate Bellman-Ford's capability to handle negative edge
weights, although the example uses only positive weights. This highlights its versatility in
dealing with various types of graph problems.
3. Educational Insight: Provide an understanding of how the Bellman-Ford algorithm
works, including the edge relaxation process, and how it can be applied to real-world
scenarios involving pathfinding and cost minimization.

Approach

Data Structures

To implement the Bellman-Ford algorithm on a grid, the following data structures are used:

● Edge Structure:
○ This structure represents an edge in the graph. Each edge connects two cells in the
matrix and carries the cost of moving from one cell to the other.
● Distance Matrix:
○ A 2D matrix distance is used to store the minimum cost to reach each cell in the
grid from the starting cell (0,0). Initially, all cells are set to infinity (INF), except
the starting cell, which is set to its own cost.

Algorithm Design

1. Initialization:
○ The distance matrix is initialized so that all cells contain INF, except the starting
cell, which contains the cost of the matrix at that position. This signifies that the
minimum cost to reach the starting cell is its own cost, while all other cells are
initially unreachable.
2. Edge List Construction:
○ An edge list is constructed where each edge represents a possible move from one
cell to a neighboring cell. For each cell in the matrix, edges are created to connect
it to its valid neighbors (right, down, left, and up). The cost of each edge is the
cost of entering the neighboring cell.
 3. Relaxation of Edges:
○ The algorithm then iterates through the edge list and "relaxes" each edge.
Relaxation involves checking if the current known minimum cost to reach the
destination cell of an edge can be reduced by using this edge. If a shorter path is
found, the distance matrix is updated with the new minimum cost.
○ This relaxation process is repeated |V| - 1 times, where |V| is the number of
vertices (or cells in this context). This ensures that all possible paths are
considered.
4. Final Result:
○ After all the relaxations, the distance matrix contains the minimum cost to reach
each cell from the starting cell. The minimum cost to reach the bottom-right
corner is found in distance[ROWS - 1][COLS - 1].

Algorithm Execution

1. Initialize Distance Matrix:

○ The distance matrix is initialized with INF for all cells except the starting cell
(0,0), which is initialized with the cost of the matrix at that position.
2. Construct Edge List:
○ An edge list is built for each cell by considering its valid neighbors. Each edge is
represented by the coordinates of the current cell, the coordinates of the
neighboring cell, and the cost to enter the neighboring cell.
3. Relax Edges:
○ The algorithm relaxes all edges multiple times (specifically, |V| - 1 times). Each
relaxation step updates the distance matrix if a shorter path is found.
4. Output Result:
○ The minimum cost to reach the bottom-right corner of the matrix is printed. If the
destination is unreachable, the distance would remain INF.

Source Code :

#include <stdio.h>

#include <limits.h>

#define ROWS 3
#define COLS 3
#define INF INT_MAX

typedef struct {
int x, y, cost;
} Edge;

void bellmanFord(int matrix[ROWS][COLS], int distance[ROWS][COLS]) {

int edges = ROWS * COLS * 4; // Maximum number of edges
Edge edgeList[edges];
int k = 0;

// Initialize distance matrix

for (int i = 0; i < ROWS; i++) {
for (int j = 0; j < COLS; j++) {
distance[i][j] = INF;
}
}
distance[0][0] = matrix[0][0];

// Build edge list

for (int i = 0; i < ROWS; i++) {
for (int j = 0; j < COLS; j++) {
int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
for (int d = 0; d < 4; d++) {
int ni = i + directions[d][0];
int nj = j + directions[d][1];
if (ni >= 0 && ni < ROWS && nj >= 0 && nj < COLS) {
edgeList[k++] = (Edge){i * COLS + j, ni * COLS + nj, matrix[ni][nj]};
}
}
}
}

// Relax edges |V| - 1 times

for (int step = 0; step < ROWS * COLS - 1; step++) {
for (int i = 0; i < k; i++) {
int u = edgeList[i].x;
int v = edgeList[i].y;
int cost = edgeList[i].cost;
 int ux = u / COLS, uy = u % COLS;
int vx = v / COLS, vy = v % COLS;

if (distance[ux][uy] != INF && distance[ux][uy] + cost < distance[vx][vy]) {

distance[vx][vy] = distance[ux][uy] + cost;
}
}
}
}

int main() {
int matrix[ROWS][COLS] = {
{1, 8, 1},
{1, 5, 1},
{9, 3, 1}
};

printf("Bellman-Ford algorithm \n");

for(int i=0;i<ROWS;i++)
{
for(int j=0;j<COLS;j++)
{
printf("%d ",matrix[i][j]);
}
printf("\n");
}

int distance[ROWS][COLS];

bellmanFord(matrix, distance);

printf("Minimum cost to reach bottom-right corner: %d\n", distance[ROWS - 1][COLS - 1]);

return 0;
}
Output:

Advantages

1. Handles Negative Weights:

○ Versatility: Bellman-Ford can handle graphs with negative edge weights, making
it suitable for a broader range of problems compared to algorithms like Dijkstra's,
which require non-negative weights.
2. Correctness Guarantee:
○ Reliable Results: The algorithm guarantees the shortest path if there are no
negative weight cycles in the graph. This makes it a reliable choice for
pathfinding in various applications.
3. Simple Implementation:
○ Ease of Coding: The Bellman-Ford algorithm is relatively straightforward to
implement and understand, especially in comparison to more complex algorithms
like Dijkstra's with priority queues.
4. Detection of Negative Cycles:
○ Cycle Detection: The algorithm can detect negative weight cycles in the graph,
providing information about the presence of such cycles, which is useful for
certain types of problems.
Disadvantages

1. Time Complexity:
○ Inefficiency: The Bellman-Ford algorithm has a time complexity of O(V⋅E)O(V
\cdot E)O(V⋅E), where VVV is the number of vertices and EEE is the number of
edges. This can be slower compared to algorithms like Dijkstra's (with priority
queues) for graphs with non-negative weights.
2. Edge Relaxation Overhead:
○ Computational Cost: The relaxation process involves iterating over all edges
multiple times, which can lead to significant computational overhead, particularly
in large graphs or grids.
3. Memory Usage:
○ Storage Requirements: The algorithm requires storing all edges in a list, which
can be memory-intensive, especially for large grids or dense graphs.
4. Limited Practical Use for Non-Negative Weights:
○ Redundancy: For graphs with non-negative weights, more efficient algorithms
like Dijkstra's are preferred due to their lower time complexity and better
performance.

Conclusion:

This case study illustrates how the Bellman-Ford algorithm can be adapted to solve a grid-based
shortest path problem, even when negative edge weights are present (though in this case, all
weights are positive). The algorithm effectively explores all possible paths by relaxing edges
iteratively, ensuring that the shortest path is found.

By understanding and implementing this algorithm, one gains a powerful tool for pathfinding in
various scenarios, particularly when dealing with graphs that may contain negative weights.
While Bellman-Ford is not as fast as Dijkstra's algorithm for non-negative weights, its ability to
handle negative weights makes it indispensable in certain applications.
CASE STUDY: IMPLEMENTING BI-DIRECTIONAL SEARCH
ALGORITHM FOR GRID-BASED PATH FINDING

Introduction

Bi-Directional Search is an advanced search algorithm designed to find the shortest path in a
graph. It operates by simultaneously searching forward from the start node and backward from
the goal node, meeting in the middle. This approach can significantly reduce the search space
and improve performance, especially in grid-based pathfinding problems.

This case study explores the implementation of Bi-Directional Search in a 2D grid environment,
where the goal is to find the minimum cost path from the top-left corner to the bottom-right
corner.

Purpose

The purpose of this case study is to:

1. Demonstrate Bi-Directional Search: Illustrate how Bi-Directional Search can be

applied to a grid-based shortest path problem to optimize the search process.
2. Optimize Pathfinding: Show how simultaneous search from both ends can reduce the
time complexity and improve efficiency in finding the shortest path.
3. Educational Insight: Provide an understanding of the Bi-Directional Search algorithm,
including its implementation and advantages in pathfinding scenarios.

Algorithm Description

Data Structures

1. Queue:
○ A queue is used to manage nodes during the search process. Two queues are
maintained: one for the forward search (from the start) and one for the backward
search (from the goal).
2. Visited Arrays:
○ visitedStart and visitedGoal are used to track which nodes have been visited from
the start and goal, respectively. This helps avoid revisiting nodes and ensures that
the search progresses efficiently.
3. Distance Matrices:
○ distanceStart and distanceGoal keep track of the minimum cost to reach each cell
from the start and goal, respectively.
Algorithm Steps

1. Initialization:
○ Initialize distanceStart and distanceGoal matrices with INF, except for the starting
cell (0,0) and the goal cell (ROWS-1,COLS-1), which are set to their respective
costs.
○ Create two queues and enqueue the starting and goal nodes.
2. Search Process:
○ Dequeue nodes from both the start and goal queues and explore their neighbors.
○ Update distances and mark nodes as visited when exploring neighbors.
○ If a node visited in the forward search has also been visited in the backward
search, the shortest path has been found.
○ Similarly, if a node visited in the backward search has been visited in the forward
search, the shortest path has been found.
3. Path Cost Calculation:
○ Calculate the minimum cost to reach the intersection node by summing the
distances from the start and goal, subtracting the overlap (the cost of the
intersection node itself).
4. Termination:
○ The process continues until the queues are empty or a path is found. If no path is
found, the algorithm returns -1.

Example Execution

Given the matrix:

7 2 9

1 3 5

5 8 6

The algorithm performs the following steps:

1. Initialization:
○ Distance matrices are initialized with INF, and the start and goal cells are set with
their respective costs.
○ The starting node (0,0) and the goal node (2,2) are enqueued.
2. Search Process:
○ Nodes are dequeued from both queues, and their neighbors are explored.
○ Distances are updated, and nodes are marked as visited.
 ○ If a node from the forward search overlaps with a node from the backward search,
the minimum cost path is computed.
3. Result Calculation:
○ If a path is found, the minimum cost is calculated and displayed.

Advantages

1. Reduced Search Space:

○ Efficiency: By searching from both ends, Bi-Directional Search can significantly
reduce the number of nodes explored, improving efficiency compared to a
single-direction search.
2. Faster Pathfinding:
○ Performance Improvement: The algorithm often finds the shortest path faster
because it narrows down the search area more quickly.
3. Effective in Grid-Based Problems:
○ Applicability: Particularly effective in grid-based pathfinding problems where
the search space is large and uniform.

Disadvantages

1. Complex Implementation:
○ Increased Complexity: The algorithm is more complex to implement compared
to simpler algorithms like Breadth-First Search (BFS), especially in managing
two queues and visited arrays.
2. Memory Usage:
○ Higher Memory Requirements: Maintaining two queues and two visited
matrices can lead to higher memory usage, which may be a limitation in
resource-constrained environments.
3. Not Always Optimal:
○ Performance Variability: The performance gain is highly dependent on the
problem's specifics and may not always be significant, particularly in cases with
small or sparse grids.

Source Code:
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

#define ROWS 3
#define COLS 3
#define INF INT_MAX
typedef struct {
int x, y, cost;
} Node;

typedef struct {
Node* nodes;
int front, rear, size, capacity;
} Queue;

Queue* createQueue(int capacity) {

Queue* queue = (Queue*)malloc(sizeof(Queue));
queue->capacity = capacity;
queue->size = 0;
queue->front = 0;
queue->rear = capacity - 1;
queue->nodes = (Node*)malloc(capacity * sizeof(Node));
return queue;
}

int isQueueEmpty(Queue* queue) {

return queue->size == 0;
}

void enqueue(Queue* queue, Node node) {

queue->rear = (queue->rear + 1) % queue->capacity;
queue->nodes[queue->rear] = node;
queue->size++;
}

Node dequeue(Queue* queue) {

Node node = queue->nodes[queue->front];
queue->front = (queue->front + 1) % queue->capacity;
queue->size--;
return node;
}

int isValid(int x, int y) {

return x >= 0 && x < ROWS && y >= 0 && y < COLS;
}
int bidirectionalSearch(int matrix[ROWS][COLS]) {
int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
int visitedStart[ROWS][COLS] = {0};
int visitedGoal[ROWS][COLS] = {0};
int distanceStart[ROWS][COLS];
int distanceGoal[ROWS][COLS];

for (int i = 0; i < ROWS; i++)

for (int j = 0; j < COLS; j++) {
distanceStart[i][j] = INF;
distanceGoal[i][j] = INF;
}

distanceStart[0][0] = matrix[0][0];
distanceGoal[ROWS - 1][COLS - 1] = matrix[ROWS - 1][COLS - 1];

Queue* queueStart = createQueue(ROWS * COLS);

Queue* queueGoal = createQueue(ROWS * COLS);

enqueue(queueStart, (Node){0, 0, matrix[0][0]});

enqueue(queueGoal, (Node){ROWS - 1, COLS - 1, matrix[ROWS - 1][COLS - 1]});
visitedStart[0][0] = 1;
visitedGoal[ROWS - 1][COLS - 1] = 1;

while (!isQueueEmpty(queueStart) && !isQueueEmpty(queueGoal)) {

Node currentStart = dequeue(queueStart);
Node currentGoal = dequeue(queueGoal);

if (visitedGoal[currentStart.x][currentStart.y]) {
return distanceStart[currentStart.x][currentStart.y] +
distanceGoal[currentStart.x][currentStart.y] - matrix[currentStart.x][currentStart.y];
}

if (visitedStart[currentGoal.x][currentGoal.y]) {
return distanceStart[currentGoal.x][currentGoal.y] +
distanceGoal[currentGoal.x][currentGoal.y] - matrix[currentGoal.x][currentGoal.y];
}

for (int i = 0; i < 4; i++) {

int nx = currentStart.x + directions[i][0];
 int ny = currentStart.y + directions[i][1];
if (isValid(nx, ny) && !visitedStart[nx][ny]) {
distanceStart[nx][ny] = distanceStart[currentStart.x][currentStart.y] + matrix[nx][ny];
visitedStart[nx][ny] = 1;
enqueue(queueStart, (Node){nx, ny, distanceStart[nx][ny]});
}

int gx = currentGoal.x + directions[i][0];

int gy = currentGoal.y + directions[i][1];
if (isValid(gx, gy) && !visitedGoal[gx][gy]) {
distanceGoal[gx][gy] = distanceGoal[currentGoal.x][currentGoal.y] + matrix[gx][gy];
visitedGoal[gx][gy] = 1;
enqueue(queueGoal, (Node){gx, gy, distanceGoal[gx][gy]});
}
}
}

return -1; // If no path is found

}

int main() {
int matrix[ROWS][COLS] = {
{7, 2, 9},
{1, 3, 5},
{5, 8, 6}
};
printf("Bi-Directional Search\n");
for(int i=0;i<ROWS;i++)
{
for(int j=0;j<COLS;j++)
{
printf("%d ",matrix[i][j]);
}
printf("\n");
}

printf("Minimum cost to reach bottom-right corner: %d\n", bidirectionalSearch(matrix));

return 0;
}
Output:

Conclusion

The Bi-Directional Search algorithm offers a powerful approach for finding the shortest path in
grid-based environments by searching from both the start and goal simultaneously. Its ability to
reduce search space and improve efficiency makes it a valuable tool in various pathfinding
scenarios. Despite its complexity and memory usage, ongoing advancements and optimizations
can enhance its applicability and performance, making it suitable for a wide range of real-world
applications.
CASE STUDY: IMPLEMENTING UNIFORM COST SEARCH FOR
GRID-BASED PATH FINDING

Introduction

Uniform Cost Search (UCS) is a pathfinding algorithm used to find the shortest path in weighted
graphs. It expands the least costly node first, making it well-suited for finding the shortest path in
scenarios where edge costs vary. This case study explores the implementation of UCS in a 2D
grid, where the goal is to determine the minimum cost path from the top-left corner to the
bottom-right corner.

Purpose

The purpose of this case study is to:

1. Demonstrate UCS: Show how Uniform Cost Search can be used effectively to find the
shortest path in a grid-based problem.
2. Illustrate Algorithm Mechanics: Explain the workings of UCS, including priority
queue management and cost updates.
3. Highlight Practical Application: Provide a practical example of UCS in a grid
environment and discuss its effectiveness and performance.

Algorithm Description

Data Structures

1. MinHeap:
○ A priority queue implemented using a binary heap to manage nodes based on their
path cost. This structure ensures efficient retrieval of the node with the minimum
cost.
2. Node:
○ Represents a point in the grid with a specific cost. It contains:
■ cost: The accumulated cost to reach the node.
■ point: The coordinates of the node in the grid.
3. Cost Matrix:
○ A 2D array cost that keeps track of the minimum cost to reach each cell in the
grid. Initialized to INF (infinity) for all cells except the start cell.

Algorithm Steps

1. Initialization:
 ○ Set up the cost matrix with INF values.
○ Initialize the cost of the start cell (0,0) with its own value from the input matrix.
○ Create a MinHeap with a capacity of ROWS * COLS and insert the start node
with its cost.
2. Search Process:
○ Continuously extract the node with the minimum cost from the MinHeap.
○ If this node is the goal node (ROWS-1, COLS-1), return its cost as the minimum
path cost.
○ Explore all valid neighboring nodes (up, down, left, right).
○ Update the cost for each neighboring node if a cheaper path is found and insert
the updated node into the MinHeap.
3. Termination:
○ The process continues until the MinHeap is empty or the goal node is reached. If
no valid path is found by the end of the process, return -1.

Example Execution

Given the matrix:

1 3 7

1 5 4

4 4 2

The UCS algorithm operates as follows:

1. Initialization:
○ cost matrix initialized with INF except cost[0][0] set to 1.
○ Start node (0,0) with cost 1 is inserted into the MinHeap.
2. Search Process:
○ Extract node (0,0) with cost 1.
○ Update costs for neighbors (0,1) and (1,0):
■ New cost to (0,1) is 1 + 3 = 4.
■ New cost to (1,0) is 1 + 1 = 2.
○ Insert updated nodes into MinHeap.
○ Continue extracting nodes with minimum costs and updating neighbors until
reaching the goal node (2,2).
3. Result Calculation:
○ Once the goal node (2,2) is extracted from the MinHeap, its cost is the minimum
path cost to reach the goal.
Advantages

1. Optimal Pathfinding:
○ Correctness: UCS guarantees finding the shortest path in weighted graphs due to
its nature of expanding the least costly node first.
2. Adaptability:
○ Flexible Use: Can handle varying edge weights and is applicable in many
pathfinding scenarios.
3. Efficiency:
○ Priority Queue: Using a MinHeap for managing nodes ensures efficient
extraction of the minimum cost node, reducing the overall computational
complexity.

Disadvantages

1. Memory Usage:
○ Space Complexity: The need to store a large number of nodes and costs in the
MinHeap and cost matrix can lead to high memory usage, especially in large
grids.
2. Processing Time:
○ Algorithm Complexity: While UCS is efficient, it can still be slower compared
to algorithms like A* in very large or complex grids due to its uniform cost
expansion.
3. Grid Size Limitation:
○ Scalability: Performance can degrade with very large grids, making UCS less
practical in such cases without optimizations.

Source Code:
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

#define ROWS 3
#define COLS 3
#define INF INT_MAX

typedef struct {
int x, y;
} Point;
typedef struct {
int cost;
Point point;
} Node;

typedef struct {
Node* nodes;
int size;
int capacity;
} MinHeap;

MinHeap* createMinHeap(int capacity) {

MinHeap* heap = (MinHeap*)malloc(sizeof(MinHeap));
heap->nodes = (Node*)malloc(capacity * sizeof(Node));
heap->size = 0;
heap->capacity = capacity;
return heap;
}

void swap(Node* a, Node* b) {

Node temp = *a;
*a = *b;
*b = temp;
}

void minHeapify(MinHeap* heap, int idx) {

int smallest = idx;
int left = 2 * idx + 1;
int right = 2 * idx + 2;

if (left < heap->size && heap->nodes[left].cost < heap->nodes[smallest].cost)

smallest = left;
if (right < heap->size && heap->nodes[right].cost < heap->nodes[smallest].cost)
smallest = right;
if (smallest != idx) {
swap(&heap->nodes[smallest], &heap->nodes[idx]);
minHeapify(heap, smallest);
}
}
Node extractMin(MinHeap* heap) {
if (heap->size == 0) {
Node node = {INF, {-1, -1}};
return node;
}
Node root = heap->nodes[0];
Node lastNode = heap->nodes[heap->size - 1];
heap->nodes[0] = lastNode;
heap->size--;
minHeapify(heap, 0);
return root;
}

void insertMinHeap(MinHeap* heap, Node node) {

heap->size++;
int i = heap->size - 1;
heap->nodes[i] = node;
while (i && heap->nodes[i].cost < heap->nodes[(i - 1) / 2].cost) {
swap(&heap->nodes[i], &heap->nodes[(i - 1) / 2]);
i = (i - 1) / 2;
}
}

int isValid(int x, int y) {

return x >= 0 && x < ROWS && y >= 0 && y < COLS;
}

int uniformCostSearch(int matrix[ROWS][COLS]) {

int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
int cost[ROWS][COLS];
for (int i = 0; i < ROWS; i++)
for (int j = 0; j < COLS; j++)
cost[i][j] = INF;
cost[0][0] = matrix[0][0];

MinHeap* heap = createMinHeap(ROWS * COLS);

insertMinHeap(heap, (Node){matrix[0][0], {0, 0}});

while (heap->size) {
 Node current = extractMin(heap);
int x = current.point.x, y = current.point.y;

if (x == ROWS - 1 && y == COLS - 1)

return cost[x][y];

for (int i = 0; i < 4; i++) {

int nx = x + directions[i][0];
int ny = y + directions[i][1];

if (isValid(nx, ny)) {
int newCost = cost[x][y] + matrix[nx][ny];
if (newCost < cost[nx][ny]) {
cost[nx][ny] = newCost;
insertMinHeap(heap, (Node){newCost, {nx, ny}});
}
}
}
}

return -1; // If there's no valid path

}

int main() {
int matrix[ROWS][COLS] = {
{1, 3, 7},
{1, 5, 4},
{4, 4, 2}
};
printf("Uniform Cost Search\n");
for(int i=0;i<ROWS;i++)
{
for(int j=0;j<COLS;j++)
{
printf("%d ",matrix[i][j]);
}
printf("\n");
}

printf("Minimum cost to reach bottom-right corner: %d\n", uniformCostSearch(matrix));

 return 0;
}

Output:

Conclusion

Uniform Cost Search is a robust and reliable algorithm for finding the shortest path in grid-based
environments with varying edge costs. By expanding the least costly node first, UCS ensures
optimal pathfinding, making it suitable for many applications. While it has limitations in terms of
memory usage and processing time, future advancements and optimizations can enhance its
performance and applicability, addressing challenges in large-scale and dynamic environments.