Question

int maxSumRec( const vector<int> & a, int left, int right )
{
    if( left == right )  // Base case
        return a[ left ];

    int center = ( left + right ) / 2;
    int maxLeftSum  = maxSumRec( a, left, center );
    int maxRightSum = maxSumRec( a, center + 1, right );

    int maxLeftBorderSum = 0, leftBorderSum = 0;
    for( int i = center; i >= left; i-- )
    {
        leftBorderSum += a[ i ];
        if( leftBorderSum > maxLeftBorderSum )
            maxLeftBorderSum = leftBorderSum;
    }

    int maxRightBorderSum = 0, rightBorderSum = 0;
    for( int j = center + 1; j <= right; j++ )
    {
        rightBorderSum += a[ j ];
        if( rightBorderSum > maxRightBorderSum )
            maxRightBorderSum = rightBorderSum;
    }

    return max3( maxLeftSum, maxRightSum,
                maxLeftBorderSum + maxRightBorderSum );
}

此函数将返回向量的最大连续子序列。任务是实现一个名为“L”的最小序列参数，然后返回至少长度为L的最大连续子序列。

示例：不带L参数：

vector<int> a(4);
a[ 0 ] = 1; a[ 1 ] = 3; a[ 2 ] = -20; a[ 3 ] = 7;
maxSumRec(a, 0, a.size() - 1);

会返回“7”

示例：使用L参数：

int L = 3;
vector<int> a(4);
a[ 0 ] = 1; a[ 1 ] = 3; a[ 2 ] = -20; a[ 3 ] = 7;
maxSumRec(a, 0, a.size() - 1, L);

会返回“-9”

我知道这可以通过其他不同的max sum函数轻松完成，但任务明确用于此递归公式。我不知道怎么开始。教授给了我们这个暗示：“将minSeq添加到递归算法中的主要困难在于边界和计算。显然，我们可以假设两个边界序列中的每一个都必须包含至少一个元素，否则通过对方的递归调用已经找到了最优解。在另一一方面，我们不知道k元素是否足够，而不知道minSeq-k会发生什么另一方面的元素。似乎需要进行一些搜索，这会增加最坏情况算法的运行时间与minSeq相关的因素有关。“

Answer 1

＆＃13;

int maxSumRec( const vector<int> & a, int left, int right, int L )
{
	int center = ( left + right ) / 2;
	...
	int maxBorderSum = 0, leftBorderSum = 0;
    // for( int i = center; i >= left; i-- )
    // {
        // ...
    // }

    // int maxRightBorderSum = 0, rightBorderSum = 0;
    // for( int j = center + 1; j <= right; j++ )
    // {
        // ...
    // }	
	int partialSum[1000] = {0}, dpR[1000] = {0};
	for(int i = center + 1; i <= right; i++) 
		partialSum[i] += partialSum[i-1];
	for(int i = right; i > center; i--)  
		dpR[i-center] = max(partialSum[i], dpR[i-center+1]);
	
	for(int i = center; i >= left; i--){
		leftBorderSum += a[i];
		int leftLength = center - i + 1;
		int minRightLength = L - leftLength;
		maxBorderSum = max(maxLeftBorderSum, leftBorderSum + dpR[minRightLength]);
	}
		
	...
	return max3( maxLeftSum, maxRightSum, maxBorderSum);
}

＆＃13;

我的想法是将评论的部分替换为类似的东西（有点伪，只是为了证明这个想法）

首先，我计算partialSum[]和dpR[]，都使用O(n)

partialSum [i] =从[center]到[i]

之和

dpR [i] =中心右侧的最大总和，其长度至少为

所以现在我们得到了特定长度的右边区域的最大总和，我们可以通过以下方式找到至少长度为L的边界总和：

对于你选择的每个左边元素，比如你选择3个元素，我们找到dpR [L-3]并将它们相加得到总和，我们在这个过程中取最大值

（注意：代码用于说明目的，你应该知道那些像你必须至少每边挑选1个元素的小东西;计算partialSum[]和dpR[]时的for循环边界处理，等）

最小连续子序列最小长度L（递归）

1 个答案: