# Reach A and B by multiplying them with K and K^2 at every step

We are given two numbers A and B, we need to write a program to determine if A and B can be reached starting from (1, 1) following the given steps. Start from (1, 1) and at every step choose a random number K and multiply K to any one of the two numbers obtained in the previous step and K^{2} to the other number.

**Examples:**

Input : A = 3, B = 9 Output : yesExplanation: Starting from A = 1 and B = 1. We choose k=3 and multiply 3 with the first number to get A=3 and multiply k^{2}=9 to the second- number to get B=9. Input : A = 60, B = 450 Output : yesExplanation: Starting from A = 1 and B = 1, Step 1: multiply k=3 and k^{2}to get 3 and 9 Step 2: Multiply k=5 and k^{2}= 25 to get to 15 and 225 Step 3: Multiply k^{2}=4 and k=2 to get to A=60 and B=450

The idea to solve this problem is to observe closely that at each step we are multiplying k and k^{2} to the numbers. So if A and B can be reached, it will have **k^3 at every step as factors in A*B**. In simple words, if the number **A*B is a perfect cube and it divides A and B both**, only then the number can be reached starting from 1 and 1 by performing given steps.

Below is the implementation of above idea:

## C++

`// CPP program to determine if ` `// A and B can be reached starting ` `// from 1, 1 following the given steps. ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// function to check is it is possible to reach ` `// A and B starting from 1 and 1 ` `bool` `possibleToReach(` `int` `a, ` `int` `b) ` `{ ` ` ` `// find the cuberoot of the number ` ` ` `int` `c = cbrt(a * b); ` ` ` ` ` `// divide the number by cuberoot ` ` ` `int` `re1 = a / c; ` ` ` `int` `re2 = b / c; ` ` ` ` ` `// if it is a perfect cuberoot and divides a and b ` ` ` `if` `((re1 * re1 * re2 == a) && (re2 * re2 * re1 == b)) ` ` ` `return` `true` `; ` ` ` `else` ` ` `return` `false` `; ` `} ` ` ` `int` `main() ` `{ ` ` ` `int` `A = 60, B = 450; ` ` ` ` ` `if` `(possibleToReach(A, B)) ` ` ` `cout << ` `"yes"` `; ` ` ` `else` ` ` `cout << ` `"no"` `; ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// Java program to determine if ` `// A and B can be reached starting ` `// from 1, 1 following the given ` `// steps. ` `class` `GFG { ` ` ` ` ` `// function to check is it is ` ` ` `// possible to reach A and B ` ` ` `// starting from 1 and 1 ` ` ` `static` `boolean` `possibleToReach(` `int` `a, ` `int` `b) ` ` ` `{ ` ` ` ` ` `// find the cuberoot of the number ` ` ` `int` `c = (` `int` `)Math.cbrt(a * b); ` ` ` ` ` `// divide the number by cuberoot ` ` ` `int` `re1 = a / c; ` ` ` `int` `re2 = b / c; ` ` ` ` ` `// if it is a perfect cuberoot and ` ` ` `// divides a and b ` ` ` `if` `((re1 * re1 * re2 == a) && ` ` ` `(re2 * re2 * re1 == b)) ` ` ` `return` `true` `; ` ` ` `else` ` ` `return` `false` `; ` ` ` `} ` ` ` ` ` `// Driver code ` ` ` `public` `static` `void` `main(String[] args) ` ` ` `{ ` ` ` `int` `A = ` `60` `, B = ` `450` `; ` ` ` ` ` `if` `(possibleToReach(A, B)) ` ` ` `System.out.println(` `"yes"` `); ` ` ` `else` ` ` `System.out.println(` `"no"` `); ` ` ` `} ` `} ` ` ` `// This code is contributed by ` `// Smitha Dinesh Semwal ` |

*chevron_right*

*filter_none*

## Python 3

`# Python 3 program to determine if ` `# A and B can be reached starting ` `# from 1, 1 following the given steps. ` `import` `numpy as np ` ` ` `# function to check is it is possible to ` `# reach A and B starting from 1 and 1 ` `def` `possibleToReach(a, b): ` ` ` ` ` `# find the cuberoot of the number ` ` ` `c ` `=` `np.cbrt(a ` `*` `b) ` ` ` ` ` `# divide the number by cuberoot ` ` ` `re1 ` `=` `a ` `/` `/` `c ` ` ` `re2 ` `=` `b ` `/` `/` `c ` ` ` ` ` `# if it is a perfect cuberoot and ` ` ` `# divides a and b ` ` ` `if` `((re1 ` `*` `re1 ` `*` `re2 ` `=` `=` `a) ` `and` ` ` `(re2 ` `*` `re2 ` `*` `re1 ` `=` `=` `b)): ` ` ` `return` `True` ` ` `else` `: ` ` ` `return` `False` ` ` `# Driver Code ` `if` `__name__ ` `=` `=` `"__main__"` `: ` ` ` ` ` `A ` `=` `60` ` ` `B ` `=` `450` ` ` ` ` `if` `(possibleToReach(A, B)): ` ` ` `print` `(` `"yes"` `) ` ` ` `else` `: ` ` ` `print` `(` `"no"` `) ` ` ` `# This code is contributed by ita_c ` |

*chevron_right*

*filter_none*

## C#

`// C# program to determine if ` `// A and B can be reached starting ` `// from 1, 1 following the given ` `// steps. ` `using` `System; ` ` ` `public` `class` `GFG{ ` ` ` ` ` `// function to check is it is ` ` ` `// possible to reach A and B ` ` ` `// starting from 1 and 1 ` ` ` `public` `static` `bool` `possibleToReach(` `int` `a, ` `int` `b) ` ` ` `{ ` ` ` ` ` `// find the cuberoot of the number ` ` ` `int` `c = (` `int` `)Math.Pow(a * b, (` `double` `) 1 / 3); ` ` ` `// divide the number by cuberoot ` ` ` `int` `re1 = a / c; ` ` ` `int` `re2 = b / c; ` ` ` ` ` `// if it is a perfect cuberoot ` ` ` `// and divides a and b ` ` ` `if` `((re1 * re1 * re2 == a) && ` ` ` `(re2 * re2 * re1 == b)) ` ` ` `return` `true` `; ` ` ` `else` ` ` `return` `false` `; ` ` ` `} ` ` ` `// Driver Code ` ` ` `static` `public` `void` `Main (String []args) ` ` ` `{ ` ` ` ` ` `int` `A = 60, B = 450; ` ` ` ` ` `if` `(possibleToReach(A, B)) ` ` ` `Console.WriteLine(` `"Yes"` `); ` ` ` `else` ` ` `Console.WriteLine(` `"No"` `); ` ` ` `} ` `} ` ` ` `// This code is contributed by Ajit. ` |

*chevron_right*

*filter_none*

## PHP

`<?php ` `// PHP program to determine if ` `// A and B can be reached starting ` `// from 1, 1 following the given steps. ` ` ` `// function to check is it is ` `// possible to reach A and B ` `// starting from 1 and 1 ` `function` `possibleToReach(` `$a` `, ` `$b` `) ` `{ ` ` ` ` ` `// find the cuberoot ` ` ` `// of the number ` ` ` `$c` `=(` `$a` `* ` `$b` `); ` ` ` ` ` `// divide the number ` ` ` `// by cuberoot ` ` ` `$re1` `= ` `$a` `/ ` `$c` `; ` ` ` `$re2` `= ` `$b` `/ ` `$c` `; ` ` ` ` ` `// if it is a perfect cuberoot ` ` ` `// and divides a and b ` ` ` `if` `((` `$re1` `* ` `$re1` `* ` `$re2` `== ` `$a` `) && ` ` ` `(` `$re2` `* ` `$re2` `* ` `$re1` `== ` `$b` `)) ` ` ` `return` `1; ` ` ` `else` ` ` `return` `-1; ` `} ` ` ` ` ` `// Driver Code ` ` ` `$A` `= 60; ` ` ` `$B` `= 450; ` ` ` `if` `(possibleToReach(` `$A` `, ` `$B` `)) ` ` ` `echo` `"yes"` `; ` ` ` `else` ` ` `echo` `"no"` `; ` ` ` `// This code is contributed by aj_36 ` `?> ` |

*chevron_right*

*filter_none*

Output:

Yes

## Recommended Posts:

- Minimum step to reach one
- Find the number of consecutive zero at the end after multiplying n numbers
- Minimum operations required to convert X to Y by multiplying X with the given co-primes
- Check if elements of array can be made equal by multiplying given prime numbers
- Program to print Step Pattern
- Steps to reduce N to zero by subtracting its most significant digit at every step
- Delete odd and even numbers at alternate step such that sum of remaining elements is minimized
- Maximize the sum of array by multiplying prefix of array with -1
- Minimum number of jumps to reach end
- Count ways to reach the n'th stair
- Find the minimum number of steps to reach M from N
- Number of steps required to reach point (x,y) from (0,0) using zig-zag way
- Reach the numbers by making jumps of two given lengths
- Total position where king can reach on a chessboard in exactly M moves
- Check if it is possible to reach a number by making jumps of two given length

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.