Longest Continuous Increasing Subsequence

Updated on 09 June, 2025
Longest Continuous Increasing Subsequence header image

Problem Statement

In practical programming scenarios, such as analyzing trends in a time series dataset, one common task might be to identify the longest sequence within an array where each element successively increases. Think of situations like tracking consecutive days of rising stock prices to evaluate momentum. This problem specifically addresses a variation of this challenge. Here, we need to determine the maximum length of a strictly increasing continuous subsequence from an unsorted array of integers, nums.

A continuous increasing subsequence is clearly defined by identifying any two indices, l and r (l < r), that derive a sequence starting at nums[l] and ending at nums[r], such that each integer in this subarray follows an increasing trend directly from its predecessor. That is, for any index i which lies between l and r inclusive, the value at nums[i] must be strictly less than the value at nums[i + 1].

Examples

Example 1

Input:

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

Output:

3

Explanation:

The longest continuous increasing subsequence is [1,3,5] with length 3.
Even though [1,3,5,7] is an increasing subsequence, it is not continuous as elements 5 and 7 are separated by element
4.

Example 2

Input:

nums = [2,2,2,2,2]

Output:

1

Explanation:

The longest continuous increasing subsequence is [2] with length 1. Note that it must be strictly
increasing.

Constraints

  • 1 <= nums.length <= 104
  • -109 <= nums[i] <= 109

Approach and Intuition

Analyzing the problem and examples provided, detecting the longest continuous increasing subsequence within an unsorted list implies a traversal and comparison operation to dynamically determine lengths of increasing sequences as they appear. Here are the intuitive steps:

  1. Initialize max_length to remember the longest length found.
  2. Start with current_length at 1 as each individual element is itself a trivial increasing sequence.
  3. Iterate through the list nums from the second element:
    • Compare the current element with the previous one:
      • If the current element is greater than the previous, it's part of an increasing sequence, thus increment current_length.
      • Else, update max_length with current_length if the former is smaller, then reset current_length to 1 since we start a new sequence.
  4. Ensure to update max_length once more after the loop if the longest sequence appears at the end of the list.

The approach's efficiency hinges on a single traversal of the list, leading to an O(n) time complexity, where n is the number of elements in the array. This single pass efficiently updates both lengths and compares them to find the required maximal sequence length, aligning well with the given constraints.

Solutions

  • Java
java
class Solution {
    public int longestContinuousIncreasingSubsequence(int[] arr) {
        int maxLength = 0, start = 0;
        for (int index = 0; index < arr.length; ++index) {
            if (index > 0 && arr[index-1] >= arr[index]) start = index;
            maxLength = Math.max(maxLength, index - start + 1);
        }
        return maxLength;
    }
}

The provided Java solution efficiently calculates the length of the longest continuous increasing subsequence in an array. Here’s a concise explanation of how the solution functions:

  • Initialize maxLength to 0 to keep track of the maximum length of any increasing subsequence found.
  • Initialize start to 0 to mark the beginning of a new potential increasing subsequence.
  • Iterate through the array using a loop. For each element:
    • Check if the current element is smaller than or equal to the previous element. If true, set start to the current index to mark a new beginning for an increasing subsequence.
    • Update maxLength using the Math.max function by comparing it with the difference between the current index and the start index plus one, representing the length of the current increasing subsequence.
  • After the loop completes, return maxLength as it now holds the length of the longest continuous increasing subsequence found in the array.

This approach ensures a linear time complexity, making it efficient for handling large arrays.

Comments

No comments yet.