Ways to sum to n numbers up to K

Given two integers n and k, find the total number of ways to represent n as the sum of positive integers in the range [1, k], where each integer can be used multiple times.

Examples:

Input: n = 8, k = 2
Output: 5
Explanation: Possible ways are: {1,1,1,1,1,1,1,1}, {2,1,1,1,1,1,1}, {2,2,1,1,1,1}, {2,2,2,1,1} and {2,2,2,2}.
Input: n = 2, k = 2
Output: 2
Explanation: Possible ways are: {1,1} and {2}.

Table of Content

[Naive Approach] Recursive Solution - O(2^(n + k)) Time and O(n + k) Space
[Expected Approach] Dynamic Programming - O(N * K) Time and O(n) Space

[Naive Approach] Recursive Solution - O(2^(n + k)) Time and O(n) Space

The idea is to explore all possible combinations by making two choices for each number k: either include it in the sum or exclude it.
If we include k, we reduce the remaining sum n by k.
If we exclude k, we reduce the range by decreasing k.

C++

using namespace std;

// Function that return Ways to sum to N using
// Natural Numbers up to K with repetitions allowed
int NumberOfways(int n, int k)
{

    // Base case
    if (n == 0)
        return 1;
    if (n < 0 || k <= 0)
        return 0;

    // including and not including K in sum
    return NumberOfways(n - k, k) + NumberOfways(n, k - 1);
}

int main()
{
    int n = 8;
    int k = 2;

    // function call
    cout << NumberOfways(n, k) << endl;
    return 0;
}

Java

class GFG {
    // Function that return Ways to sum to N using
    // Natural Numbers up to K with repetitions allowed
    public static int NumberOfways(int n, int k)
    {
        // Base case
        if (n == 0)
            return 1;
        if (n < 0 || k <= 0)
            return 0;

        // including and not including k in sum
        return NumberOfways(n - k, k)
            + NumberOfways(n, k - 1);
    }

    public static void main(String[] args)
    {
        int n = 8;
        int k = 2;

        // function call
        System.out.println(NumberOfways(n, k));
    }
}

Python

# Function that returns the number of ways to sum
# to N using natural numbers up to K with repetitions allowed

def number_of_ways(n, k):

    # Base case
    if n == 0:
        return 1
    if n < 0 or k <= 0:
        return 0

    # Including and not including K in sum
    return number_of_ways(n - k, k) + number_of_ways(n, k - 1)


if __name__ == '__main__':
    n = 8
    k = 2

    # Function call
    print(number_of_ways(n, k))

using System;

class GFG {
    // Function that return Ways to sum to N using
    // Natural Numbers up to K with repetitions allowed
    static int NumberOfWays(int n, int k)
    {
        // Base case
        if (n == 0)
            return 1;
        if (n < 0 || k <= 0)
            return 0;

        // including and not including K in sum
        return NumberOfWays(n - k, k)
            + NumberOfWays(n, k - 1);
    }

    static void Main()
    {
        int n = 8;
        int k = 2;

        // function call
        Console.WriteLine(NumberOfWays(n, k));
    }
}

JavaScript

// Function that return Ways to sum to N using
// Natural Numbers up to K with repetitions allowed
function numberOfWays(n, k)
{

    // Base case
    if (n == 0)
        return 1;
    if (n < 0 || k <= 0)
        return 0;

    // including and not including K in sum
    return numberOfWays(n - k, k) + numberOfWays(n, k - 1);
}

// Driver code
let n = 8;
let k = 2;

// function call
console.log(numberOfWays(n, k));

Output

[Expected Approach] Dynamic Programming - O(n * k) Time and O(n) Space

The Recursive approach has Overlapping Subproblems and an Optimal Substructure. To avoid recomputation, we use Dynamic Programming. We create an array dp where dp[i] stores the number of ways to form sum i. For each number from 1 to k, we update all possible sums by adding previously computed results.

Steps:

Create an array dp[0..n], where dp[i] represents the number of ways to sum to i using numbers from 1 to k.
Initialize dp[0] = 1 because there is exactly one way to sum to 0, which is using no numbers.
Loop over numbers i from 1 to k, representing the numbers you can use in sums.
For each number i, loop over j from 1 to n.
If j >= i, update dp[j] = dp[j] + dp[j - i](all possible target sums).
After completing all loops, dp[n] gives the total number of ways to sum to n.

C++

#include <vector>
using namespace std;

// Function to find the total number of ways
// to represent n as the sum of numbers from 1 to k
int NumberOfways(int n, int k)
{
    // Create a dp array where dp[i] stores
    // the number of ways to make sum i
    vector<int> dp(n + 1, 0);

    // There is 1 way to make sum 0 (use no numbers)
    dp[0] = 1;

    // Loop through all numbers from 1 to k
    for (int i = 1; i <= k; i++)
    {
        // Update dp array for all sums from i to n
        for (int j = i; j <= n; j++)
        {
            dp[j] += dp[j - i];
        }
    }

    // dp[n] now contains the total number of ways to make sum n
    return dp[n];
}

int main()
{
    int n = 8;
    int k = 2;

    cout << NumberOfways(n, k) << endl;
}