题目来源
题目描述
class Solution {
public:
int wiggleMaxLength(vector<int>& nums) {
}
};
题目解析
准备
- 某个序列被称为「上升摆动序列」，当且仅当该序列是摆动序列，而且最后一个元素呈上升趋势。如序列 [1,3,2,4]即为「上升摆动序列」
- 某个序列被称为「下降摆动序列」，当且仅当该序列是摆动序列，且最后一个元素呈下降趋势。如序列 [4,2,3,1] 即为「下降摆动序列」。
- 特别的，对于长度为1的序列，它即是「上升摆动序列」也是「下降摆动序列」
- 序列中的某个元素被称为「峰」，当且仅当该元素两侧的相邻元素均小于它。如序列 […1,3,2,…]中，3就是一个峰
- 序列中的某个元素被称为「谷」，当且仅当该元素两侧的相邻元素均大于它。如序列[…,3,2,4, …]中，2就是一个「谷」。
- 特别地，对于位于序列两端的元素，只有一侧的相邻元素小于或大于它，我们也称其为「峰」或「谷」。如序列 [1,3…2,4] 中，1也是一个「谷」，4 也是一个「峰」。
- 因为一段相邻的相同元素中我们最多只能选择其中一个，所以我们可以忽略相邻的相同元素。现在我们假定序列中任意两个相邻元素都不相同，即要么左侧大于右侧，要么右侧大于左侧。对于序列中既非「峰」也非「谷」的元素，我们称其为「过渡元素」。如序列 [1,2,3,4] 中，2 和 3 都是「过渡元素」。
动态规划
思路
只看最后一步：对于nums[i]，那么它有如下几种情况：
- 之前没有元素，直接返回1
- 之前有元素，那么需要比较nums[i - 1]和nums[i]的关系，可能情况有
- nums[i - 1] == nums[i];
- nums[i - 1] < nums[i];
- nums[i - 1] > nums[i];
（1）状态定义：
- dp[i][0]: 第i元素结尾，且最后上升的最长子序列长度 ↑
- dp[i][1]: 第i元素结尾，且最后下降的最长子序列长度 ↓
（2）状态转移
- if nums[i] < nums[i-1] : 新的尾结点下降
- dp[i][1] = dp[i-1][0] + 1
- dp[i][0] = dp[i-1][0]
- if nums[i] > nums[i-1] : 新的尾结点上升
- dp[i][0] = dp[i-1][1] + 1
- dp[i][1] = dp[i-1][1]
- if nums[i] = nums[i-1] : 新的尾结点不变
- dp[i][0] = dp[i-1][0]
- dp[i][1] = dp[i-1][1]
- 边界情况：
- dp[0][0] = 1（只看第一个元素）
- dp[0][1] = 1（只看第一个元素）
- 返回值
- max(dp[0][0] , dp[0][1]);
class Solution {
public:
int dp[1005][2];
int wiggleMaxLength(vector<int>& nums) {
memset(dp, 0, sizeof dp);
dp[0][0] = dp[0][1] = 1;
for (int i = 1; i < nums.size(); ++i)
{
dp[i][0] = dp[i][1] = 1;
for (int j = 0; j < i; ++j)
{
if (nums[j] > nums[i]) dp[i][1] = max(dp[i][1], dp[j][0] + 1);
}
for (int j = 0; j < i; ++j)
{
if (nums[j] < nums[i]) dp[i][0] = max(dp[i][0], dp[j][1] + 1);
}
}
return max(dp[nums.size() - 1][0], dp[nums.size() - 1][1]);
}
};
class Solution {
public:
int wiggleMaxLength(vector<int>& nums) {
int n = nums.size();
if(n == 1)
return 1;
vector<int> up(n);
up[0] = 1;
vector<int> down(n);
down[0] = 1;
for(int i = 1; i < n; i ++)
{
if(nums[i] > nums[i - 1])
{
up[i] = max(down[i - 1] + 1, up[i - 1]);
down[i] = down[i - 1];
}
else if(nums[i] < nums[i - 1])
{
up[i] = up[i - 1];
down[i] = max(up[i - 1] + 1, down[i - 1]);
}
else
{
up[i] = up[i - 1];
down[i] = down[i - 1];
}
}
return max(up[n - 1], down[n - 1]);
}
};
思路
（1）定义状态
每当我们选择一个元素作为摆动序列的一部分时，这个元素要么是上升的，要么是下降的。那么其状态可以定义为：
down[i]表示nums数组[0…i]中，以i结尾的最长摆动子序列的长度，并且最后的差值是负数（降序）up[i]表示nums数组[0…i]中，以i结尾的最长摆动子序列的长度，并且最后的差值是正数
（2）状态转移方程：
down[i]=up数组的[0... i-1]的最大值+1up[i]=down数组的[0... i-1]的最大值+1
（3）初始化&&边界
- 对于长度为1的序列，它即是「上升摆动序列」也是「下降摆动序列」，因此，
down[i] = 1， up[i] = 1
class Solution {
public:
int wiggleMaxLength(vector<int>& nums) {
int n = nums.size();
std::vector<int> down(n, 1);
std::vector<int> up(n, 1);
for (int i = 0; i < n; ++i) { //对于每一个i
for (int j = 0; j < i; ++j) { // 看[0...i)
if(nums[j] < nums[i]){
up[i] = std::max(up[i], down[j] + 1);
}else if(nums[j] > nums[i]){
down[i] = std::max(down[i], up[j] + 1);
}
}
}
int max = 0;
for (int i = 0; i < n; ++i) {
max = std::max(max, down[i]);
max = std::max(max, up[i]);
}
return max;
}
};
思路
（1）定义状态
- 序列长度为0 1，摆动序列长度对应0 1。序列长度>=2，摆动序列长度>=1
- 遍历序列：最长上升摆动序列
up，最长下降摆动序列down- 当前数 = 前数：摆动序列长度不变
- 当前数 > 前数 ↑
- 当前数放入最长下降摆动序列，
down + 1 -> up - 当前数放入最长上升摆动序列，则替换原末尾值或者舍弃：
up -> up
- 当前数放入最长下降摆动序列，
- 当前数 < 前数
- 当前数放入最长上升摆动序列 up + 1 → down
- 当前数放入最长下降摆动序列，替换原末位值 或 舍弃 down → down
class Solution {
public:
int wiggleMaxLength(vector<int>& nums) {
int n = nums.size();
if(n < 2){
return n;
}
int up = 1,down = 1;
for (int i = 1; i < n; ++i) {
if(nums[i] > nums[i - 1]){
up = std::max(up, down + 1);
}else if(nums[i] < nums[i - 1]){
down = std::max(down, up + 1);
}
}
return std::max(up, down);
}
};
其实这道题关键就八个字，递增看递减，递减看递增。只有这样数组才可以构成摆动数列。所以我们完全可以定义两个数来储存一个上升的和一个下降的最大值。
class Solution {
public:
int wiggleMaxLength(vector<int>& nums) {
int n = nums.size();
if(n <= 1){
return n;
}
int up = 1,down = 1;
for (int i = 1; i < n; ++i) {
if(nums[i] > nums[i - 1]){
up = down + 1;
}else if(nums[i] < nums[i - 1]){
down = up + 1;
}
}
return std::max(up, down);
}
};
贪心算法
思路
可以这么想，本题要求通过从原始序列中删除(也可以不删除)元素来获取子序列，剩下的元素保持其原始顺序
那，应该删除什么元素呢？举个例子
局部最优：删除单调坡度上的节点（不包括单调坡度两端的节点），那么这个坡度就可以有两个局部峰值。
整体最优：整个序列有最多的局部峰值，从而达到最长摆动序列。
局部最优推出全局最优，并举不出反例，那么试试贪心！
实际操作上，其实连删除的操作都不用做，因为题目要求的是最长摆动子序列的长度，所以只需要统计峰值数量就可以了(相当于是删除单一坡度上的节点，然后统计长度）)
这就是贪心所贪的地方，让峰值尽可能的保持峰值，然后删除单一坡度上的节点。
本题代码实现中，还有一些技巧，例如统计峰值的时候，数组最左面和最右面是最不好统计的。
例如序列[2,5]，它的峰值数量是2，如果靠统计差值来计算峰值个数就需要考虑数组最左面和最右面的特殊情况。
所以可以针对序列[2,5]，可以假设为[2,2,5]，这样它就有坡度了即preDiff = 0，如图：
针对以上情形，result初始为1（默认最右面有一个峰值），此时curDiff > 0 && preDiff <= 0，那么result++（计算了左面的峰值），最后得到的result就是2（峰值个数为2即摆动序列长度为2）
贪心策略：只选波峰 波谷，不在上升下降过程中选点
class Solution {
public:
int wiggleMaxLength(vector<int>& nums) {
if (nums.size() <= 1) return nums.size();
int curDiff = 0; // 当前一对差值
int preDiff = 0; // 前一对差值
int result = 1; // 记录峰值个数，序列默认序列最右边有一个峰值
for (int i = 0; i < nums.size() - 1; i++) {
curDiff = nums[i + 1] - nums[i];
// 出现峰值
if ((curDiff > 0 && preDiff <= 0) || (preDiff >= 0 && curDiff < 0)) {
result++;
preDiff = curDiff;
}
}
return result;
}
};
数顶点
这道题就是求把所有下坡路合在一起,上坡路合在一起的数组长度.
class Solution {
public:
int wiggleMaxLength(vector<int>& nums) {
int n = nums.size();
if(n <= 1){
return n;
}
int count = 1;
//1上 2 下 3 等
int up = 3;
for (int i = 1; i < n; i++) {
if (nums[i] > nums[i-1] && up != 1){
count ++;
up = 1;
}else if (nums[i] < nums[i-1] && up != 2){
count ++;
up = 2;
}
}
return count;
}
};
512
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
