letecode 编程学习（36）

题目

当 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

解题思路

首先考虑到采用了滑动窗口双指针的方法，后来参考了别人别人的解题思路采用动态规划更简单

动态规划的思想如下：

状态的定义：
定义 up[i] 表示以位置 i 结尾的，并且 arr[i - 1] < arr[i] 的最长湍流子数组长度。
定义 down[i] 表示以位置 i 结尾的，并且 arr[i - 1] > arr[i] 的最长湍流子数组长度。
up[i] 和 down[i] 初始化都是 1，因为每个数字本身都是一个最小的湍流子数组。

状态转移方程：
up[i] = down[i - 1] + 1，当 arr[i - 1] < arr[i]；
down[i] = up[i - 1] + 1，当 arr[i - 1] > arr[i]；

代码

方法一：

class Solution {
public:
    int maxTurbulenceSize(vector<int>& arr) {
        if (arr.size() < 2)
        {
            return arr.size();
        }

        int maxRes = 1;
        int left = 0;
        int right = 0;
        int preflag = 0;
        int curflag = 0;
        while(right < arr.size()-1)
        {          
             maxRes = std::max(maxRes, right-left + 1);
            if (arr[right] < arr[right+1])
            {
                if (right%2==0)
                {
                    curflag = 1;
                }
                else
                {
                    curflag = 2;
                }

            }
            else if (arr[right] > arr[right+1])
            {
                if (right%2==0)
                {
                    curflag = 2;
                }
                else
                {
                    curflag = 1;
                }
            }
            else
            {
                curflag = 0;   
            }

            if (curflag == 0)
            {
                preflag = curflag;

                left = right + 1;
                right = right +1;
            }
            else
            {
                if (preflag != curflag)
                {
                    preflag = curflag;
 
                    left = right;                    
                }

                right = right +1;
            }        
                
        }

        return std::max(maxRes, right - left + 1);
    }
};

方法二：

class Solution(object):
    def maxTurbulenceSize(self, arr):
        """
        :type arr: List[int]
        :rtype: int
        """
        N = len(arr)
        up = [1] * N
        down = [1] * N
        res = 1
        for i in range(1, N):
            if arr[i - 1] < arr[i]:
                up[i] = down[i - 1] + 1
            elif arr[i - 1] > arr[i]:
                down[i] = up[i - 1] + 1
            res = max(res, max(up[i], down[i]))
        return res