Scribd
Upload
12 views4 pages

Daa 08

Uploaded by

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

Daa 08

Uploaded by

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

Experiment 8

Student Name: Akshat Shukla UID: 22BCS12484


Branch: CSE Section/Group: 801 - A
Semester:5 Date of Performance: 08/10/24
Subject Name: DAA Lab Subject Code: 22CSH-311

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

2. Objective
Code and analyze to find shortest paths in graph with positive edge weights using
Dijkstra‟s

3. Algorithm
1. Initialize an adjacency matrix for node connections and set all distances to
infinity (INF).
2. Input number of vertices and edges, then input each edge's vertices and weight.

3. Set the initial distance from the source node to itself as zero.

4. Use a priority queue to manage and retrieve the node with the shortest distance
not yet visited.
5. For each node processed, update the distances to its adjacent nodes if a shorter
path is found.
6. Mark each node as visited once it's processed to prevent reprocessing.

7. Output the shortest distances from source node to all other nodes in the graph.
4. Implemetation/Code
#include <bits/stdc++.h>
using namespace std;

const int MAX = 1001;


const long long INF = 1e18;

int main() {
int n, m;
cin >> n >> m;

// Adjacency matrix to represent the graph


vector<vector<pair<int, long long>>> adj(n + 1); // 1-based indexing

// Initialize edge weights to infinity


for (int i = 1; i <= n; ++i) {
adj[i].assign(n + 1, {0, INF}); // Initialize with default value (0, INF)
}

// Read edges
for (int i = 0; i < m; ++i) {
int u, v, w;
cin >> u >> v >> w;
adj[u][v] = {1, w}; // Indicate connection and weight
adj[v][u] = {1, w}; // Handle undirected graphs
}

int source;
cin >> source;

// Distance array to store shortest distances


vector<long long> dist(n + 1, INF); // 1-based indexing

// Visited array to track processed vertices


vector<bool> visited(n + 1, false); // 1-based indexing

// Priority queue for efficient retrieval of nearest unvisited node


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

// Start from source node with distance 0


dist[source] = 0;
pq.emplace(0, source);

while (!pq.empty()) {
pair<long long, int> current = pq.top();
pq.pop();

long long current_dist = current.first;

int u = current.second;

if (visited[u]) {
continue; // Skip if already visited
}

visited[u] = true;

for (const auto& neighbor : adj[u]) {


int v = neighbor.first; // Neighboring vertex
long long weight = neighbor.second; // Edge weight

if (dist[v] > current_dist + weight) {


dist[v] = current_dist + weight;
pq.emplace(dist[v], v);
}
}
}

// Print shortest distances


for (int i = 1; i <= n; ++i) {
if (dist[i] == INF) {
cout << "Distance from " << source << " to " << i << " is INF\n";
} else {
cout << "Distance from " << source << " to " << i << " is " << dist[i] << "\n";
}
}

return 0;
}

Output:
5. Time Complexity : O( n2+ m + nlog n)

6. Space Complexity : O(n2)

7. Learning Outcomes:-
1. Understand the implementation of Dijkstra's algorithm using adjacency

matrices.
2. Learn how to use priority queues to manage processing order of nodes based on
distance.
3. Recognize effect of node visitation state in preventing cycles and redundant
processing.
4. Gain experience in handling large constant values for initializations and
comparisons in graph algorithms.

You might also like