算法奇妙屋(三十五)-贪心算法学习之路 2

文章目录

[一. 力扣 [376. 摆动序列](https://leetcode.cn/problems/wiggle-subsequence/description/)](#一. 力扣 376. 摆动序列)
- [1. 题目解析](#1. 题目解析)
- [2. 算法原理](#2. 算法原理)
- [3. 代码](#3. 代码)
[二. 力扣 [300. 最长递增子序列](https://leetcode.cn/problems/longest-increasing-subsequence/description/)](#二. 力扣 300. 最长递增子序列)
- [1. 题目解析](#1. 题目解析)
- [2. 算法原理](#2. 算法原理)
- [3. 代码](#3. 代码)
[三. 力扣 [334. 递增的三元子序列](https://leetcode.cn/problems/increasing-triplet-subsequence/description/)](#三. 力扣 334. 递增的三元子序列)
- [1. 题目解析](#1. 题目解析)
- [2. 算法原理](#2. 算法原理)
- [3. 代码](#3. 代码)
[四. 力扣 [674. 最长连续递增序列](https://leetcode.cn/problems/longest-continuous-increasing-subsequence/description/)](#四. 力扣 674. 最长连续递增序列)
- [1. 题目解析](#1. 题目解析)
- [2. 算法原理](#2. 算法原理)
- [3. 代码](#3. 代码)

一. 力扣 376. 摆动序列

1. 题目解析

题目这里看一眼图片就能理解

2. 算法原理

看下面图解, 最后一个值不会被计算上, 所有将ret初始值赋值为1

3. 代码

java 复制代码

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int left = 0;
        int ret = 1;
        for (int i = 0; i < nums.length - 1; i++) {
            int right = nums[i + 1] - nums[i];
            if (right == 0) {
                continue;
            }
            if (left * right <= 0) {
                ret++;
                left = right;
            }
        }
        return ret;
    }
}

二. 力扣 300. 最长递增子序列

1. 题目解析

在算法奇妙屋(十九)-子序列问题(动态规划)这篇博客中我们使用动态规划解决过这道题, 这里不过多赘述题目

2. 算法原理

贪心算法需要动态规划和二分查找的铺垫, 这里我们是根据示例, 下标从头到尾一步步模拟的, 制作不易~

回忆动态规划

贪心算法主体

3. 代码

java 复制代码

class Solution {
    public int lengthOfLIS(int[] nums) {
        int tail = 1;
        int n = nums.length;
        int[] dp = new int[n];
        dp[0] = nums[0];
        for (int i = 1; i < n; i++) {
            if (nums[i] > dp[tail - 1]) {
                dp[tail++] = nums[i];
                continue;
            }
            int left = 0;
            int right = tail - 1;
            while (left < right) {
                int mid = left + (right - left) / 2;
                if (dp[mid] < nums[i]) {
                    left = mid + 1;
                }else {
                    right = mid;
                }
            }
            if (nums[i] < dp[left]) {
                dp[left] = nums[i];
            }
        }
        return tail;
    }
}

三. 力扣 334. 递增的三元子序列

1. 题目解析

这道题和上道题(最长递增子序列)十分相似, 就只多了个条件, 长度为3时, 返回true

2. 算法原理

这里和上道题的算法原理基本一致, 这里直接copy

3. 代码

java 复制代码

class Solution {
    public boolean increasingTriplet(int[] nums) {
        int n = nums.length;
        if (n < 3) {
            return false;
        }
        int[] dp = new int[3];
        int tail = 1;
        dp[0] = nums[0];
        for (int i = 1; i < n; i++) {
            int left = 0;
            int right = tail - 1;
            if (dp[tail - 1] < nums[i]) {
                dp[tail++] = nums[i];
            }else {
                while (left < right) {
                    int mid = (left + right) / 2;
                    if (dp[mid] < nums[i]) {
                        left = mid + 1;
                    }else {
                        right = mid;
                    }
                }
            }
            if (tail == 3) {
                return true;
            }
            if (nums[i] < dp[left]) {
                dp[left] = nums[i];
            }
            
        }
        return false;
    }
}

四. 力扣 674. 最长连续递增序列

1. 题目解析

最长递增子序列的更简单版本, 这里是子数组

2. 算法原理

3. 代码

java 复制代码

class Solution {
    public int findLengthOfLCIS(int[] nums) {
        int ret = 0;
        int n = nums.length;
        for (int i = 0; i < n;) {
            int j = i + 1;
            while (j < n && nums[j] > nums[j - 1]) {
                j++;
            }
            ret = Math.max(ret, j - i);
            i = j;
        }
        return ret;
    }
}