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

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.