Skip to content
Related Articles
Open in App
Not now

Related Articles

Minimum powers of P and Q to represent N

Improve Article
Save Article
  • Last Updated : 05 Jan, 2023
Improve Article
Save Article

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 <bits/stdc++.h>
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
Related Articles

Start Your Coding Journey Now!