题目地址:
https://leetcode.com/problems/split-array-largest-sum/
给定一个正整数数组 A A A,再给定一个正整数 m m m,要求将 A A A分为若干连续的子段,使得每个子段的和的最大值最小。返回那个最小和。
法1:二分答案。答案可能的区间是 [ l , r ] = [ max A , ∑ A ] [l,r]=[\max A, \sum A] [l,r]=[maxA,∑A],对应着分 l A l_A lA段和分 1 1 1段。接着对于某个答案 x x x进行判定。我们要找的是最小的 x x x,使得 A A A能分为 m m m段,每段的和都小于等于 x x x。判定方式是,先从 A [ 0 ] A[0] A[0]开始,每次贪心地累加 A A A的一段,直到恰好到最后一个小于等于 x x x的位置为止,这一段就分出来了,然后再开始下一段的累加,直到整个 A A A被分割完毕。接着开始判定,如果 A A A被拆为小于等于 m m m段,那显然也能拆为 m m m段也使得每段的和小于等于 x x x,说明 x x x已经满足条件了,答案应该在 [ l , x ] [l,x] [l,x]中;如果 A A A被分为大于 m m m段,那说明 x x x设置的太小了,应该在 ( x , r ] (x,r] (x,r]中寻找答案(这里需要证明一下一定不存在将 A A A分为 m m m段且每段和都小于等于 x x x的分法。思路是数学归纳法和反证法。首先当 A A A长度是 1 1 1那显然成立。接着反证法,如果存在,不妨设这种分法的第一段的长度 s s s是小于上面判定所使用的分法分出来的第一段长度 t t t,这样就存在 A [ s + 1 : l A − 1 ] A[s+1:l_A-1] A[s+1:lA−1]的一种分法可以分为 m − 1 m-1 m−1段使得每段和小于等于 x x x,直接把分割点分在 A [ t + 1 : l A − 1 ] A[t+1:l_A-1] A[t+1:lA−1]上,就得到了 A [ t + 1 : l A − 1 ] A[t+1:l_A-1] A[t+1:lA−1]的 m − 1 m-1 m−1段的分法,但由归纳假设,贪心法得到的段数已经是最小的了,矛盾)。代码如下:
class Solution {
public:
int splitArray(vector<int>& A, int k) {
int l = 0, r = 0;
for (int x : A) l = max(l, x), r += x;
while (l < r) {
int mid = l + (r - l >> 1);
if (check(A, k, mid)) r = mid;
else l = mid + 1;
}
return l;
}
bool check(vector<int>& A, int k, int sum) {
int cnt = 1, ksum = 0;
for (auto x : A) {
if (ksum + x <= sum) ksum += x;
else cnt++, ksum = x;
if (cnt > k) return false;
}
return cnt <= k;
}
};
时间复杂度 O ( l A log ∑ A i ) O(l_A\log \sum A_i) O(lAlog∑Ai),这里求和只对 A A A把最大值删掉的部分求和,空间复杂度 O ( 1 ) O(1) O(1)。
法2:二分答案。设 f [ i ] [ j ] f[i][j] f[i][j]为将 A [ 0 : j ] A[0:j] A[0:j]分为 i i i段的所有方案里,使得最大子段和最小那种方案的最大子段和。则 f [ 1 ] [ j ] = ∑ k = 0 j A [ k ] f[1][j]=\sum_{k=0}^{j}A[k] f[1][j]=∑k=0jA[k]。按照最后一段分的位置分类,可以将分为 i i i段的方案划分为,最后一段是 A [ j ] , A [ j − 1 , j ] , . . . , A [ i − 1 , i , . . . , j ] A[j],A[j-1,j],...,A[i-1,i,...,j] A[j],A[j−1,j],...,A[i−1,i,...,j]这些情况,所以有: f [ i ] [ j ] = min k ≥ i − 1 { max { f [ i − 1 ] [ k − 1 ] , ∑ l = k j A [ l ] } } f[i][j]=\min_{k\ge i-1}\{\max\{f[i-1][k-1],\sum_{l=k}^{j}A[l]\}\} f[i][j]=k≥i−1min{max{f[i−1][k−1],l=k∑jA[l]}}也就是说, f [ i ] [ j ] f[i][j] f[i][j]实际上就是,枚举所有的 k ≥ i − 1 k\ge i - 1 k≥i−1,最后一段 A [ k : j ] A[k:j] A[k:j]的和与前面分割的最大子段和取个最大,这些值再随着 k k k取最小。代码如下:
class Solution {
public:
int splitArray(vector<int>& A, int k) {
int n = A.size();
int f[k + 1][n];
for (int i = 0; i < n; i++) {
f[1][i] = A[i];
if (i) f[1][i] += f[1][i - 1];
}
for (int i = 2; i <= k; i++)
for (int j = i - 1; j < n; j++) {
int sum = 0;
f[i][j] = INT_MAX;
for (int l = j; l >= i - 1; l--) {
sum += A[l];
f[i][j] = min(f[i][j], max(f[i - 1][l - 1], sum));
// 如果sum >= f[i - 1][l - 1],那么sum之后会越来越大,而f[i - 1][l - 1]会越来越小,循环没必要继续进行
if (sum >= f[i - 1][l - 1]) break;
}
}
return f[k][n - 1];
}
};
时间复杂度 O ( m n 2 ) O(mn^2) O(mn2),其中 n n n是 A A A的长度,空间 O ( m n ) O(mn) O(mn)。