Related Articles
Minimum number of moves to reach N starting from (1, 1)
• Last Updated : 04 Nov, 2019

Given an integer N and an infinite table where ith row and jth column contains the value i *j. The task is to find the minimum number of moves to reach the cell containing N starting from the cell (1, 1).

Note: From (i, j) only valid moves are (i + 1, j) and (i, j + 1)

Examples:

Input: N = 10
Output: 5
(1, 1) -> (2, 1) -> (2, 2) -> (2, 3) -> (2, 4) -> (2, 5)

Input: N = 7
Output: 6

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: Note that any cell (i, j) can be reached in i + j – 2 steps. Thus, only the pair (i, j) is required with i * j = N that minimizes i + j. It can be found out by finding all the possible pairs (i, j) and check them in O(√N). To do this, without loss of generality, it can be assumed that i ≤ j and i ≤ √N since N = i * j ≥ i2. So √N ≥ i2 i.e. √N ≥ i.
Thus, iterate over all the possible values of i from 1 to √N and, among all the possible pairs (i, j), pick the lowest value of i + j – 2 and that is the required answer.

Below is the implementation of the above approach:

C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the minimum number ` `// of moves required to reach the cell ` `// containing N starting from (1, 1) ` `int` `min_moves(``int` `n) ` `{ ` `    ``// To store the required answer ` `    ``int` `ans = INT_MAX; ` ` `  `    ``// For all possible values of divisors ` `    ``for` `(``int` `i = 1; i * i <= n; i++) { ` ` `  `        ``// If i is a divisor of n ` `        ``if` `(n % i == 0) { ` ` `  `            ``// Get the moves to reach n ` `            ``ans = min(ans, i + n / i - 2); ` `        ``} ` `    ``} ` ` `  `    ``// Return the required answer ` `    ``return` `ans; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `n = 10; ` ` `  `    ``cout << min_moves(n); ` ` `  `    ``return` `0; ` `} `

Java

 `// Java implementation of the approach ` `class` `GFG ` `{ ` `     `  `// Function to return the minimum number ` `// of moves required to reach the cell ` `// containing N starting from (1, 1) ` `static` `int` `min_moves(``int` `n) ` `{ ` `    ``// To store the required answer ` `    ``int` `ans = Integer.MAX_VALUE; ` ` `  `    ``// For all possible values of divisors ` `    ``for` `(``int` `i = ``1``; i * i <= n; i++)  ` `    ``{ ` ` `  `        ``// If i is a divisor of n ` `        ``if` `(n % i == ``0``) ` `        ``{ ` ` `  `            ``// Get the moves to reach n ` `            ``ans = Math.min(ans, i + n / i - ``2``); ` `        ``} ` `    ``} ` ` `  `    ``// Return the required answer ` `    ``return` `ans; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `n = ``10``; ` ` `  `    ``System.out.println(min_moves(n)); ` `} ` `} ` ` `  `// This code is contributed by Code_Mech `

Python3

 `# Python3 implementation of the approach  ` `import` `sys ` ` `  `from` `math ``import` `sqrt ` ` `  `# Function to return the minimum number  ` `# of moves required to reach the cell  ` `# containing N starting from (1, 1)  ` `def` `min_moves(n) : ` ` `  `    ``# To store the required answer  ` `    ``ans ``=` `sys.maxsize;  ` ` `  `    ``# For all possible values of divisors  ` `    ``for` `i ``in` `range``(``1``, ``int``(sqrt(n)) ``+` `1``) : ` ` `  `        ``# If i is a divisor of n  ` `        ``if` `(n ``%` `i ``=``=` `0``) : ` ` `  `            ``# Get the moves to reach n  ` `            ``ans ``=` `min``(ans, i ``+` `n ``/``/` `i ``-` `2``); ` ` `  `    ``# Return the required answer  ` `    ``return` `ans;  ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `: ` ` `  `    ``n ``=` `10``;  ` ` `  `    ``print``(min_moves(n));  ` ` `  `# This code is contributed by AnkitRai01 `

C#

 `// C# implementation of the approach ` `using` `System; ` `     `  `class` `GFG ` `{ ` `     `  `// Function to return the minimum number ` `// of moves required to reach the cell ` `// containing N starting from (1, 1) ` `static` `int` `min_moves(``int` `n) ` `{ ` `    ``// To store the required answer ` `    ``int` `ans = ``int``.MaxValue; ` ` `  `    ``// For all possible values of divisors ` `    ``for` `(``int` `i = 1; i * i <= n; i++)  ` `    ``{ ` ` `  `        ``// If i is a divisor of n ` `        ``if` `(n % i == 0) ` `        ``{ ` ` `  `            ``// Get the moves to reach n ` `            ``ans = Math.Min(ans, i + n / i - 2); ` `        ``} ` `    ``} ` ` `  `    ``// Return the required answer ` `    ``return` `ans; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `n = 10; ` ` `  `    ``Console.WriteLine(min_moves(n)); ` `} ` `} ` ` `  `// This code is contributed by 29AjayKumar `

Output:

```5
```

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
Recommended Articles
Page :