Longest Turbulent Subarray

A subarray A[i], A[i+1], ..., A[j] of A is said to be turbulent if and only if:

For i <= k < j, A[k] > A[k+1] when k is odd, and A[k] < A[k+1] when k is even;
OR, for i <= k < j, A[k] > A[k+1] when k is even, and A[k] < A[k+1] when k is odd.

That is, the subarray is turbulent if the comparison sign flips between each adjacent pair of elements in the subarray.

Return the length of a maximum size turbulent subarray of A.

Example 1:

Input: [9,4,2,10,7,8,8,1,9]
Output: 5
Explanation: (A[1] > A[2] < A[3] > A[4] < A[5])

Example 2:

Input: [4,8,12,16]
Output: 2

Example 3:

Input: [100]
Output: 1

Note:

1 <= A.length <= 40000
0 <= A[i] <= 10^9

Solution:

class Solution {
    public int maxTurbulenceSize(int[] A) {
        int n = A.length;
        int[] dp1 = new int[n];
        int[] dp2 = new int[n];
        int max = 1;
        dp1[0] = 1;
        dp2[0] = 1;
        for (int i = 1; i < n; i ++) {
            dp1[i] = 1;
            dp2[i] = 1;
            if (i % 2 == 0) {
                if (A[i] < A[i - 1]) {
                    dp1[i] = dp1[i - 1] + 1;
                } else if (A[i] > A[i - 1]) {
                    dp2[i] = dp2[i - 1] + 1;
                }
            } else {
                if (A[i] > A[i - 1]) {
                    dp1[i] = dp1[i - 1] + 1;
                } else if (A[i] < A[i - 1]) {
                    dp2[i] = dp2[i - 1] + 1;
                }
            }
            max = Math.max(dp1[i], max);
            max = Math.max(dp2[i], max);
        }
        // System.out.println(Arrays.toString(dp1));
        // System.out.println(Arrays.toString(dp2));
        return max;
    }
}