Different ways to sum n using numbers greater than or equal to m
Last Updated :
10 Dec, 2022
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
Method 1:
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:
C++
#include <bits/stdc++.h>
#define MAX 100
using namespace std;
int numberofways( int n, int m)
{
int dp[n+2][n+2];
memset (dp, 0, sizeof (dp));
dp[0][n + 1] = 1;
for ( int k = n; k >= m; k--) {
for ( int i = 0; i <= n; i++) {
dp[i][k] = dp[i][k + 1];
if (i - k >= 0)
dp[i][k] = (dp[i][k] + dp[i - k][k]);
}
}
return dp[n][m];
}
int main()
{
int n = 3, m = 1;
cout << numberofways(n, m) << endl;
return 0;
}
|
Java
import java.io.*;
class GFG {
static int numberofways( int n, int m)
{
int dp[][]= new int [n+ 2 ][n+ 2 ];
dp[ 0 ][n + 1 ] = 1 ;
for ( int k = n; k >= m; k--) {
for ( int i = 0 ; i <= n; i++) {
dp[i][k] = dp[i][k + 1 ];
if (i - k >= 0 )
dp[i][k] = (dp[i][k] + dp[i - k][k]);
}
}
return dp[n][m];
}
public static void main(String args[])
{
int n = 3 , m = 1 ;
System.out.println(numberofways(n, m));
}
}
|
Python3
MAX = 100
def numberofways(n, m):
dp = [[ 0 for i in range (n + 2 )] for j in range (n + 2 )]
dp[ 0 ][n + 1 ] = 1
for k in range (n, m - 1 , - 1 ):
for i in range (n + 1 ):
dp[i][k] = dp[i][k + 1 ]
if (i - k > = 0 ):
dp[i][k] = (dp[i][k] + dp[i - k][k])
return dp[n][m]
if __name__ = = "__main__" :
n, m = 3 , 1
print (numberofways(n, m))
|
C#
using System;
class GFG {
static int numberofways( int n, int m)
{
int [, ] dp = new int [n + 2, n + 2];
dp[0, n + 1] = 1;
for ( int k = n; k >= m; k--) {
for ( int i = 0; i <= n; i++) {
dp[i, k] = dp[i, k + 1];
if (i - k >= 0)
dp[i, k] = (dp[i, k] + dp[i - k, k]);
}
}
return dp[n, m];
}
public static void Main()
{
int n = 3, m = 1;
Console.WriteLine(numberofways(n, m));
}
}
|
PHP
<?php
$MAX = 100;
function numberofways( $n , $m )
{
global $MAX ;
$dp = array_fill (0, $n + 2, array_fill (0, $n +2, NULL));
$dp [0][ $n + 1] = 1;
for ( $k = $n ; $k >= $m ; $k --)
{
for ( $i = 0; $i <= $n ; $i ++)
{
$dp [ $i ][ $k ] = $dp [ $i ][ $k + 1];
if ( $i - $k >= 0)
$dp [ $i ][ $k ] = ( $dp [ $i ][ $k ] + $dp [ $i - $k ][ $k ]);
}
}
return $dp [ $n ][ $m ];
}
$n = 3;
$m = 1;
echo numberofways( $n , $m ) ;
return 0;
?>
|
Javascript
<script>
function numberofways(n,m)
{
let dp= new Array(n+2);
for (let i=0;i<dp.length;i++)
{
dp[i]= new Array(n+2);
for (let j=0;j<dp[i].length;j++)
{
dp[i][j]=0;
}
}
dp[0][n + 1] = 1;
for (let k = n; k >= m; k--) {
for (let i = 0; i <= n; i++) {
dp[i][k] = dp[i][k + 1];
if (i - k >= 0)
dp[i][k] = (dp[i][k] + dp[i - k][k]);
}
}
return dp[n][m];
}
let n = 3, m = 1;
document.write(numberofways(n, m));
</script>
|
Time Complexity: O((n-m)*n)
Auxiliary Space: O(n*n)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...