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

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`

Output:

```10

```

Time Complexity: O(2N)
Auxiliary Space: O(1)

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;`   `    ``# Prthe minimum cost` `    ``print``(minimum_cost);`     `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    ``M ``=` `6``;` `    ``N ``=` `24``;`   `    ``# Function Call` `    ``minSteps(M, N);`   `# This code contributed by shikhasingrajput`

Output:

```10

```

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

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