GFG App
Open App
Browser
Continue

# Count of ways to convert 2 into N by squaring, adding 1 or multiplying with 2

Given a positive number N, the task is to find the number of ways to reach N from 2 wherein each operation one of the following can be performed:

• Add 1 to the current number.
• Multiply the current number by 2.
• Square the current number.

Example:

Input: N = 5
Output: 3
Explanation: The integer 5 can be reached by the following ways:

• 2 (+1) => 3 (+1) => 4 (+1) => 5
• 2 (*2) => 4 (+1) => 5
• 2 (^2) => 4 (+1) => 5

Therefore, the number of ways of reaching 5 from 2 are 3.

Input: N = 9
Output: 8

Approach: The given problem can be solved efficiently by using dynamic programming. The idea is to use a DP array to calculate the number of ways required to reach N from 2. Iterate the array Dp from 2 to N and after each iteration perform the mentioned operations to calculate the number of ways required to reach N i.e, Dp[i] => Dp[i+1], Dp[i] => Dp[2 * i], and Dp[i] => Dp[i * i]. Therefore, add the number of ways to reach Dp[i] in all the three states mentioned above. The value stored at Dp[N] 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 calculate` `// number of ways required` `// to reach N from 2` `int` `waysToReach(``int` `N)` `{`   `    ``// Initialize a DP array` `    ``vector<``int``> Dp(N + 1, 0);`   `    ``// Initialize a DP[2] by 1` `    ``Dp[2] = 1;`   `    ``// Iterate the array from 2 to N` `    ``for` `(``int` `i = 2; i <= N; i++) {`   `        ``// If i+1 is not out of bounds` `        ``if` `(i + 1 <= N) {`   `            ``// Add the number of ways` `            ``Dp[i + 1] += Dp[i];` `        ``}`   `        ``// If i*2 is not out of bounds` `        ``if` `(i * 2 <= N) {`   `            ``// Add the number of ways` `            ``Dp[i * 2] += Dp[i];` `        ``}`   `        ``// If i*i is not out of bounds` `        ``if` `(i * i <= N) {`   `            ``// Add the number of ways` `            ``Dp[i * i] += Dp[i];` `        ``}` `    ``}`   `    ``// Return the answer` `    ``return` `Dp[N];` `}`   `// Driver code` `int` `main()` `{` `    ``int` `N = 5;` `    ``cout << waysToReach(N);` `    ``return` `0;` `}`   `    ``// This code is contributed by rakeshsahni`

## Java

 `// Java implementation for the above approach`   `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {`   `    ``// Function to calculate` `    ``// number of ways required` `    ``// to reach N from 2` `    ``public` `static` `int` `waysToReach(``int` `N)` `    ``{`   `        ``// Initialize a DP array` `        ``int``[] Dp = ``new` `int``[N + ``1``];`   `        ``// Initialize a DP[2] by 1` `        ``Dp[``2``] = ``1``;`   `        ``// Iterate the array from 2 to N` `        ``for` `(``int` `i = ``2``; i <= N; i++) {`   `            ``// If i+1 is not out of bounds` `            ``if` `(i + ``1` `<= N) {`   `                ``// Add the number of ways` `                ``Dp[i + ``1``] += Dp[i];` `            ``}`   `            ``// If i*2 is not out of bounds` `            ``if` `(i * ``2` `<= N) {`   `                ``// Add the number of ways` `                ``Dp[i * ``2``] += Dp[i];` `            ``}`   `            ``// If i*i is not out of bounds` `            ``if` `(i * i <= N) {`   `                ``// Add the number of ways` `                ``Dp[i * i] += Dp[i];` `            ``}` `        ``}`   `        ``// Return the answer` `        ``return` `Dp[N];` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``int` `N = ``5``;`   `        ``System.out.println(waysToReach(N));` `    ``}` `}`

## Python3

 `# Python Program to implement` `# the above approach`   `# Function to calculate` `# number of ways required` `# to reach N from 2` `def` `waysToReach(N):`   `    ``# Initialize a DP array` `    ``Dp ``=` `[``0``] ``*` `(N ``+` `1``)`   `    ``# Initialize a DP[2] by 1` `    ``Dp[``2``] ``=` `1`   `    ``# Iterate the array from 2 to N` `    ``for` `i ``in` `range``(``2``, N ``+` `1``):`   `        ``# If i+1 is not out of bounds` `        ``if` `(i ``+` `1` `<``=` `N):` `            ``# Add the number of ways` `            ``Dp[i ``+` `1``] ``+``=` `Dp[i]`   `        ``# If i*2 is not out of bounds` `        ``if` `(i ``*` `2` `<``=` `N):` `            ``# Add the number of ways` `            ``Dp[i ``*` `2``] ``+``=` `Dp[i]`   `        ``# If i*i is not out of bounds` `        ``if` `(i ``*` `i <``=` `N):` `            ``# Add the number of ways` `            ``Dp[i ``*` `i] ``+``=` `Dp[i]`   `    ``# Return the answer` `    ``return` `Dp[N]`   `# Driver code` `N ``=` `5` `print``(waysToReach(N))`   `# This code is contributed by gfgking`

## C#

 `// C# program for above approach` `using` `System;` `using` `System.Collections;` `using` `System.Collections.Generic;`   `class` `GFG` `{`   `// Function to calculate` `// number of ways required` `// to reach N from 2` `static` `int` `waysToReach(``int` `N)` `{`   `    ``// Initialize a DP array` `    ``int` `[]Dp = ``new` `int``[N+1];` `    `  `    ``for``(``int` `i = 0; i < N+1; i++) {` `        ``Dp[i] = 0;` `    ``}`   `    ``// Initialize a DP[2] by 1` `    ``Dp[2] = 1;`   `    ``// Iterate the array from 2 to N` `    ``for` `(``int` `i = 2; i <= N; i++) {`   `        ``// If i+1 is not out of bounds` `        ``if` `(i + 1 <= N) {`   `            ``// Add the number of ways` `            ``Dp[i + 1] += Dp[i];` `        ``}`   `        ``// If i*2 is not out of bounds` `        ``if` `(i * 2 <= N) {`   `            ``// Add the number of ways` `            ``Dp[i * 2] += Dp[i];` `        ``}`   `        ``// If i*i is not out of bounds` `        ``if` `(i * i <= N) {`   `            ``// Add the number of ways` `            ``Dp[i * i] += Dp[i];` `        ``}` `    ``}`   `    ``// Return the answer` `    ``return` `Dp[N];` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `    ``int` `N = 5;`   `    ``Console.Write(waysToReach(N));` `}` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`3`

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

My Personal Notes arrow_drop_up