LeetCode 1186. 删除一次得到子数组最大和

LeetCode 1186. 删除一次得到子数组最大和

给你一个整数数组，返回它的某个 非空 子数组（连续元素）在执行一次可选的删除操作后，所能得到的最大元素总和。

换句话说，你可以从原数组中选出一个子数组，并可以决定要不要从中删除一个元素（只能删一次哦），（删除后）子数组中至少应当有一个元素，然后该子数组（剩下）的元素总和是所有子数组之中最大的。

注意，删除一个元素后，子数组 不能为空。

Example1

输入：arr = [1,-2,0,3]
输出：4
解释：我们可以选出 [1, -2, 0, 3]，然后删掉 -2，这样得到 [1, 0, 3]，和最大。

Example2

输入：arr = [1,-2,-2,3]
输出：3
解释：我们直接选出 [3]，这就是最大和。

解题思路

最简单的解题思路就是动态规划了

我们定义f ( i ) 和 g ( i )，其中 f( i ) 表示不删除元素的情况下最大子数组和（以arr[i]结尾），
g( i ) 代表删除元素的情况下的最大子数组和（以arr[i]结尾）。
f(i) = max(f(i-1)+arr[i],arr[i]) //要么是当前元素累加之前的和，要么是重新从当前元素开始
g(i) = max(g(i-1)+arr[i],f(i-1)) 
//要么是加上当前元素，也就是维持之前删除某个元素的情形，即g[i-1]+arr[i]
//要么是删除当前这个元素，那么区间[0, i-1]就是不删除元素的情况，即f(i-1)+0（注意是f不是g！！）

AC代码

这里为了节省空间复杂度，简写了一下

    int maximumSum(vector<int>& arr) {
     int n = arr.size();
        int s0, s1, ans;
        s0 = ans = arr[0], s1 = INT_MIN/2;
        for (int i = 1; i < n; i++) {
            int ts0 = max(arr[i], s0 + arr[i]);
            int ts1 = max(s0, s1 + arr[i]);
            s0 = ts0;
            s1 = ts1;
            ans = max(ans, max(s0, s1));
        }
        return ans;

由此我们可以更为推广一番，当删除n次得到子数组的最大值

dp[i][j]表示以arr[i]结尾的，已经删除j次的子数组最大值

递推关系：
dp[i][j] = max(dp[i - 1][j] + arr[i],dp[i - 1][j - 1]);
面临两种情况：
不删除arr[i]， dp[i - 1][j] + arr[i]
删除arr[i]，dp[i - 1][j - 1]

for(int i = 1; i < n; i++){
            dp[i][0] = max(dp[i - 1][0] + arr[i],arr[i]);
            max = max(max,dp[i][0]);
        }
        //dp
        for(int i = 1; i < n; i++){
            for(int j = 1; j <= k; j++){
                dp[i][j] = max(dp[i - 1][j] + arr[i],dp[i - 1][j - 1]);
                max = max(max,dp[i][j]);
            }
        }