Given 3 arrays X[], Y[], and T[] all of the size N where X[i] and Y[i] represent the i-th coordinate and T[i] represents the time in seconds. Find it is possible to reach all the coordinates (X[i], Y[i]) in time T[i] from starting coordinates (0, 0). The pointer can move in four directions ( x +1, y ), ( x − 1, y ), ( x, y + 1) and (x, y − 1). From going from one coordinate to another takes 1 second and cannot stay at own palace.
Examples:
Input: N = 2, X[] = {1, 1},
Y[] = {2, 1},
T[] = {3, 6}
Output: Yes
Explanation: Suppose 2D Matrix like this:
In above matrix each point is defined as x and y coordinate Travel from ( 0, 0 ) -> ( 0, 1 ) -> ( 1, 1 ) -> ( 1, 2 ) in 3 seconds Then from ( 1, 2 ) -> ( 1, 1 ) -> ( 1, 0 ) -> ( 1, 1 ) on 6th second. So, yes it is possible to reach all the coordinates in given time.
Input: N = 1, X[] = {100 },
Y[] = {100 },
T[] = {2}
Output: No
Explanation: It is not possible to reach coordinates X and Y in 2 seconds from coordinates ( 0, 0 ).
Approach: The idea to solve this problem is based on the fact that to move from i-th point to (i+1)-th point it takes abs(X[i+1] – X[i]) + abs(Y[i+1] – Y[i]) time. In the case of the first point, the previous point is (0, 0). So, if this time is less than T[i] then it’s fine otherwise, it violates the condition. Follow the steps below to solve the problem:
- Make three variables currentX, currentY, currentTime and initialize to zero.
- Make a bool variable isPossible and initialize to true.
-
Iterate over the range [0, N) using the variable i and perform the following tasks:
- If (abs(X[i] – currentX ) + abs( Y[i] – currentY )) is greater than (T[i] – currentTime) then make isPossible false.
- Else if, ((abs(X[i] – currentX ) + abs( Y[i] – currentY )) % 2 is not equal to (T[i] – currentTime) % 2 then make isPossible false.
- Else change the previous values of currentX, currentY and currentTime with Xi, Yi and Ti.
- After performing the above steps, return the value of isPossible as the answer.
Below is the implementation of the above approach.
C++
// C++ program for the above approach#include <bits/stdc++.h>using namespace std;
// Function to check if it is possible// to traverse all the points.bool CheckItisPossible(int X[], int Y[],
int T[], int N)
{ // Make 3 variables to store given
// ith values
int currentX = 0, currentY = 0,
currentTime = 0;
// Also, make a bool variable to
// check it is possible
bool IsPossible = true;
// Now, iterate on all the coordinates
for (int i = 0; i < N; i++) {
// check first condition
if ((abs(X[i] - currentX)
+ abs(Y[i] - currentY))
> (T[i] - currentTime)) {
// means thats not possible to
// reach current coordinate
// at Ithtime from previous coordinate
IsPossible = false;
break;
}
else if (((abs(X[i] - currentX)
+ abs(Y[i] - currentY))
% 2)
> ((T[i] - currentTime) % 2)) {
// means thats not possible to
// reach current coordinate
// at Ithtime from previous coordinate
IsPossible = false;
break;
}
else {
// If both above conditions are false
// then we change the values of current
// coordinates
currentX = X[i];
currentY = Y[i];
currentTime = T[i];
}
}
return IsPossible;
}// Driver Codeint main()
{ int X[] = { 1, 1 };
int Y[] = { 2, 1 };
int T[] = { 3, 6 };
int N = sizeof(X[0]) / sizeof(int);
bool ans = CheckItisPossible(X, Y, T, N);
if (ans == true) {
cout << "Yes"
<< "\n";
}
else {
cout << "No"
<< "\n";
}
return 0;
} |
Java
// Java program for the above approachpublic class GFG {
// Function to check if it is possible
// to traverse all the points.
static boolean CheckItisPossible(int X[], int Y[],
int T[], int N)
{
// Make 3 variables to store given
// ith values
int currentX = 0, currentY = 0,
currentTime = 0;
// Also, make a bool variable to
// check it is possible
boolean IsPossible = true;
// Now, iterate on all the coordinates
for (int i = 0; i < N; i++) {
// check first condition
if ((Math.abs(X[i] - currentX) +
Math.abs(Y[i] - currentY)) > (T[i] - currentTime)) {
// means thats not possible to
// reach current coordinate
// at Ithtime from previous coordinate
IsPossible = false;
break;
}
else if (((Math.abs(X[i] - currentX) +
Math.abs(Y[i] - currentY)) % 2) > ((T[i] - currentTime) % 2)) {
// means thats not possible to
// reach current coordinate
// at Ithtime from previous coordinate
IsPossible = false;
break;
}
else {
// If both above conditions are false
// then we change the values of current
// coordinates
currentX = X[i];
currentY = Y[i];
currentTime = T[i];
}
}
return IsPossible;
}
// Driver Code
public static void main(String[] args)
{
int X[] = { 1, 1 };
int Y[] = { 2, 1 };
int T[] = { 3, 6 };
int N = X.length;
boolean ans = CheckItisPossible(X, Y, T, N);
if (ans == true) {
System.out.println("Yes");
}
else {
System.out.println("No");
}
}
}// This code is contributed by AnkThon |
Python3
# python program for the above approach# Function to check if it is possible# to traverse all the points.def CheckItisPossible(X, Y, T, N):
# Make 3 variables to store given
# ith values
currentX = 0
currentY = 0
currentTime = 0
# Also, make a bool variable to
# check it is possible
IsPossible = True
# Now, iterate on all the coordinates
for i in range(0, N):
# check first condition
if ((abs(X[i] - currentX)
+ abs(Y[i] - currentY))
> (T[i] - currentTime)):
# means thats not possible to
# reach current coordinate
# at Ithtime from previous coordinate
IsPossible = False
break
elif (((abs(X[i] - currentX)
+ abs(Y[i] - currentY))
% 2)
> ((T[i] - currentTime) % 2)):
# means thats not possible to
# reach current coordinate
# at Ithtime from previous coordinate
IsPossible = False
break
else:
# If both above conditions are false
# then we change the values of current
# coordinates
currentX = X[i]
currentY = Y[i]
currentTime = T[i]
return IsPossible
# Driver Codeif __name__ == "__main__":
X = [1, 1]
Y = [2, 1]
T = [3, 6]
N = len(X)
ans = CheckItisPossible(X, Y, T, N)
if (ans == True):
print("Yes")
else:
print("No")
# This code is contributed by rakeshsahni
|
C#
// C# program for the above approachusing System;
class GFG {
// Function to check if it is possible
// to traverse all the points.
static bool CheckItisPossible(int []X, int []Y,
int []T, int N)
{
// Make 3 variables to store given
// ith values
int currentX = 0, currentY = 0,
currentTime = 0;
// Also, make a bool variable to
// check it is possible
bool IsPossible = true;
// Now, iterate on all the coordinates
for (int i = 0; i < N; i++) {
// check first condition
if ((Math.Abs(X[i] - currentX) +
Math.Abs(Y[i] - currentY)) > (T[i] - currentTime)) {
// means thats not possible to
// reach current coordinate
// at Ithtime from previous coordinate
IsPossible = false;
break;
}
else if (((Math.Abs(X[i] - currentX) +
Math.Abs(Y[i] - currentY)) % 2) > ((T[i] - currentTime) % 2)) {
// means thats not possible to
// reach current coordinate
// at Ithtime from previous coordinate
IsPossible = false;
break;
}
else {
// If both above conditions are false
// then we change the values of current
// coordinates
currentX = X[i];
currentY = Y[i];
currentTime = T[i];
}
}
return IsPossible;
}
// Driver Code
public static void Main()
{
int []X = { 1, 1 };
int []Y = { 2, 1 };
int []T = { 3, 6 };
int N = X.Length;
bool ans = CheckItisPossible(X, Y, T, N);
if (ans == true) {
Console.Write("Yes");
}
else {
Console.Write("No");
}
}
}// This code is contributed by Samim Hossain Mondal. |
Javascript
<script>// Javascript program for the above approach// Function to check if it is possible// to traverse all the points.function CheckItisPossible(X, Y, T, N)
{ // Make 3 variables to store given
// ith values
let currentX = 0, currentY = 0,
currentTime = 0;
// Also, make a bool variable to
// check it is possible
let IsPossible = true;
// Now, iterate on all the coordinates
for (let i = 0; i < N; i++) {
// check first condition
if ((Math.abs(X[i] - currentX)
+ Math.abs(Y[i] - currentY))
> (T[i] - currentTime)) {
// means thats not possible to
// reach current coordinate
// at Ithtime from previous coordinate
IsPossible = false;
break;
}
else if (((Math.abs(X[i] - currentX)
+ Math.abs(Y[i] - currentY))
% 2)
> ((T[i] - currentTime) % 2)) {
// means thats not possible to
// reach current coordinate
// at Ithtime from previous coordinate
IsPossible = false;
break;
}
else {
// If both above conditions are false
// then we change the values of current
// coordinates
currentX = X[i];
currentY = Y[i];
currentTime = T[i];
}
}
return IsPossible;
}// Driver Codelet X = [ 1, 1 ];let Y = [ 2, 1 ];let T = [ 3, 6 ];let N = X.length;let ans = CheckItisPossible(X, Y, T, N);if (ans == true) {
document.write("Yes" + "\n");
}else {
document.write("No" + "\n");
} // This code is contributed by Samim Hossain Mondal.</script> |
Output
Yes
Time Complexity: O(N)
Auxiliary Space: O(1)
Approach 2:
- Firstly, the code initializes the values of coordinates x, y and time t. It then calculates the total time required to reach the last coordinate t[n-1] – t[0].
- Next, the code iterates over all the coordinates except the first and the last ones. It calculates the minimum time required to reach the current coordinate using two values – the time taken to reach the current coordinate directly from the previous coordinate and the time difference between the current and previous times. The min() function is used to choose the smaller value between these two.
- Finally, the code checks if the minimum time required to reach all the coordinates is less than or equal to the total time given. If it is, then it outputs “Yes”, otherwise “No”.
Here is the code of above approach:
C++
#include <bits/stdc++.h>using namespace std;
int main() {
int n = 2;
int x[n] = { 1, 1 };
int y[n] = { 2, 1 };
int t[n] = { 3, 6 };
int total_time = t[n-1] - t[0];
int min_time = abs(x[1]-x[0]) + abs(y[1]-y[0]);
for (int i = 1; i < n-1; i++) {
min_time += min(abs(x[i]-x[i-1])+abs(y[i]-y[i-1]), t[i]-t[i-1]);
}
if (min_time <= total_time) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
return 0;
} |
Java
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int n = 2;
int[] x = { 1, 1 };
int[] y = { 2, 1 };
int[] t = { 3, 6 };
int total_time = t[n-1] - t[0];
int min_time = Math.abs(x[1]-x[0]) + Math.abs(y[1]-y[0]);
for (int i = 1; i < n-1; i++) {
min_time += Math.min(Math.abs(x[i]-x[i-1])+Math.abs(y[i]-y[i-1]), t[i]-t[i-1]);
}
if (min_time <= total_time) {
System.out.println("Yes");
}
else {
System.out.println("No");
}
}
} |
Python3
# Declare and initialize variablesn = 2
x = [1, 1]
y = [2, 1]
t = [3, 6]
# Calculate the total time taken to reach all the pointstotal_time = t[n-1] - t[0]
# Calculate the minimum time required to reach all the points# starting from the first point and following the given ordermin_time = abs(x[1]-x[0]) + abs(y[1]-y[0])
# Loop through the remaining points to calculate the minimum timefor i in range(1, n-1):
time_to_reach_current_point = abs(x[i]-x[i-1]) + abs(y[i]-y[i-1])
wait_time = t[i] - t[i-1] - time_to_reach_current_point
wait_time = wait_time if wait_time > 0 else 0
min_time += min(time_to_reach_current_point, wait_time)
# Check if the minimum time required is less than or equal to the total # time availableif min_time <= total_time:
print("Yes")
else:
print("No")
|
C#
using System;
namespace TimeTravelCheck
{ class Program
{
static void Main(string[] args)
{
int n = 2;
int[] x = { 1, 1 };
int[] y = { 2, 1 };
int[] t = { 3, 6 };
// Calculate the total time elapsed from the first event to the last event
int total_time = t[n - 1] - t[0];
// Initialize the minimum time required with the distance between the first and second events
int min_time = Math.Abs(x[1] - x[0]) + Math.Abs(y[1] - y[0]);
// Loop through the intermediate events to calculate their contribution to the minimum time
for (int i = 1; i < n - 1; i++)
{
// Calculate the time taken to travel between consecutive events or the time interval if it's smaller
min_time += Math.Min(Math.Abs(x[i] - x[i - 1]) + Math.Abs(y[i] - y[i - 1]), t[i] - t[i - 1]);
}
// Compare the calculated minimum time with the total time
if (min_time <= total_time)
{
Console.WriteLine("Yes");
}
else
{
Console.WriteLine("No");
}
}
}
} |
Javascript
// Declare and initialize variableslet n = 2; let x = [1, 1]; let y = [2, 1]; let t = [3, 6]; // Calculate the total time taken to reach all the pointslet total_time = t[n-1] - t[0];// Calculate the minimum time required to reach all the points// starting from the first point and following the given orderlet min_time = Math.abs(x[1]-x[0]) + Math.abs(y[1]-y[0]);// Loop through the remaining points to calculate the minimum timefor (let i = 1; i < n-1; i++) {
let time_to_reach_current_point = Math.abs(x[i]-x[i-1]) + Math.abs(y[i]-y[i-1]);
let wait_time = t[i] - t[i-1] - time_to_reach_current_point;
wait_time = wait_time > 0 ? wait_time : 0;
min_time += Math.min(time_to_reach_current_point, wait_time);
}// Check if the minimum time required is less than or equal to the total time availableif (min_time <= total_time) {
console.log("Yes");
}else {
console.log("No");
} |
Output
Yes
Time Complexity: O(N)
Auxiliary Space: O(1)
Recommended Articles