LeetCode 978 Longest Turbulent Subarray (dp)

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/Tc_To_Top/article/details/88784412

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. 1 <= A.length <= 40000
2. 0 <= A[i] <= 10^9

题目链接：https://leetcode.com/problems/longest-turbulent-subarray/

题目分析：容易想到dp，dp[i][0]表示到i这个位置，满足a[i-1]>a[i]的turbulent的长度，dp[i][1]表示到i这个位置，满足a[i-1]<a[i]的turbulent的长度

17ms，时间击败9.5%

class Solution {
    public int maxTurbulenceSize(int[] A) {
        int[][] dp = new int[A.length][2];
        // dp[i][0] a[i-1]>a[i]
        // dp[i][1] a[i-1]<a[i]
        dp[0][0] = 1;
        dp[0][1] = 1;
        int ans = 1;
        for (int i = 1; i < A.length; i++) {
            if (A[i - 1] < A[i]) {
                dp[i][1] = dp[i - 1][0] + 1;
                dp[i][0] = 1;
            } else if (A[i - 1] > A[i]){
                dp[i][0] = dp[i - 1][1] + 1;
                dp[i][1] = 1;
            } else {
                dp[i][0] = 1;
                dp[i][1] = 1;
            }
            ans = Math.max(ans, Math.max(dp[i][0], dp[i][1]));
        }
        return ans;
    }
}

不难发现，dp[i][0/1]只与dp[i-1][0/1]，a[i]，a[i-1]有关，变量滚动

7ms，时间击败99.65%

class Solution {

    public int maxTurbulenceSize(int[] A) {
        int cur0 = 0, cur1 = 0;
        int pre0 = 1, pre1 = 1;
        int ans = 1;
        for (int i = 1; i < A.length; i++) {
            if (A[i - 1] < A[i]) {
                cur1 = pre0 + 1;
                cur0 = 1;
                ans = Math.max(ans, cur1);
            } else if (A[i - 1] > A[i]) {
                cur0 = pre1 + 1;
                cur1 = 1;
                ans = Math.max(ans, cur0);
            } else {
                cur0 = 1;
                cur1 = 1;
            }
            pre0 = cur0;
            pre1 = cur1;
        }
        return ans;
    }
}