Answers for "dijkstra's"

dijkstra algorithm

//Dijkstra's Algorithm (Using priority queue)
//Watch Striver graph series on youtube I learned from there
#include<bits/stdc++.h>
using namespace std;
void addedge(vector<pair<int,int>>adj[],int u,int v,int w)
{
    adj[u].push_back(make_pair(v,w));
    adj[v].push_back(make_pair(u,w));
}
void Dijkstra(vector<pair<int,int>>adj[],int source,int n)
{
    priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> prior; //Min-Heap storing will store distance and node
    vector<int>dist(n,INT_MAX);
    dist[source]=0;
    prior.push(make_pair(0,source));
    while(!prior.empty())
    {
        int distance=prior.top().first;
        int node=prior.top().second;
        prior.pop();
        for(auto it:adj[node])
        {
            int next_node=it.first;
            int next_weight=it.second;
            if(dist[next_node]>distance+next_weight)
            {
                dist[next_node]=dist[node]+next_weight;
                prior.push(make_pair(dist[next_node],next_node));
            }
        }
    }
    for(int i=0;i<n;i++)
    {
        cout<<dist[i]<<" ";
    }
}
int main()
{
    int vertex,edges;
    cout<<"ENTER THE NUMBER OF VERTEX AND EDGES:"<<endl;
    cin>>vertex>>edges;
    vector<pair<int,int>>adj[vertex];
    int a,b,w;
    cout<<"ENTER THE LINK AND THEN WEIGHT:"<<endl;
    for(int i=0;i<edges;i++)
    {
        cin>>a>>b>>w;
        addedge(adj,a,b,w);
    }
    int source;
    cout<<"ENTER THE SOURCE NODE FROM WHICH YOU WANT TO CALCULATE THE SHORTEST DISTANCE:"<<endl;
    cin>>source;
    Dijkstra(adj,source,vertex);
    return 0;
}

dijkstra algorithm

//djikstra's algorithm using a weighted graph (STL)
//code by Soumyadepp
//insta: @soumyadepp
//linkedinID: https://www.linkedin.com/in/soumyadeep-ghosh-90a1951b6/

#include <bits/stdc++.h>
#define ll long long
using namespace std;

//to find the closest unvisited vertex from the source
//note that numbering of vertices starts from 1 here. Calculate accordingly
ll minDist(ll dist[], ll n, bool visited[])
{
    ll min = INT_MAX;
    ll minIndex = 0;
    for (ll i = 1; i <= n; i++)
    {
        if (!visited[i] && dist[i] <= min)
        {
            min = dist[i];
            minIndex = i;
        }
    }
    return minIndex;
}

//djikstra's algorithm for single source shortest path
void djikstra(vector<pair<ll, ll>> *g, ll n, ll src)
{
    bool visited[n + 1];
    ll dist[n + 1];
    for (ll i = 0; i <= n; i++)
    {
        dist[i] = INT_MAX;
        visited[i] = false;
    }

    dist[src] = 0;

    for (ll i = 0; i < n - 1; i++)
    {
        ll u = minDist(dist, n, visited);
        visited[u] = true;
        for (ll v = 0; v < g[u].size(); v++)
        {
            if (dist[u] + g[u][v].second < dist[g[u][v].first])
            {
                dist[g[u][v].first] = dist[u] + g[u][v].second;
            }
        }
    }
    cout << "VERTEX : DISTANCE" << endl;
    for (ll i = 1; i <= n; i++)
    {
        if (dist[i] != INT_MAX)
            cout << i << "         " << dist[i] << endl;
        else
            cout << i << "         "
                 << "not reachable" << endl;
    }
    cout << endl;
}

int main()
{
    //to store the adjacency list which also contains the weight
    vector<pair<ll, ll>> *graph;
    ll n, e, x, y, w, src;
    cout << "Enter number of vertices and edges in the graph" << endl;
    cin >> n >> e;
    graph = new vector<pair<ll, ll>>[n + 1];
    cout << "Enter edges and weight" << endl;
    for (ll i = 0; i < e; i++)
    {
        cin >> x >> y >> w;
        //checking for invalid edges and negative weights.
        if (x <= 0 || y <= 0 || w <= 0)
        {
            cout << "Invalid parameters. Exiting" << endl;
            exit(-1);
        }
        graph[x].push_back(make_pair(y, w));
        graph[y].push_back(make_pair(x, w));
    }
    cout << "Enter source from which you want to find shortest paths" << endl;
    cin >> src;
    if (src >= 1 && src <= n)
        djikstra(graph, n, src);
    else
        cout << "Please enter a valid vertex as the source" << endl;
    return 0;
}

//time complexity : O(ElogV)
//space complexity: O(V)

Dijkstra's Weighted Graph Shortest Path in c++

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

#define V 9 
  

int minDistance(int dist[], bool sptSet[]) 
{ 

    int min = INT_MAX, min_index; 
  
    for (int v = 0; v < V; v++) 
        if (sptSet[v] == false && dist[v] <= min) 
            min = dist[v], min_index = v; 
  
    return min_index; 
} 
  

void printSolution(int dist[]) 
{ 
    printf("Vertex tt Distance from Sourcen"); 
    for (int i = 0; i < V; i++) 
        printf("%d tt %dn", i, dist[i]); 
} 
  

void dijkstra(int graph[V][V], int src) 
{ 
    int dist[V]; 
    
  
    bool sptSet[V];
 
    for (int i = 0; i < V; i++) 
        dist[i] = INT_MAX, sptSet[i] = false; 
  
  
    dist[src] = 0; 
  
  
    for (int count = 0; count < V - 1; count++) { 
       
        int u = minDistance(dist, sptSet); 
  
       
        sptSet[u] = true; 
  
       
        for (int v = 0; v < V; v++) 
  
           
            if (!sptSet[v] && graph[u][v] && dist[u] != INT_MAX 
                && dist[u] + graph[u][v] < dist[v]) 
                dist[v] = dist[u] + graph[u][v]; 
    } 
  
 
    printSolution(dist); 
} 
  

int main() 
{ 
    
    int graph[V][V] = { { 0, 4, 0, 0, 0, 0, 0, 8, 0 }, 
                        { 4, 0, 8, 0, 0, 0, 0, 11, 0 }, 
                        { 0, 8, 0, 7, 0, 4, 0, 0, 2 }, 
                        { 0, 0, 7, 0, 9, 14, 0, 0, 0 }, 
                        { 0, 0, 0, 9, 0, 10, 0, 0, 0 }, 
                        { 0, 0, 4, 14, 10, 0, 2, 0, 0 }, 
                        { 0, 0, 0, 0, 0, 2, 0, 1, 6 }, 
                        { 8, 11, 0, 0, 0, 0, 1, 0, 7 }, 
                        { 0, 0, 2, 0, 0, 0, 6, 7, 0 } }; 
  
    dijkstra(graph, 0); 
  
    return 0; 
}

dijkstra's algorithm

function Dijkstra(Graph, source):
       dist[source]  := 0                     // Distance from source to source is set to 0
       for each vertex v in Graph:            // Initializations
           if v ≠ source
               dist[v]  := infinity           // Unknown distance function from source to each node set to infinity
           add v to Q                         // All nodes initially in Q

      while Q is not empty:                  // The main loop
          v := vertex in Q with min dist[v]  // In the first run-through, this vertex is the source node
          remove v from Q 

          for each neighbor u of v:           // where neighbor u has not yet been removed from Q.
              alt := dist[v] + length(v, u)
              if alt < dist[u]:               // A shorter path to u has been found
                  dist[u]  := alt            // Update distance of u 

      return dist[]
  end function

dijkstra's algorithm

# Providing the graph
n = int(input("Enter the number of vertices of the graph"))

# using adjacency matrix representation 
vertices = [[0, 0, 1, 1, 0, 0, 0],
            [0, 0, 1, 0, 0, 1, 0],
            [1, 1, 0, 1, 1, 0, 0],
            [1, 0, 1, 0, 0, 0, 1],
            [0, 0, 1, 0, 0, 1, 0],
            [0, 1, 0, 0, 1, 0, 1],
            [0, 0, 0, 1, 0, 1, 0]]

edges = [[0, 0, 1, 2, 0, 0, 0],
         [0, 0, 2, 0, 0, 3, 0],
         [1, 2, 0, 1, 3, 0, 0],
         [2, 0, 1, 0, 0, 0, 1],
         [0, 0, 3, 0, 0, 2, 0],
         [0, 3, 0, 0, 2, 0, 1],
         [0, 0, 0, 1, 0, 1, 0]]

# Find which vertex is to be visited next
def to_be_visited():
    global visited_and_distance
    v = -10
    for index in range(num_of_vertices):
        if visited_and_distance[index][0] == 0 
            and (v < 0 or visited_and_distance[index][1] <=
                 visited_and_distance[v][1]):
            v = index
    return v


num_of_vertices = len(vertices[0])

visited_and_distance = [[0, 0]]
for i in range(num_of_vertices-1):
    visited_and_distance.append([0, sys.maxsize])

for vertex in range(num_of_vertices):

    # Find next vertex to be visited
    to_visit = to_be_visited()
    for neighbor_index in range(num_of_vertices):

        # Updating new distances
        if vertices[to_visit][neighbor_index] == 1 and 
                visited_and_distance[neighbor_index][0] == 0:
            new_distance = visited_and_distance[to_visit][1] 
                + edges[to_visit][neighbor_index]
            if visited_and_distance[neighbor_index][1] > new_distance:
                visited_and_distance[neighbor_index][1] = new_distance
        
        visited_and_distance[to_visit][0] = 1

i = 0

# Printing the distance
for distance in visited_and_distance:
    print("Distance of ", chr(ord('a') + i),
          " from source vertex: ", distance[1])
    i = i + 1