【算法专题】区间最大和

区间最大和

1. 概述

• 此类问题一般是：给出一个序列，让从中选出一些连续的不相交子序列，使得选出的子序列和最大。

• 子区间长度可能不定，也可能固定。选出的区间数可能是一个，也可能是多个。

• 如下给出了三个例题：

  • Leetcode 0053 最大子序和：选出一个子区间，长度不定；

  • AcWing 1051. 最大的和：选出两个子区间，长度不定；

  • Leetcode 0689 三个无重叠子数组的最大和：选出三个子区间，长度都相同。可以扩展为选出多个子区间。

2. 例题

Leetcode 0053 最大子序和

题目描述：Leetcode 0053 最大子序和

分析

• 本题的考点：动态规划、分治。

动态规划

• 考虑状态表示f[i]：表示以nums[i]结尾的最大的连续子数组和。

• 考虑状态转移：$f[i]=max(f[i-1],0)+nums[i],0<i<n$。

• 我们发现每个状态只和上一个状态有关，因此只是用一个变量f记录每个状态，并在递推过程中记录答案res即可。

分治

• 关于进阶中的分治算法，时间空间都不会优于动态规划，但是其具有拓展性，这里讲解一下。这个题目的拓展可以参考线段树中的AcWing 245. 你能回答这些问题吗。

• 下面是这一题的分治算法讲解。

• 我们对区间进行递归，对于每个区间[l, r]，我们需要记录以下内容：

struct Node {
    int sum;  // 区间总和
    int s;  // 区间最大的连续子数组和
    int ls;  // 区间最大前缀和
    int rs;  // 区间最大后缀和
}

• 根据这些信息我们就可以从子区间构造父区间的信息。具体为什么有这些字段，可以参考线段树中的AcWing 245. 你能回答这些问题吗。

• 结构体内并没有记录区间的两个端点，这是因为我们只需要求解整个区间的最大的连续子数组和，这两个端点会在递归的过程中传下去。

代码

• C++

// 动态规划
class Solution {
public:
    int maxSubArray(vector<int>& nums) {

        int f = nums[0], res = nums[0];
        for (int i = 1; i < nums.size(); i++) {
            f = max(f, 0) + nums[i];
            res = max(res, f);
        }
        return res;
    }
};

// 分治
class Solution {
public:
    struct Node {
        // 区间总和、区间最大的连续子数组和、区间最大前缀和、区间最大后缀和
        int sum, s, ls, rs;
    };

    // 返回由nums[l, r]构造的Node
    Node build(vector<int> &nums, int l, int r) {

        if (l == r) return {nums[l], nums[l], nums[l], nums[l]};

        int mid = l + r >> 1;
        auto left = build(nums, l, mid), right = build(nums, mid + 1, r);
        Node res;
        res.sum = left.sum + right.sum;
        res.s = max(max(left.s, right.s), left.rs + right.ls);
        res.ls = max(left.ls, left.sum + right.ls);
        res.rs = max(right.rs, right.sum + left.rs);
        return res;
    }

    int maxSubArray(vector<int>& nums) {

        auto t = build(nums, 0, nums.size() - 1);
        return t.s;
    }
};

• Java

// 动态规划
class Solution {
    public int maxSubArray(int[] nums) {

        int f = nums[0], res = nums[0];
        for (int i = 1; i < nums.length; i++) {
            f = Math.max(f, 0) + nums[i];
            res = Math.max(res, f);
        }
        return res;
    }
}

// 分治
class Solution {
    
    static class Node {
        // 区间总和、区间最大的连续子数组和、区间最大前缀和、区间最大后缀和
        int sum, s, ls, rs;

        public Node() {}
        public Node(int sum, int s, int ls, int rs) {
            this.sum = sum; this.s = s; this.ls = ls; this.rs = rs;
        }
    }
    
    // 返回由nums[l, r]构造的Node
    private Node build(int[] nums, int l, int r) {

        if (l == r) return new Node(nums[l], nums[l], nums[l], nums[l]);

        int mid = l + r >> 1;
        Node left = build(nums, l, mid), right = build(nums, mid + 1, r);
        Node res = new Node();
        res.sum = left.sum + right.sum;
        res.s = Math.max(Math.max(left.s, right.s), left.rs + right.ls);
        res.ls = Math.max(left.ls, left.sum + right.ls);
        res.rs = Math.max(right.rs, right.sum + left.rs);
        return res;
    }

    public int maxSubArray(int[] nums) {

        Node t = build(nums, 0, nums.length - 1);
        return t.s;
    }
}

• Python

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        f = nums[0]
        res = nums[0]
        for i in range(1, len(nums)):
            f = max(f, 0) + nums[i]
            res = max(res, f)
        return res

时空复杂度分析

• 时间复杂度：动态规划：$O(n)$，n为数组长度。分治：$O(n)$。因为$n+\frac{n}{2}+\frac{n}{4}+...\approx 2\times n$。

• 空间复杂度：动态规划：$O(1)$。分治：$O(log(n))$。$log(n)$为递归深度。

#AcWing 1051. 最大的和

问题描述

• 问题链接：AcWing 1051. 最大的和

  

分析

• 本题使用前后缀分解，然后使用AcWing 55. 连续子数组的最大和的方式解决即可。

代码

• C++

#include <iostream>

using namespace std;

const int N = 50010, INF = 1e9;

int n;
int w[N];
int g[N], h[N];  // g[i]: w[1~i]中连续最大子段和, h[i]: w[i~n]中连续最大子段和

int main() {
    
    int T;
    cin >> T;
    while (T--) {
        cin >> n;
        for (int i = 1; i <= n; i++) cin >> w[i];
        
        g[0] = -INF;
        for (int i = 1, s = 0; i <= n; i++) {
            s = max(s, 0) + w[i];
            g[i] = max(g[i - 1], s);
        }
        
        h[n + 1] = -INF;
        for (int i = n, s = 0; i; i--) {
            s = max(s, 0) + w[i];
            h[i] = max(h[i + 1], s);
        }
        
        int res = -INF;
        for (int i = 1; i < n; i++) res = max(res, g[i] + h[i + 1]);
        
        cout << res << endl;
    }
    
    return 0;
}

Leetcode 0689 三个无重叠子数组的最大和

题目描述：Leetcode 0689 三个无重叠子数组的最大和

分析

• 本题的考点：动态规划。

• 因为这里需要求解方案，且求解字典序最小的方案，因此需要类似于背包问题求解方案，需要从后向前进行DP，最后从前向后判断前面某段是否可选，能选则选，这样字典序最小。

• 分析如下：

• 可以看到，分析中需要使用某段区间的和，可以使用前缀和技巧。

• 因为牵涉到前缀和，因此下标都从1开始。

代码

• C++

class Solution {
public:
    vector<int> maxSumOfThreeSubarrays(vector<int>& nums, int k) {

        int n = nums.size();
        vector<int> s(n + 1);
        for (int i = 1; i <= n; i++) s[i] = s[i - 1] + nums[i - 1];
        vector<vector<int>> f(n + 2, vector<int>(4));

        int x = n + 1, y = 3;
        for (int i = n - k + 1; i; i--) {
            for (int j = 1; j <= 3; j++)
                f[i][j] = max(f[i + 1][j], f[i + k][j - 1] + s[i + k - 1] - s[i - 1]);
            if (f[x][3] <= f[i][3]) x = i;  // 因为要求字典序最小的方案，需要等于号
        }

        vector<int> res;
        while (y) {
            while (f[x][y] != f[x + k][y - 1] + s[x + k - 1] - s[x - 1]) x++;
            res.push_back(x - 1);
            x += k, y--;
        }
        return res;
    }
};

时空复杂度分析

• 时间复杂度：$O(n)$，n为数组长度。

• 空间复杂度：$O(n)$。