📜  计算大小为 k 的递增子序列的数量

📅  最后修改于: 2021-09-22 09:40:22             🧑  作者: Mango

给定一个包含n 个整数的数组arr[] 。问题是计算大小为k的数组中递增子序列的数量。
例子:

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

方法:这个想法是通过定义二维矩阵来使用动态规划,比如 dp[][]。 dp[i][j]存储以元素arr[j]结尾的大小为i的递增子序列的计数。所以 dp[i][j] 可以定义为:

下面是上述方法的实现:

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[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
int 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
//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


输出:

Number of Increasing Subsequences of size 4 = 39

时间复杂度: O(kn 2 )。
辅助空间: O(kn)。

如果您希望与专家一起参加现场课程,请参阅DSA 现场工作专业课程学生竞争性编程现场课程