Longest Continuous Increasing Subsequence

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

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;
    }
}