feat: add minTime solutions in Python, C++, and Go for LC problem #3604

solution/3600-3699/3604.Minimum Time to Reach Destination in Directed Graph/README.md

@@ -118,7 +118,29 @@ tags:
 #### Python3
 
 ```python
-
+class Solution:
+    def minTime(self, n: int, edges: List[List[int]]) -> int:
+        minReachTime = [inf] * n
+        minReachTime[0] = 0
+
+        nodeEdges = [[] for _ in range(n)]
+        for edge in edges:
+            nodeEdges[edge[0]].append(edge)
+
+        reachTimeHeap = [(0, 0)]
+        while reachTimeHeap:
+            curTime, node = heappop(reachTimeHeap)
+            if node == n - 1:
+                return curTime
+
+            for edge in nodeEdges[node]:
+                if curTime <= edge[3]:
+                    destTime = max(curTime, edge[2]) + 1
+                    if minReachTime[edge[1]] > destTime:
+                        minReachTime[edge[1]] = destTime
+                        heappush(reachTimeHeap, (destTime, edge[1]))
+
+        return -1
 ```
 
 #### Java
@@ -130,13 +152,143 @@ tags:
 #### C++
 
 ```cpp
-
+class Solution {
+    vector<vector<vector<int>>> adj;
+    vector<int> sol;
+    priority_queue<pair<int,int> ,vector<pair<int,int>>,greater<>> pq;
+    void pushNeighbours(int node,int curr){
+        for(auto it : adj[node]){
+            int temp = it[0] , start = it[1],end = it[2],newTime = curr+1;
+            if(curr<start)  newTime = start+1;
+            if(newTime < sol[temp] && newTime-1<=end){
+                pq.push({newTime,temp});
+                sol[temp] = newTime;
+            }
+        }
+    }
+public:
+    int minTime(int n, vector<vector<int>>& edges) {
+        adj = vector<vector<vector<int>>>(n);
+        for(auto it: edges)
+            adj[it[0]].push_back({it[1],it[2],it[3]});
+        sol = vector<int> (n,INT_MAX);
+        sol[0]=0;
+        for(pq.push({0,0});!pq.empty();pq.pop())
+            pushNeighbours(pq.top().second,pq.top().first);
+        if(sol[n-1] == INT_MAX) return -1;
+        return sol[n-1];
+    }
+};
+const auto __ = []() {
+    struct ___ {
+        static void _() {
+            std::ofstream("display_runtime.txt") << 0 << '\n';
+            std::ofstream("display_memory.txt") << 0 << '\n';
+        }
+    };
+    std::atexit(&___::_);
+    return 0;
+}();
 ```
 
 #### Go
 
 ```go
-
+import "container/heap"
+
+func minTime(n int, edges [][]int) int {
+    graph := make([][][3]int, n)
+    for _, edge := range edges {
+        u, v, start, end := edge[0], edge[1], edge[2], edge[3]
+        graph[u] = append(graph[u], [3]int{v, start, end})
+    }
+
+    dist := make([]int, n)
+    for i := range dist {
+        dist[i] = -1
+    }
+    dist[0] = 0
+
+    pq := &PriorityQueue{}
+    heap.Init(pq)
+    heap.Push(pq, &Item{value: 0, priority: 0})
+
+    for pq.Len() > 0 {
+        item := heap.Pop(pq).(*Item)
+        u := item.value
+        d := item.priority
+
+        if d > dist[u] && dist[u] != -1{
+            continue
+        }
+
+
+        if u == n-1{
+            continue
+        }
+
+
+        for _, edge := range graph[u] {
+            v, start, end := edge[0], edge[1], edge[2]
+
+            wait := 0
+            if d < start {
+                wait = start - d
+            }
+
+            if d + wait <= end {
+                newDist := d + wait + 1
+                if dist[v] == -1 || newDist < dist[v] {
+                    dist[v] = newDist
+                    heap.Push(pq, &Item{value: v, priority: newDist})
+                }
+            }
+        }
+    }
+
+    return dist[n-1]
+}
+
+type Item struct {
+	value    int // The value of the item; arbitrary.
+	priority int // The priority of the item in the queue.
+	// The index is needed to update during heap operations. It is
+	// maintained by the heap.Interface methods.
+	index int // The index of the item in the heap.
+}
+
+// A PriorityQueue implements heap.Interface and holds Items.
+type PriorityQueue []*Item
+
+func (pq PriorityQueue) Len() int { return len(pq) }
+
+func (pq PriorityQueue) Less(i, j int) bool {
+	// We want Pop to give us the lowest, not highest, priority so we use less than here.
+	return pq[i].priority < pq[j].priority
+}
+
+func (pq PriorityQueue) Swap(i, j int) {
+	pq[i], pq[j] = pq[j], pq[i]
+	pq[i].index = i
+	pq[j].index = j
+}
+
+func (pq *PriorityQueue) Push(x any) {
+	n := len(*pq)
+	item := x.(*Item)
+	item.index = n
+	*pq = append(*pq, item)
+}
+
+func (pq *PriorityQueue) Pop() any {
+	old := *pq
+	n := len(old)
+	item := old[n-1]
+	old[n-1] = nil  // avoid memory leak
+	item.index = -1 // for safety
+	*pq = old[0 : n-1]
+	return item
+}
 ```
 
 <!-- tabs:end -->

solution/3600-3699/3604.Minimum Time to Reach Destination in Directed Graph/README_EN.md

@@ -115,7 +115,29 @@ tags:
 #### Python3
 
 ```python
-
+class Solution:
+    def minTime(self, n: int, edges: List[List[int]]) -> int:
+        minReachTime = [inf] * n
+        minReachTime[0] = 0
+
+        nodeEdges = [[] for _ in range(n)]
+        for edge in edges:
+            nodeEdges[edge[0]].append(edge)
+
+        reachTimeHeap = [(0, 0)]
+        while reachTimeHeap:
+            curTime, node = heappop(reachTimeHeap)
+            if node == n - 1:
+                return curTime
+
+            for edge in nodeEdges[node]:
+                if curTime <= edge[3]:
+                    destTime = max(curTime, edge[2]) + 1
+                    if minReachTime[edge[1]] > destTime:
+                        minReachTime[edge[1]] = destTime
+                        heappush(reachTimeHeap, (destTime, edge[1]))
+
+        return -1
 ```
 
 #### Java
@@ -127,13 +149,143 @@ tags:
 #### C++
 
 ```cpp
-
+class Solution {
+    vector<vector<vector<int>>> adj;
+    vector<int> sol;
+    priority_queue<pair<int,int> ,vector<pair<int,int>>,greater<>> pq;
+    void pushNeighbours(int node,int curr){
+        for(auto it : adj[node]){
+            int temp = it[0] , start = it[1],end = it[2],newTime = curr+1;
+            if(curr<start)  newTime = start+1;
+            if(newTime < sol[temp] && newTime-1<=end){
+                pq.push({newTime,temp});
+                sol[temp] = newTime;
+            }
+        }
+    }
+public:
+    int minTime(int n, vector<vector<int>>& edges) {
+        adj = vector<vector<vector<int>>>(n);
+        for(auto it: edges)
+            adj[it[0]].push_back({it[1],it[2],it[3]});
+        sol = vector<int> (n,INT_MAX);
+        sol[0]=0;
+        for(pq.push({0,0});!pq.empty();pq.pop())
+            pushNeighbours(pq.top().second,pq.top().first);
+        if(sol[n-1] == INT_MAX) return -1;
+        return sol[n-1];
+    }
+};
+const auto __ = []() {
+    struct ___ {
+        static void _() {
+            std::ofstream("display_runtime.txt") << 0 << '\n';
+            std::ofstream("display_memory.txt") << 0 << '\n';
+        }
+    };
+    std::atexit(&___::_);
+    return 0;
+}();
 ```
 
 #### Go
 
 ```go
-
+import "container/heap"
+
+func minTime(n int, edges [][]int) int {
+    graph := make([][][3]int, n)
+    for _, edge := range edges {
+        u, v, start, end := edge[0], edge[1], edge[2], edge[3]
+        graph[u] = append(graph[u], [3]int{v, start, end})
+    }
+
+    dist := make([]int, n)
+    for i := range dist {
+        dist[i] = -1
+    }
+    dist[0] = 0
+
+    pq := &PriorityQueue{}
+    heap.Init(pq)
+    heap.Push(pq, &Item{value: 0, priority: 0})
+
+    for pq.Len() > 0 {
+        item := heap.Pop(pq).(*Item)
+        u := item.value
+        d := item.priority
+
+        if d > dist[u] && dist[u] != -1{
+            continue
+        }
+
+
+        if u == n-1{
+            continue
+        }
+
+
+        for _, edge := range graph[u] {
+            v, start, end := edge[0], edge[1], edge[2]
+
+            wait := 0
+            if d < start {
+                wait = start - d
+            }
+
+            if d + wait <= end {
+                newDist := d + wait + 1
+                if dist[v] == -1 || newDist < dist[v] {
+                    dist[v] = newDist
+                    heap.Push(pq, &Item{value: v, priority: newDist})
+                }
+            }
+        }
+    }
+
+    return dist[n-1]
+}
+
+type Item struct {
+	value    int // The value of the item; arbitrary.
+	priority int // The priority of the item in the queue.
+	// The index is needed to update during heap operations. It is
+	// maintained by the heap.Interface methods.
+	index int // The index of the item in the heap.
+}
+
+// A PriorityQueue implements heap.Interface and holds Items.
+type PriorityQueue []*Item
+
+func (pq PriorityQueue) Len() int { return len(pq) }
+
+func (pq PriorityQueue) Less(i, j int) bool {
+	// We want Pop to give us the lowest, not highest, priority so we use less than here.
+	return pq[i].priority < pq[j].priority
+}
+
+func (pq PriorityQueue) Swap(i, j int) {
+	pq[i], pq[j] = pq[j], pq[i]
+	pq[i].index = i
+	pq[j].index = j
+}
+
+func (pq *PriorityQueue) Push(x any) {
+	n := len(*pq)
+	item := x.(*Item)
+	item.index = n
+	*pq = append(*pq, item)
+}
+
+func (pq *PriorityQueue) Pop() any {
+	old := *pq
+	n := len(old)
+	item := old[n-1]
+	old[n-1] = nil  // avoid memory leak
+	item.index = -1 // for safety
+	*pq = old[0 : n-1]
+	return item
+}
 ```
 
 <!-- tabs:end -->

solution/3600-3699/3604.Minimum Time to Reach Destination in Directed Graph/Solution.cpp

@@ -0,0 +1,37 @@
+class Solution {
+    vector<vector<vector<int>>> adj;
+    vector<int> sol;
+    priority_queue<pair<int,int> ,vector<pair<int,int>>,greater<>> pq;
+    void pushNeighbours(int node,int curr){
+        for(auto it : adj[node]){
+            int temp = it[0] , start = it[1],end = it[2],newTime = curr+1;
+            if(curr<start)  newTime = start+1;
+            if(newTime < sol[temp] && newTime-1<=end){
+                pq.push({newTime,temp});
+                sol[temp] = newTime;
+            }
+        }
+    }
+public:
+    int minTime(int n, vector<vector<int>>& edges) {
+        adj = vector<vector<vector<int>>>(n);
+        for(auto it: edges)
+            adj[it[0]].push_back({it[1],it[2],it[3]});
+        sol = vector<int> (n,INT_MAX);
+        sol[0]=0;
+        for(pq.push({0,0});!pq.empty();pq.pop())
+            pushNeighbours(pq.top().second,pq.top().first);
+        if(sol[n-1] == INT_MAX) return -1;
+        return sol[n-1];
+    }
+};
+const auto __ = []() {
+    struct ___ {
+        static void _() {
+            std::ofstream("display_runtime.txt") << 0 << '\n';
+            std::ofstream("display_memory.txt") << 0 << '\n';
+        }
+    };
+    std::atexit(&___::_);
+    return 0;
+}();