Contar todas las subsecuencias crecientes

Se nos da una array de dígitos (los valores se encuentran en el rango de 0 a 9). La tarea es contar todas las subsecuencias posibles en una array de modo que en cada subsecuencia cada dígito sea mayor que sus dígitos anteriores en la subsecuencia.

Ejemplos: 

Input : arr[] = {1, 2, 3, 4}
Output: 15
There are 15 increasing subsequences
{1}, {2}, {3}, {4}, {1,2}, {1,3}, {1,4}, 
{2,3}, {2,4}, {3,4}, {1,2,3}, {1,2,4}, 
{1,3,4}, {2,3,4}, {1,2,3,4}

Input : arr[] = {4, 3, 6, 5}
Output: 8
Sub-sequences are {4}, {3}, {6}, {5}, 
{4,6}, {4,5}, {3,6}, {3,5}

Input : arr[] = {3, 2, 4, 5, 4}
Output : 14
Sub-sequences are {3}, {2}, {4}, {3,4},
{2,4}, {5}, {3,5}, {2,5}, {4,5}, {3,2,5}
{3,4,5}, {4}, {3,4}, {2,4}

Una solución simple es usar la solución de programación dinámica del problema de la subsecuencia creciente más larga (LIS) . Al igual que el problema LIS , primero calculamos el recuento de subsecuencias crecientes que terminan en cada índice. Finalmente, devolvemos la suma de todos los valores (en el problema LCS, devolvemos el máximo de todos los valores).

// We count all increasing subsequences ending at every 
// index i
subCount(i) = Count of increasing subsequences ending 
              at arr[i]. 

// Like LCS, this value can be recursively computed
subCount(i) = 1 + ∑ subCount(j) 
              where j is index of all elements
              such that arr[j] < arr[i] and j < i.
1 is added as every element itself is a subsequence
of size 1.

// Finally we add all counts to get the result.
Result = ∑ subCount(i)
         where i varies from 0 to n-1.

Ilustración: 

For example, arr[] = {3, 2, 4, 5, 4}

// There are no smaller elements on left of arr[0] 
// and arr[1]
subCount(0) = 1
subCount(1) = 1  

// Note that arr[0] and arr[1] are smaller than arr[2]
subCount(2) = 1 + subCount(0) + subCount(1)  = 3

subCount(3) = 1 + subCount(0) + subCount(1) + subCount(2) 
            = 1 + 1 + 1 + 3
            = 6
  
subCount(3) = 1 + subCount(0) + subCount(1)
            = 1 + 1 + 1
            = 3
                             
Result = subCount(0) + subCount(1) + subCount(2) + subCount(3)
       = 1 + 1 + 3 + 6 + 3
       = 14.

Complejidad de Tiempo : O(n ² ) 
Espacio Auxiliar : O(n)

Consulte esto para la implementación.

Método 2 (eficiente) 

La solución anterior no usa el hecho de que solo tenemos 10 valores posibles en una array dada. Podemos usar este hecho usando una array count[] tal que count[d] almacene dígitos de conteo actuales más pequeños que d. 

For example, arr[] = {3, 2, 4, 5, 4}

// We create a count array and initialize it as 0.
count[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0}

// Note that here value is used as index to store counts
count[3] += 1  // i = 0, arr[0] = 3
          = 1    
count[2] += 1  // i = 1, arr[1] = 2
          = 1
          
// Let us compute count for arr[2] which is 4
count[4] += 1 + count[3] + count[2] 
         += 1 + 1 + 1  
         = 3

// Let us compute count for arr[3] which is 5
count[5] += 1 + count[3] + count[2] + count[4] 
         += 1 + 1 + 1 + 3
         = 6

// Let us compute count for arr[4] which is 4
count[4] += 1 + count[0] + count[1]
         += 1 + 1 + 1
         += 3
         = 3 + 3
         = 6
            
Note that count[] = {0, 0, 1, 1, 6, 6, 0, 0, 0, 0}                  
Result = count[0] + count[1] + ... + count[9]
       = 1 + 1 + 6 + 6 {count[2] = 1, count[3] = 1
                        count[4] = 6, count[5] = 6} 
       = 14

A continuación se muestra la implementación de la idea anterior. 

// C++ program to count increasing subsequences
// in an array of digits.
#include<bits/stdc++.h>
using namespace std;
 
// Function To Count all the sub-sequences
// possible in which digit is greater than
// all previous digits arr[] is array of n
// digits
int countSub(int arr[], int n)
{
    // count[] array is used to store all sub-
    // sequences possible using that digit
    // count[] array covers all the digit
    // from 0 to 9
    int count[10] = {0};
 
    // scan each digit in arr[]
    for (int i=0; i<n; i++)
    {
        // count all possible sub-sequences by
        // the digits less than arr[i] digit
        for (int j=arr[i]-1; j>=0; j--)
            count[arr[i]] += count[j];
 
        // store sum of all sub-sequences plus
        // 1 in count[] array
        count[arr[i]]++;
    }
 
    // now sum up the all sequences possible in
    // count[] array
    int result = 0;
    for (int i=0; i<10; i++)
        result += count[i];
 
    return result;
}
 
// Driver program to run the test case
int main()
{
    int arr[] = {3, 2, 4, 5, 4};
    int n = sizeof(arr)/sizeof(arr[0]);
 
    cout << countSub(arr,n);
    return 0;
}

// Java program to count increasing
// subsequences in an array of digits.
import java.io.*;
 
class GFG {
 
    // Function To Count all the sub-sequences
    // possible in which digit is greater than
    // all previous digits arr[] is array of n
    // digits
    static int countSub(int arr[], int n)
    {
        // count[] array is used to store all
        // sub-sequences possible using that
        // digit count[] array covers all
        // the digit from 0 to 9
        int count[] = new int[10]; 
 
        // scan each digit in arr[]
        for (int i = 0; i < n; i++)
        {
            // count all possible sub-
            // sequences by the digits
            // less than arr[i] digit
            for (int j = arr[i] - 1; j >= 0; j--)
                count[arr[i]] += count[j]; 
                 
            // store sum of all sub-sequences
            // plus 1 in count[] array
            count[arr[i]]++;
        }  
 
        // now sum up the all sequences
        // possible in count[] array
        int result = 0;
        for (int i = 0; i < 10; i++)
            result += count[i];
 
        return result;
    }
 
    // Driver program to run the test case
    public static void main(String[] args)
    {
        int arr[] = {3, 2, 4, 5, 4};
        int n = arr.length;
 
        System.out.println(countSub(arr,n));
    }
}
// This code is contributed by Prerna Saini

# Python3 program to count increasing
# subsequences in an array of digits.
 
# Function To Count all the sub-
# sequences possible in which digit
# is greater than all previous digits
# arr[] is array of n digits
def countSub(arr, n):
 
    # count[] array is used to store all
    # sub-sequences possible using that
    # digit count[] array covers all the
    # digit from 0 to 9
    count = [0 for i in range(10)]
 
    # scan each digit in arr[]
    for i in range(n):
     
        # count all possible sub-sequences by
        # the digits less than arr[i] digit
        for j in range(arr[i] - 1, -1, -1):
            count[arr[i]] += count[j]
 
        # store sum of all sub-sequences
        # plus 1 in count[] array
        count[arr[i]] += 1
     
 
    # Now sum up the all sequences
    # possible in count[] array
    result = 0
    for i in range(10):
        result += count[i]
 
    return result
 
# Driver Code
arr = [3, 2, 4, 5, 4]
n = len(arr)
print(countSub(arr, n))
 
# This code is contributed by Anant Agarwal.

// C# program to count increasing
// subsequences in an array of digits.
using System;
class GFG {
 
    // Function To Count all the sub-sequences
    // possible in which digit is greater than
    // all previous digits arr[] is array of n
    // digits
    static int countSub(int []arr, int n)
    {
        // count[] array is used to store all
        // sub-sequences possible using that
        // digit count[] array covers all
        // the digit from 0 to 9
        int []count = new int[10]; 
 
        // scan each digit in arr[]
        for (int i = 0; i < n; i++)
        {
            // count all possible sub-
            // sequences by the digits
            // less than arr[i] digit
            for (int j = arr[i] - 1; j >= 0; j--)
                count[arr[i]] += count[j]; 
                 
            // store sum of all sub-sequences
            // plus 1 in count[] array
            count[arr[i]]++;
        }  
 
        // now sum up the all sequences
        // possible in count[] array
        int result = 0;
        for (int i = 0; i < 10; i++)
            result += count[i];
 
        return result;
    }
 
    // Driver program
    public static void Main()
    {
        int []arr = {3, 2, 4, 5, 4};
        int n = arr.Length;
 
        Console.WriteLine(countSub(arr,n));
    }
}
// This code is contributed by Anant Agarwal.

<script>
 
// Javascript program to count increasing
// subsequences in an array of digits.
 
// Function To Count all the sub-sequences
// possible in which digit is greater than
// all previous digits arr[] is array of n
// digits
function countSub(arr, n)
{
     
    // count[] array is used to store all sub-
    // sequences possible using that digit
    // count[] array covers all the digit
    // from 0 to 9
    let count = new Array(10).fill(0);
 
    // Scan each digit in arr[]
    for(let i = 0; i < n; i++)
    {
         
        // Count all possible sub-sequences by
        // the digits less than arr[i] digit
        for(let j = arr[i] - 1; j >= 0; j--)
            count[arr[i]] += count[j];
 
        // Store sum of all sub-sequences plus
        // 1 in count[] array
        count[arr[i]]++;
    }
 
    // Now sum up the all sequences possible in
    // count[] array
    let result = 0;
    for(let i = 0; i < 10; i++)
        result += count[i];
 
    return result;
}
 
// Driver code
let arr = [ 3, 2, 4, 5, 4 ];
let n = arr.length;
 
document.write(countSub(arr, n));
 
// This code is contributed by _saurabh_jaiswal
 
</script>

14

Complejidad de tiempo: O (n) Tenga en cuenta que el ciclo interno se ejecuta como máximo 10 veces. 
Espacio auxiliar: O (1) Tenga en cuenta que el conteo tiene como máximo 10 elementos.

Este artículo es una contribución de Shashank Mishra (Gullu) . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.