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

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
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;
}

chevron_right






                        filter_none









Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// 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 



















                        chevron_right







                        filter_none









C#














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// 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 



















                        chevron_right







                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# 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 



















                        chevron_right







                        filter_none











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
    

    

        
        

            
            
        

    


Recommended Posts:
spp____
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.