Different ways to sum n using numbers greater than or equal to m

Given two natural number n and m. The task is to find the number of ways in which the numbers that are greater than or equal to m can be added to get the sum n.

Examples:

Input : n = 3, m = 1
Output : 3
Following are three different ways
to get sum n such that each term is
greater than or equal to m
1 + 1 + 1, 1 + 2, 3 

Input : n = 2, m = 1
Output : 2
Two ways are 1 + 1 and 2



The idea is to use Dynamic Programming by define 2D matrix, say dp[][]. dp[i][j] define the number of ways to get sum i using the numbers greater than or equal to j. So dp[i][j] can be defined as:

If i < j, dp[i][j] = 0, because we cannot achieve smaller sum of i using numbers greater than or equal to j.

If i = j, dp[i][j] = 1, because there is only one way to show sum i using number i which is equal to j.

Else dp[i][j] = dp[i][j+1] + dp[i-j][j], because obtaining a sum i using numbers greater than or equal to j is equal to the sum of obtaining a sum of i using numbers greater than or equal to j+1 and obtaining the sum of i-j using numbers greater than or equal to j.

Below is the implementation of this approach:

CPP

filter_none

edit
close

play_arrow

link
brightness_4
code

// CPP Program to find number of ways to
// which numbers that are greater than
// given number can be added to get sum.
#include <bits/stdc++.h>
#define MAX 100
using namespace std;
  
// Return number of ways to which numbers
// that are greater than given number can
// be added to get sum.
int numberofways(int n, int m)
{
    int dp[n+2][n+2];
    memset(dp, 0, sizeof(dp));
  
    dp[0][n + 1] = 1;
  
    // Filling the table. k is for numbers
    // greater than or equal that are allowed.
    for (int k = n; k >= m; k--) {
  
        // i is for sum
        for (int i = 0; i <= n; i++) {
  
            // initializing dp[i][k] to number
            // ways to get sum using numbers
            // greater than or equal k+1
            dp[i][k] = dp[i][k + 1];
  
            // if i > k
            if (i - k >= 0)
                dp[i][k] = (dp[i][k] + dp[i - k][k]);
        }
    }
  
    return dp[n][m];
}
  
// Driver Program
int main()
{
    int n = 3, m = 1;
    cout << numberofways(n, m) << endl;
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java Program to find number of ways to
// which numbers that are greater than
// given number can be added to get sum.
import java.io.*;
  
class GFG {
      
    // Return number of ways to which numbers
    // that are greater than given number can
    // be added to get sum.
    static int numberofways(int n, int m)
    {
        int dp[][]=new int[n+2][n+2];
          
        dp[0][n + 1] = 1;
       
        // Filling the table. k is for numbers
        // greater than or equal that are allowed.
        for (int k = n; k >= m; k--) {
       
            // i is for sum
            for (int i = 0; i <= n; i++) {
       
                // initializing dp[i][k] to number
                // ways to get sum using numbers
                // greater than or equal k+1
                dp[i][k] = dp[i][k + 1];
       
                // if i > k
                if (i - k >= 0)
                    dp[i][k] = (dp[i][k] + dp[i - k][k]);
            }
        }
       
        return dp[n][m];
    }
       
    // Driver Program
    public static void main(String args[])
    {
        int n = 3, m = 1;
        System.out.println(numberofways(n, m));
    }
}
  
/*This code is contributed by Nikita tiwari.*/

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find number of ways to
// which numbers that are greater than
// given number can be added to get sum.
using System;
  
class GFG {
  
    // Return number of ways to which numbers
    // that are greater than given number can
    // be added to get sum.
    static int numberofways(int n, int m)
    {
        int[, ] dp = new int[n + 2, n + 2];
  
        dp[0, n + 1] = 1;
  
        // Filling the table. k is for numbers
        // greater than or equal that are allowed.
        for (int k = n; k >= m; k--) {
  
            // i is for sum
            for (int i = 0; i <= n; i++) {
  
                // initializing dp[i][k] to number
                // ways to get sum using numbers
                // greater than or equal k+1
                dp[i, k] = dp[i, k + 1];
  
                // if i > k
                if (i - k >= 0)
                    dp[i, k] = (dp[i, k] + dp[i - k, k]);
            }
        }
  
        return dp[n, m];
    }
  
    // Driver Program
    public static void Main()
    {
        int n = 3, m = 1;
        Console.WriteLine(numberofways(n, m));
    }
}
  
/*This code is contributed by vt_m.*/

chevron_right



Output:

3


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.