Question

Suppose you have an all positive edge-weighted graph G and a start vertex a and asks you to find the lowest-weight path from a to every vertex in G. Now considering the weight of a path to be the maximum weight of its edges, how can you alter Dijkstra’s algorithm to solve this?

Answer 1

Algorithm
1) Create a set sptSet (shortest path tree set) that keeps track of vertices included in shortest path tree, i.e., whose minimum distance from source is calculated and finalized. Initially, this set is empty.
2) Assign a distance value to all vertices in the input graph. Initialize all distance values as INFINITE. Assign distance value as 0 for the source vertex so that it is picked first.
3) While sptSet doesn’t include all vertices
.a) Pick a vertex u which is not there in sptSet and has minimum distance value.
.b) Include u to sptSet.
.c) Update distance value of all adjacent vertices of u. To update the distance values, iterate through all adjacent vertices. For every adjacent vertex v, if sum of distance value of u (from source) and weight of edge u-v, is less than the distance value of v, then update the distance value of v.
.d) Update the path index of adjacent vertex of v for min distance and then loop through the path

// A Java program for Dijkstra's shortest path algorithm for adjacency matrix.

import java.util.*;
import java.lang.*;
import java.io.*;
  
class ShortestPath {
// A utility function to find the vertex with minimum distance value,
// from the set of vertices not yet included in shortest path tree
static final int V = 9;
int minDistance(int dist[], Boolean sptSet[])
{
// Initialize min value
int min = Integer.MAX_VALUE, min_index = -1;
  
for (int v = 0; v < V; v++)
if (sptSet[v] == false && dist[v] <= min) {
min = dist[v];
min_index = v;
}
  
return min_index;
}
  
// A utility function to print the constructed distance array
void printSolution(int dist[], int path[], int src)
{
for (int i = 0; i < V; i++)
{
// print the distance from dist
System.out.print( "Vertex : " + i + "\t Distance : " + dist[i]);
  
System.out.print(" \t Path : ");
// loop through the path saved for parent vertex till it reaches source
for(int j = i; j != src; j = path[j]){
System.out.print( j + " -> ");
}
System.out.println(src);
}
}
  
// Function that implements Dijkstra's single source shortest path
// algorithm for a graph represented using adjacency matrix
// representation
void dijkstra(int graph[][], int src)
{
int dist[] = new int[V]; // dist[i] will hold the shortest distance from src to i
int path[] = new int[V]; // path[i] will hold the shortest path from src to i
  
// sptSet[i] will true if vertex i is included in shortest path
Boolean sptSet[] = new Boolean[V];
  
// Initialize all distances as INFINITE and stpSet[] as false
for (int i = 0; i < V; i++) {
dist[i] = Integer.MAX_VALUE;
path[i] = i;
sptSet[i] = false;
}
  
// Distance of source vertex from itself is always 0
dist[src] = 0;
  
// Find shortest path for all vertices
for (int count = 0; count < V - 1; count++) {
// Pick the minimum distance vertex from the set of vertices
// not yet processed. u is always equal to src in first iteration.
int u = minDistance(dist, sptSet);
  
// Mark the picked vertex as processed
sptSet[u] = true;
  
// Update dist value of the adjacent vertices of the
// picked vertex.
for (int v = 0; v < V; v++)
  
// Update dist[v] and path[v] only if is not in sptSet, there is an
// edge from u to v, and total weight of path from src to
// v through u is smaller than current value of dist[v]
if (!sptSet[v] && graph[u][v] != 0 && dist[u] != Integer.MAX_VALUE && dist[u] + graph[u][v] < dist[v])
{
dist[v] = dist[u] + graph[u][v];
path[v] = u; // save index of adjacent vertex min distance
}
}
  
// print the constructed distance array
printSolution(dist, path, src);
}
  
}
class Main {
// Driver method
public static void main(String[] args)
{
/* Let us create the example graph discussed above */
int graph[][] = new int[][] { { 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 } };
ShortestPath t = new ShortestPath();
t.dijkstra(graph, 0);
}  
}

Output