# Minimize operations required to obtain N

• Difficulty Level : Medium
• Last Updated : 01 Apr, 2021

Given an integer N, the task is to obtain N, starting from 1 using minimum number of operations. The operations that can be performed in one step are as follows:

• Multiply the number by 2.
• Multiply the number by 3.
• Add 1 to the number.

Explanation:

Input: N = 5
Output:
Explanation:
Starting value: x = 1

• Multiply x by 2 : x = 2
• Multiply x by 2 : x = 4
• Add 1 to x : x = 5

Therefore, the minimum number of operations required = 3

Input: N = 15
Output:
Explanation:
3 operations required to obtain x = 5.
Multiply x by 3 : x = 15.
Therefore, the minimum number of operations required = 4

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

• If minimum operations to obtain any number smaller than N is known, then minimum operations to obtain N can be calculated.
• Create the following lookup table:

dp[i] = Minimum number of operations to obtain i from 1

• So for any number x, minimum operations required to obtain x can be calculated as:

dp[x] = min(dp[x-1], dp[x/2], dp[x/3])

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `// Function to find the minimum number``// of operations``int` `minOperations(``int` `n)``{``    ``// Storing the minimum operations``    ``// to obtain all numbers up to N``    ``int` `dp[n + 1];` `    ``// Initilal state``    ``dp[1] = 0;` `    ``// Iterate for the remaining numbers``    ``for` `(``int` `i = 2; i <= n; i++) {` `        ``dp[i] = INT_MAX;` `        ``// If the number can be obtained``        ``// by multiplication by 2``        ``if` `(i % 2 == 0) {``            ``int` `x = dp[i / 2];``            ``if` `(x + 1 < dp[i]) {``                ``dp[i] = x + 1;``            ``}``        ``}``        ``// If the number can be obtained``        ``// by multiplication by 3``        ``if` `(i % 3 == 0) {``            ``int` `x = dp[i / 3];``            ``if` `(x + 1 < dp[i]) {``                ``dp[i] = x + 1;``            ``}``        ``}` `        ``// Obtaining the number by adding 1``        ``int` `x = dp[i - 1];``        ``if` `(x + 1 < dp[i]) {``            ``dp[i] = x + 1;``        ``}``    ``}` `    ``// Return the minm operations``    ``// to obtain n``    ``return` `dp[n];``}` `// Driver Code``int` `main()``{``    ``int` `n = 15;``    ``cout << minOperations(n);``    ``return` `0;``}`

## Java

 `class` `GFG{``    ` `// Function to find the minimum number``// of operations``static` `int` `minOperations(``int` `n)``{``    ` `    ``// Storing the minimum operations``    ``// to obtain all numbers up to N``    ``int` `dp[] = ``new` `int``[n + ``1``];` `    ``// Initilal state``    ``dp[``1``] = ``0``;` `    ``// Iterate for the remaining numbers``    ``for``(``int` `i = ``2``; i <= n; i++)``    ``{``        ``dp[i] = Integer.MAX_VALUE;` `        ``// If the number can be obtained``        ``// by multiplication by 2``        ``if` `(i % ``2` `== ``0``)``        ``{``            ``int` `x = dp[i / ``2``];``            ``if` `(x + ``1` `< dp[i])``            ``{``                ``dp[i] = x + ``1``;``            ``}``        ``}``        ` `        ``// If the number can be obtained``        ``// by multiplication by 3``        ``if` `(i % ``3` `== ``0``)``        ``{``            ``int` `x = dp[i / ``3``];``            ``if` `(x + ``1` `< dp[i])``            ``{``                ``dp[i] = x + ``1``;``            ``}``        ``}` `        ``// Obtaining the number by adding 1``        ``int` `x = dp[i - ``1``];``        ``if` `(x + ``1` `< dp[i])``        ``{``            ``dp[i] = x + ``1``;``        ``}``    ``}` `    ``// Return the minm operations``    ``// to obtain n``    ``return` `dp[n];``}` `// Driver Code``public` `static` `void` `main (String []args)``{``    ``int` `n = ``15``;``    ` `    ``System.out.print( minOperations(n));``}``}` `// This code is contributed by chitranayal`

## Python3

 `import` `sys` `# Function to find the minimum number``# of operations``def` `minOperations(n):``    ` `    ``# Storing the minimum operations``    ``# to obtain all numbers up to N``    ``dp ``=` `[sys.maxsize] ``*` `(n ``+` `1``)``    ` `    ``# Initial state``    ``dp[``1``] ``=` `0``    ` `    ``# Iterate for the remaining numbers``    ``for` `i ``in` `range``(``2``, n ``+` `1``):``        ` `        ``# If the number can be obtained``        ``# by multiplication by 2``        ``if` `i ``%` `2` `=``=` `0``:``            ``x ``=` `dp[i ``/``/` `2``]``            ``if` `x ``+` `1` `< dp[i]:``                ``dp[i] ``=` `x ``+` `1``        ` `        ``# If the number can be obtained``        ``# by multiplication by 3``        ``if` `i ``%` `3` `=``=` `0``:``            ``x ``=` `dp[i ``/``/` `3``]``            ``if` `x ``+` `1` `< dp[i]:``                ``dp[i] ``=` `x ``+` `1``                ` `        ``# Obtaining the number by adding 1``        ``x ``=` `dp[i ``-` `1``]``        ``if` `x ``+` `1` `< dp[i]:``            ``dp[i] ``=` `x ``+` `1``            ` `    ``# Return the minimum operations``    ``# to obtain n``    ``return` `dp[n]` `# Driver code``n ``=` `15` `print``(minOperations(n))``        ` `# This code is contributed by Stuti Pathak`

## C#

 `using` `System;``class` `GFG{``     ` `// Function to find the minimum number``// of operations``static` `int` `minOperations(``int` `n)``{``     ` `    ``// Storing the minimum operations``    ``// to obtain all numbers up to N``    ``int` `[]dp = ``new` `int``[n + 1];`` ` `    ``int` `x;``    ``// Initilal state``    ``dp[1] = 0;`` ` `    ``// Iterate for the remaining numbers``    ``for``(``int` `i = 2; i <= n; i++)``    ``{``        ``dp[i] = ``int``.MaxValue;`` ` `        ``// If the number can be obtained``        ``// by multiplication by 2``        ``if` `(i % 2 == 0)``        ``{``            ``x = dp[i / 2];``            ``if` `(x + 1 < dp[i])``            ``{``                ``dp[i] = x + 1;``            ``}``        ``}``         ` `        ``// If the number can be obtained``        ``// by multiplication by 3``        ``if` `(i % 3 == 0)``        ``{``            ``x = dp[i / 3];``            ``if` `(x + 1 < dp[i])``            ``{``                ``dp[i] = x + 1;``            ``}``        ``}`` ` `        ``// Obtaining the number by adding 1``        ``x = dp[i - 1];``        ``if` `(x + 1 < dp[i])``        ``{``            ``dp[i] = x + 1;``        ``}``    ``}`` ` `    ``// Return the minm operations``    ``// to obtain n``    ``return` `dp[n];``}`` ` `// Driver Code``public` `static` `void` `Main (``string` `[]args)``{``    ``int` `n = 15;``     ` `    ``Console.Write(minOperations(n));``}``}`` ` `// This code is contributed by rock_cool`

## Javascript

 ``

Output:

`4`

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

My Personal Notes arrow_drop_up