分析
- 最经典的做法还是使用两个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;
}
}
- 贪心算法:每一步都在做当前认为最优的操作
代码
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;
}
}