Min operations to reduce N to 1 by multiplying by A or dividing by B

Given a number N and two integers A and B, the task is to check if it is possible to convert the number to 1 by the following two operations:

  • Multiply it by A
  • Divide it by B

If it is possible to reduce N to 1 then print the minimum number of operations required to achieve it otherwise print “-1”.

Examples:

Input: N = 48, A = 3, B = 12
Output: 3
Explanation:
Below are the 3 operations:
1. Divide 48 by 12 to get 4.
2. Multiply 4 by 3 to get 12.
3.Divide 12 by 12 to get 1.
Hence the total number of operation is 3.

Input: N = 26, A = 3, B = 9
Output: -1
Explanation:
It is not possible to convert 26 to 1.



 

Approach: The problem can be solved using Greedy Approach. The idea is to check if B is divisible by A or not and on the basis of that we have the below observations:

  • If B%A != 0, then it is only possible to convert N to 1 if N is completely divisible by B and it would require N/B steps to do so. whereas if N = 1 then it would require 0 steps, otherwise it’s impossible and prints “-1”.
  • If B%A == 0, then consider a variable C whose value is B/A. Divide N by B, using the second operation until it cannot be divided any further, let’s call the number of division as x.
  • Again divide the remaining N by C until it cannot be divided any further, let’s call the number of divisions in this operation be y. 
  • If N does not equal 1 after the above operations then it is impossible to convert N to 1 using the above-mentioned operations and the answer will be “-1”, but if it is equal to 1 then we can use the formula total_steps = x + (2 * y)  to calculate the total minimum steps required.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach 
#include <iostream> 
using namespace std; 
  
// Function to check if it is possible 
// to convert a number N to 1 by a minimum 
// use of the two operations 
int findIfPossible(int n, int a, int b) 
    // For the Case b % a != 0 
    if (b % a != 0) { 
  
        // Check if n equal to 1 
        if (n == 1) 
            return 0; 
  
        // Check if n is not 
        // divisible by b 
        else if (n % b != 0) 
            return -1; 
        else
            return (int)n / b; 
    
  
    // For the Case b % a == 0 
  
    // Initialize a variable 'c' 
    int c = b / a; 
    int x = 0, y = 0; 
  
    // Loop until n is divisible by b 
    while (n % b == 0) { 
        n = n / b; 
  
        // Count number of divisions 
        x++; 
    
  
    // Loop until n is divisible by c 
    while (n % c == 0) { 
        n = n / c; 
  
        // Count number of operations 
        y++; 
    
  
    // Check if n is reduced to 1 
    if (n == 1) { 
  
        // Count steps 
        int total_steps = x + (2 * y); 
  
        // Return the total number of steps 
        return total_steps; 
    
    else
        return -1; 
  
// Driver Code 
int main() 
    // Given n, a and b 
    int n = 48; 
    int a = 3, b = 12; 
  
    // Function Call 
    cout << findIfPossible(n, a, b); 
    return 0; 
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach 
import java.util.*;
  
class GFG{
      
// Function to check if it is possible 
// to convert a number N to 1 by a minimum 
// use of the two operations 
static int findIfPossible(int n, int a, int b) 
      
    // For the Case b % a != 0 
    if (b % a != 0
    
  
        // Check if n equal to 1 
        if (n == 1
            return 0
  
        // Check if n is not 
        // divisible by b 
        else if (n % b != 0
            return -1
        else
            return (int)n / b; 
    
  
    // For the Case b % a == 0 
  
    // Initialize a variable 'c' 
    int c = b / a; 
    int x = 0, y = 0
  
    // Loop until n is divisible by b 
    while (n % b == 0
    
        n = n / b; 
  
        // Count number of divisions 
        x++; 
    
  
    // Loop until n is divisible by c 
    while (n % c == 0
    
        n = n / c; 
  
        // Count number of operations 
        y++; 
    
  
    // Check if n is reduced to 1 
    if (n == 1
    
  
        // Count steps 
        int total_steps = x + (2 * y); 
  
        // Return the total number of steps 
        return total_steps; 
    
    else
        return -1
  
// Driver Code
public static void main(String s[])
{
      
    // Given n, a and b 
    int n = 48
    int a = 3, b = 12
      
    // Function Call 
    System.out.println(findIfPossible(n, a, b));
}
  
// This code is contributed by rutvik_56

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for the above approach
  
# Function to check if it is possible 
# to convert a number N to 1 by a minimum 
# use of the two operations 
def FindIfPossible(n, a, b):
      
    # For the Case b % a != 0
    if (b % a) != 0:
          
    # Check if n equal to 1
        if n == 1:
            return 0
          
        # Check if n is not 
        # divisible by b 
        elif (n % b) != 0:
            return -1
        else:
            return int(n / b)
      
    # For the Case b % a == 0 
    # Initialize a variable 'c' 
    c = b / a
    x = 0
    y = 0
      
    # Loop until n is divisible by b 
    while (n % b == 0):
        n /= b
          
    # Count number of divisions 
        x += 1
          
    # Loop until n is divisible by c
    while (n % c == 0):
        n /= c
          
        # Count number of operations 
        y += 1
      
    # Check if n is reduced to 1 
    if n == 1:
          
        # Count steps
        total_steps = x + 2 * y
          
        # Return the total number of steps 
        return total_steps
    else:
        return -1
          
# Driver code
  
# Given n, a and b 
n = 48
a = 3
b = 12
  
print(FindIfPossible(n, a, b))
  
# This code is contributed by virusbuddah_

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach 
using System;
  
class GFG{ 
      
// Function to check if it is possible 
// to convert a number N to 1 by a minimum 
// use of the two operations 
static int findIfPossible(int n, int a, int b) 
      
    // For the Case b % a != 0 
    if (b % a != 0) 
    
  
        // Check if n equal to 1 
        if (n == 1) 
            return 0; 
  
        // Check if n is not 
        // divisible by b 
        else if (n % b != 0) 
            return -1; 
        else
            return (int)n / b; 
    
  
    // For the Case b % a == 0 
  
    // Initialize a variable 'c' 
    int c = b / a; 
    int x = 0, y = 0; 
  
    // Loop until n is divisible by b 
    while (n % b == 0) 
    
        n = n / b; 
  
        // Count number of divisions 
        x++; 
    
  
    // Loop until n is divisible by c 
    while (n % c == 0) 
    
        n = n / c; 
  
        // Count number of operations 
        y++; 
    
  
    // Check if n is reduced to 1 
    if (n == 1) 
    
  
        // Count steps 
        int total_steps = x + (2 * y); 
  
        // Return the total number of steps 
        return total_steps; 
    
    else
        return -1; 
  
// Driver Code 
public static void Main() 
      
    // Given n, a and b 
    int n = 48; 
    int a = 3, b = 12; 
      
    // Function call 
    Console.WriteLine(findIfPossible(n, a, b)); 
  
// This code is contributed by Stream_Cipher

chevron_right


Output: 

3

 

Time Complexity: O(log (B/A))
Auxiliary Space: O(1)

competitive-programming-img




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.