leetocde410. 分割数组的最大值/动态规划，二分+贪心

题目：410. 分割数组的最大值

给定一个非负整数数组和一个整数 m，你需要将这个数组分成 m 个非空的连续子数组。设计一个算法使得这 m 个子数组各自和的最大值最小。

注意:
数组长度 n 满足以下条件:

• 1 ≤ n ≤ 1000
• 1 ≤ m ≤ min(50, n)

示例:

输入:
nums = [7,2,5,10,8]
m = 2

输出:
18

解释:
一共有四种方法将nums分割为2个子数组。
其中最好的方式是将其分为[7,2,5] 和 [10,8]，
因为此时这两个子数组各自的和的最大值为18，在所有情况中最小。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/split-array-largest-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

基本思想1：动态规划

• dp[i][j]：表示前 j 个元素（包括第j 个元素）分割成 i 个数组的最大值
• 状态：每个元素，分割的数组数
• 选择：最后一个分割点在哪个元素处，需要遍历前面的元素来确定

注意：这里定义的数组dp的元素是long型，原因在于：测试用例中有元素INT_MAX。

class Solution {
public:
    int splitArray(vector<int>& nums, int m) {
        if(nums.size() == 0)
            return 0;
        vector<vector<long>> dp(m + 1, vector<long>(nums.size(), INT_MAX));
        for(int i = 1; i <= m; ++i){
            for(int j = 0; j < nums.size(); ++j){
                
                if(i == 1){
                    dp[i][j] = nums[j] + (j > 0 ? dp[i][j - 1] : 0);
                }
                else
                for(int k = i - 2; k < j; ++k){
                    int cur = max(dp[i - 1][k], dp[1][j] - dp[1][k]);
                    if(dp[i][j] > cur)
                        dp[i][j] = cur;
                }
            }
        }
        return dp[m][nums.size() - 1];
    }
};

基本思想2：二分+贪心

分隔数组的最大值在[max(nums[i]), sum(nums[i])]之间，也就是单个元素的最大值和，元素的总和之间。
借助二分法，来寻找这个最大值：

• 初始时，选择边界作为左右元素，验证中间值是否是结果

如何验证中间值是否是结果？贪心算法

• 以中间值作为连续子数组和的标准，统计最接近且不超过中间值的子数组的数量cnt
• 如果cnt > m，说明中间值太小了，左指针移动为mid+1
• 如果cnt <= m，说明中间值太大了或者也有可能就是最终结果，右指针移动为mid

class Solution {
public:
    int splitArray(vector<int>& nums, int m) {
        long left = 0, right = 0;
        for(int i = 0; i < nums.size(); ++i){
            right += nums[i];
            if(left < nums[i])
            left = nums[i];
        }
        while(left < right){
            int mid = (right - left) / 2 + left;
            if(judge(nums, mid, m)){
                right = mid;
            }
            else
                left = mid + 1;
        }
        return right;
    }
private:
    bool judge(vector<int>& nums, int mid, int m){
        int cnt = 1; 
        long sum = 0;
        for(int i = 0; i < nums.size(); ++i){
            if(sum + nums[i] > mid){
                ++cnt;
                sum = nums[i];
            }
            else{
                sum += nums[i];
            }
        }
        return cnt <= m;
    }
};