 Open in App
Not now

# Minimum cost to convert M to N by repeated addition of its even divisors

• Last Updated : 29 Nov, 2022

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

 `// C++ program for the above approach``#include ``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

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

 `# 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#

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

## Javascript

 ``

Output:

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

 `// C++ program for the above approach``#include ``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

 `// 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);``    ``}``}`

## C#

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

## Python3

 `# 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`

## Javascript

 ``

Output:

`10`

Time Complexity: O(Nlog(M))
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up