三、删除一次得到子数组最大和（Weekly Contest 153）

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

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

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

请看示例：

示例 1：

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

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

输入：arr = [-1,-1,-1,-1]
输出：-1
解释：最后得到的子数组不能为空，所以我们不能选择 [-1] 并从中删去 -1 来得到 0。
我们应该直接选择 [-1]，或者选择 [-1, -1] 再从中删去一个 -1。

提示：

1 <= arr.length <= 10^5
-10^4 <= arr[i] <= 10^4

没写出来，老是超时…

class Solution {
    public int maximumSum(int[] arr) {
        int le[ ] = new int[arr.length];
        le[0] = arr[0];
        for(int i=1;i<arr.length;++i){
            if(le[i-1]>0){
                le[i] = arr[i]+le[i-1];
            }else{
                le[i] = arr[i];
            }
        }
        int ri[ ] = new int[arr.length];
        ri[arr.length-1] = arr[arr.length-1];
        for(int i=arr.length-2;i>=0;--i){
            if(ri[i+1]>0){
                ri[i] = arr[i]+ri[i+1];
            }else{
                ri[i] = arr[i];
            }
        }
        int all = -100000000;
        for(int i=0;i<arr.length;++i){
            int s = 0;
            if(i-1>=0&&le[i-1]>=0){
                s += le[i-1];
            }  
            if(i+1<arr.length&&ri[i+1]>=0){
                s += ri[i+1];
            } 
            if(s>0){
                
                if(arr[i]>0){
                    s+= arr[i];
                }
                
            }else{
                s = arr[i];
            }
            all = Math.max(all,s);
        }
        return all;
    }
}

使用dp来，dp[i][0]表示的是不删除得到的最大值，dp[i][1]表示的是删除该元素或者上一个元素的最大值，注意题目意思，是可选的删除操作，因此可以不删除一个元素。

class Solution {
    public int maximumSum(int[] arr) {
      int ans = arr[0];
        int len = arr.length;
        int[][] dp = new int[len][2];
        dp[0][0] = arr[0];
        dp[0][1] = 0;
        for (int i = 1; i < len; i++) {
            dp[i][0] = arr[i];
            if (dp[i - 1][0] >= 0) {
                dp[i][0] += dp[i - 1][0];
            }
            dp[i][1] = Math.max(dp[i - 1][1] + arr[i], dp[i - 1][0]);
            ans = Math.max(ans, dp[i][0]);
            ans = Math.max(ans, dp[i][1]);
        }
        return ans;
    }
}