GATE-CS-2015(Set 1) Problem 19

This is a problem from the GATE Computer Science exam conducted in 2015. The problem involves analyzing a given sequence to determine certain properties of subsequences.

Problem Statement

Given a sequence of n numbers, design an algorithm that determines whether it contains a contiguous subsequence of length at least 3 in which the values form a strictly increasing sequence (not necessarily consecutive in the original sequence). The algorithm should run in O(n) time.

Approach

To solve this problem, we will use a sliding window approach. We will maintain two pointers, left and right, representing the left and right boundaries of the current subsequence. We will also maintain a variable count representing the length of the current subsequence.

We will start by initializing left, right, and count to 0. Then, we will iterate over the sequence, incrementing right and count at each step. If the value at right is greater than the value at right - 1, we know that the subsequence is still increasing, so we can continue to the next iteration.

If the value at right is not greater than the value at right - 1, we know that the subsequence is no longer increasing, so we need to reset left and count and start a new subsequence at right. We can do this by setting left to right - 1 and count to 2 (since we know that there are at least two values in the new subsequence).

At each iteration, we will also check if count is greater than or equal to 3. If it is, we know that we have found a contiguous subsequence of length at least 3 that is strictly increasing, so we can return True.

If we reach the end of the sequence without finding such a subsequence, we can return False.

Here is the Python code for the algorithm:

def find_increasing_subsequence(seq):
    left = right = count = 0
    n = len(seq)
    while right < n:
        if right > 0 and seq[right] <= seq[right - 1]:
            left = right - 1
            count = 2
        else:
            count += 1
        if count >= 3:
            return True
        right += 1
    return False

Complexity Analysis

The time complexity of this algorithm is O(n), since we iterate over the sequence exactly once. The space complexity is O(1), since we only use constant extra memory to store the variables left, right, count, and n. Therefore, this algorithm meets the requirements specified in the problem statement.

Conclusion

In this problem, we have seen how to use a sliding window approach to solve a problem involving subsequences. This approach is often useful when we need to examine contiguous subsequences of a sequence and can be used to solve a wide variety of problems.