Related Articles

# Count of ways to choose K elements from given Array with maximum sum

• Last Updated : 04 Aug, 2021

Given an array, arr[] of size N and an integer K, the task is to find the number of ways of selecting K array elements, such that the sum of these K elements is the maximum possible sum.

Examples:

Input: arr[] = {3, 1, 1, 2}, K = 3
Output: 2
Explanation:
The possible ways of selecting 3 elements are:

1. {arr[0] (=3), arr[1] (=1), arr[2] (=1)}, the sum of the subset is equal to (3+1+1 = 5).
2. {arr[0] (=3), arr[1] (=1), arr[3] (=2)}, the sum of the subset is equal to (3+1+2 = 6).
3. {arr[0] (=3), arr[2] (=1), arr[3] (=2)}, the sum of the subset is equal to (3+1+2 = 6).
4. {arr[1] (=1), arr[2] (=1), arr[3] (=2)}, the sum of the subset is equal to (1+1+2 = 4).

Therefore, the total number of ways of selecting the K element with the maximum sum(= 6) is equal to 2.

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

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

Approach: The problem can be solved by sorting the array in descending order. Follow the steps below to solve the problem:

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the factorial of an``// integer``int` `fact(``int` `n)``{``    ``int` `res = 1;``    ``for` `(``int` `i = 2; i <= n; i++)``        ``res = res * i;``    ``return` `res;``}` `// Function to find the value of nCr``int` `C(``int` `n, ``int` `r)``{``    ``return` `fact(n) / (fact(r) * fact(n - r));``}` `// Function to find the number of ways``// to select K elements with maximum``// sum``int` `findWays(``int` `arr[], ``int` `N, ``int` `K)``{``    ``// Sort the array in descending order``    ``sort(arr, arr + N, greater<``int``>());` `    ``// Stores the frequency of arr[K-1]``    ``// in the prefix of K-1``    ``int` `p = 0;` `    ``// Stores the frequency of arr[K-1]``    ``// in the array arr[]``    ``int` `q = 0;` `    ``// Iterate over the range [0, K]``    ``for` `(``int` `i = 0; i < K; i++) {``        ``// If arr[i] is equal to arr[K-1]``        ``if` `(arr[i] == arr[K - 1]) {``            ``p++;``        ``}``    ``}` `    ``// Traverse the array arr[]``    ``for` `(``int` `i = 0; i < N; i++) {``        ``// If arr[i] is equal to arr[K-1]``        ``if` `(arr[i] == arr[K - 1]) {``            ``q += 1;``        ``}``    ``}``    ``// Stores the number of ways of``    ``// selecting p from q elements``    ``int` `ans = C(q, p);` `    ``// Return ans``    ``return` `ans;``}` `// Driver Code``int` `main()``{``    ``// Input``    ``int` `arr[] = { 2, 3, 4, 5, 2, 2 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``int` `K = 4;` `    ``// Function call``    ``cout << findWays(arr, N, K);``    ``return` `0;``}`

## Java

 `// Java program for the above approach` `import` `java.util.*;` `class` `GFG{` `// Function to find the factorial of an``// integer``static` `int` `fact(``int` `n)``{``    ``int` `res = ``1``;``    ``for` `(``int` `i = ``2``; i <= n; i++)``        ``res = res * i;``    ``return` `res;``}` `// Function to find the value of nCr``static` `int` `C(``int` `n, ``int` `r)``{``    ``return` `fact(n) / (fact(r) * fact(n - r));``}` `// Function to find the number of ways``// to select K elements with maximum``// sum``static` `int` `findWays(Integer arr[], ``int` `N, ``int` `K)``{``  ` `    ``// Sort the array in descending order``    ``Arrays.sort(arr, Collections.reverseOrder());` `    ``// Stores the frequency of arr[K-1]``    ``// in the prefix of K-1``    ``int` `p = ``0``;` `    ``// Stores the frequency of arr[K-1]``    ``// in the array arr[]``    ``int` `q = ``0``;` `    ``// Iterate over the range [0, K]``    ``for` `(``int` `i = ``0``; i < K; i++)``    ``{``      ` `        ``// If arr[i] is equal to arr[K-1]``        ``if` `(arr[i] == arr[K - ``1``]) {``            ``p++;``        ``}``    ``}` `    ``// Traverse the array arr[]``    ``for` `(``int` `i = ``0``; i < N; i++)``    ``{``      ` `        ``// If arr[i] is equal to arr[K-1]``        ``if` `(arr[i] == arr[K - ``1``]) {``            ``q += ``1``;``        ``}``    ``}``  ` `    ``// Stores the number of ways of``    ``// selecting p from q elements``    ``int` `ans = C(q, p);` `    ``// Return ans``    ``return` `ans;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``  ` `    ``// Input``    ``Integer arr[] = { ``2``, ``3``, ``4``, ``5``, ``2``, ``2` `};``    ``int` `N = arr.length;``    ``int` `K = ``4``;` `    ``// Function call``    ``System.out.print(findWays(arr, N, K));``}``}` `// This code is contributed by shikhasingrajput`

## Python3

 `# Python for the above approach` `# Function to find the factorial of an``# integer``def` `fact(n):``    ``res ``=` `1``    ``for` `i ``in` `range``(``2``, n ``+` `1``):``        ``res ``=` `res ``*` `i` `    ``return` `res` `# Function to find the value of nCr``def` `C(n, r):``    ``return` `fact(n) ``/` `(fact(r) ``*` `fact(n ``-` `r))` `# Function to find the number of ways``# to select K elements with maximum``# sum``def` `findWays(arr, N, K):` `    ``# Sort the array in descending order``    ``arr.sort(reverse``=``True``)` `    ``# Stores the frequency of arr[K-1]``    ``# in the prefix of K-1``    ``p ``=` `0` `    ``# Stores the frequency of arr[K-1]``    ``# in the array arr[]``    ``q ``=` `0` `    ``# Iterate over the range [0, K]``    ``for` `i ``in` `range``(K):` `        ``# If arr[i] is equal to arr[K-1]``        ``if` `(arr[i] ``=``=` `arr[K ``-` `1``]):``            ``p ``+``=` `1` `    ``# Traverse the array arr[]``    ``for` `i ``in` `range``(N):` `        ``# If arr[i] is equal to arr[K-1]``        ``if` `(arr[i] ``=``=` `arr[K ``-` `1``]):``            ``q ``+``=` `1` `    ``# Stores the number of ways of``    ``# selecting p from q elements``    ``ans ``=` `C(q, p)` `    ``# Return ans``    ``return` `int``(ans)` `# Driver Code`  `# Input``arr ``=` `[``2``, ``3``, ``4``, ``5``, ``2``, ``2``]``N ``=` `len``(arr)``K ``=` `4` `# Function call``print``(findWays(arr, N, K))` `# This code is contributed by gfgking.`

## C#

 `// C# program for the above approach``using` `System;` `class` `Program{``    ` `// Function to find the factorial of an``// integer``static` `int` `fact(``int` `n)``{``    ``int` `res = 1;``    ``for``(``int` `i = 2; i <= n; i++)``        ``res = res * i;``        ` `    ``return` `res;``}` `// Function to find the value of nCr``static` `int` `C(``int` `n, ``int` `r)``{``    ``return` `fact(n) / (fact(r) * fact(n - r));``}` `// Function to find the number of ways``// to select K elements with maximum``// sum``static` `int` `findWays(``int` `[]arr, ``int` `N, ``int` `K)``{``    ` `    ``// Sort the array in descending order``    ``Array.Sort(arr);``    ``Array.Reverse(arr);` `    ``// Stores the frequency of arr[K-1]``    ``// in the prefix of K-1``    ``int` `p = 0;` `    ``// Stores the frequency of arr[K-1]``    ``// in the array arr[]``    ``int` `q = 0;` `    ``// Iterate over the range [0, K]``    ``for``(``int` `i = 0; i < K; i++)``    ``{``        ` `        ``// If arr[i] is equal to arr[K-1]``        ``if` `(arr[i] == arr[K - 1])``        ``{``            ``p++;``        ``}``    ``}` `    ``// Traverse the array arr[]``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ` `        ``// If arr[i] is equal to arr[K-1]``        ``if` `(arr[i] == arr[K - 1])``        ``{``            ``q += 1;``        ``}``    ``}``  ` `    ``// Stores the number of ways of``    ``// selecting p from q elements``    ``int` `ans = C(q, p);` `    ``// Return ans``    ``return` `ans;``}` `// Driver code``static` `void` `Main()``{``    ``int` `[]arr = { 2, 3, 4, 5, 2, 2 };``    ``int` `N = arr.Length;``    ``int` `K = 4;``    ` `    ``// Function call``    ``Console.Write(findWays(arr, N, K));``}``}` `// This code is contributed by SoumikMondal`

## Javascript

 ``
Output
`3`

Time Complexity: O(N*log(N) + K)
Auxiliary Space: O(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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up