# Minimum number of operations required to reduce N to 0

Given an integer N, the task is to count the minimum steps required to reduce the value of N to 0 by performing the following two operations:

• Consider integers A and B where N = A * B (A != 1 and B != 1), reduce N to min(A, B)
• Decrease the value of N by 1

Examples :

Input: N = 3
Output: 3
Explanation:
Steps involved are 3 -> 2 -> 1 -> 0
Therefore, the minimum steps required is 3.

Input: N = 4
Output: 3
Explanation:
Steps involved are 4->2->1->0.
Therefore, the minimum steps required is 3.

Naive Approach: The idea is to use the concept of Dynamic Programming.  Follow the steps below to solve the problem:

• The simple solution to this problem is to replace N with each possible value until it is not 0.
• When N reaches 0, compare the count of moves with the minimum obtained so far to obtain the optimal answer.
• Finally, print the minimum steps calculated.

Illustration:

N = 4,

• On applying the first rule, factors of 4  are [ 1, 2, 4 ].
Therefore, all possible pairs (a, b) are (1 * 4), (2 * 2), (4 * 1).
Only pair satisfying the condition (a!=1 and b!=1) is (2, 2) . Therefore, reduce 4 to 2
Finally, reduce N to 0, in 3 steps(4 -> 2 -> 1 -> 0)
• On applying the second rule, steps required is 4, (4 -> 3 -> 2 -> 1 -> 0).

```Recursive tree for N = 4 is
4
/   \
3     2(2*2)
|      |
2      1
|      |
1      0
|
0
```
• Therefore, minimum steps required to reduce N to 0 is 3.

Therefore, the relation is:

f(N) = 1 + min( f(N-1), min(f(x)) ), where N % x == 0 and x is in range [2, K] where K = sqrt(N)

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement ` `// the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to count the minimum ` `// steps required to reduce n ` `int` `downToZero(``int` `n) ` `{ ` `    ``// Base case ` `    ``if` `(n <= 3) ` `        ``return` `n; ` ` `  `    ``// Allocate memory for storing ` `    ``// intermediate results ` `    ``vector<``int``> dp(n + 1, -1); ` ` `  `    ``// Store base values ` `    ``dp = 0; ` `    ``dp = 1; ` `    ``dp = 2; ` `    ``dp = 3; ` ` `  `    ``// Stores square root ` `    ``// of each number ` `    ``int` `sqr; ` `    ``for` `(``int` `i = 4; i <= n; i++) { ` ` `  `        ``// Compute square root ` `        ``sqr = ``sqrt``(i); ` ` `  `        ``int` `best = INT_MAX; ` ` `  `        ``// Use rule 1 to find optimized ` `        ``// answer ` `        ``while` `(sqr > 1) { ` ` `  `            ``// Check if it perfectly divides n ` `            ``if` `(i % sqr == 0) { ` `                ``best = min(best, 1 + dp[sqr]); ` `            ``} ` ` `  `            ``sqr--; ` `        ``} ` ` `  `        ``// Use of rule 2 to find ` `        ``// the optimized answer ` `        ``best = min(best, 1 + dp[i - 1]); ` ` `  `        ``// Store computed value ` `        ``dp[i] = best; ` `    ``} ` ` `  `    ``// Return answer ` `    ``return` `dp[n]; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `n = 4; ` `    ``cout << downToZero(n); ` `    ``return` `0; ` `}`

## Java

 `// Java program to implement ` `// the above approach ` `class` `GFG{ ` ` `  `// Function to count the minimum ` `// steps required to reduce n ` `static` `int` `downToZero(``int` `n) ` `{ ` `     `  `    ``// Base case ` `    ``if` `(n <= ``3``) ` `        ``return` `n; ` ` `  `    ``// Allocate memory for storing ` `    ``// intermediate results ` `    ``int` `[]dp = ``new` `int``[n + ``1``]; ` `    ``for``(``int` `i = ``0``; i < n + ``1``; i++) ` `        ``dp[i] = -``1``; ` `         `  `    ``// Store base values ` `    ``dp[``0``] = ``0``; ` `    ``dp[``1``] = ``1``; ` `    ``dp[``2``] = ``2``; ` `    ``dp[``3``] = ``3``; ` ` `  `    ``// Stores square root ` `    ``// of each number ` `    ``int` `sqr; ` `    ``for``(``int` `i = ``4``; i <= n; i++) ` `    ``{ ` `         `  `        ``// Compute square root ` `        ``sqr = (``int``)Math.sqrt(i); ` ` `  `        ``int` `best = Integer.MAX_VALUE; ` ` `  `        ``// Use rule 1 to find optimized ` `        ``// answer ` `        ``while` `(sqr > ``1``) ` `        ``{ ` ` `  `            ``// Check if it perfectly divides n ` `            ``if` `(i % sqr == ``0``)  ` `            ``{ ` `                ``best = Math.min(best, ``1` `+ dp[sqr]); ` `            ``} ` `            ``sqr--; ` `        ``} ` ` `  `        ``// Use of rule 2 to find ` `        ``// the optimized answer ` `        ``best = Math.min(best, ``1` `+ dp[i - ``1``]); ` ` `  `        ``// Store computed value ` `        ``dp[i] = best; ` `    ``} ` ` `  `    ``// Return answer ` `    ``return` `dp[n]; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `n = ``4``; ` `    ``System.out.print(downToZero(n)); ` `} ` `} ` ` `  `// This code is contributed by amal kumar choubey `

## Python3

 `# Python3 program to implement ` `# the above approach ` `import` `math ` `import` `sys ` ` `  `# Function to count the minimum ` `# steps required to reduce n ` `def` `downToZero(n): ` ` `  `    ``# Base case ` `    ``if` `(n <``=` `3``): ` `        ``return` `n ` ` `  `    ``# Allocate memory for storing ` `    ``# intermediate results ` `    ``dp ``=` `[``-``1``] ``*` `(n ``+` `1``) ` ` `  `    ``# Store base values ` `    ``dp[``0``] ``=` `0` `    ``dp[``1``] ``=` `1` `    ``dp[``2``] ``=` `2` `    ``dp[``3``] ``=` `3` ` `  `    ``# Stores square root ` `    ``# of each number ` `    ``for` `i ``in` `range``(``4``, n ``+` `1``): ` ` `  `        ``# Compute square root ` `        ``sqr ``=` `(``int``)(math.sqrt(i)) ` ` `  `        ``best ``=` `sys.maxsize ` ` `  `        ``# Use rule 1 to find optimized ` `        ``# answer ` `        ``while` `(sqr > ``1``): ` ` `  `            ``# Check if it perfectly divides n ` `            ``if` `(i ``%` `sqr ``=``=` `0``): ` `                ``best ``=` `min``(best, ``1` `+` `dp[sqr]) ` `             `  `            ``sqr ``-``=` `1` ` `  `        ``# Use of rule 2 to find ` `        ``# the optimized answer ` `        ``best ``=` `min``(best, ``1` `+` `dp[i ``-` `1``]) ` ` `  `        ``# Store computed value ` `        ``dp[i] ``=` `best ` ` `  `    ``# Return answer ` `    ``return` `dp[n] ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` `     `  `    ``n ``=` `4` ` `  `    ``print``(downToZero(n)) ` ` `  `# This code is contributed by chitranayal     `

## C#

 `// C# program to implement ` `// the above approach ` `using` `System; ` ` `  `class` `GFG{ ` ` `  `// Function to count the minimum ` `// steps required to reduce n ` `static` `int` `downToZero(``int` `n) ` `{ ` `     `  `    ``// Base case ` `    ``if` `(n <= 3) ` `        ``return` `n; ` ` `  `    ``// Allocate memory for storing ` `    ``// intermediate results ` `    ``int` `[]dp = ``new` `int``[n + 1]; ` `    ``for``(``int` `i = 0; i < n + 1; i++) ` `        ``dp[i] = -1; ` `         `  `    ``// Store base values ` `    ``dp = 0; ` `    ``dp = 1; ` `    ``dp = 2; ` `    ``dp = 3; ` ` `  `    ``// Stores square root ` `    ``// of each number ` `    ``int` `sqr; ` `    ``for``(``int` `i = 4; i <= n; i++) ` `    ``{ ` `         `  `        ``// Compute square root ` `        ``sqr = (``int``)Math.Sqrt(i); ` ` `  `        ``int` `best = ``int``.MaxValue; ` ` `  `        ``// Use rule 1 to find optimized ` `        ``// answer ` `        ``while` `(sqr > 1) ` `        ``{ ` ` `  `            ``// Check if it perfectly divides n ` `            ``if` `(i % sqr == 0)  ` `            ``{ ` `                ``best = Math.Min(best, 1 + dp[sqr]); ` `            ``} ` `            ``sqr--; ` `        ``} ` ` `  `        ``// Use of rule 2 to find ` `        ``// the optimized answer ` `        ``best = Math.Min(best, 1 + dp[i - 1]); ` ` `  `        ``// Store computed value ` `        ``dp[i] = best; ` `    ``} ` ` `  `    ``// Return answer ` `    ``return` `dp[n]; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `n = 4; ` `    ``Console.Write(downToZero(n)); ` `} ` `} ` ` `  `// This code is contributed by amal kumar choubey`

Output:

```3
```

Time complexity: O(N * sqrt(n))
Auxiliary Space: O(N)

Efficient Approach: The idea is to observe that it is possible to replace N by N’ where N’ = min(a, b) (N = a * b) (a != 1 and b != 1).

• If N is even, then the smallest value that divides N is 2. Therefore, directly calculate f(N) = 1 + f(2) = 3.
• If N is odd, then reduce N by 1 from it i.e N = N – 1. Apply the same logic as used for even numbers. Therefore, for odd numbers, the minimum steps required is 4.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement ` `// the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find the minimum ` `// steps required to reduce n ` `int` `downToZero(``int` `n) ` `{ ` `    ``// Base case ` `    ``if` `(n <= 3) ` `        ``return` `n; ` ` `  `    ``// Return answer based on ` `    ``// parity of n ` `    ``return` `n % 2 == 0 ? 3 : 4; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `n = 4; ` `    ``cout << downToZero(n); ` ` `  `    ``return` `0; ` `}`

## Java

 `// Java Program to implement ` `// the above approach ` `class` `GFG{ ` `  `  `// Function to find the minimum ` `// steps required to reduce n ` `static` `int` `downToZero(``int` `n) ` `{ ` `    ``// Base case ` `    ``if` `(n <= ``3``) ` `        ``return` `n; ` `  `  `    ``// Return answer based on ` `    ``// parity of n ` `    ``return` `n % ``2` `== ``0` `? ``3` `: ``4``; ` `} ` `  `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `n = ``4``; ` `    ``System.out.println(downToZero(n)); ` `} ` `} ` ` `  `// This code is contributed by rock_cool`

## Python3

 `# Python3 Program to implement ` `# the above approach ` ` `  `# Function to find the minimum ` `# steps required to reduce n ` `def` `downToZero(n): ` `   `  `    ``# Base case ` `    ``if` `(n <``=` `3``): ` `        ``return` `n; ` ` `  `    ``# Return answer based on ` `    ``# parity of n ` `    ``if``(n ``%` `2` `=``=` `0``): ` `        ``return` `3``; ` `    ``else``: ` `        ``return` `4``; ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``n ``=` `4``; ` `    ``print``(downToZero(n)); ` `     `  `# This code is contributed by Rohit_ranjan`

## C#

 `// C# Program to implement ` `// the above approach ` `using` `System; ` `class` `GFG{ ` `  `  `// Function to find the minimum ` `// steps required to reduce n ` `static` `int` `downToZero(``int` `n) ` `{ ` `    ``// Base case ` `    ``if` `(n <= 3) ` `        ``return` `n; ` `  `  `    ``// Return answer based on ` `    ``// parity of n ` `    ``return` `n % 2 == 0 ? 3 : 4; ` `} ` `  `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``int` `n = 4; ` `    ``Console.WriteLine(downToZero(n)); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji`

Output:

```3
```

Time complexity: O(1)
Auxiliary Space: O(1)

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.