Number of Longest Increasing Subsequence - Practice Coding Problems

Number of Longest Increasing Subsequence - Problem

Given an integer array nums, find the longest increasing subsequence and return how many such sequences exist.

A subsequence is a sequence that can be derived from the array by deleting some or no elements without changing the order of the remaining elements. The sequence must be strictly increasing.

Example: In array [1, 3, 5, 4, 7], there are two longest increasing subsequences of length 4: [1, 3, 5, 7] and [1, 3, 4, 7], so the answer is 2.

This problem combines the classic Longest Increasing Subsequence challenge with a counting twist - you need to track not just the length, but also how many ways you can achieve that optimal length.

Input & Output

example_1.py — Basic Case

$ Input: [1,3,5,4,7]

› Output: 2

💡 Note: Two longest increasing subsequences of length 4: [1,3,5,7] and [1,3,4,7]

example_2.py — Single Element

$ Input: [2,2,2,2,2]

› Output: 5

💡 Note: All elements are equal, so each single element forms a LIS of length 1. There are 5 such subsequences.

example_3.py — Strictly Increasing

$ Input: [1,2,3,4,5]

› Output: 1

💡 Note: Only one longest increasing subsequence: [1,2,3,4,5] with length 5

Visualization

Tap to expand

Understanding the Visualization

Initialize

Each block can form a tower of height 1 by itself

Extend Towers

For each new block, check which existing towers it can extend

Update Counts

Add up the number of ways to build towers of the new height

Find Maximum

Identify the tallest towers and count all ways to build them

Key Takeaway

🎯 Key Insight: Use dynamic programming to track both the maximum length and count of increasing subsequences ending at each position, then sum up counts for positions with the global maximum length.

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting and coordinate compression, O(n log n) for segment tree operations

⚡ Linearithmic

Space Complexity

O(n)

Space for coordinate mapping and segment tree structure

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 2000
-10⁶ ≤ nums[i] ≤ 10⁶
The subsequence must be strictly increasing

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 25

The optimal approach uses dynamic programming to track both the length of the longest increasing subsequence ending at each position and the count of such subsequences. For each element, we check all previous elements and either extend existing subsequences or start new ones, carefully maintaining the count of ways to achieve each length.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Coordinate Compression	O(n log n)	O(n)	Use coordinate compression and segment tree for efficient DP solution
Brute Force (Generate All Subsequences)	O(n * 2^n)	O(n)	Generate all possible subsequences, filter increasing ones, find max length and count

Dynamic Programming with Coordinate Compression — Algorithm Steps

Compress coordinates by sorting unique values and mapping to indices
Process elements from left to right
For each element, query the data structure for best length ending before current value
Update the data structure with current element's length and count
Return the count of subsequences with maximum length

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Arrays

Create arrays to track max length and count ending at each position

Fill DP Arrays

For each position, check all previous positions and update accordingly

Aggregate Result

Sum up counts for all positions with maximum length

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int findNumberOfLIS(int* nums, int n) {
    if (n == 0) return 0;
    if (n == 1) return 1;
    
    int* lengths = (int*)malloc(n * sizeof(int));
    int* counts = (int*)malloc(n * sizeof(int));
    
    for (int i = 0; i < n; i++) {
        lengths[i] = 1;
        counts[i] = 1;
    }
    
    for (int i = 1; i < n; i++) {
        for (int j = 0; j < i; j++) {
            if (nums[j] < nums[i]) {
                if (lengths[j] + 1 > lengths[i]) {
                    lengths[i] = lengths[j] + 1;
                    counts[i] = counts[j];
                } else if (lengths[j] + 1 == lengths[i]) {
                    counts[i] += counts[j];
                }
            }
        }
    }
    
    int maxLength = 0;
    for (int i = 0; i < n; i++) {
        if (lengths[i] > maxLength) {
            maxLength = lengths[i];
        }
    }
    
    int result = 0;
    for (int i = 0; i < n; i++) {
        if (lengths[i] == maxLength) {
            result += counts[i];
        }
    }
    
    free(lengths);
    free(counts);
    return result;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    scanf("%c", &c); // Skip '['
    while (scanf("%d%c", &nums[n], &c)) {
        n++;
        if (c == ']') break;
    }
    printf("%d\n", findNumberOfLIS(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

O(n log n) for sorting and coordinate compression, O(n log n) for segment tree operations

⚡ Linearithmic

Space Complexity

O(n)

Space for coordinate mapping and segment tree structure

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 2000
-10⁶ ≤ nums[i] ≤ 10⁶
The subsequence must be strictly increasing

67.0K Views

High Frequency

~25 min Avg. Time

1.9K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming with Coordinate Compression — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler