题目

题目链接：
https://www.nowcoder.com/practice/e9f3282363844355aa51497c5410beee

思路

动态规划
两种情况（首位相连的）和首位不相连的
首尾相连的可以算最小的连续子数组得出，sum-就是。

Java代码

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param nums int整型ArrayList
     * @return int整型
     */
    public int maxSubarraySumCircular (ArrayList<Integer> nums) {
        //动态规划
        // 两种情况（首位相连的）和首位不相连的
        // 首尾相连的可以算最小的连续子数组得出，sum-就是。
        int n = nums.size();
        int[] dpmin = new int[n];
        int[] dpmax = new int[n];
        int sum = nums.get(0);
        dpmin[0] = nums.get(0);
        dpmax[0] = nums.get(0);
        int max1 = nums.get(0);
        int min1 = nums.get(0);
        int premin = nums.get(0);
        int premax = nums.get(0);

        for (int i = 1; i < n ; i++) {
            sum += nums.get(i);
            int p1 = nums.get(i);
            int p2 = nums.get(i) + premax;
            int p3 = nums.get(i) + premin;
            int curmax = Math.max(p1, p2);
            max1 = Math.max(max1, curmax);
            premax = curmax;

            dpmax[i] = max1;


            int curmin = Math.min(p1, p3);
            min1 = Math.min(min1, curmin);

            premin = curmin;
            dpmin[i] = min1;
        }

        if (sum == min1) {
            return max1;
        } else {
            return Math.max(max1, sum - min1);
        }
    }
}

Go代码

package main

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 *
 * @param nums int整型一维数组
 * @return int整型
 */
func maxSubarraySumCircular(nums []int) int {
	//动态规划
	// 两种情况（首位相连的）和首位不相连的
	// 首尾相连的可以算最小的连续子数组得出，sum-就是。
	n := len(nums)
	sum := nums[0]

	dpmin := make([]int, n)
	dpmax := make([]int, n)
	dpmax[0] = nums[0]
	dpmin[0] = nums[0]
	premax := nums[0]
	premin := nums[0]
	max1 := nums[0]
	min1 := nums[0]

	for i := 1; i < n; i++ {
		sum += nums[i]
		p1 := nums[i]
		p2 := nums[i] + premax
		p3 := nums[i] + premin

		curmax := p1
		if curmax < p2 {
			curmax = p2
		}

		if max1 < curmax {
			max1 = curmax
		}

		dpmax[i] = max1
		premax = curmax

		curmin := p1
		if curmin > p3 {
			curmin = p3
		}

		if min1 > curmin {
			min1 = curmin
		}

		dpmin[i] = min1
		premin = curmin

	}

	if sum == min1 {
		return max1
	} else {
		if sum-min1 > max1 {
			return sum - min1
		} else {
			return max1
		}
	}
}

PHP代码

<?php


/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param nums int整型一维数组 
 * @return int整型
 */
function maxSubarraySumCircular( $nums )
{
     //动态规划
    // 两种情况（首位相连的）和首位不相连的
    // 首尾相连的可以算最小的连续子数组得出，sum-就是。
    $sum = $nums[0];
    $n = count($nums);
    $dpmax = [0=>$nums[0]];
    $dpmin = [0=>$nums[0]];
    $premax =$premin=$max1 =$min1 = $nums[0];

    for($i=1;$i<$n;$i++){
        $sum+=$nums[$i];
        $p1 = $nums[$i];
        $p2 = $nums[$i]+$premax;
        $p3 = $nums[$i]+$premin;

        $curmax = $p1;
        if($curmax < $p2) {
            $curmax = $p2;
        }

        if($max1 <$curmax){
            $max1 = $curmax;
        }

        $dpmax[$i] = $max1;
        $premax = $curmax;

        $curmin = $p1;
        if($curmin > $p3){
            $curmin = $p3;
        }

        if($min1 > $curmin){
            $min1 = $curmin;
        }

        $dpmin[$i] = $min1;
        $premin = $curmin;
    }

    if($sum ==$min1){
        return $max1;
    }else{
        if($max1 > $sum-$min1){
            return $max1;
        }else{
            return $sum-$min1;
        }
    }
}

C++代码

class Solution {
  public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param nums int整型vector
     * @return int整型
     */
    int maxSubarraySumCircular(vector<int>& nums) {
        //动态规划
        // 两种情况（首位相连的）和首位不相连的
        // 首尾相连的可以算最小的连续子数组得出，sum-就是。

        int n = nums.size();
        vector<int> dpmax(n);
        vector<int> dpmin(n);
        int  sum, max1, min1, premax, premin;
        max1 = min1 = premax = premin = sum = nums[0];
        for (int i = 1; i < n; i++) {
            sum += nums[i];
            int p1 = nums[i];
            int p2 = nums[i] + premax;
            int p3 = nums[i] + premin;
            int curmax = p1;
            if (curmax < p2) {
                curmax = p2;
            }

            if (max1 < curmax) {
                max1 = curmax;
            }

            dpmax[i] = max1;
            premax = curmax;

            int curmin = p1;
            if (curmin > p3) {
                curmin = p3;
            }

            if (min1 > curmin) {
                min1 = curmin;
            }

            dpmin[i] = min1;
            premin = curmin;
        }

        if (sum == min1) {
            return max1;
        } else {
            if (max1 > sum - min1) {
                return max1;
            } else {
                return sum - min1;
            }
        }
    }
};