leetcode 376 摆动序列

动态规划

class Solution {
      public int wiggleMaxLength(int[] nums) {
        if (nums.length == 1)
            return nums.length;
        //动态规划
        //dp[i][0]表示当前数字的子序列长度，dp[i][1]表示当前数字状态，0是开始，1是当前数字是凹点，2是凸点
        int[][] dp = new int[nums.length][2];
        //初始化第一个
        dp[0][0] = 1;
        for(int i = 1; i < nums.length; i++){
            //遍历前面，找到最大的
            // 默认是1，如果都不能和前面合成子序列，那么当前就是1，作为开头,序列永远有一个数
            dp[i][0] = 1;
            for(int j = 0; j < i; j++){
                //如果j是0，判断是否相等，如果不想等才可以加上去
                if (dp[j][1] == 0) {
                    if (nums[i] != nums[j]){
                    dp[i][0] = Math.max(dp[i][0], dp[j][0] + 1);
                    dp[i][1] = nums[i] - nums[j] > 0 ? 2 : 1;
                    }
                }
                else {
                    //如果j是凹点，那么i是凸点
                    if (dp[j][1] == 1){
                        if (nums[i] - nums[j] > 0) {
                            dp[i][0] = Math.max(dp[i][0], dp[j][0] + 1);
                            dp[i][1] = 2;
                        }
                    }
                    if (dp[j][1] == 2){
                        if (nums[i] - nums[j] < 0){
                            dp[i][0] = Math.max(dp[i][0], dp[j][0] + 1);
                            dp[i][1] = 1;
                        }
                    }
                }
            }
        }
        int max = 1;
        for(int i = 0; i < dp.length;i++)
            max = Math.max(dp[i][0],max);
        return max;
    }
}