Count number of increasing subsequences of size k

• Difficulty Level : Hard
• Last Updated : 01 Oct, 2021

Given an array arr[] containing n integers. The problem is to count number of increasing subsequences in the array of size k.

Examples:

Input : arr[] = {2, 6, 4, 5, 7},
k = 3
Output : 5
The subsequences of size '3' are:
{2, 6, 7}, {2, 4, 5}, {2, 4, 7},
{2, 5, 7} and {4, 5, 7}.

Input : arr[] = {12, 8, 11, 13, 10, 15, 14, 16, 20},
k = 4
Output : 39

Approach: The idea is to use Dynamic Programming by define 2D matrix, say dp[][]. dp[i][j] stores the count of increasing subsequences of size i ending with element arr[j]. So dp[i][j] can be defined as:

dp[i][j] = 1, where i = 1 and 1 <= j <= n
dp[i][j] = sum(dp[i-1][j]), where 1 < i <= k, i <= j <= n and arr[m] < arr[j] for (i-1) <= m < j.

Below is the implementation of above approach:

C++

 // C++ implementation to count number of// increasing subsequences of size k#include  using namespace std; // function to count number of increasing// subsequences of size kint numOfIncSubseqOfSizeK(int arr[], int n, int k){    int dp[k][n], sum = 0;    memset(dp, 0, sizeof(dp));     // count of increasing subsequences of size 1    // ending at each arr[i]    for (int i = 0; i < n; i++)        dp[i] = 1;     // building up the matrix dp[][]    // Here 'l' signifies the size of    // increasing subsequence of size (l+1).    for (int l = 1; l < k; l++) {         // for each increasing subsequence of size 'l'        // ending with element arr[i]        for (int i = l; i < n; i++) {             // count of increasing subsequences of size 'l'            // ending with element arr[i]            dp[l][i] = 0;            for (int j = l - 1; j < i; j++) {                if (arr[j] < arr[i])                    dp[l][i] += dp[l - 1][j];            }        }    }     // sum up the count of increasing subsequences of    // size 'k' ending at each element arr[i]    for (int i = k - 1; i < n; i++)        sum += dp[k - 1][i];     // required number of increasing    // subsequences of size k    return sum;} // Driver program to test aboveint main(){    int arr[] = { 12, 8, 11, 13, 10, 15, 14, 16, 20 };    int n = sizeof(arr) / sizeof(arr);    int k = 4;     cout << "Number of Increasing Subsequences of size "         << k << " = " << numOfIncSubseqOfSizeK(arr, n, k);     return 0;}

Java

 //Java implementation to count number of// increasing subsequences of size k class GFG { // function to count number of increasing// subsequences of size k    static int numOfIncSubseqOfSizeK(int arr[], int n, int k) {        int dp[][] = new int[k][n], sum = 0;         // count of increasing subsequences of size 1        // ending at each arr[i]        for (int i = 0; i < n; i++) {            dp[i] = 1;        }         // building up the matrix dp[][]        // Here 'l' signifies the size of        // increasing subsequence of size (l+1).        for (int l = 1; l < k; l++) {             // for each increasing subsequence of size 'l'            // ending with element arr[i]            for (int i = l; i < n; i++) {                 // count of increasing subsequences of size 'l'                // ending with element arr[i]                dp[l][i] = 0;                for (int j = l - 1; j < i; j++) {                    if (arr[j] < arr[i]) {                        dp[l][i] += dp[l - 1][j];                    }                }            }        }         // sum up the count of increasing subsequences of        // size 'k' ending at each element arr[i]        for (int i = k - 1; i < n; i++) {            sum += dp[k - 1][i];        }         // required number of increasing        // subsequences of size k        return sum;    } // Driver program to test above    public static void main(String[] args) {        int arr[] = {12, 8, 11, 13, 10, 15, 14, 16, 20};        int n = arr.length;        int k = 4;         System.out.print("Number of Increasing Subsequences of size "                + k + " = " + numOfIncSubseqOfSizeK(arr, n, k));     }}// This code is contributed by 29AjayKumar

Python3

 # Python3 implementation to count number# of increasing subsequences of size kimport math as mt # function to count number of increasing# subsequences of size kdef numOfIncSubseqOfSizeK(arr, n, k):     dp = [[0 for i in range(n)]             for i in range(k)]                  # count of increasing subsequences    # of size 1 ending at each arr[i]    for i in range(n):        dp[i] = 1     # building up the matrix dp[][]    # Here 'l' signifies the size of    # increasing subsequence of size (l+1).    for l in range(1, k):         # for each increasing subsequence of        # size 'l' ending with element arr[i]        for i in range(l, n):             # count of increasing subsequences of            # size 'l' ending with element arr[i]            dp[l][i] = 0            for j in range(l - 1, i):                if (arr[j] < arr[i]):                    dp[l][i] += dp[l - 1][j]                 # Sum up the count of increasing subsequences    # of size 'k' ending at each element arr[i]    Sum = 0    for i in range(k - 1, n):        Sum += dp[k - 1][i]     # required number of increasing    # subsequences of size k    return Sum # Driver Codearr = [12, 8, 11, 13, 10,          15, 14, 16, 20 ]n = len(arr)k = 4 print("Number of Increasing Subsequences of size",         k, "=", numOfIncSubseqOfSizeK(arr, n, k)) # This code is contributed by# Mohit kumar 29

C#

 // C# implementation to count number of// increasing subsequences of size k  using System;                     public class GFG {  // function to count number of increasing// subsequences of size k    static int numOfIncSubseqOfSizeK(int []arr, int n, int k) {        int [,]dp = new int[k,n]; int sum = 0;          // count of increasing subsequences of size 1        // ending at each arr[i]        for (int i = 0; i < n; i++) {            dp[0,i] = 1;        }          // building up the matrix dp[,]        // Here 'l' signifies the size of        // increasing subsequence of size (l+1).        for (int l = 1; l < k; l++) {              // for each increasing subsequence of size 'l'            // ending with element arr[i]            for (int i = l; i < n; i++) {                  // count of increasing subsequences of size 'l'                // ending with element arr[i]                dp[l,i] = 0;                for (int j = l - 1; j < i; j++) {                    if (arr[j] < arr[i]) {                        dp[l,i] += dp[l - 1,j];                    }                }            }        }          // sum up the count of increasing subsequences of        // size 'k' ending at each element arr[i]        for (int i = k - 1; i < n; i++) {            sum += dp[k - 1,i];        }          // required number of increasing        // subsequences of size k        return sum;    }  // Driver program to test above    public static void Main() {        int []arr = {12, 8, 11, 13, 10, 15, 14, 16, 20};        int n = arr.Length;        int k = 4;          Console.Write("Number of Increasing Subsequences of size "                + k + " = " + numOfIncSubseqOfSizeK(arr, n, k));      }}// This code is contributed by 29AjayKumar



Javascript



Output:

Number of Increasing Subsequences of size 4 = 39

Time Complexity: O(kn2).
Auxiliary Space: O(kn).

My Personal Notes arrow_drop_up