# Ways to sum to N using Natural Numbers up to K with repetitions allowed

• Difficulty Level : Hard
• Last Updated : 13 Sep, 2021

Given two integers N and K, the task is to find the total number of ways of representing N as the sum of positive integers in the range [1, K], where each integer can be chosen multiple times.

Examples:

Input: N = 8, K = 2
Output: 5
Explanation: All possible ways of representing N as sum of positive integers less than or equal to K are:

1. {1, 1, 1, 1, 1, 1, 1, 1}, the sum is 8.
2. {2, 1, 1, 1, 1, 1, 1}, the sum is 8.
3. {2, 2, 1, 1, 1, 1}, the sum is 8.
4. 2, 2, 2, 1, 1}, the sum is 8.
5. {2, 2, 2, 2}}, the sum is 8.

Therefore, the total number of ways is 5.

Input: N = 2, K = 2
Output: 2

Naive Approach: The simplest approach to solve the given problem is to generate all possible combinations of choosing integers over the range [1, K] and count those combinations whose sum is N

Time Complexity: O(KN)
Auxiliary Space: O(1)

Efficient Approach: The above approach has Overlapping Subproblems and an Optimal Substructure. Hence, in order to optimize, Dynamic Programming is needed to be performed based on the following observations:

• Considering dp[i] stores the total number of ways for representing i as the sum of integers lying in the range [1, K], then the transition of states can be defined as:
• For i in the range [1, K] and for every j in the range [1, N]
• The value of dp[j] is equal to (dp[j]+ dp[j – i]), for all j ≥ i.

Follow the steps below to solve the problem:

• Initialize an array, say dp[], with all elements as 0, to store all the recursive states.
• Initialize dp as 1.
• Now, iterate over the range [1, K] using a variable i and perform the following steps:
• Iterate over the range [1, N], using a variable j, and update the value of dp[j] as dp[j]+ dp[j – i], if j ≥ i.
• After completing the above steps, print the value of dp[N] as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the total number of``// ways to represent N as the sum of``// integers over the range [1, K]``int` `NumberOfways(``int` `N, ``int` `K)``{` `    ``// Initialize a list``    ``vector<``int``> dp(N + 1, 0);``  ` `    ``// Update dp to 1``    ``dp = 1;` `    ``// Iterate over the range [1, K + 1]``    ``for` `(``int` `row = 1; row < K + 1; row++)``    ``{` `        ``// Iterate over the range [1, N + 1]``        ``for` `(``int` `col = 1; col < N + 1; col++)``        ``{` `            ``// If col is greater``            ``// than or equal to row``            ``if` `(col >= row)``              ` `                ``// Update current``                ``// dp[col] state``                ``dp[col] = dp[col] + dp[col - row];``          ``}``    ``}` `    ``// Return the total number of ways``    ``return``(dp[N]);``}` `// Driver Code``int` `main()``{``  ``int` `N = 8;``  ``int` `K = 2;` `  ``cout << (NumberOfways(N, K));``}` `// This code is contributed by mohit kumar 29.`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{``    ` `// Function to find the total number of``// ways to represent N as the sum of``// integers over the range [1, K]``static` `int` `NumberOfways(``int` `N, ``int` `K)``{``    ` `    ``// Initialize a list``    ``int``[] dp = ``new` `int``[N + ``1``];``  ` `    ``// Update dp to 1``    ``dp[``0``] = ``1``;` `    ``// Iterate over the range [1, K + 1]``    ``for``(``int` `row = ``1``; row < K + ``1``; row++)``    ``{` `        ``// Iterate over the range [1, N + 1]``        ``for``(``int` `col = ``1``; col < N + ``1``; col++)``        ``{``            ` `            ``// If col is greater``            ``// than or equal to row``            ``if` `(col >= row)``              ` `                ``// Update current``                ``// dp[col] state``                ``dp[col] = dp[col] + dp[col - row];``          ``}``    ``}` `    ``// Return the total number of ways``    ``return``(dp[N]);``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given inputs``    ``int` `N = ``8``;``    ``int` `K = ``2``;``    ` `    ``System.out.println(NumberOfways(N, K));``}``}` `// This code is contributed by offbeat`

## Python

 `# Python program for the above approach` `# Function to find the total number of``# ways to represent N as the sum of``# integers over the range [1, K]``def` `NumberOfways(N, K):``  ` `    ``# Initialize a list``    ``dp ``=` `[``0``] ``*` `(N ``+` `1``)``    ` `    ``# Update dp to 1``    ``dp[``0``] ``=` `1``    ` `    ``# Iterate over the range [1, K + 1]``    ``for` `row ``in` `range``(``1``, K ``+` `1``):``      ` `        ``# Iterate over the range [1, N + 1]``        ``for` `col ``in` `range``(``1``, N ``+` `1``):``          ` `            ``# If col is greater``            ``# than or equal to row``            ``if` `(col >``=` `row):``              ` `                ``# Update current``                ``# dp[col] state``                ``dp[col] ``=` `dp[col] ``+` `dp[col ``-` `row]``                ` `                ` `    ``# Return the total number of ways``    ``return``(dp[N])` `# Driver Code` `N ``=` `8``K ``=` `2` `print``(NumberOfways(N, K))`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG``{``  ` `    ``// Function to find the total number of``    ``// ways to represent N as the sum of``    ``// integers over the range [1, K]``    ``static` `int` `NumberOfways(``int` `N, ``int` `K)``    ``{` `        ``// Initialize a list``        ``int``[] dp = ``new` `int``[(N + 1)];` `        ``// Update dp to 1``        ``dp = 1;` `        ``// Iterate over the range [1, K + 1]``        ``for` `(``int` `row = 1; row < K + 1; row++) {` `            ``// Iterate over the range [1, N + 1]``            ``for` `(``int` `col = 1; col < N + 1; col++) {` `                ``// If col is greater``                ``// than or equal to row``                ``if` `(col >= row)` `                    ``// Update current``                    ``// dp[col] state``                    ``dp[col] = dp[col] + dp[col - row];``            ``}``        ``}` `        ``// Return the total number of ways``        ``return` `(dp[N]);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``int` `N = 8;``        ``int` `K = 2;` `        ``Console.WriteLine(NumberOfways(N, K));``    ``}``}` `// This code is contributed by ukasp.`

## Javascript

 ``
Output:
`5`

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

My Personal Notes arrow_drop_up