Given an integer N representing the number of cities near you along with two arrays pos[] representing the position of the city and time[] representing the time required to move 1 unit of distance for a particular city, the task is to find the minimum time required to visit any city where you are currently at cur position.
Examples:
Input: N = 3, cur = 4, pos[] = [1, 5, 6], time[] = [2, 3, 1]
Output: 2
Explanation:
- Total time taken by the 1st taxi will be: (4-1)*2 = 6
- Total time taken by the 2nd taxi will be: (5-4)*3 = 3
- Total time taken by the 3rd taxi will be: (6-4)*1 = 2
So, the minimum time will be 2 sec.
Input: N = 2, cur = 1, pos[] = [1, 6], time[] = [10, 3]
Output: 0
Explanation:
- Total time taken by the 1st taxi will be: (1-1)*10 = 0
- Total time taken by the 2nd taxi will be: (6-1)*3 = 15
So, the minimum time will be 0 sec.
Approach: This can be solved with the following idea:
Determine the lowest amount of time required by you to reach each city by first calculating the absolute distance between you and each city.
Below are the steps involved in the implementation of the code:
- Run a loop from 0 to N(number of taxis).
- Keep calculating the distance and then multiply it by the time taken by you to travel each city per unit distance.
- Now keep storing the minimum time.
- Return in the min time possible.
Below is the code implementation of the above code:
#include <cmath> #include <iostream> #include <limits> using namespace std;
// Minimum time required to // reach any city int minimumTime( int N, int cur, int pos[], int time [])
{ // Initialising with maximum
// distance
int mn = numeric_limits< int >::max();
// iterate over all positions
for ( int i = 0; i < N; i++) {
// Calculate the distance from
// the current position to the
// current position in pos
int dist = abs (pos[i] - cur);
// Update mn if the time
// taken to move to the
// current position is
// smaller than the
// previous minimum time
mn = min(mn, dist * time [i]);
}
// Return the minimum time taken
// to move to any position
return mn;
} // Driver code int main()
{ int N = 3;
int cur = 4;
int pos[] = { 1, 5, 6 };
int time [] = { 2, 3, 1 };
// Function call
int minTime = minimumTime(N, cur, pos, time );
cout << minTime << endl;
return 0;
} // This code is contributed by Ayush pathak |
import java.util.*;
public class GFG {
// Minimum time required to
// reach any city
public static int minimumTime( int N, int cur, int [] pos,
int [] time)
{
// Initialising with maximum
// distance
int mn = ( int )1e9;
// iterate over all positions
for ( int i = 0 ; i < N; i++) {
// Calculate the distance from
// the current position to the
// current position in pos
int dist = Math.abs(pos[i] - cur);
// Update mn if the time
// taken to move to the
// current position is
// smaller than the
// previous minimum time
mn = Math.min(mn, dist * time[i]);
}
// Return the minimum time taken
// to move to any position
return mn;
}
// Driver code
public static void main(String[] args)
{
int N = 3 ;
int cur = 4 ;
int [] pos = { 1 , 5 , 6 };
int [] time = { 2 , 3 , 1 };
// Function call
int minTime = minimumTime(N, cur, pos, time);
System.out.println(minTime);
}
} |
using System;
public class GFG
{ // Minimum time required to
// reach any city
public static int minimumTime( int N, int cur, int [] pos, int [] time)
{
// Initialising with maximum
// distance
int mn = ( int )1e9;
// iterate over all positions
for ( int i = 0; i < N; i++)
{
// Calculate the distance from
// the current position to the
// current position in pos
int dist = Math.Abs(pos[i] - cur);
// Update mn if the time
// taken to move to the
// current position is
// smaller than the
// previous minimum time
mn = Math.Min(mn, dist * time[i]);
}
// Return the minimum time taken
// to move to any position
return mn;
}
// Driver code
public static void Main( string [] args)
{
int N = 3;
int cur = 4;
int [] pos = { 1, 5, 6 };
int [] time = { 2, 3, 1 };
// Function call
int minTime = minimumTime(N, cur, pos, time);
Console.WriteLine(minTime);
}
} |
import sys
# Minimum time required to # reach any city def minimumTime(N, cur, pos, time):
# Initialising with maximum
# distance
mn = sys.maxsize
# iterate over all positions
for i in range (N):
# Calculate the distance from
# the current position to the
# current position in pos
dist = abs (pos[i] - cur)
# Update mn if the time
# taken to move to the
# current position is
# smaller than the
# previous minimum time
mn = min (mn, dist * time[i])
# Return the minimum time taken
# to move to any position
return mn
# Driver code if __name__ = = "__main__" :
N = 3
cur = 4
pos = [ 1 , 5 , 6 ]
time = [ 2 , 3 , 1 ]
# Function call
minTime = minimumTime(N, cur, pos, time)
print (minTime)
|
function minimumTime(N, cur, pos, time) {
// Initialising with maximum distance
let mn = Number.MAX_SAFE_INTEGER;
// iterate over all positions
for (let i = 0; i < N; i++) {
// Calculate the distance from
// the current position to the
// current position in pos
let dist = Math.abs(pos[i] - cur);
// Update mn if the time
// taken to move to the
// current position is
// smaller than the
// previous minimum time
mn = Math.min(mn, dist * time[i]);
}
// Return the minimum time taken
// to move to any position
return mn;
} // Driver code const N = 3; const cur = 4; const pos = [1, 5, 6]; const time = [2, 3, 1]; // Function call const minTime = minimumTime(N, cur, pos, time); console.log(minTime); |
2
Time Complexity: O(N)
Auxiliary Space: O(1)