《LeetCode之每日一题》:88.最长湍流子数组

题目链接： 最长湍流子数组

有关题目

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

题解

法一：滑动窗口
代码一：

int odd(int* arr, int arrSize, int left, int right){
    int maxLen = 1;
    while(right < arrSize - 1){
        //k为奇数位
        if (right % 2 == 1 && arr[right] > arr[right + 1]){
            right++;
            continue;
        }
        //且对应偶数位
        if (right % 2 == 0 && arr[right] < arr[right + 1]){
            right++;
            continue;
        }

        //发现不符合情况，获取最大长度
        maxLen = fmax(maxLen,right - left + 1);

        //移动
        right++;
        left = right;//重新定义左边界
    }
    maxLen = fmax(maxLen,right - left + 1);//循环外也得有一层最大长度获取
    return maxLen;
}

int even(int* arr, int arrSize, int left, int right){
    int maxLen = 1;
    while(right < arrSize - 1){
        //k为偶数位
        if (right % 2 == 0 && arr[right] > arr[right + 1]){
            right++;
            continue;
        }
        //且对应奇数位
        if (right % 2 == 1 && arr[right] < arr[right + 1]){
            right++;
            continue;
        }

        //发现不符合情况，获取最大长度
        maxLen = fmax(maxLen,right - left + 1);

        //移动
        right++;
        left = right;//重新定义左边界
    }
    maxLen = fmax(maxLen,right - left + 1);//循环外也得有一层最大长度获取
    return maxLen;
}


int maxTurbulenceSize(int* arr, int arrSize){
    int ret = 1, left = 0, right = 0;
    ret = fmax(odd(arr,arrSize,left,right),even(arr,arrSize,left,right));//根据k的奇偶来获取最大值
    return ret;
}

代码二：

int maxTurbulenceSize(int* arr, int arrSize){
    int ret = 1;
    int left = 0, right = 0;
    while (right < arrSize - 1){
        if (left == right){//窗口为1
            if (arr[left] == arr[left + 1]){
                left++;
            }
            right++;
        }
        else{//窗口不为1，当前窗口[left,right],满足湍流子数组判断条件
        //right能否右移看是否满足湍流子数组判断条件
            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 + 1]无法构成湍流子数组，我们改变窗口
                left = right;
            }
        }
        ret = fmax(ret, right - left + 1);
    }
    return ret;
}

法二：动态规划

int maxTurbulenceSize(int* arr, int arrSize){
    int dp[arrSize][2];

    //i > 0,当arr[i - 1] = arr[i]以i结尾的湍流子数组长度为1,
    for (int i = 0; i < arrSize; i++) {
        dp[i][0] = dp[i][1] = 1;
    }
	//当arr[i - 1] != arr[i]
    for (int i = 1; i < arrSize; i++) {
        if (arr[i - 1] > arr[i]) {
            dp[i][0] = dp[i - 1][1] + 1;//dp[i - 1][1]-->将arr[i - 1] > arr[i - 2]状态添加进去
        } else if (arr[i - 1] < arr[i]) {
            dp[i][1] = dp[i - 1][0] + 1;//dp[i - 1][0]-->将arr[i - 2] > arr[i - 1]状态添加进去
        }
    }

     int ret = 1;
     //结果出现在两种状态下的湍流子数组中
     for (int i = 0; i < arrSize; i++) {
        ret = fmax(ret, dp[i][0]);
        ret = fmax(ret, dp[i][1]);
    }
    return ret;
}

法三：滚动数组

int maxTurbulenceSize(int* arr, int arrSize){
    int ret = 1;
    int dp0 = 1, dp1 = 1;
    for (int i = 1; i < arrSize; i++) {
        if (arr[i - 1] > arr[i]) {
            dp0 = dp1 + 1;//满足if了
            dp1 = 1;//那么肯定不满足arr[i - 1] < arr[i]所以dp1只能为1，下同理
        } else if (arr[i - 1] < arr[i]) {
            dp1 = dp0 + 1;
            dp0 = 1;
        } else {
            dp0 = 1;
            dp1 = 1;
        }
        ret = fmax(ret, dp0);
        ret = fmax(ret, dp1);
    }
    return ret;
}