[LeetCode 困难]410. 分割数组的最大值

最新推荐文章于 2024-01-21 09:59:47 发布

barbaraaa:D

最新推荐文章于 2024-01-21 09:59:47 发布

阅读量316

点赞数

CC 4.0 BY-SA版权

文章标签： leetcode

本文链接：https://blog.csdn.net/weixin_50088096/article/details/114097676

博客围绕将非负整数数组分成 m 个非空连续子数组，使子数组和的最大值最小这一问题展开。介绍了二分查找和动态规划两种解法，并分别分析了它们的时间复杂度和空间复杂度，二分查找时间复杂度为 O(n×log(sum−maxn)) 、空间复杂度为 O(1)，动态规划时间复杂度为 O(n^2 ×m) 、空间复杂度为 O(n×m)。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

给定一个非负整数数组 nums 和一个整数 m ，你需要将这个数组分成 m 个非空的连续子数组。

设计一个算法使得这 m 个子数组各自和的最大值最小。

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

输入：nums = [1,2,3,4,5], m = 2
输出：9
示例 3：

输入：nums = [1,4,4], m = 3
输出：4
 

提示：
1 <= nums.length <= 1000
0 <= nums[i] <= 106
1 <= m <= min(50, nums.length)

二分查找

复杂度分析

时间复杂度：O(n×log(sum−maxn))，其中 sum 表示数组 nums 中所有元素的和，maxn 表示数组所有元素的最大值。每次二分查找时，需要对数组进行一次遍历，时间复杂度为 O(n)，因此总时间复杂度是 O(n×log(sum−maxn))。
空间复杂度：O(1)

class Solution {
    public int splitArray(int[] nums, int m) {
        int left = 0, right = 0;
        for (int i = 0; i < nums.length; i++) {
            right += nums[i];
            if (left < nums[i]) {
                left = nums[i];
            }
        }
        while (left < right) {
            int mid = (right - left) / 2 + left;
            //是否能够产生n个和的值小于等于mid的数组
            if (check(nums, mid, m)) {
                right = mid;
            } else {
                left = mid + 1;
            }
        }
        return left;
    }


    public boolean check(int[] nums, int x, int m) {
        int sum = 0;
        int cnt = 1;
        for (int i = 0; i < nums.length; i++) {
            if (sum + nums[i] > x) {
                cnt++;
                sum = nums[i];
            } else {
                sum += nums[i];
            }
        }
        return cnt <= m;
    }
}

动态规划

时间复杂度：O(n^2 ×m)，其中 n 是数组的长度，m 是分成的非空的连续子数组的个数。总状态数为 O(n ×m)，状态转移时间复杂度 O(n)，所以总时间复杂度为 O(n^2×m)。
空间复杂度：O(n×m)，为动态规划数组的开销。

class Solution {
   public int splitArray(int[] nums, int m) {
       int n = nums.length;
       int[][] f = new int[n + 1][m + 1];
       for (int i = 0; i <= n; i++) {
           Arrays.fill(f[i], Integer.MAX_VALUE);
       }
       int[] sub = new int[n + 1];
       for (int i = 0; i < n; i++) {
           sub[i + 1] = sub[i] + nums[i];
       }
       f[0][0] = 0;
       for (int i = 1; i <= n; i++) {
           for (int j = 1; j <= Math.min(i, m); j++) {
               for (int k = 0; k < i; k++) {
                   //每次循环找的是 前k位组成 j-1组 后k位组成1组 来比较两个组大小
                   //再和自身的大小比较 寻找最小的
                   f[i][j] = Math.min(f[i][j], Math.max(f[k][j - 1], sub[i] - sub[k]));
               }
           }
       }
       return f[n][m];
   }
}