# Number of K length subsequences with minimum sum

Given an array arr[] of size N and an integer K, the task is to find the number of K length subsequences of this array such that the sum of these subsequences is minimum possible.

Examples:

Input: arr[] = {1, 2, 3, 4}, K = 2
Output: 1
Subsequences of lengths 2 are (1, 2), (1, 3), (1, 4),
(2, 3), (2, 4) and (3, 4).
The minimum sum is 3 and the only subsequence
with this sum is (1, 2).

Input: arr[] = {2, 1, 2, 2, 2, 1}, K = 3
Output: 4

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: The minimum possible sum of a subsequence of length K from the given array is the sum of the K smallest elements of the array. Let X be the maximum element among the K smallest elements of the array, and let the number of times it occurs among the K smallest elements of the array be Y and its total occurrence in the complete array be cntX. Now, there are cntXCY ways to select this element in the K smallest elements which is the count of required subsequences.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the value of ` `// Binomial Coefficient C(n, k) ` `int` `binomialCoeff(``int` `n, ``int` `k) ` `{ ` `    ``int` `C[n + 1][k + 1]; ` `    ``int` `i, j; ` ` `  `    ``// Calculate value of Binomial Coefficient ` `    ``// in bottom up manner ` `    ``for` `(i = 0; i <= n; i++) { ` `        ``for` `(j = 0; j <= min(i, k); j++) { ` ` `  `            ``// Base Cases ` `            ``if` `(j == 0 || j == i) ` `                ``C[i][j] = 1; ` ` `  `            ``// Calculate value using previously ` `            ``// stored values ` `            ``else` `                ``C[i][j] = C[i - 1][j - 1] + C[i - 1][j]; ` `        ``} ` `    ``} ` ` `  `    ``return` `C[n][k]; ` `} ` ` `  `// Function to return the count ` `// of valid subsequences ` `int` `cntSubSeq(``int` `arr[], ``int` `n, ``int` `k) ` `{ ` ` `  `    ``// Sort the array ` `    ``sort(arr, arr + n); ` ` `  `    ``// Maximum among the minimum K elements ` `    ``int` `num = arr[k - 1]; ` ` `  `    ``// Y will store the frequency of num ` `    ``// in the minimum K elements ` `    ``int` `Y = 0; ` `    ``for` `(``int` `i = k - 1; i >= 0; i--) { ` `        ``if` `(arr[i] == num) ` `            ``Y++; ` `    ``} ` ` `  `    ``// cntX will store the frequency of ` `    ``// num in the complete array ` `    ``int` `cntX = Y; ` `    ``for` `(``int` `i = k; i < n; i++) { ` `        ``if` `(arr[i] == num) ` `            ``cntX++; ` `    ``} ` ` `  `    ``return` `binomialCoeff(cntX, Y); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 1, 2, 3, 4 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(``int``); ` `    ``int` `k = 2; ` ` `  `    ``cout << cntSubSeq(arr, n, k); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach  ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` `     `  `    ``// Function to return the value of  ` `    ``// Binomial Coefficient C(n, k)  ` `    ``static` `int` `binomialCoeff(``int` `n, ``int` `k)  ` `    ``{  ` `        ``int` `C[][] = ``new` `int` `[n + ``1``][k + ``1``];  ` `        ``int` `i, j;  ` `     `  `        ``// Calculate value of Binomial Coefficient  ` `        ``// in bottom up manner  ` `        ``for` `(i = ``0``; i <= n; i++)  ` `        ``{  ` `            ``for` `(j = ``0``; j <= Math.min(i, k); j++)  ` `            ``{  ` `     `  `                ``// Base Cases  ` `                ``if` `(j == ``0` `|| j == i)  ` `                    ``C[i][j] = ``1``;  ` `     `  `                ``// Calculate value using previously  ` `                ``// stored values  ` `                ``else` `                    ``C[i][j] = C[i - ``1``][j - ``1``] +  ` `                              ``C[i - ``1``][j];  ` `            ``}  ` `        ``}  ` `        ``return` `C[n][k];  ` `    ``}  ` `     `  `    ``// Function to return the count  ` `    ``// of valid subsequences  ` `    ``static` `int` `cntSubSeq(``int` `arr[], ``int` `n, ``int` `k)  ` `    ``{  ` `     `  `        ``// Sort the array  ` `        ``Arrays.sort(arr);  ` `     `  `        ``// Maximum among the minimum K elements  ` `        ``int` `num = arr[k - ``1``];  ` `     `  `        ``// Y will store the frequency of num  ` `        ``// in the minimum K elements  ` `        ``int` `Y = ``0``;  ` `        ``for` `(``int` `i = k - ``1``; i >= ``0``; i--)  ` `        ``{  ` `            ``if` `(arr[i] == num)  ` `                ``Y++;  ` `        ``}  ` `     `  `        ``// cntX will store the frequency of  ` `        ``// num in the complete array  ` `        ``int` `cntX = Y;  ` `        ``for` `(``int` `i = k; i < n; i++)  ` `        ``{  ` `            ``if` `(arr[i] == num)  ` `                ``cntX++;  ` `        ``}  ` `        ``return` `binomialCoeff(cntX, Y);  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `main (String[] args) ` `    ``{  ` `        ``int` `arr[] = { ``1``, ``2``, ``3``, ``4` `};  ` `        ``int` `n = arr.length;  ` `        ``int` `k = ``2``;  ` `     `  `        ``System.out.println(cntSubSeq(arr, n, k));  ` `    ``}  ` `} ` ` `  `// This code is contributed by AnkitRai01 `

## C#

 `// C# implementation of the approach  ` `using` `System; ` `     `  `class` `GFG ` `{ ` `     `  `    ``// Function to return the value of  ` `    ``// Binomial Coefficient C(n, k)  ` `    ``static` `int` `binomialCoeff(``int` `n, ``int` `k)  ` `    ``{  ` `        ``int` `[,]C = ``new` `int` `[n + 1, k + 1];  ` `        ``int` `i, j;  ` `     `  `        ``// Calculate value of Binomial Coefficient  ` `        ``// in bottom up manner  ` `        ``for` `(i = 0; i <= n; i++)  ` `        ``{  ` `            ``for` `(j = 0; j <= Math.Min(i, k); j++)  ` `            ``{  ` `     `  `                ``// Base Cases  ` `                ``if` `(j == 0 || j == i)  ` `                    ``C[i, j] = 1;  ` `     `  `                ``// Calculate value using previously  ` `                ``// stored values  ` `                ``else` `                    ``C[i, j] = C[i - 1, j - 1] +  ` `                              ``C[i - 1, j];  ` `            ``}  ` `        ``}  ` `        ``return` `C[n, k];  ` `    ``}  ` `     `  `    ``// Function to return the count  ` `    ``// of valid subsequences  ` `    ``static` `int` `cntSubSeq(``int` `[]arr, ``int` `n, ``int` `k)  ` `    ``{  ` `     `  `        ``// Sort the array  ` `        ``Array.Sort(arr);  ` `     `  `        ``// Maximum among the minimum K elements  ` `        ``int` `num = arr[k - 1];  ` `     `  `        ``// Y will store the frequency of num  ` `        ``// in the minimum K elements  ` `        ``int` `Y = 0;  ` `        ``for` `(``int` `i = k - 1; i >= 0; i--)  ` `        ``{  ` `            ``if` `(arr[i] == num)  ` `                ``Y++;  ` `        ``}  ` `     `  `        ``// cntX will store the frequency of  ` `        ``// num in the complete array  ` `        ``int` `cntX = Y;  ` `        ``for` `(``int` `i = k; i < n; i++)  ` `        ``{  ` `            ``if` `(arr[i] == num)  ` `                ``cntX++;  ` `        ``}  ` `        ``return` `binomialCoeff(cntX, Y);  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `Main (String[] args) ` `    ``{  ` `        ``int` `[]arr = { 1, 2, 3, 4 };  ` `        ``int` `n = arr.Length;  ` `        ``int` `k = 2;  ` `     `  `        ``Console.WriteLine(cntSubSeq(arr, n, k));  ` `    ``}  ` `} ` ` `  `// This code is contributed by 29AjayKumar `

## Python3

 `# Python3 implementation of the approach ` ` `  `# Function to return the value of ` `# Binomial Coefficient C(n, k) ` `def` `binomialCoeff(n, k) : ` ` `  `    ``C ``=` `[[``0` `for` `i ``in` `range``(n ``+` `1``)]  ` `               ``for` `j ``in` `range``(k ``+` `1``)] ` ` `  `    ``# Calculate value of Binomial Coefficient ` `    ``# in bottom up manner ` `    ``for` `i ``in` `range` `(``0``, n ``+` `1` `): ` `        ``for` `j ``in` `range` `(``0``, ``min``(i, k) ``+` `1``): ` ` `  `            ``# Base Cases ` `            ``if` `(j ``=``=` `0` `or` `j ``=``=` `i): ` `                ``C[i][j] ``=` `1` ` `  `            ``# Calculate value using previously ` `            ``# stored values ` `            ``else` `: ` `                ``C[i][j] ``=` `C[i ``-` `1``][j ``-` `1``] ``+` `C[i ``-` `1``][j] ` `         `  `    ``return` `C[n][k] ` ` `  `# Function to return the count ` `# of valid subsequences ` `def` `cntSubSeq(arr, n, k) : ` ` `  `    ``# Sort the array ` `    ``arr.sort() ` ` `  `    ``# Maximum among the minimum K elements ` `    ``num ``=` `arr[k ``-` `1``]; ` ` `  `    ``# Y will store the frequency of num ` `    ``# in the minimum K elements ` `    ``Y ``=` `0``; ` `    ``for` `i ``in` `range` `(k ``-` `1``, ``-``1``, ``1``) : ` `        ``if` `(arr[i] ``=``=` `num): ` `            ``Y ``+``=` `1` ` `  `    ``# cntX will store the frequency of ` `    ``# num in the complete array ` `    ``cntX ``=` `Y; ` `    ``for` `i ``in` `range` `(k, n): ` `        ``if` `(arr[i] ``=``=` `num) : ` `            ``cntX ``+``=` `1` `     `  `    ``return` `binomialCoeff(cntX, Y) ` ` `  `# Driver code ` `arr ``=` `[ ``1``, ``2``, ``3``, ``4` `] ` `n ``=` `len``(arr) ` `k ``=` `2` `print``(cntSubSeq(arr, n, k)) ` ` `  `# This code is contributed by ihritik `

Output:

```1
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

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.