Count number of increasing subsequences of size k - GeeksforGeeks

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++
Java
Python3
C#
PHP
Javascript
// C++ implementation to count number of// increasing subsequences of size k#include <bits/stdc++.h> 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[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 aboveint main(){    int arr[] = { 12, 8, 11, 13, 10, 15, 14, 16, 20 };    int n = sizeof(arr) / sizeof(arr[0]);    int k = 4;     cout << "Number of Increasing Subsequences of size "         << k << " = " << numOfIncSubseqOfSizeK(arr, n, k);     return 0;}
//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        // 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 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[0][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# 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
<?php// PHP implementation to count// number of increasing// subsequences of size k // function to count number// of increasing subsequences// of size kfunction numOfIncSubseqOfSizeK($arr,                               $n, $k){    $dp = array(array());    $sum = 0;    $dp = array_fill(0, $n + 1, false);     // count of increasing    // subsequences of size 1    // ending at each arr[i]    for ($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 ($l = 1; $l < $k; $l++)    {         // for each increasing        // subsequence of size 'l'        // ending with element arr[i]        for ($i = $l; $i < $n; $i++)        {             // count of increasing            // subsequences of size 'l'            // ending with element arr[i]            $dp[$l][$i] = 0;            for ($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 ($i = $k - 1; $i < $n; $i++)        $sum += $dp[$k - 1][$i];     // required number of increasing    // subsequences of size k    return $sum;} // Driver Code$arr = array(12, 8, 11, 13,             10, 15, 14, 16, 20);$n = sizeof($arr);$k = 4; echo "Number of Increasing ".     "Subsequences of size ",                 $k , " = " ,     numOfIncSubseqOfSizeK($arr,                           $n, $k); // This code is contributed// by akt_mit?>
<script> // JavaScript implementation to count number of// increasing subsequences of size k // function to count number of increasing// subsequences of size k    function numOfIncSubseqOfSizeK(arr, n, k)    {        let dp = new Array(k), sum = 0;                 // Loop to create 2D array using 1D array        for (let i = 0; i < dp.length; i++) {            dp[i] = new Array(2);        }           // count of increasing subsequences of size 1        // ending at each arr[i]        for (let 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 (let l = 1; l < k; l++) {               // for each increasing subsequence of size 'l'            // ending with element arr[i]            for (let i = l; i < n; i++) {                   // count of increasing subsequences of size 'l'                // ending with element arr[i]                dp[l][i] = 0;                for (let 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 (let i = k - 1; i < n; i++) {            sum += dp[k - 1][i];        }           // required number of increasing        // subsequences of size k        return sum;    } // Driver code                     let arr = [12, 8, 11, 13, 10, 15, 14, 16, 20];        let n = arr.length;        let k = 4;           document.write("Number of Increasing Subsequences of size "                + k + " = " + numOfIncSubseqOfSizeK(arr, n, k));             </script>
Output: 
Number of Increasing Subsequences of size 4 = 39
Time Complexity: O(kn2). Auxiliary Space: O(kn). 
jit_t
29AjayKumar
mohit kumar 29
ManasChhabra2
splevel62
surindertarika1234
LIS
Arrays
Dynamic Programming
Arrays
Dynamic Programming
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Arrays
Multidimensional Arrays in Java
Linear Search
Linked List vs Array
Given an array A[] and a number x, check for pair in A[] with sum as x (aka Two Sum)
0-1 Knapsack Problem | DP-10
Program for Fibonacci numbers
Longest Common Subsequence | DP-4
Bellman–Ford Algorithm | DP-23
Floyd Warshall Algorithm | DP-16