Split Array Largest Sum

Given an array which consists of non-negative integers and an integer m, you can split the array into m non-empty continuous subarrays. Write an algorithm to minimize the largest sum among these m subarrays.

Note:
Given m satisfies the following constraint: 1 ≤ m ≤ length(nums) ≤ 14,000.

Examples:

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

Output:
18

Explanation:
There are four ways to split nums into two subarrays.
The best way is to split it into [7,2,5] and [10,8],
where the largest sum among the two subarrays is only 18.

分析：暴力解法

虽然要把数组分成几份，但是因为数组里的元素是连续的，所以，我们可以把前面部分当成第一份，然后找出后边部分分出 m - 1次时最大的和。所以递归方法可解。但是，很明显，cost太高了。

public class Solution {
    //brute-force approach
    public int splitArray(int[] nums, int m) {
        long[] sums = new long[nums.length];
        sums[0] = nums[0];

        for (int i = 1; i < sums.length; i++) {
            sums[i] = sums[i - 1] + nums[i];
        }

        return (int) helper(nums, sums, 0, sums.length - 1, m);
    }

    public long helper(int[] nums, long[] sums, int start, int end, int k) {
        if (k <= 0)
            return Integer.MAX_VALUE;
        if (k == 1) {
            if (start == 0) {
                return sums[end];
            } else {
                return sums[end] - sums[start - 1];
            }
        }
        long min = Long.MAX_VALUE;

        for (int i = start; i <= end; i++) {

            long leftSum;
            if (start == 0) {
                leftSum = sums[i];
            } else {
                leftSum = sums[i] - sums[start - 1];
            }

            min = Math.min(min, Math.max(leftSum, helper(nums, sums, i + 1, end, k - 1)));
        }
        return min;
    }
}

 

第二种方法：

首先找出数组的最大值max和所有值的和sum。然后那个最小值一定是在max和sum之间。 所以可以利用binary search来寻找。

reference: https://discuss.leetcode.com/topic/61315/java-easy-binary-search-solution-8ms

public class Solution {
    public int splitArray(int[] nums, int m) {
        long sum = 0;
        int max = 0;
        for (int num : nums) {
            max = Math.max(max, num);
            sum += num;
        }
        return (int) binary(nums, m, sum, max);
    }

    private long binary(int[] nums, int m, long high, long low) {
        long mid = 0;
        while (low <= high) {
            mid = (high + low) / 2;
            if (valid(nums, m, mid)) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        return low;
    }

    private boolean valid(int[] nums, int m, long max) {
        int cur = 0, count = 1;
        for (int num : nums) {
            cur += num;
            if (cur > max) {
                cur = num;
                count++;
                if (count > m) {
                    return false;
                }
            }
        }
        return true;
    }
}