摆动序列

分析

• 最经典的做法还是使用两个dp表的动态规划(代码放下面)
• 这里采用贪心算法，直接上结论
• 整个序列中，波峰波谷+起点和重点的个数就是整个最长的摆动序列长度
  
  那么如何判断波峰/波谷呢？也很简单
• left = nums[i] - nums[i-1]
• right = nums[i+1] - nums[i]
• 波峰/波谷：left * right < 0
• 其余位置:left * right > 0

如果趋势是平的怎么处理

后面两种情况从宏观角度来看是存在波峰和波谷的，所有相同的点(平直部分)其实可以当作一个点，所以如果遇到right == 0,直接跳过即可

动态规划代码

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int n = nums.length;

        int[] f = new int[n], g = new int[n];
        for(int i = 0; i < n; i++) f[i] = g[i] = 1;

        int ret = f[0];
        for(int i = 1; i < n; i++) {
            for(int j = 0; j < i; j++) {
                if(nums[i] - nums[j] > 0) f[i] = Math.max(g[j] + 1, f[i]);
                else if(nums[i] - nums[j] < 0) {g[i] = Math.max(f[j] + 1, g[i]);}
            }

            ret = Math.max(f[i], g[i]);
        }

        return ret;
    }
}

贪心算法代码

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int left = 0, right = 0, ret = 0;
        for(int i = 0; i < nums.length - 1; i++) {
            right = nums[i + 1] - nums[i];// 右边趋势
            if(right == 0) continue;// 平地  直接略过即可
            if(left * right <= 0) ret++;// 波峰/波谷
            left = right;
        }

        return ret + 1;// 结尾也算  因为可升可降
    }
}

---

最长递增子序列
动态规划的解题思路中,当走到i位置的元素时,我们只关心i位置之前的所有递增子序列的最后位置的元素nums[j]是否小于nums[i],如果小于,就能构成一个新的,更长的递增子序列,取所有情况中的最大值

观察dp的思路不难发现,只需要关心递增子序列最后位置的元素的大小即可,无需关注序列本身的组成,

dp解法

class Solution {
    public int lengthOfLIS(int[] nums) {
        // 时间复杂度O(N^2)
        int n = nums.length;
        int[] dp = new int[n];
        for (int i = 0; i < n; i++)
            dp[i] = 1;

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

        return ret;
    }
}

思路

贪心+二分解法

class Solution {
    public int lengthOfLIS(int[] nums) {
        // 时间复杂度O(N * logN)
        int n = nums.length;
        List<Integer> ret = new ArrayList<>();
        ret.add(nums[0]);

        for(int i = 1; i < n; i++) {
            // 处理边界情况
            if(nums[i] > ret.get(ret.size() - 1)) {
                ret.add(nums[i]);
            }else {
                // 不是边界--二分搜索插入
                int l = 0, r = ret.size();
                while(l < r) {
                    int mid = l + ((r - l) >> 1);
                    if(ret.get(mid) >= nums[i]) r = mid;
                    else l = mid + 1;
                }
                ret.set(l, nums[i]);
            }
        }
        return ret.size();
    }
}

相似题目(简化版)
链接:递增的三元子序列

class Solution {
    public boolean increasingTriplet(int[] nums) {
        int len = nums.length;
        if(len < 3) return false;

        // min就是len==1的递增子序列的最后位置的元素
        // mid就是len==2的递增子序列的最后位置的元素
        // 只要找到比mid大的,就存在长度为三递增子序列
        int min = Integer.MAX_VALUE, mid = Integer.MAX_VALUE;
        for(int x : nums) {
            if(x <= min) min = x;
            else if(x > min && x <= mid) mid = x;
            else return true;
        }

        return false;
    }
}

---

买卖股票的最佳时机

贪心策略: 每次都假定今天卖出,那么就需要知道今天之前的最小值,这样才能获得当天的最大利润,所有的今天构成了每天 ,这样遍历一遍数组就能得到最大利润

class Solution {
    public int maxProfit(int[] prices) {
        if(prices == null || prices.length == 0) return 0;
        int minPrice = Integer.MAX_VALUE, maxProfit = 0;

        for(int price : prices) {
            if(price < minPrice) minPrice = price;// 记录最低价格
            if(price - minPrice > maxProfit) maxProfit = price - minPrice;// 记录最大利润
        }

        return maxProfit;
    }
}

---

买卖股票的最佳时机II

• 贪心算法:每一步都在做当前认为最优的操作

代码

class Solution {
    public int maxProfit(int[] prices) {
        // 只要是上升趋势就卖出
        int ret = 0;
        for(int i = 1; i < prices.length; i++)
            if(prices[i] > prices[i - 1])
                ret += prices[i] - prices[i - 1];

        return ret;
    }
}