Related Articles

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



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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


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 :