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

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 = 2Output: 5Explanation: 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}, the sum is 8.{2, 1, 1, 1, 1, 1, 1}, the sum is 8.{2, 2, 1, 1, 1, 1}, the sum is 8.2, 2, 2, 1, 1}, the sum is 8.{2, 2, 2, 2}}, the sum is 8.
{1, 1, 1, 1, 1, 1, 1, 1}, the sum is 8.
{2, 1, 1, 1, 1, 1, 1}, the sum is 8.
{2, 2, 1, 1, 1, 1}, the sum is 8.
2, 2, 2, 1, 1}, the sum is 8.
{2, 2, 2, 2}}, the sum is 8.
Therefore, the total number of ways is 5.
Input: N = 2, K = 2Output: 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.
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[0] 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.
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++
Java
Python
C#
Javascript
// C++ program for the above approach#include <bits/stdc++.h>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[0] 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 Codeint main(){  int N = 8;  int K = 2;   cout << (NumberOfways(N, K));} // This code is contributed by mohit kumar 29.
// Java program for the above approachimport 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[0] 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 codepublic 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 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[0] 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 = 8K = 2 print(NumberOfways(N, K))
// C# program for the above approachusing 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[0] 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()    {        int N = 8;        int K = 2;         Console.WriteLine(NumberOfways(N, K));    }} // This code is contributed by ukasp.
<script>// Javascript implementation 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]function NumberOfways(N, K){         // Initialize a list    let dp = Array.from({length: N +1}, (_, i) => 0);       // Update dp[0] to 1    dp[0] = 1;     // Iterate over the range [1, K + 1]    for(let row = 1; row < K + 1; row++)    {         // Iterate over the range [1, N + 1]        for(let 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         // Given inputs    let N = 8;    let K = 2;         document.write(NumberOfways(N, K)); </script>
5
 
Time Complexity: O(N * K)Auxiliary Space: O(N)
mohit kumar 29
ukasp
offbeat
sanjoy_62
simranarora5sos
Natural Numbers
Permutation and Combination
Combinatorial
Dynamic Programming
Mathematical
Dynamic Programming
Mathematical
Combinatorial
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Count of subsets with sum equal to X
Python program to get all subsets of given size of a set
Heap's Algorithm for generating permutations
Print all distinct permutations of a given string with duplicates
Make all combinations of size k
0-1 Knapsack Problem | DP-10
Program for Fibonacci numbers
Largest Sum Contiguous Subarray
Bellman–Ford Algorithm | DP-23
Floyd Warshall Algorithm | DP-16