# Minimum moves to make M and N equal by repeated addition of divisors except 1 | Set-2 (Dynamic Programming)

• Last Updated : 23 Nov, 2021

Given two integers N and M, the task is to calculate the minimum number of moves to change N to M, where In one move it is allowed to add any divisor of the current value of N to N itself except 1. Print “-1” if it is not possible.

Example

Input: N = 4, M = 24
Output: 5
Explanation: The given value of N can be converted into M using the following steps: (4)+2 -> (6)+2 -> (8)+4 -> (12)+6 ->  (18)+6 -> 24. Hence, the count of moves is 5 which is the minimum possible.

Input: N = 4, M = 576
Output: 14

BFS Approach: The given problem has already been discussed in Set 1 of this article which using the Breadth First Traversal to solve the given problem.

Approach: This article focused on a different approach based on Dynamic Programming. Below are the steps to follow:

• Create a 1-D array dp[], where dp[i] stores the minimum number of operations to reach i from N. Initially, dp[N+1… M] = {INT_MAX} and dp[N] = 0.
• Iterate through the range [N, M] using a variable i and for each i, iterate through all the factors of the given number i. For a factor X, the DP relation can be define as follows:

dp[i + X] = min( dp[i], dp[i + X])

• The value stored at dp[M] is the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ implementation for the above approach``#include ``using` `namespace` `std;` `// Function to find the minimum count of``// operations to convert N to M``int` `minOperationCnt(``int` `N, ``int` `M)``{` `    ``// Stores the DP state of the array``    ``int` `dp[M + 1];` `    ``// Initialize each index with INT_MAX``    ``for` `(``int` `i = N + 1; i <= M; i++) {``        ``dp[i] = INT_MAX;``    ``}` `    ``// Initial condition``    ``dp[N] = 0;` `    ``// Loop to iterate over range [N, M]``    ``for` `(``int` `i = N; i <= M; i++) {` `        ``// Check if this position``// can be reached or not``        ``if` `(dp[i] == INT_MAX) {``            ``continue``;``        ``}` `        ``// Loop to iterate through all divisors``        ``// of the current value i``        ``for` `(``int` `j = 2; j * j <= i; j++) {` `            ``// If j is a divisor of i``            ``if` `(i % j == 0) {``                ``if` `(i + j <= M) {` `                    ``// Update the value of dp[i + j]``                    ``dp[i + j] = min(dp[i + j], dp[i] + 1);``                ``}` `                ``// Check for value i / j;``                ``if` `(i + i / j <= M) {` `                    ``// Update the value of dp[i + i/j]``                    ``dp[i + i / j]``                        ``= min(dp[i + i / j], dp[i] + 1);``                ``}``            ``}``        ``}``    ``}` `    ``// Return Answer``    ``return` `(dp[M] == INT_MAX) ? -1 : dp[M];``}` `// Driver Code``int` `main()``{``    ``int` `N = 4;``    ``int` `M = 576;` `    ``cout << minOperationCnt(N, M);` `    ``return` `0;``}`

## Java

 `// Java implementation for the above approach``class` `GFG {` `    ``// Function to find the minimum count of``    ``// operations to convert N to M``    ``public` `static` `int` `minOperationCnt(``int` `N, ``int` `M) {` `        ``// Stores the DP state of the array``        ``int``[] dp = ``new` `int``[M + ``1``];` `        ``// Initialize each index with INT_MAX``        ``for` `(``int` `i = N + ``1``; i <= M; i++) {``            ``dp[i] = Integer.MAX_VALUE;``        ``}` `        ``// Initial condition``        ``dp[N] = ``0``;` `        ``// Loop to iterate over range [N, M]``        ``for` `(``int` `i = N; i <= M; i++) {` `            ``// Check if this position``            ``// can be reached or not``            ``if` `(dp[i] == Integer.MAX_VALUE) {``                ``continue``;``            ``}` `            ``// Loop to iterate through all divisors``            ``// of the current value i``            ``for` `(``int` `j = ``2``; j * j <= i; j++) {` `                ``// If j is a divisor of i``                ``if` `(i % j == ``0``) {``                    ``if` `(i + j <= M) {` `                        ``// Update the value of dp[i + j]``                        ``dp[i + j] = Math.min(dp[i + j], dp[i] + ``1``);``                    ``}` `                    ``// Check for value i / j;``                    ``if` `(i + i / j <= M) {` `                        ``// Update the value of dp[i + i/j]``                        ``dp[i + i / j] = Math.min(dp[i + i / j], dp[i] + ``1``);``                    ``}``                ``}``            ``}``        ``}` `        ``// Return Answer``        ``return` `(dp[M] == Integer.MAX_VALUE) ? -``1` `: dp[M];``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String args[]) {``        ``int` `N = ``4``;``        ``int` `M = ``576``;` `        ``System.out.println(minOperationCnt(N, M));``    ``}``}` `// This code is contributed by saurabh_jaiswal.`

## Python3

 `# python implementation for the above approach``import` `math` `INT_MAX ``=` `2147483647` `# Function to find the minimum count of``# operations to convert N to M``def` `minOperationCnt(N, M):` `     ``# Stores the DP state of the array``    ``dp ``=` `[``0` `for` `_ ``in` `range``(M ``+` `1``)]` `    ``# Initialize each index with INT_MAX``    ``for` `i ``in` `range``(N``+``1``, M``+``1``):``        ``dp[i] ``=` `INT_MAX` `        ``# Initial condition``    ``dp[N] ``=` `0` `    ``# Loop to iterate over range [N, M]``    ``for` `i ``in` `range``(N, M``+``1``):` `                ``# Check if this position``        ``# can be reached or not``        ``if` `(dp[i] ``=``=` `INT_MAX):``            ``continue` `            ``# Loop to iterate through all divisors``            ``# of the current value i``        ``for` `j ``in` `range``(``2``, ``int``(math.sqrt(i))``+``1``):` `                        ``# If j is a divisor of i``            ``if` `(i ``%` `j ``=``=` `0``):``                ``if` `(i ``+` `j <``=` `M):` `                     ``# Update the value of dp[i + j]``                    ``dp[i ``+` `j] ``=` `min``(dp[i ``+` `j], dp[i] ``+` `1``)` `                    ``# Check for value i / j;``                ``if` `(i ``+` `i ``/``/` `j <``=` `M):` `                     ``# Update the value of dp[i + i/j]``                    ``dp[i ``+` `i ``/``/` `j] ``=` `min``(dp[i ``+` `i ``/``/` `j], dp[i] ``+` `1``)` `        ``# Return Answer``    ``if` `dp[M] ``=``=` `INT_MAX:``        ``return` `-``1``    ``else``:``        ``return` `dp[M]` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``N ``=` `4``    ``M ``=` `576` `    ``print``(minOperationCnt(N, M))` `    ``# This code is contributed by rakeshsahni`

## C#

 `// C# implementation for the above approach``using` `System;``class` `GFG``{` `  ``// Function to find the minimum count of``  ``// operations to convert N to M``  ``public` `static` `int` `minOperationCnt(``int` `N, ``int` `M)``  ``{` `    ``// Stores the DP state of the array``    ``int``[] dp = ``new` `int``[M + 1];` `    ``// Initialize each index with INT_MAX``    ``for` `(``int` `i = N + 1; i <= M; i++)``    ``{``      ``dp[i] = ``int``.MaxValue;``    ``}` `    ``// Initial condition``    ``dp[N] = 0;` `    ``// Loop to iterate over range [N, M]``    ``for` `(``int` `i = N; i <= M; i++)``    ``{` `      ``// Check if this position``      ``// can be reached or not``      ``if` `(dp[i] == ``int``.MaxValue)``      ``{``        ``continue``;``      ``}` `      ``// Loop to iterate through all divisors``      ``// of the current value i``      ``for` `(``int` `j = 2; j * j <= i; j++)``      ``{` `        ``// If j is a divisor of i``        ``if` `(i % j == 0)``        ``{``          ``if` `(i + j <= M)``          ``{` `            ``// Update the value of dp[i + j]``            ``dp[i + j] = Math.Min(dp[i + j], dp[i] + 1);``          ``}` `          ``// Check for value i / j;``          ``if` `(i + i / j <= M)``          ``{` `            ``// Update the value of dp[i + i/j]``            ``dp[i + i / j] = Math.Min(dp[i + i / j], dp[i] + 1);``          ``}``        ``}``      ``}``    ``}` `    ``// Return Answer``    ``return` `(dp[M] == ``int``.MaxValue) ? -1 : dp[M];``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main()``  ``{``    ``int` `N = 4;``    ``int` `M = 576;` `    ``Console.Write(minOperationCnt(N, M));``  ``}``}` `// This code is contributed by saurabh_jaiswal.`

## Javascript

 ``
Output
`14`

Time Complexity: O((M – N)*√(M – N))
Auxiliary Space: O(M)

My Personal Notes arrow_drop_up