贪心算法系列(二)|摆动序列最长递增子序列|买卖股票的最佳时机|买卖股票的最佳时机II

摆动序列

分析

  • 最经典的做法还是使用两个dp表的动态规划(代码放下面)
  • 这里采用贪心算法,直接上结论
  • 整个序列中,波峰波谷+起点和重点的个数 就是整个最长的摆动序列长度

    那么如何判断波峰/波谷呢?也很简单
  • left = nums[i] - nums[i-1]
  • right = nums[i+1] - nums[i]
  • 波峰/波谷:left * right < 0
  • 其余位置:left * right > 0

如果趋势是平的怎么处理

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

动态规划代码

java 复制代码
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;
    }
}

贪心算法代码

java 复制代码
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解法

java 复制代码
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;
    }
}

思路

贪心+二分解法

java 复制代码
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();
    }
}

相似题目(简化版)

链接:递增的三元子序列

java 复制代码
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;
    }
}

买卖股票的最佳时机

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

java 复制代码
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

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


代码

java 复制代码
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;
    }
}
相关推荐
火星机器人life1 小时前
基于ceres优化的3d激光雷达开源算法
算法·3d
虽千万人 吾往矣1 小时前
golang LeetCode 热题 100(动态规划)-更新中
算法·leetcode·动态规划
arnold662 小时前
华为OD E卷(100分)34-转盘寿司
算法·华为od
ZZTC2 小时前
Floyd算法及其扩展应用
算法
lshzdq3 小时前
【机器人】机械臂轨迹和转矩控制对比
人工智能·算法·机器人
2401_858286113 小时前
115.【C语言】数据结构之排序(希尔排序)
c语言·开发语言·数据结构·算法·排序算法
猫猫的小茶馆3 小时前
【数据结构】数据结构整体大纲
linux·数据结构·算法·ubuntu·嵌入式软件
u0107735144 小时前
【字符串】-Lc5-最长回文子串(中心扩展法)
java·算法
帅逼码农4 小时前
K-均值聚类算法
算法·均值算法·聚类
姚先生974 小时前
LeetCode 209. 长度最小的子数组 (C++实现)
c++·算法·leetcode