# Minimum powers of P and Q to represent N

• Last Updated : 05 Jan, 2023

Given integer N and values P and Q, The task is to calculate the minimum number of powers of P and Q required to generate N.

Note: The 0th power of the values is also considered.

Examples:

Input: N = 15, P = 2, Q = 3
Output: 3
Explanation: We can make 15 by using (8, 4, 3) or (9, 3, 3). Both take 3 numbers.

Input: N = 19, P = 4, Q = 3
Output: 2
Explanation: In the second case, we can make 19 by using (16, 3) which is 2 numbers.

Approach: Recursion (Memoization)

The Basic idea is to use memoization approach for this problem, simply we’ll check ways to reach or to generate N by considering both  P and Q powers by making recursive calls.

Pseudo Code:

To check the powers being used in recursive relation.

‘long long int a=1;
ans = 1e9;   // to store potential answer

if(power = 1){
return n;
}
while(n-a >= 0)
{
ans = min(ans, dp[n-a]);
a = a*power;
}

return ans+1;

Follow the steps mentioned below to implement the idea:

• Initialize a dp[] array of size N+1 and initialize it with 1e9.
• Set, the base cases, dp[0] = 0 and dp[1] = 1.
• Traverse through 2 to N and find the ways with powers.
•  Way1 by considering the power of P.
•  Way2 by considering the power of Q.
• Consider dp[i] = min(way1, way2).
• After traversing return dp[N].

Below is the implementation of the above approach.

## C++

 `// C++ code to implement the approach` `#include ``using` `namespace` `std;` `// Function to check minimum steps for``// a particular power for n``int` `check(``int` `n, ``int` `power, vector<``int``>& dp)``{``    ``// Initialize the variables``    ``long` `long` `int` `a = 1;``    ``int` `ans = 1e9;` `    ``// Edge Case``    ``if` `(power == 1)``        ``return` `n;` `    ``// Until N hits 0``    ``while` `(n - a >= 0) {``        ``ans = min(ans, dp[n - a]);``        ``a = a * power;``    ``}` `    ``return` `ans + 1;``}` `// Function to find minimum number``// of steps``int` `moves(``int` `n, ``int` `p, ``int` `q)``{``    ``// Initialize a dp array``    ``vector<``int``> dp(n + 1, 1e9);` `    ``// Base Case``    ``dp[0] = 0;``    ``dp[1] = 1;` `    ``for` `(``int` `i = 2; i <= n; ++i) {``        ``int` `way1 = check(i, p, dp);``        ``int` `way2 = check(i, q, dp);``        ``dp[i] = min(way1, way2);``    ``}` `    ``// Return dp[] as answer``    ``return` `dp[n];``}` `// Driver Code``int` `main()``{``    ``int` `N = 15, P = 2, Q = 3;` `    ``// Function call``    ``cout << moves(N, P, Q) << endl;``    ``return` `0;``}`

## Java

 `// Java code to implement the approach``import` `java.util.*;``public` `class` `GFG {` `  ``// Function to check minimum steps for``  ``// a particular power for n``  ``public` `static` `int` `check(``int` `n, ``int` `power, ``int` `dp[])``  ``{``    ` `    ``// Initialize the variables``    ``long` `a = ``1``;``    ``int` `ans = Integer.MAX_VALUE;` `    ``// Edge Case``    ``if` `(power == ``1``)``      ``return` `n;` `    ``// Untill N hits 0``    ``while` `(n - a >= ``0``) {``      ``ans = Math.min(ans, dp[n - (``int``)a]);``      ``a = a * power;``    ``}` `    ``return` `ans + ``1``;``  ``}` `  ``// Function to find minimum number``  ``// of steps``  ``public` `static` `int` `moves(``int` `n, ``int` `p, ``int` `q)``  ``{``    ``// Initialize a dp array``    ``int` `dp[] = ``new` `int``[n + ``1``];``    ``for` `(``int` `i = ``0``; i < n + ``1``; i++) {``      ``dp[i] = Integer.MAX_VALUE;``    ``}` `    ``// Base Case``    ``dp[``0``] = ``0``;``    ``dp[``1``] = ``1``;` `    ``for` `(``int` `i = ``2``; i <= n; ++i) {``      ``int` `way1 = check(i, p, dp);``      ``int` `way2 = check(i, q, dp);``      ``dp[i] = Math.min(way1, way2);``    ``}` `    ``// Return dp[] as answer``    ``return` `dp[n];``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String args[])``  ``{``    ``int` `N = ``15``, P = ``2``, Q = ``3``;` `    ``// Function call``    ``System.out.println(moves(N, P, Q));``  ``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Python3

 `# Python code to implement the approach` `# Function to check minimum steps for a particular power of n``def` `check(n, power, dp):``    ``# Initialize the variables``    ``a ``=` `1``    ``ans ``=` `float``(``"inf"``)` `    ``# Edge case``    ``if``(power ``=``=` `1``):``        ``return` `n` `    ``# Until N hits 0``    ``while``(n``-``a >``=` `0``):``        ``ans ``=` `min``(ans, dp[n``-``a])``        ``a ``=` `a ``*` `power` `    ``return` `ans ``+` `1`  `# Function to find minimum number of steps``def` `moves(n, p, q):``  ` `    ``# Initialize a dp array``    ``dp ``=` `[``float``(``"inf"``)]``*``(n``+``1``)` `    ``# Base case``    ``dp[``0``] ``=` `0``    ``dp[``1``] ``=` `1` `    ``for` `i ``in` `range``(``2``, n``+``1``):``        ``way1 ``=` `check(i, p, dp)``        ``way2 ``=` `check(i, q, dp)``        ``dp[i] ``=` `min``(way1, way2)` `    ``# Return dp[] as answer``    ``return` `dp[n]`  `N, P, Q ``=` `15``, ``2``, ``3``# Function Call``print``(moves(N, P, Q))` `# This code is contributed by lokeshmvs21.`

## C#

 `// C# code to implement the approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG {` `    ``// Function to check minimum steps for``    ``// a particular power for n``    ``public` `static` `int` `check(``int` `n, ``int` `power, ``int``[] dp)``    ``{` `        ``// Initialize the variables``        ``long` `a = 1;``        ``int` `ans = ``int``.MaxValue;` `        ``// Edge Case``        ``if` `(power == 1)``            ``return` `n;` `        ``// Until N hits 0``        ``while` `(n - a >= 0) {``            ``ans = Math.Min(ans, dp[n - (``int``)a]);``            ``a = a * power;``        ``}` `        ``return` `ans + 1;``    ``}` `    ``// Function to find minimum number``    ``// of steps``    ``public` `static` `int` `moves(``int` `n, ``int` `p, ``int` `q)``    ``{``        ``// Initialize a dp array``        ``int``[] dp = ``new` `int``[n + 1];``        ``for` `(``int` `i = 0; i < n + 1; i++) {``            ``dp[i] = ``int``.MaxValue;``        ``}` `        ``// Base Case``        ``dp[0] = 0;``        ``dp[1] = 1;` `        ``for` `(``int` `i = 2; i <= n; ++i) {``            ``int` `way1 = check(i, p, dp);``            ``int` `way2 = check(i, q, dp);``            ``dp[i] = Math.Min(way1, way2);``        ``}` `        ``// Return dp[] as answer``        ``return` `dp[n];``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int` `N = 15, P = 2, Q = 3;` `        ``// Function call``        ``Console.WriteLine(moves(N, P, Q));``    ``}``}` `// This code is contributed by Tapesh(tapeshdua420)`

## Javascript

 `// Javascript code to implement the approach` `// Function to check minimum steps for a particular power of n``function` `check(n, power, dp) {``    ``// Initialize the variables``    ``var` `a = 1;``    ``var` `ans = Number.MAX_VALUE;` `    ``// Edge case``    ``if` `(power == 1) {``        ``return` `n;``    ``}` `    ``// Until N hits 0``    ``while` `(n - a >= 0) {``        ``ans = Math.min(ans, dp[n - a]);``        ``a = a * power;``    ``}` `    ``return` `ans + 1;``}`  `// Function to find minimum number of steps``function` `moves(n, p, q) {` `    ``// Initialize a dp array``    ``var` `dp = ``new` `Array(n + 1).fill(Number.MAX_VALUE);` `    ``// Base case``    ``dp[0] = 0;``    ``dp[1] = 1;` `    ``for` `(``var` `i = 2; i <= n; i++) {``        ``var` `way1 = check(i, p, dp);``        ``var` `way2 = check(i, q, dp);``        ``dp[i] = Math.min(way1, way2);``    ``}` `    ``// Return dp[] as answer``    ``return` `dp[n];``}`  `var` `N = 15, P = 2, Q = 3;``// Function Call``console.log(moves(N, P, Q));` `// This code is contributed by Tapesh(tapeshdua420)`

Output

`3`

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

Related Articles:

My Personal Notes arrow_drop_up