Number of Longest Increasing Subsequences

Given an array arr[] of size N, the task is to count the number of longest increasing subsequences present in the given array.

Examples:

Input: arr[] = {2, 2, 2, 2, 2}
Output: 5
Explanation: The length of the longest increasing subsequence is 1, i.e. {2}. Therefore, count of longest increasing subsequences of length 1 is 5.

Input: arr[] = {1, 3, 5, 4, 7}
Output: 2
Explanation: The length of the longest increasing subsequence is 4, and there are 2 longest increasing subsequences of length 4, i.e. {1, 3, 4, 7} and {1, 3, 5, 7}.

Naive Approach: The simplest approach is to generate all possible subsequences present in the given array arr[] and count the increasing subsequences of maximum length. Print the count after checking all subsequences. 

Time Complexity: O(N*2^N)
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is to use Dynamic Programming as the above problem has overlapping subproblems that need to be calculated more than once, and to reduce that calculation use tabulation or memoization. Follow the steps below to solve the problem:

• Initialize two arrays dp_l[] and dp_c[] to store the length of the longest increasing subsequences and the count of the longest increasing subsequence at each index respectively.
• Iterate over the range [1, N – 1] using the variable i:
  • Iterate over the range [0, i – 1] using the variable j:
    • If arr[i] > arr[j] then check for the following cases:
              ~ If (dp_l[j]+1) greater than dp_l[i], then update dp_l[i] as dp_l[j] + 1 and dp_c[i] as dp_c[j]
              ~ Else if (dp_l[j] + 1) is the same as dp_l[i], then update dp_c[i] as dp_c[i] + dp_c[j].
• Find the maximum element in the array dp_l[] and store it in a variable max_length that will give the length of LIS.
• Initialize a variable count with 0 to store the number of the longest increasing subsequence.
• Traverse the array dp_l[] and if at any index idx, dp_l[idx] is the same as max_length then increment the count by dp_c[idx].
• After the above steps, print the value of count, which is the number of longest increasing subsequences in the given array.

Below is the implementation of the above approach:

2

Time Complexity: O(N²)
Auxiliary Space: O(N)

Segment Tree Approach

We can solve this problem using segment trees. The idea is to build a segment tree and then querying for the range [0,arr[i]-1]. The reason is arr[i] can append to any number which is less than it to make a increasing subsequence. 

For example if arr[i]=5, arr[i] can append after 0,1,2,3,4 to make increasing subsequence. This logic is what we will try to implement using a segment Tree. We will have a segment tree having nodes containing a pair. The pair contains the LIS length, ways ending at node. Our result would be at the root of the tree. 

We make the segment Tree using the maximum value in the array. If it is too large, then we need to step it down using RANKING method. For example, {9,1,4,2} and {3,0,2,1} have the same LIS counts. It is because if you observe, the ordering is the same. We can exploit this idea to minimize the space requirement in our segment Tree to just O(4*N), where N is the size of the array.

Let us briefly go over the implementation of ranking arrangement.

Given arr = [1,9,100,2,2]

Copy the arr in a new array temp and sort temp array

temp = [1,2,2,9,100]

Now, maintain a mx variable initialized to zero. Store the ]element , mx], if it not present in the map and increment mx.

Map -> 1 , 0

             2 , 1

             9 , 2

         100 , 3

Iterate on arr , and place the corresponding value from the map

arr = [0,2,3,1,1]

This is our new stepped down array. This technique is very useful when only the ordering of elements matter more than the value of element. 

Below is the implementation of the above approach:

2

Time Complexity: O(NlogN), logN query for N elements
Auxiliary Space: O(N)