Product of all Subsequences of size K except the minimum and maximum Elements

Given an array A[] containing N elements and an integer K. The task is to calculate the product of all elements of subsequences of size K except the minimum and the maximum elements for each subsequence.

Note: Since the answer can be very large so print the final answer as mod of 109 + 7.

Examples:

Input : arr[] = {1, 2, 3 4}, K = 3
Output : 36
Subsequences of length 3 are:
{1, 2, 3}, {1, 2, 4}, {1, 3, 4}, {2, 3, 4}
Excluding minimum and maximum elements from 
each of the above subsequences, product will be:
(2 * 2 * 3 * 3) = 36.

Input : arr[] = {10, 5, 16, 6}, k=3
Output : 3600

Naive Approach: A simple approach is to generate all possible subsequences one by one and multiply all elements except maximum and minimum and further multiplying all of them. Since there will be a total of (n)C(K) subsequences all having K – 2 elements to be multiplied which is a tedious work to do.

Efficient Approach: The idea is to first sort the array since it doesn’t matter if we consider subsequences or subsets.



Now count the occurrence of each element one by one.

In total a number can occur in (n-1)C(K-1) subsequences out of which (i)C(K-1) times it will occur as maximum element and (n-i-1)C(K-1) times it will occur as minimum element of that subsequence.

Hence, in total element will occur:

(n-1)C(K-1)  - (i)C(K-1) - (n-i-1)C(K-1) times. (let's say it x)

So, at first we’ll be calculating x for each element a[i] and then multiply a[i] x times. i.e ().

Since, It’s too difficult to calculate this for large arrays, so we’ll use the Fermat’s Little Theorem.

Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to find product of all 
// Subsequences of size K except the 
// minimum and maximum Elements
  
#include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
  
#define ll long long
  
#define max 101
  
// 2D array to store value of 
// combinations nCr
ll C[max - 1][max - 1];
  
ll power(ll x, unsigned ll y)
{
    unsigned ll res = 1;
    x = x % MOD;
    while (y > 0) {
        if (y & 1) {
            res = (res * x) % MOD;
        }
  
        y = y >> 1;
        x = (x * x) % MOD;
    }
    return res % MOD;
}
  
// Function to pre-calculate value of all 
// combinations nCr
void combi(int n, int k)
{
    int i, j;
  
    for (i = 0; i <= n; i++) {
        for (j = 0; j <= min(i, k); j++) {
            if (j == 0 || j == i)
                C[i][j] = 1;
            else
                C[i][j] = (C[i - 1][j - 1] % MOD 
                            + C[i - 1][j] % MOD) % MOD;
        }
    }
}
  
// Function to calculate product of all subsequences 
// except the minimum and maximum elements
unsigned ll product(ll a[], int n, int k)
{
    unsigned ll ans = 1;
  
    // Sorting array so that it becomes easy 
    // to calculate the number of times an 
    // element will come in first or last place
    sort(a, a + n);
      
    // An element will occur 'powa' times in total
    // of which 'powla' times it will be last element
    // and 'powfa' times it will be first element
    ll powa = C[n - 1][k - 1];
  
    for (int i = 0; i < n; i++) {
        ll powla = C[i][k - 1];
        ll powfa = C[n - i - 1][k - 1];
          
        // In total it will come 
        // powe = powa-powla-powfa times
        ll powe = ((powa % MOD) - (powla + powfa) % MOD + MOD) % MOD;
          
        // Multiplying a[i] powe times using 
        // Fermat Little Theorem under MODulo 
        // MOD for fast exponentiation
        unsigned ll mul = power(a[i], powe) % MOD;
        ans = ((ans % MOD) * (mul % MOD)) % MOD;
    }
      
    return ans % MOD;
}
  
// Driver Code
int main()
{
    // pre-calculation of all combinations
    combi(100, 100);
  
    ll arr[] = { 1, 2, 3, 4 };
    int n = sizeof(arr) / sizeof arr[0];
    int k = 3;
  
    unsigned ll ans = product(arr, n, k);
      
    cout << ans << endl;
  
    return 0;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to find product of all 
// Subsequences of size K except the 
// minimum and maximum Elements
import java.util.Arrays;
  
class GFG 
{
      
static int MOD= 1000000007;
static int max =101;
  
// 2D array to store value of 
// combinations nCr
static long C[][] = new long[max ][max];
  
static long power(long x, long y)
{
    long res = 1;
    x = x % MOD;
    while (y > 0)
    {
        if (y % 2== 1)
        {
            res = (res * x) % MOD;
        }
  
        y = y >> 1;
        x = (x * x) % MOD;
    }
    return res % MOD;
}
  
// Function to pre-calculate value of all 
// combinations nCr
static void combi(int n, int k)
{
    int i, j;
  
    for (i = 0; i <= n; i++)
    {
        for (j = 0; j <= Math.min(i, k); j++) 
        {
            if (j == 0 || j == i)
                C[i][j] = 1;
            else
                C[i][j] = (C[i - 1][j - 1] % MOD 
                            + C[i - 1][j] % MOD) % MOD;
        }
    }
}
  
// Function to calculate product of all subsequences 
// except the minimum and maximum elements
static long product(long a[], int n, int k)
{
    long ans = 1;
  
    // Sorting array so that it becomes easy 
    // to calculate the number of times an 
    // element will come in first or last place
    Arrays.sort(a);
      
    // An element will occur 'powa' times in total
    // of which 'powla' times it will be last element
    // and 'powfa' times it will be first element
    long powa = C[n - 1][k - 1];
  
    for (int i = 0; i < n; i++) 
    {
        long powla = C[i][k - 1];
        long powfa = C[n - i - 1][k - 1];
          
        // In total it will come 
        // powe = powa-powla-powfa times
        long powe = ((powa % MOD) - (powla + powfa) % MOD + MOD) % MOD;
          
        // Multiplying a[i] powe times using 
        // Fermat Little Theorem under MODulo 
        // MOD for fast exponentiation
        long mul = power(a[i], powe) % MOD;
        ans = ((ans % MOD) * (mul % MOD)) % MOD;
    }
      
    return ans % MOD;
}
  
// Driver Code
public static void main(String[] args)
{
    // pre-calculation of all combinations
    combi(100, 100);
  
    long arr[] = { 1, 2, 3, 4 };
    int n = arr.length;
    int k = 3;
  
    long ans = product(arr, n, k);
      
    System.out.println(ans);
}
}
  
/* This code contributed by PrinciRaj1992 */
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python 3 program to find product of all 
# Subsequences of size K except the 
# minimum and maximum Elements
  
MOD = 1000000007
  
max = 101
  
# 2D array to store value of 
# combinations nCr
C = [[0 for i in range(max)] for j in range(max)]
  
def power(x,y):
    res = 1
    x = x % MOD
    while (y > 0):
        if (y & 1):
            res = (res * x) % MOD
  
        y = y >> 1
        x = (x * x) % MOD
  
    return res % MOD
  
# Function to pre-calculate value of all 
# combinations nCr
def combi(n, k):
    for i in range(n + 1):
        for j in range(min(i, k) + 1):
            if (j == 0 or j == i):
                C[i][j] = 1
            else:
                C[i][j] = (C[i - 1][j - 1] % MOD + 
                            C[i - 1][j] % MOD) % MOD
  
# Function to calculate product of all subsequences 
# except the minimum and maximum elements
def product(a, n, k):
    ans = 1
  
    # Sorting array so that it becomes easy 
    # to calculate the number of times an 
    # element will come in first or last place
    a.sort(reverse = False)
      
    # An element will occur 'powa' times in total
    # of which 'powla' times it will be last element
    # and 'powfa' times it will be first element
    powa = C[n - 1][k - 1]
  
    for i in range(n):
        powla = C[i][k - 1]
        powfa = C[n - i - 1][k - 1]
          
        # In total it will come 
        # powe = powa-powla-powfa times
        powe = ((powa % MOD) - (powla + powfa) % MOD + MOD) % MOD
          
        # Multiplying a[i] powe times using 
        # Fermat Little Theorem under MODulo 
        # MOD for fast exponentiation
        mul = power(a[i], powe) % MOD
        ans = ((ans % MOD) * (mul % MOD)) % MOD
      
    return ans % MOD
  
# Driver Code
if __name__ == '__main__':
    # pre-calculation of all combinations
    combi(100, 100)
  
    arr = [1, 2, 3, 4]
    n = len(arr)
    k = 3
  
    ans = product(arr, n, k)
    print(ans)
  
# This code is contributed by
# Surendra_Gangwar
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to find product of all 
// Subsequences of size K except the 
// minimum and maximum Elements
using System;
  
class GFG
{
static int MOD = 1000000007;
static int max = 101;
  
// 2D array to store value of 
// combinations nCr
static long [,]C = new long[max, max];
  
static long power(long x, long y)
{
    long res = 1;
    x = x % MOD;
    while (y > 0)
    {
        if (y % 2 == 1)
        {
            res = (res * x) % MOD;
        }
  
        y = y >> 1;
        x = (x * x) % MOD;
    }
    return res % MOD;
}
  
// Function to pre-calculate value 
// of all combinations nCr
static void combi(int n, int k)
{
    int i, j;
  
    for (i = 0; i <= n; i++)
    {
        for (j = 0;
             j <= Math.Min(i, k); j++) 
        {
            if (j == 0 || j == i)
                C[i, j] = 1;
            else
                C[i, j] = (C[i - 1, j - 1] % MOD + 
                           C[i - 1, j] % MOD) % MOD;
        }
    }
}
  
// Function to calculate product of 
// all subsequences except 
// the minimum and maximum elements
static long product(long []a, int n, int k)
{
    long ans = 1;
  
    // Sorting array so that it becomes easy 
    // to calculate the number of times an 
    // element will come in first or last place
    Array.Sort(a);
      
    // An element will occur 'powa' times 
    // in total of which 'powla' times it 
    // will be last element and 'powfa' times
    // it will be first element
    long powa = C[n - 1, k - 1];
  
    for (int i = 0; i < n; i++) 
    {
        long powla = C[i, k - 1];
        long powfa = C[n - i - 1, k - 1];
          
        // In total it will come 
        // powe = powa-powla-powfa times
        long powe = ((powa % MOD) -     
                     (powla + powfa) % 
                      MOD + MOD) % MOD;
          
        // Multiplying a[i] powe times using 
        // Fermat Little Theorem under MODulo 
        // MOD for fast exponentiation
        long mul = power(a[i], powe) % MOD;
        ans = ((ans % MOD) * 
               (mul % MOD)) % MOD;
    }
      
    return ans % MOD;
}
  
// Driver Code
static public void Main ()
{
    // pre-calculation of all combinations
    combi(100, 100);
  
    long []arr = { 1, 2, 3, 4 };
    int n = arr.Length;
    int k = 3;
  
    long ans = product(arr, n, k);
      
    Console.WriteLine(ans);
}
}
  
// This code contributed by ajit 
chevron_right

Output:
36

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.





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.



Article Tags :