function Dijkstra(Graph, source):
// Initializations
for each vertex v in Graph:
 
// Distance = cost from source node to v-th node
dist[v] := infinity ;                                // One can use a huge number e.g. "1000000" as approximation for infinity.
 
// Previous node in optimal path from source
previous[v] := undefined ;                           // One cau use e.g. "-1" => -1st node does not exist, so we say is not defined.
end for
 
dist[source] := 0 ;                                  // Distance from source to source is 0, so cost = 0
Q := the set of all nodes in Graph ;                 // All nodes in the graph are unoptimized - thus are in Q
 
while Q is not empty:                                // Loop until we find the path
u := vertex in Q with smallest distance in dist[] ;  // Which is actually the start node in first case. At the beginning all nodes have cost of "1000000" and the start node has cost of "0".
 
remove u from Q ;                                    // Somehow mark the node as alredy examined
 
if dist[u] = infinity:                               // Test if it is worth it to examine u-th node.
break ;                                              // All remaining vertices are inaccessible from source
end if
 
for each neighbor v of u:                            // Where v-th node has not yet been removed from Q.
 
alt := dist[u] + dist_between(u, v) ;                // alt - possible alternative best distance
if alt < dist[v]:                                    // alt is better than dist[v] so overwrite dist[v]
dist[v] := alt ;
previous[v] := u ;                                   // Remember a path to this node, because the point is important, it has a good cost.
end if
end for
end while
return dist;

S := empty sequence                                           // Stack "S" will contain our path 
 u := target
 while previous[u] is defined:                                 // Construct the shortest path by looking backwards - traverse from end to start
 insert u at the beginning of S                            // Push the vertex into the stack "S"
 u := previous[u]                                          // Traverse from target to source
 end while ;