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:
If n is the length of array, assume the following constraints are satisfied:
1 ≤ n ≤ 1000
1 ≤ m ≤ min(50, n)
E
这题有两种解法,动态规划和二分搜索,动态规划需要三层循环,不如二分搜索高效
DP solution. This is 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 not take advantage of the fact that the numbers are non-negative (except to break the inner loop early). That is a loss. (On the other hand, it can be 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];
}
采用二分搜索
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;
}
}
vaild函数是一种贪心的将数组分成多份的方法,每次累加直到超过target。如果分出的分数大于m,说明target太小了,应该增加,在二分搜索中修正l = mid +1;如果小于m,说明target选的太大了,修正r = mid-1。如果等于m,说明安装贪心是一种分的方法,寻求能否更小,所以修正r = mid-1。