Ways to Express an Integer as Sum of Powers

Ways to Express an Integer as Sum of Powers - Problem

Dynamic Programming Medium

Problem Statement: Given two positive integers n and x, find the number of ways to express n as the sum of xth powers of unique positive integers.

In other words, you need to count all possible sets [n1, n2, ..., nk] where:
• All elements are unique positive integers
• n = n1^x + n2^x + ... + nk^x

Example: If n = 160 and x = 3, one valid way is 2³ + 3³ + 5³ = 8 + 27 + 125 = 160.

Note: Since the result can be very large, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Case

$ Input: n = 10, x = 2

› Output: 1

💡 Note: Only one way: 1² + 3² = 1 + 9 = 10. Note that 2² + 6² would exceed our constraint since we need unique positive integers and their sum of squares must equal 10.

example_2.py — Multiple Ways

$ Input: n = 160, x = 3

› Output: 1

💡 Note: One way: 2³ + 3³ + 5³ = 8 + 27 + 125 = 160. This demonstrates finding a combination of three unique cubes that sum to the target.

example_3.py — Small Input

$ Input: n = 1, x = 1

› Output: 1

💡 Note: Only one way: use the number 1 itself (1¹ = 1). This is the simplest case where we need just one number to reach our target.

Visualization

Tap to expand

Understanding the Visualization

Find Available Stones

Identify all stones (numbers) whose weight (x-th power) doesn't exceed n

DP Decision Process

For each stone, decide: include it in our collection or skip it

Update Possibilities

Update count of ways to achieve each possible total weight

Final Count

Return the number of ways to achieve exactly weight n

Key Takeaway

🎯 Key Insight: Dynamic programming transforms this combinatorial problem into an efficient counting process by building up solutions incrementally, ensuring each number is used at most once through backward iteration.

Time & Space Complexity

Time Complexity

⏱️

O(n × k)

Where k is the largest number such that k^x ≤ n. We iterate through k numbers and for each, update up to n DP states.

✓ Linear Growth

Space Complexity

O(n)

DP array of size n+1 to store number of ways for each sum

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 300
1 ≤ x ≤ 5
All integers are positive
Numbers in the sum must be unique

Asked in

G Google 15 f Meta 12 a Amazon 8 ⊞ Microsoft 6

The optimal solution uses dynamic programming with time complexity O(n × k) where k is the count of valid numbers. We maintain a DP array where dp[i] represents the number of ways to achieve sum i, processing each number and updating the array backwards to ensure uniqueness.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n × k)	O(n)	Use DP to count ways by deciding include/exclude for each number
Brute Force (Generate All Subsets)	O(2^k * k)	O(2^k)	Generate all possible subsets and count valid ones

Dynamic Programming (Optimal) — Algorithm Steps

Initialize dp[0] = 1 (one way to get sum 0: empty set)
Find maximum number max_num where max_num^x ≤ n
For each number i from 1 to max_num:
Update dp array backwards from n to i^x
For each sum j, add dp[j - i^x] to dp[j]
Return dp[n]

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP

Set dp[0] = 1, rest to 0

Process Number 1

Update dp[j] += dp[j - 1^x] for valid j

Process Number 2

Update dp[j] += dp[j - 2^x] for valid j

Continue

Process all numbers until num^x > n

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int numberOfWays(int n, int x) {
    const int MOD = 1000000007;
    
    // dp[i] = number of ways to get sum i
    long long* dp = calloc(n + 1, sizeof(long long));
    dp[0] = 1; // One way to get sum 0: empty set
    
    // Find maximum number whose x-th power <= n
    int num = 1;
    while (pow(num, x) <= n) {
        int power = pow(num, x);
        // Update dp array backwards to avoid using same number twice
        for (int j = n; j >= power; j--) {
            dp[j] = (dp[j] + dp[j - power]) % MOD;
        }
        num++;
    }
    
    int result = dp[n];
    free(dp);
    return result;
}

int main() {
    int n, x;
    scanf("%d %d", &n, &x);
    printf("%d\n", numberOfWays(n, x));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × k)

Where k is the largest number such that k^x ≤ n. We iterate through k numbers and for each, update up to n DP states.

✓ Linear Growth

Space Complexity

O(n)

DP array of size n+1 to store number of ways for each sum

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 300
1 ≤ x ≤ 5
All integers are positive
Numbers in the sum must be unique

21.5K Views

Medium Frequency

~25 min Avg. Time

890 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler