【力扣-动态规划入门】【第 5 天】918. 环形子数组的最大和

标题：918. 环形子数组的最大和
难度：中等
天数：第5天,第2/2题

给定一个由整数数组 A 表示的环形数组 C，求 C 的非空子数组的最大可能和。

在此处，环形数组意味着数组的末端将会与开头相连呈环状。（形式上，当0 <= i < A.length 时 C[i] = A[i]，且当 i >= 0 时 C[i+A.length] = C[i]）

此外，子数组最多只能包含固定缓冲区 A 中的每个元素一次。（形式上，对于子数组 C[i], C[i+1], ..., C[j]，不存在 i <= k1, k2 <= j 其中 k1 % A.length = k2 % A.length）

 

示例 1：

输入：[1,-2,3,-2]
输出：3
解释：从子数组 [3] 得到最大和 3

示例 2：

输入：[5,-3,5]
输出：10
解释：从子数组 [5,5] 得到最大和 5 + 5 = 10

示例 3：

输入：[3,-1,2,-1]
输出：4
解释：从子数组 [2,-1,3] 得到最大和 2 + (-1) + 3 = 4

示例 4：

输入：[3,-2,2,-3]
输出：3
解释：从子数组 [3] 和 [3,-2,2] 都可以得到最大和 3

示例 5：

输入：[-2,-3,-1]
输出：-1
解释：从子数组 [-1] 得到最大和 -1

提示：

1. -30000 <= A[i] <= 30000
2. 1 <= A.length <= 30000

来源：力扣（LeetCode）
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：

1. 这题相当于是53. 最大子数组和的扩展，不考虑环形，我们可以采用相同方法找到出现的最大和
   • 我们用dpMax代表算上当前值得最大累计值
   • 我们用max记录出现过所有最大值里最大的那个

 	//记录最大值累计值
	int dpMax = 0;
	//记录最大值里最大的
	int max = nums[0];
	for(int i = 0 ; i < nums.length;i++){
		int item = nums[i];
		//累计数组每个值的和
		sum += item;
		
		if(dpMax > 0){
			dpMax += item;
		}else{
			dpMax = item;
		}
		max = Math.max(dpMax,max);
	}

2. 考虑到环形问题
   • 累加数组所有元素得到和sum
   • 找出最小的连续和min
   • sum-min就有可能是环形数组最大的和
   • 最后从max和sum-min取最大值,

 	if(dpMin < 0){
		dpMin += item;
	}else{
		dpMin = item;
	}
	min = Math.min(min,dpMin);
xxxx

 return Math.max(max,sum - min);

3. 如果都计算完，但是max<0代表数组都是负数，直接返回max

 	//max <0  代表数组都是负数，直接返回max
	if(max < 0){
		return max;
	}

完整代码：

class Solution {
    //动态规划  第5天  2/2
    public int maxSubarraySumCircular(int[] nums) {
        //记录最大值累计值
        int dpMax = 0;
        //记录最小值累计值
        int dpMin = 0;
        //记录最大值里最大的
        int max = nums[0];
         //记录累计最小值
        int min = nums[0];
        int sum = 0;
        
        for(int i = 0 ; i < nums.length;i++){
           int item = nums[i];
           //累计数组每个值的和
            sum += item;
           //------记录最大值部分 start-----
            if(dpMax > 0){
                dpMax += item;
            }else{
                dpMax = item;
            }
            max = Math.max(dpMax,max);
            //------记录最大值部分 end-----

            //------记录最小值部分 start ------
            if(dpMin < 0){
                dpMin += item;
            }else{
                dpMin = item;
            }
            min = Math.min(min,dpMin);
             //------记录最小值部分 end ------
        }
        //max <0  代表数组都是负数，直接返回max
        if(max < 0){
            return max;
        }
         //对比 最大值，和总和-最小值  大小
        //如果max最大，代表不包含头尾
        //如果总和-最小值  大，代表包含头尾
        
        return Math.max(max,sum - min);
    }
}

还有一种看着不乱的写法，但耗时和浪费内存

class Solution {
    //动态规划  第5天  2/2
    public int maxSubarraySumCircular(int[] nums) {
        int m = nums.length;
        int[][] dp = new int[m][5];
        //记录全部累计值
        dp[0][0] = nums[0];
        //记录当前最大累计和
        dp[0][1] =  nums[0];
        //记录当前最小累计和
        dp[0][2] = nums[0];
        //记录从0-n出现过的最大连续和
        dp[0][3] = nums[0];
        //记录从0-n 出现过的最小连续和
        dp[0][4] = nums[0];
        
        for(int i = 1 ; i < nums.length;i++){
            int item = nums[i];
            //记录从0-n的累计值
            dp[i][0] = dp[i-1][0] + item;
            
            //记录算当前元素的最大和
            if(dp[i-1][1] > 0){
                dp[i][1] =dp[i-1][1] + item;
            }else{
                dp[i][1] = item;
            }
            //记录从0-n出现过的最大和
            dp[i][3] = Math.max(dp[i-1][3],dp[i][1]);
            
            //记录算当前元素的最小和
            if(dp[i-1][2] < 0){
                dp[i][2] = dp[i-1][2]+item;
            }else{
                dp[i][2] = item;
            }
            //记录从0-n出现过的最小和
            dp[i][4] = Math.min(dp[i-1][4],dp[i][2]);
        }

        //如果从0-n最大和<0,代表数组都是负数
        if(dp[m-1][3] < 0){
            return dp[m-1][3];
        }
        //对比  记录的最大和 vs  累计值-最小值
        return Math.max(dp[m-1][3],dp[m-1][0] - dp[m-1][4]);
    }
}