Minimum time to reach from city 1 to city N [closed] - algorithm

Question

Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 1 year ago.
Improve this question
There are a lot of graph problems that require some modification of the BFS algorithm. I just come across this problem. I thought of this question with just an extension of the standard BFS algorithm.
The question states that:
We are given a country, having N cities and M bidirectional roads. Each city has a traffic light, showing only 2 colors i.e Green and Red. All the traffic lights switch their color from Green to Red or vice versa after every T seconds. We can cross a city only when the traffic light is green. Initially, all traffic light is green. In any city, if the traffic light is Red then we have to wait for its light to turn green. Time taken to travel any road is C. We have to find minimum time to reach City N from 1.
Note: graph doesn't contain a self-loop or multiple edges.
For example:
N=5,M=5,T=3,C=5
Edges are:
1 2,
1 3,
2 4,
1 4,
2 5.
Here minimum time to go from 1 to 5 is 11 through path 1 2 5.WE can reach city 2 in 5 secs. then wait for 1 second for the light to turn green and then 5 seconds to go to 5.
Can anyone share his approach toward this problem? whether it is a BFS problem or some other graph algorithm required too?
Better to unsderstand if psedoucode will be there along with algorithm?

Answer 1

Because all the cities start with same initial state, switch lights with the same frequency, and all the roads have the same duration, the traffic lights delay all routes equally.
As all roads have the same duration, this means that BFS will be an efficient way to solve the problem. The only adjustment to the standard algorithm is to adjust the time at each node to account for any delay due to the traffic lights.
(If the roads had different durations, or the lights switched irregularly, then a more advanced algorithm such as Dijkstra would be required.)

Answer 2

I'm assuming all edge weights have an integer number of seconds.
Note that the period of a traffic light is 2T. Take your original graph G and duplicate its nodes 2T times: G0, G1, ..., G2T - 1. If there is an edge in the original graph G from node a to b with weight w, then add an edge with weight w from each node a in Gt to b in G(t + w) mod 2T for each t where the light in a is green. Add an edge with weight 1 between each respective node in Gt, G(t+1) mod 2T, representing the possibility to wait at a city.
Finally, add one more copy of the nodes of G to your graph, D, that will be used for the destination nodes. Add an edge from each node in Gt to its respective node in D with weight 0.
Then the shortest path between nodes s in G0 and t in D follows exactly your problem.

Answer 3

#include <bits/stdc++.h>
using namespace std;
#define ll long long int
vector<int> g[1001];
vector<pair<ll,vector<ll>>> pt;
void dfs(ll st,ll e,ll vis[],vector<ll> rs,ll w){
rs.push_back(st);
if(st == e){
pt.push_back({w*(rs.size()-1),rs});
return;
}
for(auto u : g[st]){
if(vis[u] == 0){
vis[st] = 1;
dfs(u,e,vis,rs,w);
vis[st] = 0;
}
}
}
int main()
{
ll n,m,t,c,u,v;
cin>>n>>m>>t>>c;
while(m--){
cin>>u>>v;
g[u].push_back(v);
g[v].push_back(u);
}
if(n == 1)
cout<<0<<endl;
else if(n == 2)
cout<<t<<endl;
else{
vector<ll> rs;
ll w = c;
ll vis[n+1] = {0};
dfs(1,n,vis,rs,w);
if(pt.size() == 0)
cout<<-1<<endl;
else{
sort(pt.begin(),pt.end());
ll te = 0;
ll nt = 0;
for(int i=1;i<pt[0].second.size();i++){
te += c + (nt-te);
while(nt < te)
nt += t;
}
cout<<te<<endl;
}//else
}
return 0;
}

Answer 4

This Question was asked in a coding round of a company that i attended, I could come up with a BFS solution with O(n) Time Complexity.
(The coding round is over now. So here's my solution)-Edited
My Solution (Python 3):
def getPresentTrafficColorAndWaitTime(curr_color,traffic,cost_travel):
#color
val = (cost_travel//traffic)%2
if val == 1:
curr_color = 0 if curr_color==1 else 1
#waitTime
waitTime = traffic - (cost_travel%traffic)
return curr_color,waitTime
def bfs(adj,visited,curr,final,traffic,cost_travel):
queue = []
queue.append(1)
visited[1] = 1
dist = 0
# Red: 1 , Green: 0
curr_color = 0
temp_cost_travel = cost_travel
while queue:
length = len(queue)
for _ in range(length):
curr = queue[0]
queue.pop(0)
for i in adj[curr]:
if i == final:
return dist+cost_travel
elif visited[i] == 0:
visited[i] = 1
queue.append(i)
curr_color,waitTime = getPresentTrafficColorAndWaitTime(curr_color,traffic,temp_cost_travel)
if curr_color == 1:
add_dist = waitTime
temp_cost_travel = cost_travel
curr_color = 0
else:
add_dist = 0
temp_cost_travel += cost_travel
dist += cost_travel + add_dist
return -1
# Taking Input and creating Adjacency-list using defaultdict
n,m,t,c = map(int,input().split())
adj_list = defaultdict(list)
for _ in range(m):
u,v = map(int,input().split())
adj_list[u] = adj_list.get(u,[]) + [v]
adj_list[v] = adj_list.get(v,[]) + [u]
visited = [0]*(n+1)
answer = bfs(adj_list,visited,1,n,t,c)
print(answer)