feat(algorithms, dynamic-programming): longest increasing subsequence

Author: BrianLusina

algorithms/dynamic_programming/longest_increasing_subsequence/README.md

@@ -41,3 +41,75 @@ Explanation: The longest increasing subsequence is {3, 7, 40, 80}
 - Array
 - Binary Search
 - Dynamic Programming
+- Binary Indexed Tree
+- Segment Tree
+
+---
+# Number of Longest Increasing Subsequence
+
+Given an integer array nums, return the number of longest increasing subsequences.
+
+Notice that the sequence has to be strictly increasing.
+
+## Examples
+
+Example 1:
+```text
+Input: nums = [1,3,5,4,7]
+Output: 2
+Explanation: The two longest increasing subsequences are [1, 3, 4, 7] and [1, 3, 5, 7].
+```
+
+Example 2:
+```text
+Input: nums = [2,2,2,2,2]
+Output: 5
+Explanation: The length of the longest increasing subsequence is 1, and there are 5 increasing subsequences of length 1,
+so output 5.
+```
+
+## Related Topics
+
+- Array
+- Dynamic Programming
+- Binary Indexed Tree
+- Segment Tree
+
+## Solution
+
+The key intuition behind this algorithm is that for every position in the array, we figure out two things: the length of
+the longest increasing subsequence that ends there, and how many such subsequences exist. By looking at all earlier
+elements, we extend any subsequence that can grow by placing the current number at the end. Each time we form a longer
+subsequence, we update both its length and its count, and if we find another way to reach the same length, we add those
+counts as well. In the end, the longest subsequence length across all positions is known, and by summing how many
+subsequences achieve that length, we determine the total number of longest increasing subsequences.
+
+Using the intuition above, we implement the algorithm as follows:
+
+1. Start by creating two arrays of the same size as the input: length to track the length of the longest increasing
+   subsequence ending at each index, and count to track how many such subsequences end at that index. Initialize both
+   arrays with 1 because every element alone forms an increasing subsequence of length 1
+2. Initialize a variable, maxLen, with 1 to track the longest subsequence length found so far.
+3. Iterate through each element in the array using index i. For each i:
+   - Check all previous elements using index j, where j is less than i.
+     - For each pair, check if nums[j] is less than nums[i]. If so:
+       - If extending the subsequence from j creates a longer subsequence than what is currently recorded for i:
+         - Update the length at i to be length[j] + 1.
+         - Update count[i] to count[j] because all subsequences ending at j now extend to i.
+       - Otherwise, if extending from j produces a subsequence of the same length as the best known for i:
+         - Add count[j] to count[i]. This accumulates all valid ways to produce the same LIS length ending at i.
+   - After processing all j for index i, update maxLen if length[i] is larger.
+4. Initialize a variable, result, with 0 to accumulate the final count.
+5. Scan through the length array to identify the indexes that achieved the maximum LIS length:
+   - If length[i] equals maxLen, add count[i] to result.
+6. Return result as the total number of longest increasing subsequences.
+
+### Time Complexity
+
+The algorithm’s time complexity is O(n^2), where n is the number of elements in nums. This is because for each element
+in the array, we compare it with all previous elements to determine whether it can extend an increasing subsequence.
+This results in a nested loop over the input size n.
+
+### Space Complexity
+
+The algorithm’s space complexity is O(n) because we use two additional arrays, length and count, each of size n.

algorithms/dynamic_programming/longest_increasing_subsequence/__init__.py

@@ -20,3 +20,38 @@ def longest_increasing_subsequence(nums: List[int]) -> int:
             piles.append(num)
 
     return len(piles)
+
+
+def find_number_of_lis(nums: List[int]) -> int:
+    n = len(nums)
+    # length[i]: length of the LIS ending at i
+    # count[i]: number of LIS of that length ending at i
+    length = [1] * n
+    count = [1] * n
+
+    # Try to build LIS ending at each index i
+    for i in range(n):
+        # Check all previous positions j < i
+        for j in range(i):
+            # Can nums[i] extend an increasing subsequence from j?
+            if nums[j] < nums[i]:
+                # Found a strictly longer subsequence ending at i
+                if length[j] + 1 > length[i]:
+                    length[i] = length[j] + 1
+                    # inherit all ways ending at j
+                    count[i] = 0
+                # Found another way to reach the same LIS length at i
+                if length[j] + 1 == length[i]:
+                    # accumulate all valid paths
+                    count[i] += count[j]
+
+    # Update global maximum LIS length
+    max_length = max(length)
+    result = 0
+
+    # Sum counts of all positions that achieve the LIS length
+    for i in range(n):
+        if length[i] == max_length:
+            result += count[i]
+    # total number of longest increasing subsequences
+    return result

algorithms/dynamic_programming/longest_increasing_subsequence/test_longest_increasing_subsequence.py

@@ -1,63 +1,37 @@
 import unittest
-
-from . import longest_increasing_subsequence
+from typing import List
+from parameterized import parameterized
+from algorithms.dynamic_programming.longest_increasing_subsequence import (
+    longest_increasing_subsequence,
+    find_number_of_lis,
+)
+
+LONGEST_INCREASING_SUBSEQUENCE_TEST = [
+    ([1, 2, 1, 5], 3),
+    ([0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15], 6),
+    ([3, 10, 2, 1, 20], 3),
+    ([3, 2], 1),
+    ([50, 3, 10, 7, 40, 80], 4),
+    ([10, 9, 2, 5, 3, 7, 101, 18], 4),
+    ([0, 1, 0, 3, 2, 3], 4),
+    ([7, 7, 7, 7, 7, 7, 7], 1),
+]
+
+FIND_NUMBER_OF_LONGEST_INCREASING_SUBSEQUENCE_TEST_CASES = [
+    ([1, 3, 5, 4, 7], 2),
+    ([2, 2, 2, 2, 2], 5),
+]
 
 
 class LongestIncreasingSubsequenceTestCase(unittest.TestCase):
-    def test_1(self):
-        """should return 3 from input of [1, 2, 1, 5]"""
-        nums = [1, 2, 1, 5]
-        expected = 3
-        actual = longest_increasing_subsequence(nums)
-        self.assertEqual(expected, actual)
-
-    def test_2(self):
-        """should return 6 from input of [0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15]"""
-        nums = [0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15]
-        expected = 6
-        actual = longest_increasing_subsequence(nums)
-        self.assertEqual(expected, actual)
-
-    def test_3(self):
-        """should return 3 from input of [3, 10, 2, 1, 20]"""
-        nums = [3, 10, 2, 1, 20]
-        expected = 3
-        actual = longest_increasing_subsequence(nums)
-        self.assertEqual(expected, actual)
-
-    def test_4(self):
-        """should return 1 from input of [3, 2]"""
-        nums = [3, 2]
-        expected = 1
+    @parameterized.expand(LONGEST_INCREASING_SUBSEQUENCE_TEST)
+    def test_longest_increasing_subsequence(self, nums: List[int], expected: int):
         actual = longest_increasing_subsequence(nums)
         self.assertEqual(expected, actual)
 
-    def test_5(self):
-        """should return 4 from input of [50, 3, 10, 7, 40, 80]"""
-        nums = [50, 3, 10, 7, 40, 80]
-        expected = 4
-        actual = longest_increasing_subsequence(nums)
-        self.assertEqual(expected, actual)
-
-    def test_6(self):
-        """should return 4 from input of [10,9,2,5,3,7,101,18]"""
-        nums = [10, 9, 2, 5, 3, 7, 101, 18]
-        expected = 4
-        actual = longest_increasing_subsequence(nums)
-        self.assertEqual(expected, actual)
-
-    def test_7(self):
-        """should return 4 from input of [0,1,0,3,2,3]"""
-        nums = [0, 1, 0, 3, 2, 3]
-        expected = 4
-        actual = longest_increasing_subsequence(nums)
-        self.assertEqual(expected, actual)
-
-    def test_8(self):
-        """should return 4 from input of [7,7,7,7,7,7,7]"""
-        nums = [7, 7, 7, 7, 7, 7, 7]
-        expected = 1
-        actual = longest_increasing_subsequence(nums)
+    @parameterized.expand(FIND_NUMBER_OF_LONGEST_INCREASING_SUBSEQUENCE_TEST_CASES)
+    def test_find_number_of_lis(self, nums: List[int], expected: int):
+        actual = find_number_of_lis(nums)
         self.assertEqual(expected, actual)