【力扣】978. 最长湍流子数组

以下为力扣官方题解

题目

当 $A$ 的子数组$ A[i], A[i+1], …, A[j]$ 满足下列条件时，我们称其为湍流子数组：

• 若 $i<=k<j$，当 $k$ 为奇数时， $A[k]>A[k+1]$，且当 $k$ 为偶数时，$A[k]<A[k+1]$；
• 若 $i<=k<j$，当 $k$ 为偶数时，$A[k]>A[k+1]$ ，且当 $k$ 为奇数时，$A[k]<A[k+1]$。

也就是说，如果比较符号在子数组中的每个相邻元素对之间翻转，则该子数组是湍流子数组。
返回 $A$ 的最大湍流子数组的长度。

示例1

输入：$[9,4,2,10,7,8,8,1,9]$
输出：$5$
解释：$(A[1]>A[2]<A[3]>A[4]<A[5])$

示例2

输入：$[4,8,12,16]$
输出：$2$

示例3

输入：$[100]$
输出：$1$

提示

1. 1 <= A.length <= 40000
2. 0 <= A[i] <= 10⁹

官方题解

思路一 滑动窗口

设数组 $arr$ 的长度为 $n$，窗口 $[left,right](0\le left\le right\le n-1)$ 为当前的窗口，窗口内构成了一个「湍流子数组」。随后，我们要考虑下一个窗口的位置。

根据「湍流子数组」的定义，当 $0<right<n-1$ 时：

• 如果 $arr[right-1]<arr[right]$ 且 $arr[right]>arr[right+1]$，则 $[left,right+1]$ 也构成了「湍流子数组」，因此需要将 $right$ 右移一个单位；
• 如果 $arr[right-1]>arr[right]$ 且 $arr[right]<arr[right+1]$，同理，也需要将 $right$ 右移一个单位；
• 否则，$[right-1,right+1]$ 无法构成「湍流子数组」，当 $left<right$，$[left,right+1]$ 也无法构成「湍流子数组」，因此需要将 $left$ 移到 $right$，即令 $left=right$。

此外，我们还需要特殊考虑窗口长度为 $1$ （即 $left$ 和 $right$ 相等的情况）：只要 $arr[right]\ne arr[right+1]$，就可以将 $right$ 右移一个单位；否则，$left$ 和 $right$ 都要同时右移。

代码

class Solution {
    public int maxTurbulenceSize(int[] arr) {
        int n = arr.length;
        int ret = 1;
        int left = 0, right = 0;

        while (right < n - 1) {
            if (left == right) {
                if (arr[left] == arr[left + 1]) {
                    left++;
                }
                right++;
            } else {
                if (arr[right - 1] < arr[right] && arr[right] > arr[right + 1]) {
                    right++;
                } else if (arr[right - 1] > arr[right] && arr[right] < arr[right + 1]) {
                    right++;
                } else {
                    left = right;
                }
            }
            ret = Math.max(ret, right - left + 1);
        }
        return ret;
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 为数组的长度。窗口的左右端点最多各移动 $n$ 次。
• 空间复杂度：$O(1)$。只需要维护常数额外空间。

思路二

也可以使用动态规划的方法计算最长湍流子数组的长度。

记 $dp[i][0]$ 为以 $arr[i]$ 结尾，且 $arr[i-1]>arr[i]$ 的「湍流子数组」的最大长度；$dp[i][1]$ 为以 $arr[i]$ 结尾，且 $arr[i-1]<arr[i]$ 的「湍流子数组」的最大长度。显然，以下标 $0$ 结尾的「湍流子数组」的最大长度为 $1$，因此边界情况为 $dp[0][0]=dp[0][1]=1$。

当 $i>0$ 时，考虑 $arr[i-1]$ 和 $arr[i]$ 之间的大小关系：

• 如果 $arr[i-1]>arr[i]$，则如果以下标 $i-1$ 结尾的子数组是「湍流子数组」，应满足 $i-1=0$，或者当 $i-1>0$ 时 $arr[i-2]<arr[i-1]$，因此 $dp[i][0]=dp[i-1][1]+1$；
• 如果 $arr[i-1]<arr[i]$，则如果以下标 $i-1$ 结尾的子数组是「湍流子数组」，应满足 $i-1=0$，或者当 $i-1>0$ 时 $arr[i-2]>arr[i-1]$，因此 $dp[i][1]=dp[i-1][0]+1$；
• 如果 $arr[i-1]=arr[i]$，则 $arr[i-1]$ 和 $arr[i]$ 不能同时出现在同一个湍流子数组中，因此 $dp[i][0]=dp[i][1]=1$。

最终，$dp$ 数组的最大值即为所求的答案。

代码

class Solution {
    public int maxTurbulenceSize(int[] arr) {
        int n = arr.length;
        int[][] dp = new int[n][2];
        dp[0][0] = dp[0][1] = 1;
        for (int i = 1; i < n; i++) {
            dp[i][0] = dp[i][1] = 1;
            if (arr[i - 1] > arr[i]) {
                dp[i][1] = dp[i - 1][0] + 1;
            } else if (arr[i - 1] < arr[i]) {
                dp[i][0] = dp[i - 1][1] + 1;
            }
        }

        int ret = 1;
        for (int i = 0; i < n; i++) {
            ret = Math.max(ret, dp[i][0]);
            ret = Math.max(ret, dp[i][1]);
        }
        return ret;
    }
}

优化代码

上述实现的空间复杂度是 $O(n)$。注意到当 $i>0$ 时，下标 $i$ 处的 $dp$ 值只和下标 $i-1$ 处的 $dp$ 值有关，因此可以用两个变量 $dp0$ 和 $dp1$​ 代替 $dp[i][0]$ 和 $dp[i][1]$，将空间复杂度降到 $O(1)$。

class Solution {
    public int maxTurbulenceSize(int[] arr) {
        int ret = 1;
        int n = arr.length;
        int dp0 = 1, dp1 = 1;
        for (int i = 1; i < n; i++) {
            if (arr[i - 1] > arr[i]) {
                dp0 = dp1 + 1;
                dp1 = 1;
            } else if (arr[i - 1] < arr[i]) {
                dp1 = dp0 + 1;
                dp0 = 1;
            } else {
                dp0 = 1;
                dp1 = 1;
            }
            ret = Math.max(ret, dp0);
            ret = Math.max(ret, dp1);
        }
        return ret;
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 为数组的长度。需要遍历数组 $arr$ 一次，计算 $dp$ 的值。
• 空间复杂度：$O(1)$。使用空间优化的做法，只需要维护常数额外空间。