Skip to content
Related Articles

Related Articles

Improve Article
Number of subsequences of maximum length K containing no repeated elements
  • Last Updated : 15 Jun, 2021

Given an array arr[] of N elements and a positive integer K such that K ≤ N. The task is to find the number of subsequences of maximum length K i.e. subsequences of length 0, 1, 2, …, K – 1, K that have all distinct elements.

Examples:  

Input: arr[] = {2, 2, 3, 3, 5}, K = 2 
Output: 14 
All the valid subsequences are {}, {2}, {2}, {3}, {3}, {5}, 
{2, 3}, {2, 3}, {2, 3}, {2, 3}, {2, 5}, {2, 5}, {3, 5} and {3, 5}.

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

Approach: 



  • Sort the array a[] if it is not already sorted and in a vector arr[] store the frequencies of each element of the original array. For example, if a[] = {2, 2, 3, 3, 5} then arr[] = {2, 2, 1} because 2 is present twice, 3 is present twice and 5 only once.
  • Say m is the length of the vector arr[]. So m will be the number of distinct elements. There can be subsequences of maximum length m without repetition. If m < k then there is no subsequence of length k. So, declare n = minimum(m, k).
  • Now apply dynamic programming. Create a 2-d array dp[n + 1][m + 1] such that dp[i][j] will store the number of subsequences of length i whose first element begins after j-th element from arr[]. For example, dp[1][1] = 3 because it means number 
    of subsequences of length 1 whose first element starts after 1-st element of arr[] which are {3}, {3}, {5}. 
    • Initialize first row of dp[][] to 1.
    • Run two loops top to bottom and right to left inside of the former loop.
    • If j > m – i that means there cannot be any such sequences due to lack of elements. So dp[i][j] = 0.
    • Else, dp[i][j] = dp[i][j + 1] + arr[j] * dp[i – 1][j + 1] as the number will be number of already existing subsequences of length i plus the number of subsequences of length i – 1 multiplied by arr[j] due to repetition.

Below is the implementation of the above approach: 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Returns number of subsequences
// of maximum length k and
// contains no repeated element
int countSubSeq(int a[], int n, int k)
{
    // Sort the array a[]
    sort(a, a + n);
    vector<int> arr;
 
    // Store the frequencies of all the
    // distinct element in the vector arr
    for (int i = 0; i < n;) {
        int count = 1, x = a[i];
        i++;
        while (i < n && a[i] == x) {
            count++;
            i++;
        }
        arr.push_back(count);
    }
 
    int m = arr.size();
    n = min(m, k);
 
    // count is the the number
    // of such subsequences
    int count = 1;
 
    // Create a 2-d array dp[n+1][m+1] to
    // store the intermediate result
    int dp[n + 1][m + 1];
 
    // Initialize the first row to 1
    for (int i = 0; i <= m; i++)
        dp[0][i] = 1;
 
    // Update the dp[][] array based
    // on the recurrence relation
    for (int i = 1; i <= n; i++) {
        for (int j = m; j >= 0; j--) {
            if (j > m - i)
                dp[i][j] = 0;
            else {
                dp[i][j] = dp[i][j + 1]
                           + arr[j] * dp[i - 1][j + 1];
            }
        }
        count = count + dp[i][0];
    }
 
    // Return the number of subsequences
    return count;
}
 
// Driver code
int main()
{
    int a[] = { 2, 2, 3, 3, 5 };
    int n = sizeof(a) / sizeof(int);
    int k = 3;
 
    cout << countSubSeq(a, n, k);
 
    return 0;
}
Java



// Java implementation of the approach
import java.util.*;
 
class GFG
{
 
// Returns number of subsequences
// of maximum length k and
// contains no repeated element
static int countSubSeq(int a[], int n, int k)
{
    // Sort the array a[]
    Arrays.sort(a);
    List<Integer> arr = new LinkedList<>();
 
    // Store the frequencies of all the
    // distinct element in the vector arr
    for (int i = 0; i < n;)
    {
        int count = 1, x = a[i];
        i++;
        while (i < n && a[i] == x)
        {
            count++;
            i++;
        }
        arr.add(count);
    }
 
    int m = arr.size();
    n = Math.min(m, k);
 
    // count is the the number
    // of such subsequences
    int count = 1;
 
    // Create a 2-d array dp[n+1][m+1] to
    // store the intermediate result
    int [][]dp = new int[n + 1][m + 1];
 
    // Initialize the first row to 1
    for (int i = 0; i <= m; i++)
        dp[0][i] = 1;
 
    // Update the dp[][] array based
    // on the recurrence relation
    for (int i = 1; i <= n; i++)
    {
        for (int j = m; j >= 0; j--)
        {
            if (j > m - i)
                dp[i][j] = 0;
            else
            {
                dp[i][j] = dp[i][j + 1] +
                             arr.get(j) *
                           dp[i - 1][j + 1];
            }
        }
        count = count + dp[i][0];
    }
 
    // Return the number of subsequences
    return count;
}
 
// Driver code
public static void main(String[] args)
{
    int a[] = { 2, 2, 3, 3, 5 };
    int n = a.length;
    int k = 3;
 
    System.out.println(countSubSeq(a, n, k));
}
}
 
// This code is contributed by PrinciRaj1992
Python 3



# Python 3 implementation of the approach
 
# Returns number of subsequences
# of maximum length k and
# contains no repeated element
def countSubSeq(a, n, k):
     
    # Sort the array a[]
    a.sort(reverse = False)
    arr = []
 
    # Store the frequencies of all the
    # distinct element in the vector arr
    i = 0
    while(i < n):
        count = 1
        x = a[i]
        i += 1
        while (i < n and a[i] == x):
            count += 1
            i += 1
         
        arr.append(count)
 
    m = len(arr)
    n = min(m, k)
 
    # count is the the number
    # of such subsequences
    count = 1
 
    # Create a 2-d array dp[n+1][m+1] to
    # store the intermediate result
    dp = [[0 for i in range(m + 1)]
             for j in range(n + 1)]
 
    # Initialize the first row to 1
    for i in range(m + 1):
        dp[0][i] = 1
 
    # Update the dp[][] array based
    # on the recurrence relation
    for i in range(1, n + 1, 1):
        j = m
        while(j >= 0):
            if (j > m - i):
                dp[i][j] = 0
            else:
                dp[i][j] = dp[i][j + 1] + \
                  arr[j] * dp[i - 1][j + 1]
                 
            j -= 1
             
        count = count + dp[i][0]
 
    # Return the number of subsequences
    return count
 
# Driver code
if __name__ == '__main__':
    a = [2, 2, 3, 3, 5]
    n = len(a)
    k = 3
 
    print(countSubSeq(a, n, k))
 
# This code is contributed by Surendra_Gangwar
C#



// C# implementation of the approach
using System;
using System.Collections.Generic;
     
class GFG
{
 
// Returns number of subsequences
// of maximum length k and
// contains no repeated element
static int countSubSeq(int []a, int n, int k)
{
    // Sort the array a[]
    Array.Sort(a);
    List<int> arr = new List<int>();
    int count, x;
     
    // Store the frequencies of all the
    // distinct element in the vector arr
    for (int i = 0; i < n;)
    {
        count = 1;
        x = a[i];
        i++;
        while (i < n && a[i] == x)
        {
            count++;
            i++;
        }
        arr.Add(count);
    }
 
    int m = arr.Count;
    n = Math.Min(m, k);
 
    // count is the the number
    // of such subsequences
    count = 1;
 
    // Create a 2-d array dp[n+1][m+1] to
    // store the intermediate result
    int [,]dp = new int[n + 1, m + 1];
 
    // Initialize the first row to 1
    for (int i = 0; i <= m; i++)
        dp[0, i] = 1;
 
    // Update the dp[][] array based
    // on the recurrence relation
    for (int i = 1; i <= n; i++)
    {
        for (int j = m; j >= 0; j--)
        {
            if (j > m - i)
                dp[i, j] = 0;
            else
            {
                dp[i, j] = dp[i, j + 1] +
                                 arr[j] *
                           dp[i - 1, j + 1];
            }
        }
        count = count + dp[i, 0];
    }
 
    // Return the number of subsequences
    return count;
}
 
// Driver code
public static void Main(String[] args)
{
    int []a = { 2, 2, 3, 3, 5 };
    int n = a.Length;
    int k = 3;
 
    Console.WriteLine(countSubSeq(a, n, k));
}
}
 
// This code is contributed by 29AjayKumar
Javascript



<script>
 
// Javascript implementation of the approach
 
// Returns number of subsequences
// of maximum length k and
// contains no repeated element
function countSubSeq(a, n, k)
{
    // Sort the array a[]
    a.sort();
    var arr = [];
 
    // Store the frequencies of all the
    // distinct element in the vector arr
    for (var i = 0; i < n;) {
        var count = 1, x = a[i];
        i++;
        while (i < n && a[i] == x) {
            count++;
            i++;
        }
        arr.push(count);
    }
 
    var m = arr.length;
    n = Math.min(m, k);
 
    // count is the the number
    // of such subsequences
    var count = 1;
 
    // Create a 2-d array dp[n+1][m+1] to
    // store the intermediate result
    var dp = Array.from(Array(n+1), ()=>Array(m+1));
 
    // Initialize the first row to 1
    for (var i = 0; i <= m; i++)
        dp[0][i] = 1;
 
    // Update the dp[][] array based
    // on the recurrence relation
    for (var i = 1; i <= n; i++) {
        for (var j = m; j >= 0; j--) {
            if (j > m - i)
                dp[i][j] = 0;
            else {
                dp[i][j] = dp[i][j + 1]
                           + arr[j] * dp[i - 1][j + 1];
            }
        }
        count = count + dp[i][0];
    }
 
    // Return the number of subsequences
    return count;
}
 
// Driver code
var a = [2, 2, 3, 3, 5];
var n = a.length;
var k = 3;
document.write( countSubSeq(a, n, k));
 
 
</script>
Output: 
18
 
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 industry experts, please refer DSA Live Classes



My Personal Notes
arrow_drop_up
Previous
DecimalField - Django Forms
Next

Program to convert Java list to a Vector in Scala
Recommended Articles
Page :
Number of subsequences as "ab" in a string repeated K times
14, Nov 17
Find two equal subsequences of maximum length with at least one different index
29, Jan 20
Minimize sum of smallest elements from K subsequences of length L
03, Jul 20
Maximum sum of K-length subarray consisting of same number of distinct elements as the given array
02, Mar 21
Count of subsequences of length atmost K containing distinct prime elements
29, May 20
Maximize subsequences having array elements not exceeding length of the subsequence
30, Sep 20
Find product of all elements at indexes which are factors of M for all possible sorted subsequences of length M
09, May 20
Number of K length subsequences with minimum sum
18, Oct 19
Number of palindromic subsequences of length k where k <= 3
06, Dec 17
Count the number of subsequences of length k having equal LCM and HCF
20, Sep 19
Find maximum array sum after making all elements same with repeated subtraction
02, Feb 17
Count of subsequences having maximum distinct elements
22, Dec 17
Product of all Subsequences of size K except the minimum and maximum Elements
18, Apr 19
Make all array elements equal by repeated subtraction of absolute difference of pairs from their maximum
16, Sep 20
Maximum K-digit number possible from subsequences of two given arrays
16, Nov 20
Split an array into equal length subsequences consisting of equal elements only
13, Jan 21
Maximum length of the sub-array whose first and last elements are same
19, Feb 19
Find Maximum Length Of A Square Submatrix Having Sum Of Elements At-Most K
09, Jan 20
Maximum sum of Bitwise XOR of all elements of two equal length subsets
21, Aug 20
Maximum length subsequence with difference between adjacent elements as either 0 or 1
01, Sep 17
Maximum length subarray with difference between adjacent elements as either 0 or 1
18, Feb 19
Maximum distinct prime factors of elements in a K-length subarray
27, Sep 20
Repeated subsequence of length 2 or more
22, Jun 16
Divide array in two maximum equal length arrays of similar and dissimilar elements
30, Apr 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
kaustavbhattachaarya
@kaustavbhattachaarya
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox