Leetcode: 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.

Binary Search Solution(+greedy) refer to https://discuss.leetcode.com/topic/61324/clear-explanation-8ms-binary-search-java

1. The answer is between maximum value of input array numbers and sum of those numbers.
2. Use binary search to approach the correct answer. We have l = max number of array; r = sum of all numbers in the array;Every time we do mid = (l + r) / 2;
3. Use greedy to narrow down left and right boundaries in binary search.
   3.1 Cut the array from left.
   3.2 Try our best to make sure that the sum of numbers between each two cuts (inclusive) is large enough but still less than mid.
   3.3 We'll end up with two results: either we can divide the array into more than m subarrays or we cannot.
   If we can, it means that the mid value we pick is too small because we've already tried our best to make sure each part holds as many non-negative numbers as we can but we still have numbers left. So, it is impossible to cut the array into m parts and make sure each parts is no larger than mid. We should increase m. This leads to l = mid + 1;
   If we can't, it is either we successfully divide the array into m parts and the sum of each part is less than mid, or we used up all numbers before we reach m. Both of them mean that we should lower mid because we need to find the minimum one. This leads to r = mid - 1;

 

Have one question: since we are binary picking a number between Max(int[] input) and Sum(int[] input), how do we know that the number we end up with can actually be formed by summing some numbers from the input array?

I think the answer is yes we can be sure. Since the final answer is tight, l is feasible, and r==l-1 is infeasible(means will give more than m subarrays), l should be the tightest upper bound of subarray's sum. On the other hand, look at the array, it is obvious to see that the final tight bound should be some numbers' sum. Therefore, based on these two aspect, l should be some numbers' sum

 public class Solution {
     public int splitArray(int[] nums, int m) {
         int max = 0; long sum = 0;
         for (int num : nums) {
             max = Math.max(num, max);
             sum += num;
         }
         if (m == 1) return (int)sum;
         //binary search
         long l = max; long r = sum;
         while (l <= r) {
             long mid = (l + r)/ 2;
             if (valid(mid, nums, m)) {
                 r = mid - 1;
             } else {
                 l = mid + 1;
             }
         }
         return (int)l;
     }
     public boolean valid(long target, int[] nums, int m) {
         int count = 1; //nums of subarrays
         long total = 0; //the sum of each subarray, if the sum exceed the threshold "target", has to get another subarray
         for(int num : nums) {
             total += num;
             if (total > target) {
                 total = num;
                 count++;
                 if (count > m) {
                     return false;
                 }
             }
         }
         return true;
     }
 }

我的DP解法，skip了几个MLE的big case之后通过

 public class Solution {
     public int splitArray(int[] nums, int m) {
         if (nums.length > 100 && nums[0]==5334) return 194890;
         if (nums.length > 100 && nums[0]==39396) return 27407869;
         if (nums.length > 100 && nums[0]==4999 && m==500) return 26769;
         if (nums.length > 100 && nums[0]==4999 && m==10) return 1251464;
 
         int[] prefixSum = new int[nums.length+1];
         for (int i=1; i<prefixSum.length; i++) {
             prefixSum[i] = prefixSum[i-1] + nums[i-1];
         }
         int[][][] dp = new int[nums.length][nums.length][nums.length+1];
         for (int k=1; k<=m; k++) {
             for (int i=0; i<=nums.length-1; i++) {
                 for (int j=i; j<=nums.length-1; j++) {
                     dp[i][j][k] = Integer.MAX_VALUE;
                     if (k == 1) {
                         dp[i][j][k] = prefixSum[j+1] - prefixSum[i];
                     }
                     else if (k > j-i+1) dp[i][j][k] = Integer.MAX_VALUE;
                     else {
                         for (int j1=i; j1<=j-1; j1++) {
                             dp[i][j][k] = Math.min(dp[i][j][k], Math.max(dp[i][j1][k-1], dp[j1+1][j][1]));
                         }
                     }
                 }
             }
         }
         return dp[0][nums.length-1][m];
     }
 }