Given two integers M and N, the task is to find the minimum cost to convert M to N by repetitive addition of even divisors of the current value of M (except M).
The cost to add an even divisor of the current value of M, say d, is equal to M / d.
Print “-1” if it is impossible to convert M to N.
Examples:
Input: M = 6, N = 24
Output: 10
Explanation:
Step 1: M = 6 + 2 = 8, Cost = (6 / 2) = 3
Step 2: M = 8 + 4 = 12, Cost = 3 + (8 / 2) = 5
Step 3: M = 12 + 6 = 18, Cost = 5 + (12/ 6) = 7
Step 4: M = 18 + 6 = 24, Cost = 7 + (18 / 6) = 10
Therefore, the minimum cost to convert M to N is equal to 10.Input: M = 9, N = 17
Output: -1
Explanation:
Since there are no even divisors of 9, therefore, conversion is not possible.
Naive approach: The simplest approach is to iterate through all possible even divisors of given number M and recursively calculate the minimum cost to change M to N. The recurrence relation formed is given by:
min_cost = Math.min(min_cost, m / i + minSteps(m + i, n))
Below is the implementation of the above approach :
// C++ program for the above approach #include <iostream> using namespace std;
int inf = 1000000008;
// Function to find the value of // minimum steps to convert m to n int minSteps( int m, int n)
{ // Base Case
if (n == m)
return 0;
// If n exceeds m
if (m > n)
return inf;
int min_cost = inf;
// Iterate through all possible
// even divisors of m
for ( int i = 2; i < m; i += 2)
{
// If m is divisible by i,
// then find the minimum cost
if (m % i == 0)
{
// Add the cost to convert
// m to m+i and recursively
// call next state
min_cost = min(min_cost,
m / i +
minSteps(m + i, n));
}
}
// Return min_cost
return min_cost;
} // Driver code int main()
{ int M = 6;
int N = 24;
// Function call
int minimum_cost = minSteps(M, N);
// If conversion is
// not possible
if (minimum_cost == inf)
minimum_cost = -1;
// Print the cost
cout << minimum_cost;
return 0;
} // This code is contributed by akhilsaini |
// Java program for the above approach import java.util.*;
public class GFG {
static int inf = 1000000008 ;
// Function to find the value of
// minimum steps to convert m to n
public static int
minSteps( int m, int n)
{
// Base Case
if (n == m)
return 0 ;
// If n exceeds m
if (m > n)
return inf;
int min_cost = inf;
// Iterate through all possible
// even divisors of m
for ( int i = 2 ; i < m; i += 2 ) {
// If m is divisible by i,
// then find the minimum cost
if (m % i == 0 ) {
// Add the cost to convert
// m to m+i and recursively
// call next state
min_cost
= Math.min(
min_cost,
m / i
+ minSteps(m + i, n));
}
}
// Return min_cost
return min_cost;
}
// Driver Code
public static void
main(String args[])
{
int M = 6 ;
int N = 24 ;
// Function Call
int minimum_cost
= minSteps(M, N);
// If conversion is
// not possible
minimum_cost
= minimum_cost
== inf
? - 1
: minimum_cost;
// Print the cost
System.out.println(minimum_cost);
}
} |
# Python3 program for the above approach inf = 1000000008
# Function to find the value of # minimum steps to convert m to n def minSteps(m, n):
# Base Case
if (n = = m):
return 0
# If n exceeds m
if (m > n):
return inf
min_cost = inf
# Iterate through all possible
# even divisors of m
for i in range ( 2 , m, 2 ):
# If m is divisible by i,
# then find the minimum cost
if (m % i = = 0 ):
# Add the cost to convert
# m to m+i and recursively
# call next state
min_cost = min (min_cost, m / i +
minSteps(m + i, n))
# Return min_cost
return min_cost
# Driver Code if __name__ = = '__main__' :
M = 6
N = 24
# Function call
minimum_cost = minSteps(M, N)
# If conversion is
# not possible
if minimum_cost = = inf:
minimum_cost = - 1
# Print the cost
print (minimum_cost)
# This code is contributed by mohit kumar 29 |
// C# program for the above approach using System;
class GFG{
static int inf = 1000000008;
// Function to find the value of
// minimum steps to convert m to n
public static int minSteps( int m,
int n)
{
// Base Case
if (n == m)
return 0;
// If n exceeds m
if (m > n)
return inf;
int min_cost = inf;
// Iterate through all possible
// even divisors of m
for ( int i = 2; i < m; i += 2)
{
// If m is divisible by i,
// then find the minimum cost
if (m % i == 0)
{
// Add the cost to convert
// m to m+i and recursively
// call next state
min_cost = Math.Min(min_cost, m / i +
minSteps(m + i, n));
}
}
// Return min_cost
return min_cost;
}
// Driver Code
public static void Main(String []args)
{
int M = 6;
int N = 24;
// Function Call
int minimum_cost = minSteps(M, N);
// If conversion is
// not possible
minimum_cost = minimum_cost == inf ? -1 :
minimum_cost;
// Print the cost
Console.WriteLine(minimum_cost);
}
} // This code is contributed by Rajput-Ji |
<script> // Javascript program to implement // the above approach let inf = 1000000008; // Function to find the value of
// minimum steps to convert m to n
function
minSteps(m, n)
{
// Base Case
if (n == m)
return 0;
// If n exceeds m
if (m > n)
return inf;
let min_cost = inf;
// Iterate through all possible
// even divisors of m
for (let i = 2; i < m; i += 2) {
// If m is divisible by i,
// then find the minimum cost
if (m % i == 0) {
// Add the cost to convert
// m to m+i and recursively
// call next state
min_cost
= Math.min(
min_cost,
m / i
+ minSteps(m + i, n));
}
}
// Return min_cost
return min_cost;
}
// Driver Code let M = 6;
let N = 24;
// Function Call
let minimum_cost
= minSteps(M, N);
// If conversion is
// not possible
minimum_cost
= minimum_cost
== inf
? -1
: minimum_cost;
// Print the cost
document.write(minimum_cost);
</script> |
10
Time Complexity: O(2N)
Auxiliary Space: O(2N) for recursive call stack
Efficient Approach: The above approach can be optimized by using dynamic programming and memoization to the above implementation. Instead of computing the states again and again store it in an array dp[] and use it when required.
dp(m) = min(dp(m), (m/i) + dp(m+i)) for all even divisors of m less than m
Below is the implementation of the above approach:
// C++ program for the above approach #include <iostream> using namespace std;
int inf = 1000000008;
// Utility function to calculate the // minimum cost int minStepsUtil( int m, int n, int dp[])
{ // Positive base case
if (n == m)
return 0;
// Negative base case
if (m > n)
return inf;
// If current state is already
// computed then return the
// current state value
if (dp[m] != inf)
return dp[m];
int min_cost = inf;
// Iterate through all possible
// even divisors
for ( int i = 2; i < m; i += 2)
{
if (m % i == 0)
{
min_cost = min(min_cost,
m / i +
minStepsUtil(m + i,
n, dp));
}
}
// Store the precomputed answer
return dp[m] = min_cost;
} void minSteps( int M, int N)
{ // Initialise the dp array
// with infinity
int dp[N + 5];
for ( int i = 0; i < N + 5; i++)
{
dp[i] = inf;
}
// Function call
int minimum_cost = minStepsUtil(M, N, dp);
if (minimum_cost == inf)
minimum_cost = -1;
// Print the minimum cost
cout << minimum_cost;
} // Driver code int main()
{ int M = 6;
int N = 24;
// Function call
minSteps(M, N);
} // This code is contributed by akhilsaini |
// Java program for the above approach import java.util.*;
public class GFG {
static int inf = 1000000008 ;
// Utility function to calculate the
// minimum cost
public static int
minStepsUtil( int m, int n, int dp[])
{
// Positive base case
if (n == m)
return 0 ;
// Negative base case
if (m > n)
return inf;
// If current state is already
// computed then return the
// current state value
if (dp[m] != inf)
return dp[m];
int min_cost = inf;
// Iterate through all possible
// even divisors
for ( int i = 2 ; i < m; i += 2 ) {
if (m % i == 0 ) {
min_cost = Math.min(
min_cost,
m / i
+ minStepsUtil(m + i, n, dp));
}
}
// Store the precomputed answer
return dp[m] = min_cost;
}
public static void
minSteps( int M, int N)
{
// Initialise the dp array
// with infinity
int dp[] = new int [N + 5 ];
Arrays.fill(dp, inf);
// Function Call
int minimum_cost
= minStepsUtil(M, N, dp);
minimum_cost
= minimum_cost
== inf
? - 1
: minimum_cost;
// Print the minimum cost
System.out.println(minimum_cost);
}
// Driver code
public static void main(String args[])
{
int M = 6 ;
int N = 24 ;
// Function Call
minSteps(M, N);
}
} |
# Python program for the above approach inf = 1000000008 ;
# Utility function to calculate the # minimum cost def minStepsUtil(m, n, dp):
# Positive base case
if (n = = m):
return 0 ;
# Negative base case
if (m > n):
return inf;
# If current state is already
# computed then return the
# current state value
if (dp[m] ! = inf):
return dp[m];
min_cost = inf;
# Iterate through all possible
# even divisors
for i in range ( 2 ,m, 2 ):
if (m % i = = 0 ):
min_cost = min (min_cost, m / / i + minStepsUtil(m + i, n, dp));
# Store the precomputed answer
dp[m] = min_cost
return dp[m];
def minSteps(M, N):
# Initialise the dp array
# with infinity
dp = [inf] * (N + 5 );
# Function Call
minimum_cost = minStepsUtil(M, N, dp);
minimum_cost = - 1 if minimum_cost = = inf else minimum_cost;
# Print the minimum cost
print (minimum_cost);
# Driver code if __name__ = = '__main__' :
M = 6 ;
N = 24 ;
# Function Call
minSteps(M, N);
# This code contributed by shikhasingrajput |
// C# program for the above approach using System;
class GFG{
static int inf = 1000000008;
// Utility function to calculate the // minimum cost public static int minStepsUtil( int m,
int n, int []dp)
{ // Positive base case
if (n == m)
return 0;
// Negative base case
if (m > n)
return inf;
// If current state is already
// computed then return the
// current state value
if (dp[m] != inf)
return dp[m];
int min_cost = inf;
// Iterate through all possible
// even divisors
for ( int i = 2; i < m; i += 2)
{
if (m % i == 0)
{
min_cost = Math.Min(min_cost, m / i +
minStepsUtil(m + i,
n, dp));
}
}
// Store the precomputed answer
return dp[m] = min_cost;
}
public static void minSteps( int M,
int N)
{
// Initialise the dp array
// with infinity
int []dp = new int [N + 5];
for ( int i = 0; i < dp.GetLength(0);
i++)
dp[i] = inf;
// Function Call
int minimum_cost = minStepsUtil(M, N, dp);
minimum_cost = minimum_cost ==
inf ? -1 : minimum_cost;
// Print the minimum cost
Console.WriteLine(minimum_cost);
}
// Driver code
public static void Main(String []args)
{
int M = 6;
int N = 24;
// Function Call
minSteps(M, N);
}
} // This code is contributed by 29AjayKumar |
<script> // Javascript program for the above approach var inf = 1000000008;
// Utility function to calculate the // minimum cost function minStepsUtil(m, n, dp)
{ // Positive base case
if (n == m)
return 0;
// Negative base case
if (m > n)
return inf;
// If current state is already
// computed then return the
// current state value
if (dp[m] != inf)
return dp[m];
var min_cost = inf;
// Iterate through all possible
// even divisors
for ( var i = 2; i < m; i += 2)
{
if (m % i == 0)
{
min_cost = Math.min(min_cost,
m / i +
minStepsUtil(m + i,
n, dp));
}
}
// Store the precomputed answer
return dp[m] = min_cost;
} function minSteps(M, N)
{ // Initialise the dp array
// with infinity
var dp = Array(N+5);
for ( var i = 0; i < N + 5; i++)
{
dp[i] = inf;
}
// Function call
var minimum_cost = minStepsUtil(M, N, dp);
if (minimum_cost == inf)
minimum_cost = -1;
// Print the minimum cost
document.write( minimum_cost);
} // Driver code var M = 6;
var N = 24;
// Function call minSteps(M, N); // This code is contributed by itsok. </script> |
10
Time Complexity: O(Nlog(M))
Auxiliary Space: O(N)
Another approach : Using DP Tabulation method ( Iterative approach )
The approach to solve this problem is same but DP tabulation(bottom-up) method is better then Dp + memoization(top-down) because memoization method needs extra stack space of recursion calls.
Steps to solve this problem :
- Create a table DP to store the solution of the subproblems and initialize it with INF.
- Initialize the table DP with base cases
- Now Iterate over subproblems to get the value of current problem form previous computation of subproblems stored in DP.
- Return the final solution is present stored in dp[n].
Implementation :
// C++ program for above approach #include <iostream> #include <cstring> using namespace std;
const int INF = 1000000008;
// Utility function to calculate the // minimum cost void minSteps( int M, int N) {
int dp[N+5];
memset (dp, INF, sizeof (dp)); // initialize dp array with INF
dp[M] = 0; // base case
// iterave over subproblems to get the current solution
for ( int i = M; i <= N; i++) {
for ( int j = 2; j < i; j += 2) {
if (i % j == 0) {
dp[i+j] = min(dp[i+j], dp[i] + i/j);
}
}
}
// return if answer is exists
if (dp[N] == INF) {
cout << "-1" ; // no path found
} else {
cout << dp[N]; // print minimum cost
}
} // Driver Code int main() {
int M = 6;
int N = 24;
// function call
minSteps(M, N);
return 0;
} // this code is contributed by bhardwajji |
import java.io.*;
public class GFG {
static final int INF = 1000000008 ;
// Utility function to calculate the minimum cost
static void minSteps( int M, int N) {
int [] dp = new int [N + 5 ];
for ( int i = 0 ; i < dp.length; i++) {
dp[i] = INF;
}
dp[M] = 0 ;
// iterate over subproblems to
// get the current solution
for ( int i = M; i <= N; i++) {
for ( int j = 2 ; (i + j) < dp.length && j < i; j += 2 ) {
if (i % j == 0 ) {
dp[i + j] = Math.min(dp[i + j], dp[i] + i / j);
}
}
}
// return if answer exists
if (dp[N] == INF) {
System.out.println( "-1" );
} else {
System.out.println(dp[N]);
}
}
// Driver Code
public static void main(String[] args) {
int M = 6 ;
int N = 24 ;
// function call
minSteps(M, N);
}
} |
INF = 1000000008
# Utility function to calculate the minimum cost def minSteps(M, N):
dp = [INF] * (N + 5 )
dp[M] = 0 # base case
# iterate over subproblems to get the current solution
for i in range (M, N + 1 - M):
for j in range ( 2 , i, 2 ):
if i % j = = 0 :
dp[i + j] = min (dp[i + j], dp[i] + i / / j)
# return if answer is exists
if dp[N] = = INF:
print ( "-1" ) # no path found
else :
print (dp[N]) # print minimum cost
# Driver Code M = 6
N = 24
# function call minSteps(M, N) |
using System;
class Program {
const int INF = 1000000008;
// Utility function to calculate the minimum cost
static void MinSteps( int M, int N)
{
int [] dp = new int [N + 5];
for ( int i = 0; i < dp.Length; i++) {
dp[i] = INF;
}
dp[M] = 0; // base case
// iterate over subproblems to get the current
// solution
for ( int i = M; i <= N - M; i++) {
for ( int j = 2; j < i; j += 2) {
if (i % j == 0) {
dp[i + j] = Math.Min(dp[i + j],
dp[i] + i / j);
}
}
}
// return if answer exists
if (dp[N] == INF) {
Console.WriteLine( "-1" ); // no path found
}
else {
Console.WriteLine(dp[N]); // print minimum cost
}
}
// Driver Code
static void Main()
{
int M = 6;
int N = 24;
// function call
MinSteps(M, N);
}
} |
function minSteps(M, N) {
const INF = 1000000008;
let dp = new Array(N+5).fill(INF); // initialize dp array with INF
dp[M] = 0; // base case
// iterave over subproblems to get the current solution
for (let i = M; i <= N; i++) {
for (let j = 2; j < i; j += 2) {
if (i % j == 0) {
dp[i+j] = Math.min(dp[i+j], dp[i] + i/j);
}
}
}
// return if answer is exists
if (dp[N] == INF) {
console.log( "-1" ); // no path found
} else {
console.log(dp[N]); // print minimum cost
}
} // Driver Code let M = 6; let N = 24; // function call minSteps(M, N); |
10
Time complexity: O(N*N)
Auxiliary Space: O(N)