# Solving Leetcode Interviews in Seconds with AI: Longest Increasing Subsequence


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "300" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> Given an integer array nums, return the length of the longest strictly increasing subsequence.   Example 1:  Input: nums = [10,9,2,5,3,7,101,18] Output: 4 Explanation: The longest increasing subsequence is [2,3,7,101], therefore the length is 4.  Example 2:  Input: nums = [0,1,0,3,2,3] Output: 4  Example 3:  Input: nums = [7,7,7,7,7,7,7] Output: 1    Constraints:  1 <= nums.length <= 2500 -104 <= nums[i] <= 104    Follow up: Can you come up with an algorithm that runs in O(n log(n)) time complexity? 

	# Explanation
	Here's the breakdown of the approach, complexities, and the Python code:

*   **High-Level Approach:**
    *   Use dynamic programming with a "tails" array. The `tails` array stores the smallest tail of all increasing subsequences of a given length.
    *   Iterate through the input `nums` array. For each number, either extend the longest increasing subsequence found so far (if the number is larger than the current tail) or update a tail within the `tails` array using binary search to maintain the smallest possible tail for each subsequence length.
    *   The length of the `tails` array at the end represents the length of the longest increasing subsequence.

*   **Complexity:**
    *   Runtime Complexity: O(n log n)
    *   Storage Complexity: O(n)

	
	# Code
	```python
	def lengthOfLIS(nums):
    """
    Finds the length of the longest strictly increasing subsequence in an array.

    Args:
        nums: A list of integers.

    Returns:
        The length of the longest strictly increasing subsequence.
    """

    tails = []  # tails[i] is the smallest tail of all increasing subsequences with length i+1

    for num in nums:
        # If num is greater than all tails, extend the longest increasing subsequence.
        if not tails or num > tails[-1]:
            tails.append(num)
        else:
            # Binary search to find the smallest tail that is greater than or equal to num.
            l, r = 0, len(tails) - 1
            while l <= r:
                mid = (l + r) // 2
                if tails[mid] < num:
                    l = mid + 1
                else:
                    r = mid - 1
            # Replace the tail with num to potentially form a smaller tail for a subsequence of the same length.
            tails[l] = num

    return len(tails)
	```