Check if it is possible to travel all points in given time by moving in adjacent four directions

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 Code
int 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 approach
public 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 Code
if __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 approach
using 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 Code
let 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)