Leetcode 1043. 分隔数组以得到最大和

Leetcode 1043. 分隔数组以得到最大和

题目

给你一个整数数组 arr，请你将该数组分隔为长度最多为 k 的一些（连续）子数组。分隔完成后，每个子数组的中的所有值都会变为该子数组中的最大值。

返回将数组分隔变换后能够得到的元素最大和。

 

注意，原数组和分隔后的数组对应顺序应当一致，也就是说，你只能选择分隔数组的位置而不能调整数组中的顺序。

示例 1：

输入：arr = [1,15,7,9,2,5,10], k = 3
输出：84
解释：
因为 k=3 可以分隔成 [1,15,7] [9] [2,5,10]，结果为 [15,15,15,9,10,10,10]，和为 84，是该数组所有分隔变换后元素总和最大的。
若是分隔成 [1] [15,7,9] [2,5,10]，结果就是 [1, 15, 15, 15, 10, 10, 10] 但这种分隔方式的元素总和（76）小于上一种。 

示例 2：

输入：arr = [1,4,1,5,7,3,6,1,9,9,3], k = 4
输出：83

示例 3：

输入：arr = [1], k = 1
输出：1

思路

• 这道题目一看感觉可以用dfs来解决， 但是剪枝没剪好， 所以超时了
• 所以换成dp来解决
• 设置状态：dp[size] —— 从第一位开始总长度为size的最大和
• 状态转移： dp[i] = max(dp[i], dp[j] + (i - j) * Max)
• 初始状态： 全部设置为0即可

代码

• dfs（c++） —— 超时

class Solution {
public:
    void dfs(vector<int>& arr, int k, long long& res, int start, long long sum) {
        if (start >= arr.size()) {
            res = max(res, sum);
            return;
        }

        int Max = 0;

        for (int i = start;i <= start + k - 1 && i < arr.size();++i) {
            for (int j = start;j <= i;++j) {
                Max = max(Max, arr[j]);
            }

            dfs(arr, k, res, i + 1, sum + 1LL * (i - start + 1) * Max);
        }
    }

    int maxSumAfterPartitioning(vector<int>& arr, int k) {
        long long res = 0;
        dfs(arr, k, res, 0, 0);
        return res;
    }
};

• dp（python3）

class Solution:
    def maxSumAfterPartitioning(self, arr: List[int], k: int) -> int:
        size = len(arr)
        dp = (size + 1) * [0]

        for i in range(size + 1):
            for j in range(i - 1, max(i - k - 1, -1), -1):
                Max = max(arr[j:i])
                dp[i] = max(dp[i], dp[j] + (i - j) * Max)

        return dp[size]