问题:
给定两个大小为A
的数组B
和n
,找到最大化[i,j] (0 <= i,j <= n-1)
值的区间V = sum(A[i:j]) - min(B[i:j])
。
如果没有数组B
扭曲,这个问题只是最大的子阵列和问题,可以在O(N)
中使用Kadane算法解决。现在,我们有第二个数组,我们从范围中选择最小元素,并从总和中扣除它。
Example:
A = [-5, 2, 3, 4, 5]
B = [-5, 1, 2, 0, -5]
Solution: 19
i=1 to j=4
2+3+4+5 - (-5) = 19
一个简单的算法是执行双循环来计算每个(i,j)
区间,但这种天真的方法具有O(N^2)
时间复杂度。
我一直在努力寻找O(N)
或至少O(NlogN)
算法,但我还没有能够实现它。
我很感激任何想法,谢谢!
编辑:Peter的解决方案实施参考:
#include<iostream>
#include<vector>
#include<climits>
using namespace std;
int kadane_modified(vector<int>& A, vector<int>& B){
if(A.empty() || B.empty()) return 0;
int size = A.size();
// Backward Kadane's
vector<int> R(size);
int max_so_far = INT_MIN, max_starting_here = 0;
for (int i = size-1; i >= 0; i--)
{
max_starting_here = max_starting_here + A[i];
if (max_so_far < max_starting_here)
max_so_far = max_starting_here;
if (max_starting_here < 0)
max_starting_here = 0;
R[i] = max_starting_here;
}
// Forward Kadane's
vector<int> F(size);
max_so_far = INT_MIN; int max_ending_here = 0;
for (int i = 0; i < size; i++)
{
max_ending_here = max_ending_here + A[i];
if (max_so_far < max_ending_here)
max_so_far = max_ending_here;
if (max_ending_here < 0)
max_ending_here = 0;
F[i] = max_ending_here;
}
// DP that combines previous results
vector<int> V(size);
for(int k = 0; k < size; k++){
if(k < size-1 & k > 0)
V[k] = A[k] + R[k+1] - B[k] + F[k-1];
else if(k == 0)
V[k] = A[k] - B[k] + R[k+1];
else if(k == size-1)
V[k] = A[k] - B[k] + F[k-1];
}
// The maximum V is our answer
int solution = INT_MIN;
for(int i = 0; i < size; i++){
if(solution < V[i]) solution = V[i];
}
return solution;
}
int main()
{
vector<int> A = {-5, 2, 3, 4, 5};
vector<int> B = {-5, 1, 2, 0, -5};
int solution = kadane_modified(A, B);
cout << solution << endl;
return 0;
}
输出
19
答案 0 :(得分:2)
Kadane的算法计算每个位置的A结尾的最大总和(称为F [i])。
您还可以在反向数组A上运行Kadane算法,以找到从每个位置开始的A的最大总和(称为R [i])。
然后,我们可以使用这两个数组来计算最大子阵列和A [i:j] -B [k],其中对于每个位置k,i <= k <= j(通过简单地计算F [k-1] +每个k)的[k] + R [k + 1] - B [k]。 然后,这解决了稍微不同的问题:找到满足i <= k <= j并且最大化A [i:j] -B [k]&#34;的间隔i:j。但是,这个最高值与选择B [k]为B [i:j]的最小值相同,所以这相当于你原来的问题。这种方法的复杂性是O(n)。