Minimize operations required to obtain N
Last Updated :
19 Dec, 2022
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: 3
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: 4
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 <bits/stdc++.h>
using namespace std;
int minOperations( int n)
{
int dp[n + 1];
dp[1] = 0;
for ( int i = 2; i <= n; i++) {
dp[i] = INT_MAX;
if (i % 2 == 0) {
int x = dp[i / 2];
if (x + 1 < dp[i]) {
dp[i] = x + 1;
}
}
if (i % 3 == 0) {
int x = dp[i / 3];
if (x + 1 < dp[i]) {
dp[i] = x + 1;
}
}
int x = dp[i - 1];
if (x + 1 < dp[i]) {
dp[i] = x + 1;
}
}
return dp[n];
}
int main()
{
int n = 15;
cout << minOperations(n);
return 0;
}
|
Java
class GFG{
static int minOperations( int n)
{
int dp[] = new int [n + 1 ];
dp[ 1 ] = 0 ;
for ( int i = 2 ; i <= n; i++)
{
dp[i] = Integer.MAX_VALUE;
if (i % 2 == 0 )
{
int x = dp[i / 2 ];
if (x + 1 < dp[i])
{
dp[i] = x + 1 ;
}
}
if (i % 3 == 0 )
{
int x = dp[i / 3 ];
if (x + 1 < dp[i])
{
dp[i] = x + 1 ;
}
}
int x = dp[i - 1 ];
if (x + 1 < dp[i])
{
dp[i] = x + 1 ;
}
}
return dp[n];
}
public static void main (String []args)
{
int n = 15 ;
System.out.print( minOperations(n));
}
}
|
Python3
import sys
def minOperations(n):
dp = [sys.maxsize] * (n + 1 )
dp[ 1 ] = 0
for i in range ( 2 , n + 1 ):
if i % 2 = = 0 :
x = dp[i / / 2 ]
if x + 1 < dp[i]:
dp[i] = x + 1
if i % 3 = = 0 :
x = dp[i / / 3 ]
if x + 1 < dp[i]:
dp[i] = x + 1
x = dp[i - 1 ]
if x + 1 < dp[i]:
dp[i] = x + 1
return dp[n]
n = 15
print (minOperations(n))
|
C#
using System;
class GFG{
static int minOperations( int n)
{
int []dp = new int [n + 1];
int x;
dp[1] = 0;
for ( int i = 2; i <= n; i++)
{
dp[i] = int .MaxValue;
if (i % 2 == 0)
{
x = dp[i / 2];
if (x + 1 < dp[i])
{
dp[i] = x + 1;
}
}
if (i % 3 == 0)
{
x = dp[i / 3];
if (x + 1 < dp[i])
{
dp[i] = x + 1;
}
}
x = dp[i - 1];
if (x + 1 < dp[i])
{
dp[i] = x + 1;
}
}
return dp[n];
}
public static void Main ( string []args)
{
int n = 15;
Console.Write(minOperations(n));
}
}
|
Javascript
<script>
function minOperations(n)
{
let dp = new Array(n + 1);
dp[1] = 0;
for (let i = 2; i <= n; i++)
{
dp[i] = Number.MAX_VALUE;
if (i % 2 == 0)
{
let x = dp[parseInt(i / 2, 10)];
if (x + 1 < dp[i])
{
dp[i] = x + 1;
}
}
if (i % 3 == 0)
{
let x = dp[parseInt(i / 3, 10)];
if (x + 1 < dp[i])
{
dp[i] = x + 1;
}
}
let x = dp[i - 1];
if (x + 1 < dp[i])
{
dp[i] = x + 1;
}
}
return dp[n];
}
let n = 15;
document.write(minOperations(n));
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...