Scribd
Upload
16 views4 pages

DAA Exp - 3.2

The student implemented Dijkstra's algorithm to find the shortest paths in a graph with positive edge weights. The algorithm initializes all distances to infinity except the source which is 0. It then uses a priority queue to iteratively explore the neighbors of the current vertex and update distances if a shorter path is found. The code includes structures for edges, implements Dijkstra's algorithm to return the shortest distances, and tests it on a sample graph.

Uploaded by

varun thakur
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
16 views4 pages

DAA Exp - 3.2

The student implemented Dijkstra's algorithm to find the shortest paths in a graph with positive edge weights. The algorithm initializes all distances to infinity except the source which is 0. It then uses a priority queue to iteratively explore the neighbors of the current vertex and update distances if a shorter path is found. The code includes structures for edges, implements Dijkstra's algorithm to return the shortest distances, and tests it on a sample graph.

Uploaded by

varun thakur
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 4

DEPARTMENT OF

COMPUTER SCIENCE & ENGINEERING

Experiment-3.2

Student Name: Varun Pratap UID: 21BCS9015


Branch: CSE Section/Group: IOT_636-A
Semester: 5th Date of Performance:30/10/23
Subject Name: DAA Lab Subject Code: 21CSP-314

1. Aim: Develop a program and analyze complexity to find shortest paths in a graph with
positive edge weights using Dijkstra’s algorithm.

2. Algorithms:
Step 1: Initialize an array 'dist' of size V (number of vertices) to store the shortest distances. Set
all distances to infinity except for the source vertex, which is set to 0.

Step 2: Initialize a priority queue (min-heap) to store pairs (distance, vertex) and push (0, source)
into it. This represents the starting vertex with a distance of 0.

Step 3: While the priority queue is not empty:


Step 3a: Pop the vertex 'u' with the smallest distance from the priority queue.
Step 3b: For each neighboring vertex 'v' of 'u':
Step 3b(i): Calculate the potential new distance to 'v' as 'dist[u] + weight(u, v)'.
Step 3b(ii): If the new distance is smaller than the current distance 'dist[v]', update 'dist[v]' to
the new distance and push (new distance, 'v') into the priority queue.

Step 4: After processing all vertices or when the priority queue is empty, 'dist' contains the
shortest distances from the source vertex to all other vertices.

Step 5: Return the 'dist' array as the output.

End of Algorithm.
DEPARTMENT OF
COMPUTER SCIENCE & ENGINEERING

3. Code:
#include <iostream>
#include <vector>
#include <queue>
#include <climits>

using namespace std;

// Define a structure to represent a weighted edge


struct Edge {
int to;
int weight;
Edge(int t, int w) : to(t), weight(w) {}
};

// Define a function to find the shortest path using Dijkstra's algorithm


vector<int> dijkstra(vector<vector<Edge>>& graph, int start) {
int V = graph.size();
vector<int> dist(V, INT_MAX); // Initialize distances to infinity
dist[start] = 0; // Distance to the start vertex is 0

// Create a priority queue for Dijkstra's algorithm


priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;

pq.push({0, start});

while (!pq.empty()) {
int u = pq.top().second;
int u_dist = pq.top().first;
pq.pop();

if (u_dist > dist[u]) continue; // Skip if we have a better path to u

for (const Edge& edge : graph[u]) {


int v = edge.to;
int weight = edge.weight;
if (dist[u] + weight < dist[v]) {
dist[v] = dist[u] + weight;
pq.push({dist[v], v});
}
}
}
DEPARTMENT OF
COMPUTER SCIENCE & ENGINEERING

return dist;
}

int main() {
int V = 6; // Number of vertices
vector<vector<Edge>> graph(V);

// Add edges and their weights to the graph


graph[0].push_back(Edge(1, 5));
graph[0].push_back(Edge(2, 3));
graph[1].push_back(Edge(3, 6));
graph[1].push_back(Edge(2, 2));
graph[2].push_back(Edge(4, 4));
graph[2].push_back(Edge(5, 2));
graph[2].push_back(Edge(3, 7));
graph[3].push_back(Edge(5, 1));
graph[4].push_back(Edge(5, 3));

int start = 0; // Starting vertex

vector<int> shortestDistances = dijkstra(graph, start);

cout << "Shortest distances from vertex " << start << " to all other vertices:" << endl;
for (int i = 0; i < V; i++) {
cout << "Vertex " << i << ": " << shortestDistances[i] << endl;
}

return 0;
}
DEPARTMENT OF
COMPUTER SCIENCE & ENGINEERING

3. Output:

4. Time complexity: O((V + E) * log(V))

You might also like