We use cookies (including Google cookies) to personalize ads and analyze traffic. By continuing to use our site, you accept our Privacy Policy.

SimplyLeet
TagsDisclaimersPrivacyTermsContactAbout Us

Longest Increasing Subsequence II

Difficulty: Hard

Problem Description

You are given an integer array nums and an integer k. Find the longest subsequence of nums that is strictly increasing and has adjacent elements differing by at most k. Return the length of this longest subsequence.

Key Insights

  • A subsequence is derived by deleting elements while maintaining the order.
  • The subsequence must be strictly increasing.
  • The difference between adjacent elements in the subsequence must not exceed k.
  • This problem can be approached using dynamic programming along with efficient data structures to maintain the potential subsequences.

Space and Time Complexity

Time Complexity: O(n log n)
Space Complexity: O(n)

Solution

To solve the problem, we can utilize a dynamic programming approach combined with a binary search technique. The idea is to maintain an array that keeps track of the smallest end elements of all increasing subsequences of different lengths. For each element in the input array, we use binary search to determine its position in this array. If it can extend an existing subsequence, we update the end element; otherwise, we create a new subsequence. The length of this tracking array will yield the length of the longest valid subsequence.

Code Solutions

from bisect import bisect_right

def lengthOfLIS(nums, k):
    dp = []
    for num in nums:
        if not dp or num > dp[-1]:
            dp.append(num)
        else:
            pos = bisect_right(dp, num)
            if pos == len(dp) or num - dp[pos - 1] <= k:
                dp[pos] = num
    return len(dp)
← Back to All Questions