最大化子数组的总成本

思路：

理解了题意之后，可以发现，正数是不需要做任何改动的，可以直接加到res（最终的结果）里面。如果是负数的话，就需要分两种情况分析：

• 如果这个负数是在整个数组的第一个位置，那这个负数是一定无法进行操作的，所以要选取。

• 如果这个负数不在整个数组的第一个位置，那这个负数有两种可能转移的状态：变 和 不变。(z1存储变的状态，z2存储不变的状态）

   如果变的话，z1[i] = z2[i-1] - nums[i]; //当前位置的结果只能是当前位置的数+前面不变的结果
   如果不变的话，z2[i] = max(z1[i-1],z2[i-1]) + nums[i];//当前位置的结果是当前位置的数+max（前面不变的结果，前面变的结果）
  

解题方法：

1. 从头开始遍历，遇到正数直接加到res里面
2. 遇到负数，得到以当前位置为起点的连续负数段[l,r]，进行判断：
   l == 0 && r == 0，说明 l 是整个数组的第一个位置且数量唯一，直接加到res中；
   l == 0 && r != 0，说明 l 是整个数组的第一个位置且数量不唯一，那第一个数字必选，从 l + 1 开始dp
   l != 0 && r != 0, 说明 l 不是整个数组的第一个位置且数量不唯一，那 l 前面的数字一定是正数，所以直接从 l 开始dp

代码：

class Solution {
public:
    long long maximumTotalCost(vector<int>& nums) {
        int n = nums.size();
        int l = 0;
        int r = 0;
        long long int res = 0;
        for(int i = 0 ; i < n ; i++){
            l = -1;
            r = -1;
            if(nums[i] < 0){
                l = i;
                for(int j = i+1 ; j < n ; j++){
                    if(nums[j] < 0)
                        continue;
                    else{
                        r = j-1;
                        i = j-1;
                        break;
                    }
                }
                if(r == -1){
                    r = n-1;
                    i = n-1;
                }
                long long int sum1 = 0 , sum2 = 0;
                if(l == 0 && r == 0){
                    res += nums[0];
                    continue;
                }
                if(l == 0 && r != 0){
                    vector<long long int> z1(r-l+5 , 0);
                    vector<long long int> z2(r-l+5 , 0);
                    long long int rr = nums[l];
                    l = l+1;
                    for(int j = l ; j <= r ; j++){
                        z1[j-l+1] = z2[j-l] - nums[j]; //变
                        z2[j-l+1] = max(z1[j-l],z2[j-l]) + nums[j];
                    }
                    res += max(rr + z1[r-l+1] , rr + z2[r-l+1]);
                    continue;
                }
                vector<long long int> z1(r-l+5 , 0);
                vector<long long int> z2(r-l+5 , 0);
                for(int j = l ; j <= r ; j++){
                    z1[j-l+1] = z2[j-l] - nums[j]; //变
                    z2[j-l+1] = max(z1[j-l],z2[j-l]) + nums[j]; //不变
                }
                res += max(z1[r-l+1] , z2[r-l+1]);
            }
            else
                res += nums[i];
        }
        return res;
    }
};