# Check if a destination is reachable from source with two movements allowed | Set 2

Given a pair of coordinates (X1, Y1)(source) and (X2, Y2)(destination), the task is to check if it is possible to reach the destination form the source by the following movements from any cell (X, Y):

1. (X + Y, Y)
2. (X, Y + X)

Note: All coordinates are positive and can be as large as 1018.

Examples:

Input: X1 = 2, Y1 = 10, X2 = 26, Y2 = 12
Output: Yes

Explanation: Possible path: (2, 10) → (2, 12) ⇾ (14, 12) → (26, 12)
Therefore, a path exists between source and destination.

Input: X1 = 20, Y1 = 10, X2 = 6, Y2 = 12
Output: No

Naive Approach: The simplest approach to solve the problem is by using recursion. Refer to the article check if a destination is reachable from source with two movements allowed for the recursive approach.

Efficient Approach: The main idea is to check if a path from the destination coordinates (X2, Y2) to the source (X1, Y1) exists or not.

Follow the steps below to solve the problem:

• Keep subtracting the smallest of (X2, Y2) from the largest of (X2, Y2) and stop if X2 becomes less than X1 or Y2 becomes less than Y1.
• Now, compare (X1, Y1) and modified (X2, Y2). If X1 is equal to X2 and Y1 is equal to Y2, then print “Yes“.
• If X1 is not equal to X2 or Y1 is equal, not Y2, then print “No“.

To optimize the complexity of the subtraction operation, the modulus operation can be used instead. Simply perform x2 = x2 % y2 and y2 = y2 % x2 and check for the necessary condition mentioned above.

## C++

 `// C++ program to implement` `// the above approach`   `#include ` `using` `namespace` `std;`   `// Check if (x2, y2) can be reached` `// from (x1, y1)` `bool` `isReachable(``long` `long` `x1, ``long` `long` `y1,` `                 ``long` `long` `x2, ``long` `long` `y2)` `{` `    ``while` `(x2 > x1 && y2 > y1) {`   `        ``// Reduce x2 by y2 until it is` `        ``// less than or equal to x1` `        ``if` `(x2 > y2)` `            ``x2 %= y2;`   `        ``// Reduce y2 by x2 until it is` `        ``// less than or equal to y1` `        ``else` `            ``y2 %= x2;` `    ``}`   `    ``// If x2 is reduced to x1` `    ``if` `(x2 == x1)`   `        ``// Check if y2 can be` `        ``// reduced to y1 or not` `        ``return` `(y2 - y1) >= 0` `               ``&& (y2 - y1) % x1 == 0;`   `    ``// If y2 is reduced to y1` `    ``else` `if` `(y2 == y1)`   `        ``// Check if x2 can be` `        ``// reduced to x1 or not` `        ``return` `(x2 - x1) >= 0` `               ``&& (x2 - x1) % y1 == 0;` `    ``else` `        ``return` `0;` `}`   `// Driver Code` `int` `main()` `{` `    ``long` `long` `source_x = 2, source_y = 10;` `    ``long` `long` `dest_x = 26, dest_y = 12;`   `    ``if` `(isReachable(source_x, source_y,` `                    ``dest_x, dest_y))` `        ``cout << ``"Yes"``;` `    ``else` `        ``cout << ``"No"``;` `    ``return` `0;` `}`

## Python3

 `# Python3 program to implement` `# the above approach`   `# Check if (x2, y2) can be reached` `# from (x1, y1)` `def` `isReachable(x1, y1, x2, y2):`   `    ``while``(x2 > x1 ``and` `y2 > y1):`   `        ``# Reduce x2 by y2 until it is` `        ``# less than or equal to x1` `        ``if``(x2 > y2):` `            ``x2 ``%``=` `y2`   `        ``# Reduce y2 by x2 until it is` `        ``# less than or equal to y1` `        ``else``:` `            ``y2 ``%``=` `x2`   `    ``# If x2 is reduced to x1` `    ``if``(x2 ``=``=` `x1):`   `        ``# Check if y2 can be` `        ``# reduced to y1 or not` `        ``return` `(y2 ``-` `y1) >``=` `0` `and` `(` `                ``y2 ``-` `y1) ``%` `x1 ``=``=` `0`   `    ``# If y2 is reduced to y1` `    ``elif``(y2 ``=``=` `y1):`   `        ``# Check if x2 can be` `        ``# reduced to x1 or not ` `        ``return` `(x2 ``-` `x1) >``=` `0` `and` `(` `                ``x2 ``-` `x1) ``%` `y1 ``=``=` `0` `    ``else``:` `        ``return` `0`   `# Driver Code` `source_x ``=` `2` `source_y ``=` `10` `dest_x ``=` `26` `dest_y ``=` `12`   `# Function call` `if``(isReachable(source_x, source_y,` `                 ``dest_x, dest_y)):` `    ``print``(``"Yes"``)` `else``:` `    ``print``(``"No"``)`   `# This code is contributed by Shivam Singh`

## Java

 `// Java program to implement` `// the above approach` `class` `GFG{`   `// Check if (x2, y2) can be reached` `// from (x1, y1)` `static` `boolean` `isReachable(``long` `x1, ``long` `y1,` `                           ``long` `x2, ``long` `y2)` `{` `    ``while` `(x2 > x1 && y2 > y1) ` `    ``{` `        ``// Reduce x2 by y2 until it is` `        ``// less than or equal to x1` `        ``if` `(x2 > y2)` `            ``x2 %= y2;`   `        ``// Reduce y2 by x2 until it is` `        ``// less than or equal to y1` `        ``else` `            ``y2 %= x2;` `    ``}`   `    ``// If x2 is reduced to x1` `    ``if` `(x2 == x1)`   `        ``// Check if y2 can be` `        ``// reduced to y1 or not` `        ``return` `(y2 - y1) >= ``0` `&& ` `               ``(y2 - y1) % x1 == ``0``;`   `    ``// If y2 is reduced to y1` `    ``else` `if` `(y2 == y1)`   `        ``// Check if x2 can be` `        ``// reduced to x1 or not` `        ``return` `(x2 - x1) >= ``0` `&& ` `               ``(x2 - x1) % y1 == ``0``;` `    ``else` `        ``return` `false``;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``long` `source_x = ``2``, source_y = ``10``;` `    ``long` `dest_x = ``26``, dest_y = ``12``;`   `    ``if` `(isReachable(source_x, source_y,` `                    ``dest_x, dest_y))` `        ``System.out.print(``"Yes"``);` `    ``else` `        ``System.out.print(``"No"``);` `}` `}`   `// This code is contributed by shikhasingrajput`

## C#

 `// C# program to implement` `// the above approach` `using` `System;` `class` `GFG{`   `// Check if (x2, y2) can be reached` `// from (x1, y1)` `static` `bool` `isReachable(``long` `x1, ``long` `y1,` `                        ``long` `x2, ``long` `y2)` `{` `  ``while` `(x2 > x1 && ` `         ``y2 > y1) ` `  ``{` `    ``// Reduce x2 by y2 ` `    ``// until it is less ` `    ``// than or equal to x1` `    ``if` `(x2 > y2)` `      ``x2 %= y2;`   `    ``// Reduce y2 by x2 ` `    ``// until it is less ` `    ``// than or equal to y1` `    ``else` `      ``y2 %= x2;` `  ``}`   `  ``// If x2 is reduced to x1` `  ``if` `(x2 == x1)`   `    ``// Check if y2 can be` `    ``// reduced to y1 or not` `    ``return` `(y2 - y1) >= 0 && ` `           ``(y2 - y1) % x1 == 0;`   `  ``// If y2 is reduced to y1` `  ``else` `if` `(y2 == y1)`   `    ``// Check if x2 can be` `    ``// reduced to x1 or not` `    ``return` `(x2 - x1) >= 0 && ` `           ``(x2 - x1) % y1 == 0;` `  ``else` `    ``return` `false``;` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `  ``long` `source_x = 2, source_y = 10;` `  ``long` `dest_x = 26, dest_y = 12;`   `  ``if` `(isReachable(source_x, source_y,` `                  ``dest_x, dest_y))` `    ``Console.Write(``"Yes"``);` `  ``else` `    ``Console.Write(``"No"``);` `}` `}`   `// This code is contributed by shikhasingrajput`

Output:

```Yes

```

Time Complexity: O(1)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.