Question

Suppose that we are given a model of a city as a directed, weighted graph G = (V, E); w : E → R≥0, where we have n neighbourhoods and m streets, represented by the vertices and edges respectively. We will assume that the streets are one-way. We are also given that k of these neighbourhoods have fire stations installed. We want to find the nearest fire station for each neighbourhood, where we measure the distance from the fire station to the neighbourhood.

Give an algorithm which finds the nearest fire station for each neighbourhood in O((n+m+k) log n).

Please explain time complexity.

Answer 1

1.### Suppose we get a graph with edges in format {{u1,v1,w1},{u2,v2,w2},......,{uM,vM,wM}}.
       where ui = source vertex, vi = destination vertex, wi = directed edge weight.
2.###   Also we get N = the number of nodes

3.### firestations - array which contains the vertex number with the firestations

4.We use Dijkstra's algo to solve this problem.

5. We use the data structure adjacency list and queue to solve this problem with time complexity O((N+M) logN).

6. Since for Dijkstra's algo there is a single source time complexity is O((N+M) logN), but for this problem all
the firestations nodes are the source from where we have to find the shortest distance to all vertices.

7. Hence we push all the firestations nodes in the queue unlike in the Dijkstra where we only push src vertex and
set distance[src]=0;
8. We set distance[ui]=0 for all the firestations nodes.

9. Then we implement queue just like dijkstra's algo.

10. Thus overall time complexity with K(Total firestation nodes) source is O((n+m+k) log n).

Below is the function code for the Problem in C++
where
   vector<vector<int>> edges = edges in format {{u1,v1,w1},{u2,v2,w2},......,{uM,vM,wM}}
   vector<int> firestations - array which contains the vertex number with the firestations
   N = the number of nodes

   we create adjacency list with
   unordered_map<int,unordered_map<int,int>> graph

   and queue<int> q

void NearestDist(vector<vector<int>>& edges, int N, vector<int> firestations) {
// distance stores the distance to the nearest firestations
vector<int> distance(N,INT_MAX);
unordered_map<int,unordered_map<int,int>> graph;
int m=edges.size();
// graph[u][v]=w, stores the directed edge from u to v with weight w
for(int i=0;i<m;i++)
{
int x=times[i][0],y=times[i][1],cost=times[i][2];
graph[x-1][y-1]=cost;
}
// k is the number of neighbourhoods with firestations
int k=firestations.size();
queue<int> q;
// those neighbourhoods that have firestations have distance[i]=0;
for(int i=0;i<k;i++)
{
// from hoods with firestations we go to every hood and update their distance
q.push(firestations[i]);
distance[firestations[i]]=0;
}
while(!q.empty())
{
int u=q.front();
q.pop();
for(auto i:graph[u])   
{
int v=i.first; // v is the second vertex which have a directed edge from u
int w=i.second // w is the weight from an edge u to v
if(distance[v]>distance[u]+w)
{
distance[v]=distance[u]+w;
q.push(v);
}
}
}
for(int i=0;i<N;i++)
{
if(distance[i]==INT_MAX)
{
cout<<i<<"th index does not have a route to any firestations "<<endl;
}
else
{
cout<<i<<"th index have nearest firestations with distance "<<distance[i]<<endl;
}
}
}