Given a positive integer N, the task is to find the minimum number of operations needed to convert N to 2 either by decrementing N by 3 or dividing N by 5 if N is divisible by 5. If it is not possible to reduce N to 2, then print “-1”.
Examples:
Input: N =10
Output: 1
Explanation:
Following are the operations performed to reduce N to 2:
- Dividing N by 5, reduces N to 10/5 = 2.
After the above operations, N is reduced to 2. Therefore, the minimum number of operations required is 1.
Input: N = 25
Output: 2
Approach: The given problem can be solved by using Dynamic Programming, the idea is to start iterating from 2 and perform both the operations in a reverse manner i.e., instead of subtracting, perform addition of 3 and instead of dividing, perform multiplication with 5 at every state and store the minimum number of operations for every possible value of N in the array dp[].
If the value of N is reached, then print the value of dp[N] as the minimum number of operations. Otherwise, print -1. Follow the steps below to solve the problem:
- Initialize an auxiliary array, say dp[] of size (N + 1), and initialize all array elements with INT_MAX.
- Set the value of dp[2] equal to 0.
-
Iterate over the range [0, N], and update the value of dp[i] as:
- dp[i * 5] = min(dp[i * 5], dp[i] + 1).
- dp[i + 3] = min(dp[i + 3], dp[i] + 1).
- If the value of dp[N] is INT_MAX, then print -1. Otherwise, print dp[N] as the result.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to find the minimum number // of operations to reduce N to 2 by // dividing N by 5 or decrementing by 3 int minimumOperations( int N)
{ // Initialize the dp array
int dp[N + 1];
int i;
// Initialize the array dp[]
for ( int i = 0; i <= N; i++) {
dp[i] = 1e9;
}
// For N = 2 number of operations
// needed is zero
dp[2] = 0;
// Iterating over the range [1, N]
for (i = 2; i <= N; i++) {
// If it's not possible to
// create current N
if (dp[i] == 1e9)
continue ;
// Multiply with 5
if (i * 5 <= N) {
dp[i * 5] = min(dp[i * 5],
dp[i] + 1);
}
// Adding the value 3
if (i + 3 <= N) {
dp[i + 3] = min(dp[i + 3],
dp[i] + 1);
}
}
// Checking if not possible to
// make the number as 2
if (dp[N] == 1e9)
return -1;
// Return the minimum number
// of operations
return dp[N];
} // Driver Code int main()
{ int N = 25;
cout << minimumOperations(N);
return 0;
} |
// Java program for the above approach import java.io.*;
class GFG {
// Function to find the minimum number
// of operations to reduce N to 2 by
// dividing N by 5 or decrementing by 3
static int minimumOperations( int N)
{
// Initialize the dp array
int [] dp = new int [N + 1 ];
int i;
// Initialize the array dp[]
for (i = 0 ; i <= N; i++) {
dp[i] = ( int )1e9;
}
// For N = 2 number of operations
// needed is zero
dp[ 2 ] = 0 ;
// Iterating over the range [1, N]
for (i = 2 ; i <= N; i++) {
// If it's not possible to
// create current N
if (dp[i] == ( int )1e9)
continue ;
// Multiply with 5
if (i * 5 <= N) {
dp[i * 5 ] = Math.min(dp[i * 5 ], dp[i] + 1 );
}
// Adding the value 3
if (i + 3 <= N) {
dp[i + 3 ] = Math.min(dp[i + 3 ], dp[i] + 1 );
}
}
// Checking if not possible to
// make the number as 2
if (dp[N] == 1e9)
return - 1 ;
// Return the minimum number
// of operations
return dp[N];
}
// Driver Code
public static void main(String[] args)
{
int N = 25 ;
System.out.println(minimumOperations(N));
}
} // This code is contributed by Potta Lokesh |
// C# program for above approach using System;
class GFG{
// Function to find the minimum number
// of operations to reduce N to 2 by
// dividing N by 5 or decrementing by 3
static int minimumOperations( int N)
{
// Initialize the dp array
int [] dp = new int [N + 1];
int i;
// Initialize the array dp[]
for (i = 0; i <= N; i++) {
dp[i] = ( int )1e9;
}
// For N = 2 number of operations
// needed is zero
dp[2] = 0;
// Iterating over the range [1, N]
for (i = 2; i <= N; i++) {
// If it's not possible to
// create current N
if (dp[i] == ( int )1e9)
continue ;
// Multiply with 5
if (i * 5 <= N) {
dp[i * 5] = Math.Min(dp[i * 5], dp[i] + 1);
}
// Adding the value 3
if (i + 3 <= N) {
dp[i + 3] = Math.Min(dp[i + 3], dp[i] + 1);
}
}
// Checking if not possible to
// make the number as 2
if (dp[N] == 1e9)
return -1;
// Return the minimum number
// of operations
return dp[N];
}
// Driver Code public static void Main(String[] args)
{ int N = 25;
Console.Write(minimumOperations(N));
} } // This code is contributed by sanjoy_62. |
<script> // JavaScript Program for the above approach
// Function to find the minimum number
// of operations to reduce N to 2 by
// dividing N by 5 or decrementing by 3
function minimumOperations(N)
{
// Initialize the dp array
let dp = new Array(N + 1);
let i;
// Initialize the array dp[]
for (i = 0; i <= N; i++) {
dp[i] = 1e9;
}
// For N = 2 number of operations
// needed is zero
dp[2] = 0;
// Iterating over the range [1, N]
for (i = 2; i <= N; i++) {
// If it's not possible to
// create current N
if (dp[i] == 1e9)
continue ;
// Multiply with 5
if (i * 5 <= N) {
dp[i * 5] = Math.min(dp[i * 5], dp[i] + 1);
}
// Adding the value 3
if (i + 3 <= N) {
dp[i + 3] = Math.min(dp[i + 3], dp[i] + 1);
}
}
// Checking if not possible to
// make the number as 2
if (dp[N] == 1e9)
return -1;
// Return the minimum number
// of operations
return dp[N];
}
// Driver Code
let N = 25;
document.write(minimumOperations(N));
// This code is contributed by sanjoy_62. </script> |
# Python 3 program for the above approach # Function to find the minimum number # of operations to reduce N to 2 by # dividing N by 5 or decrementing by 3 def minimumOperations(N):
# Initialize the dp array
dp = [ 0 for i in range (N + 1 )]
# Initialize the array dp[]
for i in range (N + 1 ):
dp[i] = 1000000000
# For N = 2 number of operations
# needed is zero
dp[ 2 ] = 0
# Iterating over the range [1, N]
for i in range ( 2 ,N + 1 , 1 ):
# If it's not possible to
# create current N
if (dp[i] = = 1000000000 ):
continue
# Multiply with 5
if (i * 5 < = N):
dp[i * 5 ] = min (dp[i * 5 ], dp[i] + 1 )
# Adding the value 3
if (i + 3 < = N):
dp[i + 3 ] = min (dp[i + 3 ], dp[i] + 1 )
# Checking if not possible to
# make the number as 2
if (dp[N] = = 1000000000 ):
return - 1
# Return the minimum number
# of operations
return dp[N]
# Driver Code if __name__ = = '__main__' :
N = 25
print (minimumOperations(N))
|
2
Time Complexity: O(N)
Auxiliary Space: O(N)