Compruebe si es posible llegar a (x, y) desde el origen exactamente en Z pasos usando solo movimientos positivos

Dado un punto (x, y) , la tarea es verificar si es posible llegar desde el origen a (x, y) exactamente en Z pasos. Desde un punto dado (x, y) solo podemos movernos en cuatro direcciones izquierda (x – 1, y) , derecha (x + 1, y) , arriba (x, y + 1) y abajo (x, y – 1 ) .
Ejemplos: 
 

Entrada: x = 5, y = 5, z = 11 
Salida: No posible
Entrada: x = 10, y = 15, z = 25 
Salida: Posible 
 

Acercarse: 
 

1. El camino más corto desde el origen hasta (x, y) es |x|+|y| .
2. Entonces, está claro que si Z es menor que |x|+|y| , entonces no podemos llegar a (x, y) desde el origen exactamente en Z pasos.
3. Si el número de pasos no es menor que |x|+|y| luego, tenemos que verificar a continuación dos condiciones para verificar si podemos llegar a (x, y) o no: 
   • Si Z ≥ |x| + |y| , y
   • Si (Z – |x| + |y|)%2 es 0 .
4. Para las segundas condiciones en el paso anterior, si llegamos a (x, y) , podemos tomar dos pasos más como (x, y)–>(x, y+1)–>(x, y) para regresar a la misma posición (x, y) . Y esto es posible solo si la diferencia entre ellos es par.

A continuación se muestra la implementación del enfoque anterior:
 

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if it is possible to
// reach (x, y) from origin in exactly z steps
void possibleToReach(int x, int y, int z)
{
 
    // Condition if we can't reach in Z steps
    if (z < abs(x) + abs(y)
        || (z - abs(x) - abs(y)) % 2) {
        cout << "Not Possible" << endl;
    }
    else
        cout << "Possible" << endl;
}
 
// Driver Code
int main()
{
    // Destination point coordinate
    int x = 5, y = 5;
 
    // Number of steps allowed
    int z = 11;
 
    // Function Call
    possibleToReach(x, y, z);
    return 0;
}

// Java program for the above approach
class GFG{
 
// Function to check if it is possible
// to reach (x, y) from origin in
// exactly z steps
static void possibleToReach(int x, int y, int z)
{
     
    // Condition if we can't reach in Z steps
    if (z < Math.abs(x) + Math.abs(y) ||
       (z - Math.abs(x) - Math.abs(y)) % 2 == 1)
    {
        System.out.print("Not Possible" + "\n");
    }
    else
        System.out.print("Possible" + "\n");
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Destination point coordinate
    int x = 5, y = 5;
 
    // Number of steps allowed
    int z = 11;
 
    // Function Call
    possibleToReach(x, y, z);
}
}
 
// This code is contributed by 29AjayKumar

# Python3 program for the above approach
 
# Function to check if it is possible to
# reach (x, y) from origin in exactly z steps
def possibleToReach(x, y, z):
 
    #Condition if we can't reach in Z steps
    if (z < abs(x) + abs(y) or
       (z - abs(x) - abs(y)) % 2):
        print("Not Possible")
    else:
        print("Possible")
 
# Driver Code
if __name__ == '__main__':
     
    # Destination pocoordinate
    x = 5
    y = 5
 
    # Number of steps allowed
    z = 11
 
    # Function call
    possibleToReach(x, y, z)
 
# This code is contributed by mohit kumar 29

// C# program for the above approach
using System;
class GFG{
 
// Function to check if it is possible
// to reach (x, y) from origin in
// exactly z steps
static void possibleToReach(int x, int y, int z)
{
     
    // Condition if we can't reach in Z steps
    if (z < Math.Abs(x) + Math.Abs(y) ||
       (z - Math.Abs(x) - Math.Abs(y)) % 2 == 1)
    {
        Console.Write("Not Possible" + "\n");
    }
    else
        Console.Write("Possible" + "\n");
}
 
// Driver Code
public static void Main(String[] args)
{
     
    // Destination point coordinate
    int x = 5, y = 5;
 
    // Number of steps allowed
    int z = 11;
 
    // Function Call
    possibleToReach(x, y, z);
}
}
 
// This code is contributed by 29AjayKumar

<script>
// javascript program for the above approach
 
 
// Function to check if it is possible
// to reach (x, y) from origin in
// exactly z steps
function possibleToReach(x , y , z)
{
     
    // Condition if we can't reach in Z steps
    if (z < Math.abs(x) + Math.abs(y) ||
       (z - Math.abs(x) - Math.abs(y)) % 2 == 1)
    {
        document.write("Not Possible" + "\n");
    }
    else
        document.write("Possible" + "\n");
}
 
// Driver Code
// Destination point coordinate
var x = 5, y = 5;
 
// Number of steps allowed
var z = 11;
 
// Function Call
possibleToReach(x, y, z);
 
// This code is contributed by Amit Katiyar
</script>

Not Possible

Tiempo Complejidad: O(1)  
Espacio Auxiliar: O(1)