LeeCode:摆动序列376
摆动序列
如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。第一个差（如果存在的话）可能是正数或负数。少于两个元素的序列也是摆动序列。
例如， [1,7,4,9,2,5] 是一个摆动序列，因为差值 (6,-3,5,-7,3) 是正负交替出现的。相反, [1,4,7,2,5] 和 [1,7,4,5,5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。
给定一个整数序列，返回作为摆动序列的最长子序列的长度。 通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。
示例 1:
输入: [1,7,4,9,2,5]
输出: 6
解释: 整个序列均为摆动序列。
示例 2:
输入: [1,17,5,10,13,15,10,5,16,8]
输出: 7
解释: 这个序列包含几个长度为 7 摆动序列，其中一个可为[1,17,10,13,10,16,8]。
示例 3:
输入: [1,2,3,4,5,6,7,8,9]
输出: 2
解析：
本题和最长上升子序列类似，与最长上升子序列不同的是，本题无法用一个数组，来记录以i结尾的最长上升子序列，因为摆动数组的每一个元素即可以是最长摆动子序列下降后的元素，也可以是上升后的元素,这取决于前一个元素的大小
dp[n]表示数组中第n个数字的最长摆动序列长度，那么这个序列最后一个差值就可能是负数或者正数两种情况，所以一维的状态方程不能清楚的表示子问题的状态，需要再加一个维度，dp[n][m]，m表示最后一个差值的状态，0表示负数，1表示正数，那么状态方程就出来了
差值位负数
dp[n][0]=max(dp[n-1][1]+1,dp[n-1][0]);
差值位正数::max(dp[n-1][0]+1,dp[n-1][1]_
差值位0的时候，维持上一个状态，0为负数
dp[n][0]=dp[n-1][0]
dp[n][1]=dp[n-1][1];
如果上一次的摆动时正时，那么如果此次为负摆动的时候，最长摆动序列为上一次的最长摆动序列加1，如果此次为正摆动或者没有摆动时，最长摆动序列就是上一次的最长摆动序列数；如果上一次摆动为负时，那么如果此次为正摆动的时候，最长摆动序列为上一次的最长摆动序列加1，如果此次为负摆动或者没有摆动时，最长摆动序列就是上一次的最长摆动序列数
package 摆动序列;
import java.util.Scanner;
//最长摆动序列
public class 差值摆动序列 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int[] nums=new int[n];
for(int i=0;i<n;i++)
nums[i]=sc.nextInt();
if(n<2){
System.out.println(n);
return;
}
int[][] dp=new int[n+1][2];
//从1开始
for(int i=1;i<n;i++){
if(nums[i]-nums[i-1]>0){//大于0
dp[i+1][1]=Math.max(dp[i][0]+1,dp[i][1]);//要不要这个数
}else if(nums[i]-nums[i-1]<0){
dp[i+1][0]=Math.max(dp[i][1]+1,dp[i][0]);
}else{
dp[i+1][1]=dp[i][1];//保持不变
dp[i+1][0]=dp[i][0];//保持不变
}
}
//
int ans=Math.max(dp[dp.length-1][1],dp[dp.length-1][0])+1;
System.out.println(ans);
}
}
用两个一维数组来写dp
package 摆动序列;
import java.util.Scanner;
public class 差值摆动数列1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int[] nums=new int[n];
for(int i=0;i<n;i++)
nums[i]=sc.nextInt();
if(n<2){
System.out.println(n);
return;
}
int[] up=new int[n];
int[] down=new int[n];
for(int i=1;i<n;i++){
for(int j=0;j<i;j++){
if(nums[i]>nums[j]){//即差值大于0
up[i]=Math.max(up[i],down[j]+1);
}else if(nums[i]<down[j])
down[i]=Math.max(down[i],up[j]+1);
}
}
int ans=Math.max(down[n-1],up[n-1])+1;
System.out.println(ans);
}
}
线性动态规划
图解呢看这个
https://leetcode-cn.com/problems/wiggle-subsequence/solution/bai-dong-xu-lie-by-leetcode/、
这个和第一个的思路差不多
package 摆动序列;
import java.util.Scanner;
public class 差值摆动序列线性动态规划 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int[] nums=new int[n];
for(int i=0;i<n;i++)
nums[i]=sc.nextInt();
if(n<2){
System.out.println(n);
return;
}
int[] up=new int[n];
int[] down=new int[n];
up[0]=down[0]=1;
for(int i=1;i<nums.length;i++){
if(nums[i]>nums[i-1]){
up[i]=down[i-1]+1;
down[i]=down[i-1];
}else if(nums[i]<nums[i-1]){
down[i]=up[i-1]+1;
up[i]=up[i-1];
}else{
down[i]=down[i-1];
up[i]=up[i-1];
}
}
int ans=Math.max(down[n-1],up[n-1]);
System.out.println(ans);
}
}
空间优化的动态规划
这个确定减少了空间
package 摆动序列;
import java.util.Scanner;
public class 差值摆动序列空间优化的动态规划 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int[] nums=new int[n];
for(int i=0;i<n;i++)
nums[i]=sc.nextInt();
if(n<2){
System.out.println(n);
return;
}
int down=1,up=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;
}
int ans=Math.max(down,up);
System.out.println(ans);
}
}
leetCode的提交
class Solution {
public int wiggleMaxLength(int[] nums) {
int n=nums.length;
if(n<2){
System.out.println(n);
return n;
}
int down=1,up=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;
}
int ans=Math.max(down,up);
return ans;
}
}