Longest Increasing Continuous Subsequence

Give an integer array，find the longest increasing continuous subsequence in this array.

An increasing continuous subsequence:

• Can be from right to left or from left to right.
• Indices of the integers in the subsequence should be continuous.

 Notice

O(n) time and O(1) extra space.

Example

For [5, 4, 2, 1, 3], the LICS is [5, 4, 2, 1], return 4.

For [5, 1, 2, 3, 4], the LICS is [1, 2, 3, 4], return 4.

Runtime: 29ms

class Solution {
public:
    /**
     * @param A an array of Integer
     * @return  an integer
     */
    int longestIncreasingContinuousSubsequence(vector<int>& A) {
        // Write your code here
        
        if (A.empty()) return 0;
        int result = 1;
        int leftMax = 1, rightMax = 1;
        for (int i = 1; i < A.size(); i++) {
            // from left to right
            if (A[i] > A[i - 1]) {
                leftMax++;
                rightMax = 1;
                result = max(result, leftMax);
            }
            else { // from right to left
                leftMax = 1;
                rightMax++;
                result = max(result, rightMax);
            }
        }
        return result;
    }
};

Runtime: 838ms

class Solution {
public:
    /**
     * @param A an array of Integer
     * @return  an integer
     */
    int longestIncreasingContinuousSubsequence(vector<int>& A) {
        // Write your code here
        if (A.empty()) return 0;
        
        // scan from left to right
        int leftMax = 1;
        for (int i = 1; i < A.size(); i++) {
            int j = i;
            while (j < A.size() && A[j] > A[j - 1]) j++;
            leftMax = max(leftMax, j - i + 1);
        }
        
        // scan from right to left
        int rightMax = 1;
        for (int i = A.size() - 2; i >= 0; i--) {
            int j = i;
            while (j >= 0 && A[j] > A[j + 1]) j--;
            rightMax = max(i - j + 1, rightMax);
        }
        return max(leftMax, rightMax);
    }
};