Related Articles

# Count number of increasing subsequences of size k

• Difficulty Level : Hard
• Last Updated : 12 Apr, 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 k``int` `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``    ``// increassing 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``int` `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[``0``][i] = ``1``;``        ``}` `        ``// building up the matrix dp[][]``        ``// Here 'l' signifies the size of``        ``// increassing 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 k``import` `math as mt` `# function to count number of increasing``# subsequences of size k``def` `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[``0``][i] ``=` `1` `    ``# building up the matrix dp[][]``    ``# Here 'l' signifies the size of``    ``# increassing 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 Code``arr ``=` `[``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``        ``// increassing 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`

## PHP

 ``

## Javascript

 ``

Output:

`Number of Increasing Subsequences of size 4 = 39`

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

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