坚持数组中的递归算法

如何解决坚持数组中的递归算法

我遇到了以下任务： “编写一个递归函数，该函数采用由 100 个随机设置的整数组成的一维数组，并找到 10 个数字序列以最小和开始的位置。

我写了两个函数：

int recursiveArrSum(int mass[],int dim = 10,int sum = 0) {
    if (dim == 0) return sum;
    sum += mass[dim-1];
    return recursiveArrSum(mass,--dim,sum);
}

int recArrMinSum(int mass[],int dim=100,int tempSum=100,int idx=0,int addPar=0){
    if (dim == 0) return idx;
    mass[dim]=mass[addPar];
    
    if (tempSum >= recursiveArrSum(mass)){
        tempSum = recursiveArrSum(mass);
        idx = dim-1;
        //mass[dim]=mass[addPar];
    }return recArrMinSum(mass,tempSum,idx,++addPar);

第一个 (recursiveArrSum) - 工作正常，但第二个让我发疯......

我无法理解如何在调用最后一个 return 语句的函数期间迭代数组。我使用 for 循环制作它，并且它工作正常：

for (int i=0; i<91; i++){
        int tempS=0;
        for (int j=i; j<=i+9; j++){
            tempS += arr[j];
            cout << tempS<< endl;
        }
        if (tempS<tempSum) {
            tempSum=tempS;
            k=i+1;
       }
}

但递归不会...

谁能建议我解决这个问题的方法？欢迎提出任何问题。

提前致谢。

解决方法

目前尚不清楚您的代码应该如何工作。要迭代数组并找到最小的总和，您可以执行以下操作（伪代码）：

 int currentSum = sum of elements 0 till 9
 int smallestSum = currentSum
 int smallestIndex = 0
 for (i = 10; i < 100; ++i) {
       currentSum = currentSum - mass[ i -10] + mass[i]
       if (currentSum < smallestSum) {
            smallestSum = currentSum
            smallestIndex = i
       }
 }

作为初始猜测，它取前 10 个元素的总和，即元素 0 到 9。之后它迭代数组。元素 1 到 10 的总和与元素 0 到 9 的总和减去第一个元素加上元素 10 相同。更一般地：为了在下一次迭代中获得总和，减去 i-10 处的元素和 {{1} 处的元素}} 被添加。

不确定您可以从 STL 中包含哪些内容，但有以下解决方案：

// Or std::pair<int,int*>
struct resultPair {
    int first;
    int* second;
};

// Or std::accumulate
int sumOf(int* arr,size_t s) {
    int sum = 0;
    for (size_t i=0; i<s; ++i)
        sum += arr[i];
    return sum;
}

resultPair minSeqOfN(int* arr,size_t s,size_t N) {
    if (s < N) throw; // Or however you want to check pre-conditions

    int sum = sumOf(arr,N);
    
    if (s == N) return { sum,arr }; // Base case
    auto nextRes = minSeqOfN(arr+1,s-1,N);
    if (nextRes.first < sum) return nextRes;
    else return resultPair{sum,arr};
}

函数不断调用自身减去第一个元素，直到序列大小等于输入数组大小（那么只有 1 个可能的答案）。

我会这样做：

在其参数中保留当前位置、当前总和、最小总和以及此最小总和的起始位置的函数。该函数还将数组（显然）、其大小和总和的维度（在您的情况下为 10）作为参数传输。

void compute(int mass[],int massSize = 100,int dim = 10,int currentPosition = 0,int currentSum = 0,int minSum = 99999,int minPosition = -1)
{
    // Before suming the first dim elements,we keep going adding the element at the current position and we increase the current position.
    if (currentPosition < dim) 
    {
        compute(mass,massSize,dim,currentPosition + 1,currentSum + mass[currentPosition],minSum,minPosition);
        return;
    }
    
    // When reaching the end of the array,we print our best solution.
    if (currentPosition > massSize)
    {
        std::cout << "Min sum of " << dim << " elements is " << minSum << ",starting at position " << minPosition << std::endl;
        return;
    }
    
    // In all the other cases,we check if the current sum is better than the minimum sum. If yes,we update the minimum sum and its starting position. Then call again the function!
    if (currentSum < minSum)
    {
        minSum = currentSum;
        minPosition = currentPosition - dim;
    }
    
    compute(mass,currentSum + mass[currentPosition ] - mass[currentPosition -dim],minPosition);
}

调用函数很简单：compute(mass,SIZE,10); 其中 mass 是您的数组，SIZE 是它的大小，10 是您的维度。

此数组中的维度等于 5：

8; 8; 4; 10; 9; 9; 6; 3; 3; 5; 3; 8; 3; 7; 9; 10; 10; 5; 6; 4; 1; 4; 1; 5; 2; 8; 6; 1; 7; 9; 
Min sum of 5 elements is 13,starting at position 20

在编写递归函数时，首先要考虑退出案例、初始化案例（如果有的话）和搜索过程中的“经典”案例。

随意提出任何问题，我添加了一些评论以使其足够清楚。