Number of Longest Increasing Subsequences

Dynamic Programming LIS Easy

Given an integer array nums, find the number of Longest Increasing Subsequences (LIS) in the array.

Examples:

Input: nums = [1, 3, 5, 4, 7]

Output: 2

Explanation: There are two LIS of length 4:

[1, 3, 4, 7]

[1, 3, 5, 7].

Input: nums = [2, 2, 2, 2, 2]

Output: 5

Explanation: All elements are the same, so every single element can form an LIS of length 1. There are 5 such subsequences.

Input: nums = [10, 9, 2, 5, 3, 7, 101, 18]

Constraints

1 <= nums.length <= 10³
-10⁶ <= nums[i] <= 10⁶

Hints

"We solve this using Dynamic Programming (DP) with two arrays: dp[i] → The length of the longest increasing subsequence ending at index i. count[i] → The number of LIS ending at index i."
"For each index i, iterate over all j < i: If nums[j] < nums[i]: If dp[j] + 1 > dp[i], update dp[i] and reset count[i] = count[j]. If dp[j] + 1 == dp[i], add count[j] to count[i]. Finally, sum up all count[i] where dp[i] equals the maximum LIS length."

Editorial

Pre-requisite: Memoization approach to find the length of Longest Increasing Subsequence

Intuition:

The first step will be to create a DP table that will help in printing the Longest Increasing Subsequence.

Steps to convert recursive code to tabulation code:

Declare a dp array of size [n][n]: There are two states of dp which are:
- ind: which can go from 0 to n-1, requiring a total of n indices.
- prev_ind: which can go from -1 to n-2, requiring a total of (n-2 -(-1) +1) or n states.
Initialize all the values in the dp table to 0, as base case for all the subproblems will initially by zero.
Set Base Cases in the Table: In the recursive code, the base condition occurs when i == arr.size() - 1. At this point:
- If no element is picked yet (prevInd == -1) or the previous element in the subsequence is less than the current element (arr[prevInd] < arr[i]), the function returns 1.
For tabulation, this translates into filling the dp table for the last row (i == n-1):
- For every possible prevInd (from -1 to n-1), set the values based on the logic in the base condition.
Iterative Computation Using Loops:
- Use two nested loops:
  - The outer loop iterates over i from n-1 to 0 (bottom-up approach).
  - The inner loop iterates over prevInd from 0 to (i) (actually representing -1 to i-1).
- For each combination of i and prevInd, compute
  - Not Take case: Get the result when the current element is not included.
  - Take case: If the current element can be included (when prevInd == -1 or arr[prevInd] < arr[i]), compute the result by including it.
  - Store the maximum of the two cases in the dp[i][prevInd + 1] cell (adjusted to avoid negative indexing).
Final Result Extraction: After completing the loops, the answer will be stored in dp[0][-1+1] or dp[0][0], representing the maximum LIS length starting from index 0 with no previous element.

Note

If memory optimization is required, the 2D dp table can be reduced to a 1D array using space optimization techniques (based on only needing the previous row during computation).

Solution:

#include <bits/stdc++.h>
using namespace std;

class Solution {
public:
    int longestStrChain(vector<string>& words) {
        unordered_map<std::string, int> chains;  // Stores the max chain length for each word
        vector<std::string> sortedWords = words;
        sort(sortedWords.begin(), sortedWords.end(), [](const std::string& a, const std::string& b) {
            return a.length() < b.length();  // Sort words by length
        });

        for (const std::string& word : sortedWords) {
            chains[word] = 1;  // Initialize the chain length for the current word

            for (int i = 0; i < word.length(); i++) {
                std::string pred = word.substr(0, i) + word.substr(i + 1);  // Generate predecessor by removing one character
                if (chains.find(pred) != chains.end()) {
                    chains[word] = std::max(chains[word], chains[pred] + 1);
                }
            }
        }

        int maxChainLength = 0;
        for (const auto& entry : chains) {
            maxChainLength = std::max(maxChainLength, entry.second);
        }

        return maxChainLength;        
    }
};


int main() {
    vector<int> nums = {10, 9, 2, 5, 3, 7, 101, 18};
    
    // Creating an object of Solution class
    Solution sol;
    int lengthOfLIS = sol.LIS(nums);
    
    cout << "The length of the LIS for the given array is: " << lengthOfLIS << endl;
    
    return 0;
}
import java.util.*;

class Solution {
    public int longestStrChain(String[] words) {
        Map<String, Integer> chains = new HashMap<>();  // Stores the max chain length for each word
        String[] sortedWords = Arrays.copyOf(words, words.length);
        Arrays.sort(sortedWords, (a, b) -> a.length() - b.length());  // Sort words by length

        for (String word : sortedWords) {
            chains.put(word, 1);  // Initialize the chain length for the current word

            for (int i = 0; i < word.length(); i++) {
                String pred = word.substring(0, i) + word.substring(i + 1);  // Generate predecessor by removing one character
                if (chains.containsKey(pred)) {
                    chains.put(word, Math.max(chains.getOrDefault(word, 0), chains.get(pred) + 1));
                }
            }
        }

        int maxChainLength = chains.values().stream().mapToInt(Integer::intValue).max().orElse(0);
        return maxChainLength;        
    }
}

class Main {
    public static void main(String[] args) {
        int[] nums = {10, 9, 2, 5, 3, 7, 101, 18};
        
        // Creating an object of Solution class
        Solution sol = new Solution();
        int lengthOfLIS = sol.LIS(nums);
        
        System.out.println("The length of the LIS for the given array is: " + lengthOfLIS);
    }
}
class Solution:
    def longestStrChain(self, words: List[str]) -> int:
        chains = {}  # Stores the max chain length for each word
        sorted_words = sorted(words, key=len) # Sort words by length

        for word in sorted_words:
            chains[word] = 1  # Initialize the chain length for the current word
            
            for i in range(len(word)):
                # Generate predecessor by removing one character
                pred = word[:i] + word[i+1:]  
                if pred in chains:
                    chains[word] = max(chains[word], chains[pred] + 1)

        return max(chains.values())

# Example usage
nums = [10, 9, 2, 5, 3, 7, 101, 18]

# Creating an object of Solution class
sol = Solution()
lengthOfLIS = sol.LIS(nums)

print("The length of the LIS for the given array is:", lengthOfLIS)
var longestStrChain = function(words) {
    const chains = new Map();  // Stores the max chain length for each word
    const sortedWords = words.slice().sort((a, b) => a.length - b.length);  // Sort words by length

    for (const word of sortedWords) {
        chains.set(word, 1);  // Initialize the chain length for the current word

        for (let i = 0; i < word.length; i++) {
            const pred = word.slice(0, i) + word.slice(i + 1);  // Generate predecessor by removing one character
            if (chains.has(pred)) {
                chains.set(word, Math.max(chains.get(word) || 0, chains.get(pred) + 1));
            }
        }
    }

    return Math.max(...Array.from(chains.values()));  // Return the maximum chain length    
};

// Example usage
let nums = [10, 9, 2, 5, 3, 7, 101, 18];

// Creating an object of Solution class
let sol = new Solution();
let lengthOfLIS = sol.LIS(nums);

console.log("The length of the LIS for the given array is:", lengthOfLIS);

Complexity Analysis:

Time Complexity: O(N²), where N is the size of the array
Because there will be a total of N*N states for which the function will be called.

Space Complexity: O(N²), because of the 2D dp array created taking O(N²) space and O(N) recursive stack space.

Code

Problem List

Number of Longest Increasing Subsequences

Examples:

Constraints

Hints

Editorial

Intuition:

Steps to convert recursive code to tabulation code:

Note

Solution:

Complexity Analysis:

Complexity Analysis:

Frequently Occurring Doubts

Interview Followup Questions

Notes

Code