leetcode978 最长湍流子数组 中等

题目：

题目链接

思路：
我使用动态规划的做法
题目提供了两种方案，那么每一步都考虑用哪种方案最好，使用两个dp数组记录当前位置i的最长湍流子数组长度
以实例1为例：
9>4且9在偶数位置上所以优先考虑方案2，所以方案1是不符合的，为1，故two[i] = 2, one[i] = 1
4>2且4在奇数位置上所以优先考虑方案1，所以方案2是不符合的，为1，此时方案1要考虑前一个数的最长湍流子数组长，其值+1与2比较谁大，谁大dp[i]就等于谁，因为要求最长，所以要看前面的位置能不能和当前位置连起来构成子数组
剩下同理

class Solution {
    public int maxTurbulenceSize(int[] A) {
        if(A == null || A.length == 0){
            return 0;
        }
        if(A.length == 1){
            return 1;
        }
        int len = A.length;
        int[] ruleOne = new int[len];
        int[] ruleTwo = new int[len];
        int max = 0;
        for(int i = 0; i < len-1; i++){
            //偶数
            if(i%2 == 0){
                if(A[i] > A[i+1]){
                    if(i == 0){
                        ruleTwo[i] = 2;
                        ruleOne[i] = 1;
                    }else{
                        ruleTwo[i] = Math.max(ruleTwo[i-1]+1, 2);
                        ruleOne[i] = 1;
                    }
                }else if(A[i] < A[i+1]){
                    if(i == 0){
                        ruleOne[i] = 2;
                        ruleTwo[i] = 1;
                    }else{
                        ruleOne[i] = Math.max(ruleOne[i-1]+1, 2);
                        ruleTwo[i] = 1;
                    }
                }else{
                    //相等
                    ruleOne[i] = ruleTwo[i] = 1;
                }
            }else{
                //奇数

                if(A[i] > A[i+1]){
                    if(i == 0){
                        ruleOne[i] = 2;
                        ruleTwo[i] = 1;
                    }else{
                        ruleOne[i] = Math.max(ruleOne[i-1]+1, 2);
                        ruleTwo[i] = 1;
                    }
                }else if(A[i] < A[i+1]){
                    if(i == 0){
                        ruleTwo[i] = 2;
                        ruleOne[i] = 1;
                    }else{
                        ruleTwo[i] = Math.max(ruleTwo[i-1]+1, 2);
                        ruleOne[i] = 1;
                    }
                }else{
                    //相等
                    ruleOne[i] = ruleTwo[i] = 1;
                }
            }
            max = Math.max(max, Math.max(ruleOne[i], ruleTwo[i]));
        }
        return max;
    }
}

此题解法有更有解，可以参考其他人的题解，这里我只讲动态规划的做法