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;
    }
}