【算法】Maximum Alternating Subsequence Sum 最大子序列交替和 动态规划

Maximum Alternating Subsequence Sum 最大子序列交替和

问题描述：

一个下标从 0 开始的数组的 交替和 定义为 偶数 下标处元素之 和 减去 奇数 下标处元素之 和 。

比方说，数组 [4,2,5,3] 的交替和为 (4 + 5) - (2 + 3) = 4 。
给你一个数组 nums ，请你返回 nums 中任意子序列的 最大交替和 （子序列的下标 重新 从 0 开始编号）。

一个数组的 子序列 是从原数组中删除一些元素后（也可能一个也不删除）剩余元素不改变顺序组成的数组。比方说，[2,7,4] 是 [4,2,3,7,2,1,4] 的一个子序列（加粗元素），但是 [2,4,2] 不是。

$$\begin{gathered} 1<=nums.length<=10^5 \\ 1<=nums[i]<=10^5 \end{gathered}$$

分析

要求在一个数组中找出一个subsequence，而且它的交替和最大。

要完成2个事情，子序列，交替和最大。

给的定义 交替和 alternating sum，是子序列中偶数下标的元素和 - 奇数下标的元素和。
对于相同的元素a[i],它所处的不同的子序列，它的相对下标也可能会发生变化，可能是奇数，也可能是偶数。

这个问题其实和LIS很像，对于该问题的思路很多，子序列的长度，最小就是1，也就是单元素构造的子序列。
所以理论上，这个交替和的范围下边界就是单元素的最小值。
对于原数组的下标i，a[i]来讨论。

• 情况1 $a[i]$可能自身就是一个备选。
• 情况2 $a[i]$可能作为某个子序列的$odd$下标，即$0\to i-1$存在一个even下标结尾的子序列的最大值。
• 情况3 $a[i]$可能作为某个子序列的$even$下标，即$0\to i-1$存在一个$odd$下标结尾的子序列的最大值。

所以状态转移方程就出来了。

$f[i][j]$表示以i为结尾的元素构造的子序列，交替和可以得到的最大值，j为0表示当前元素是偶数结尾，1表示是奇数结尾。
$$\begin{gathered} f[i][0]=max(f[k][1]+nums[i-1]),i>k>0 \\ f[i][1]=max(f[k][0]-nums[i-1]),i>k>0 \end{gathered}$$

时间复杂度$O(N^2)$,TLE

由于最终只是计算结果，为了使$f[i][0]$最大，只是需要从$0\to i-1$ 找到一个以奇数结尾的最大交替和，所以不一定需要知道这个结果是哪个序列产生的。
所以使用一个$odd$来记录这个结果就可以，就可以避免进行一次$O(N)$的遍历。

代码

DP

 public long maxAlternatingSum(int[] nums) {
        int n = nums.length;
        long[][] f = new long[n+1][2];
        long ans = 0;
        for(int i =1;i<=n;i++){
            f[i][0] = nums[i-1];
            f[i][1] = -nums[i-1];
            for(int j=i-1;j>0;j--){
                f[i][0] = Math.max(f[i][0],f[j][1]+nums[i-1]);
                f[i][1] = Math.max(f[i][1],f[j][0]-nums[i-1]);
            }
            ans = Math.max(ans,Math.max(f[i][0],f[i][1]));
        }
        return ans;
    }

时间复杂度$O((N){)}^2)$

空间复杂度$O(N)$

TLE

改进

public long maxAlternatingSum(int[] nums) {
        int n = nums.length;
        long[][] f = new long[n+1][2];
        long ans = 0,max0 = 0, max1 = 0; 
        for(int i =1;i<=n;i++){
            f[i][0] = nums[i-1];
            f[i][1] = -nums[i-1];
            f[i][0] = Math.max(f[i][0],max1+nums[i-1]);
            f[i][1] = Math.max(f[i][1],max0-nums[i-1]);
            max1 = Math.max(max1,f[i][1]); 
            max0 = Math.max(max0,f[i][0]); 
            ans = Math.max(ans,Math.max(f[i][0],f[i][1]));
        }
        return ans;
    }

时间复杂度$O(N)$

空间复杂度$O(N)$

public long maxAlternatingSum(int[] nums) {
        int n = nums.length; 
        long ans = 0,even = 0, odd = 0;
        long cureven = 0, curodd = 0; 
        for(int i =1;i<=n;i++){
            cureven = nums[i-1];
            curodd = -nums[i-1];
            cureven = Math.max(cureven,odd+nums[i-1]);
            curodd = Math.max(curodd,even-nums[i-1]);
            odd = Math.max(odd,curodd); 
            even = Math.max(even,cureven); 
            ans = Math.max(ans,Math.max(cureven,curodd));
        }
        return ans;
    }

时间复杂度$O(N)$

空间复杂度$O(1)$

Tag

Array
Dynamic Programming