Leetcode 410. Split Array Largest Sum

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

Note:
If n is the length of an array, assume the following constraints is satisfied:

1≤n≤1000
1≤m≤min (50 , N)
E

This problem has two solutions, dynamic planning and binary search, dynamic planning requires three-layer cycle, not as efficient as two-point search

DP solution. This was obviously not as good as the binary search solutions;

But it did pass OJ.

DP[S,J] is the solution for splitting Subarray n[j]...n[l-1] into s parts.  Dp[s+1,i] = min{max (dp[s,j], n[i]+...+n[j-1])}, i+1 <= J <= L-s This solution does don't take advantage of the fact That the numbers is non-negative (except to break the inner loop early). That's a loss. 
(On the other hand, it can is used for the problem containing arbitrary numbers) public int splitarray (int[] nums, int m)
    {int L = nums.length;
    int[] S = new int[l+1];
    s[0]=0;

    for (int i=0; i<l; i++) s[i+1] = s[i]+nums[i];
    Int[] dp = new INT[L];

    for (int i=0; i<l; i++) dp[i] = s[l]-s[i];
            for (int s=1, s<m; s++) {for (int i=0; i<l-s; i++) {dp[i]=integer.max_value;
                for (int j=i+1; j<=l-s; J + +) {int t = Math.max (Dp[j], s[j]-s[i]);
                  if (T<=dp[i])  dp[i]=t;
            else break;
}}} return dp[0]; }

Using binary search

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;
        Long total = 0;
        for (int. num:nums) {Total
            + = num;
            if (Total > Target) {total
                = num;
                count++;
                if (Count > m) {
                    return false;
                }
            }
        }
        return true;
    }
}

The

Vaild function is a greedy way of dividing an array into multiple parts, each time accumulating until it exceeds target. If the score is greater than M, the target is too small, should be increased, in the binary search correction L = mid +1; if it is less than M, the target selection is too large, and the correct R = mid-1. If equal to M, the installation of greed is a way to find out whether or not to be smaller, so the correction R = mid-1.