求解最大m子段和问题

分享两个版本的解决方案，共个3版，后面2版为优化后的代码。

    private int mSubArray(int[] nums, int m) {
        int n = nums.length;
        int[][] dp = new int[2][n + 1];
        int cur = 1;
        int old = 1 - cur;
        for (int i = 1; i <= m; i++) {
            old = cur;
            cur = 1 - cur;
            for (int j = i; j <= n - m + i; j++) {
                if (j > i) {
                    dp[cur][j] = dp[cur][j - 1] + nums[j - 1];
                    for (int t = i - 1; t < j; t++) {
                        int s = dp[old][t] + nums[j - 1];
                        if (s > dp[cur][j]) {
                            dp[cur][j] = s;
                        }
                    }
                } else {
                    dp[cur][j] = dp[old][j - 1] + nums[j - 1];
                }
            }

        }
        int sum = 0;
        for (int j = m; j <= n; j++) {
            if (dp[cur][j] > sum) {
                sum = dp[cur][j];
            }
        }
        return sum;
    }

    private int mSubArraySum(int[] nums, int m) {
        int n = nums.length;
        int[] dp = new int[n + 1];
        int[] lastMax = new int[n + 1];
        for (int i = 1; i <= m; i++) {
            int max = 0;
            for (int j = i; j <= n - m + i; j++) {
           
                if (j > i) {
                    dp[j] = (dp[j - 1] > lastMax[j - 1] ? dp[j - 1] : lastMax[j - 1]) + nums[j - 1]; 
                    lastMax[j - 1] = max;
                    max = Math.max(max, dp[j]);
                } else {
                    dp[j] = dp[j - 1] + nums[j - 1];
                    max = Math.max(max, dp[j]);
                }
                lastMax[n - m + i] = max;
            }
        }
        int sum = 0;
        for (int j = m; j <= n; j++) {
            if (dp[j] > sum) {
                sum = dp[j];
            }
        }
        return sum;
    }

    private int mSubArraySum(int[] nums, int n, int m) {
        int[] dp = new int[n + 1];
        int[] lastMax = new int[n + 1];
        int globalMax = -1;
        for (int i = 1; i <= m; i++) {
            int max = 0;
            for (int j = i; j <= n - m + i; j++) { 
                if (j > i) {
                    dp[j] = (dp[j - 1] > lastMax[j - 1] ? dp[j - 1] : lastMax[j - 1]) + nums[j - 1]; 
                    lastMax[j - 1] = max;
                    max = Math.max(max, dp[j]);
                } else {
                    dp[j] = dp[j - 1] + nums[j - 1];
                    max = Math.max(max, dp[j]);
                }
                if (i == m) {
                    globalMax = Math.max(globalMax, dp[j]);
                }
            }
            lastMax[n - m + i] = max;
        }
        return globalMax;
    }

main函数中需要对输入的数据进行处理，以优化存储空间。

    public static void main(String[] args) {

        Main pl = new Main();

        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int n = scanner.nextInt();
            int m = scanner.nextInt();
            int[] nums = new int[n];
            for (int i = 0; i < n; i++) {
                nums[i] = scanner.nextInt();
            }
            //对数据进行预处理
            int count = 0;
            int partSum = 0;
            boolean posSum = true;
            boolean negSum = true;
            for (int i = 0; i < nums.length; i++) {
                if (nums[i] == 0) {
                    continue;
                }
                if (nums[i] > 0 && posSum) {
                    //posSum = true;
                    negSum = false;
                    partSum += nums[i];
                    continue;
                } else if (nums[i] < 0 && negSum) {
                    posSum = false;
                    // negSum = true;
                    partSum += nums[i];
                    continue;
                } else if ((nums[i] > 0 && negSum) || (nums[i] < 0 && posSum)) { 
                    posSum = !posSum;
                    negSum = !negSum;
                    nums[count++] = partSum;
                    partSum = nums[i];
                }
            }
            nums[count++] = partSum;

            int maxSum = pl.mSubArraySumSubmit(nums, count, m);
            System.out.println(maxSum);
        }
    }