Question

为了更好地理解递归，我尝试在代码中打印一些输出，以便我可以研究这些步骤。

#include <tuple>
#include <string>
#include <iostream>
#include <map>
#include "print.h"
std::tuple<int, int, int> find_max_crossing_subarray(int A[], int low, int mid, int high)
{
    int max_left, max_right;
    int left_sum = std::numeric_limits<int>::min();
    int sum = 0; 
    for(int i = mid; i >= low; i--) {
    sum += A[i];
    if(sum > left_sum) {
        left_sum = sum;
        max_left = i;
        }
    }
    int right_sum = std::numeric_limits<int>::min();
    sum = 0;
    for(int j = mid + 1; j <= high; j++) {
    sum += A[j];
    if(sum > right_sum) {
        right_sum = sum;
        max_right = j;
        }
    }
    return std::make_tuple(max_left, max_right, left_sum + right_sum);
}
std::tuple<int, int, int> find_max_subarray(int A[], int low, int high)
{
    if(high == low) {
        return std::make_tuple(low, high, A[low]);
    }
    else {
        int mid = (high + low) / 2;
        std::tuple<int, int, int> left(find_max_subarray(A, low, mid));
        std::cout << "left: ";
        print(left);
        int left_low, left_high, left_sum;
        std::tie(left_low, left_high, left_sum) = left;
        std::tuple<int, int, int> right(find_max_subarray(A, mid + 1, high));
        std::cout << "right: ";
        print(right);
        int right_low, right_high, right_sum;
        std::tie(right_low, right_high, right_sum) = right;
        std::tuple<int, int, int> cross(find_max_crossing_subarray(A, low, mid, high));
        std::cout << "cross: ";
        print(cross);
        int cross_low, cross_high, cross_sum;
        std::tie(cross_low, cross_high, cross_sum) = cross;
        if(left_sum >= right_sum && left_sum >= cross_sum) {
            return left;
        }
        else if(right_sum >= left_sum && right_sum >= cross_sum) {
            return right;
        }
        else {
            return cross;
        }
    }
}
int main()
{
    int arr_3[3] = {-3, 2, 3};
    int arr_4[4] = {5, -23, 1, 44};
    int arr_6[6] = {5, -23, 1, 44, -2, 5};
    int arr[16] = {-23, 3, 9 ,7, -12, 87, -25, 2, 3, 5, 32, -8, 6, -82, 3, 9};
    print(arr_4, 4);
    std::tuple<int, int, int> maple(find_max_subarray(arr_4, 0, 3));
    print(maple);
    return 0;
}

OUTPUT ::

5 -23 1 44 
left: 0 0 5
right: 1 1 -23
cross: 0 1 -18
left: 0 0 5
left: 2 2 1
right: 3 3 44
cross: 2 3 45
right: 2 3 45
cross: 0 3 27
2 3 45

我理解输出的前三行（即左，右，十字开始的位置）。但我不明白第四行及其后的来源。我尝试追溯函数，我一直认为我应该在left: 1 1 -23后的第四行输出中得到cross: 0 1 -18。

编辑：

我应该指出，在left: 2 2 1之后，虽然很难想象，但我有点理解。递归已经到了结束，代码只是向后级联。

第二次编辑：

我想第四行中发生的事情是第一个find_max_subarray正在完成，它将返回功能代码中的第一个if语句。现在它正在转移到第二个find_max_subarray。

第三次编辑：

我想我的困惑是代码不向后级联，而是在它到达递归结束后返回到第一个调用。

第四次编辑：

当我出去看六个元素时，似乎它不会简单地回到第一个电话。

5 -23 1 44 -2 5 
left: 0 0 5
right: 1 1 -23
cross: 0 1 -18
left: 0 0 5
right: 2 2 1
cross: 0 2 -17
left: 0 0 5
left: 3 3 44
right: 4 4 -2
cross: 3 4 42
left: 3 3 44
right: 5 5 5
cross: 3 5 47
right: 3 5 47
cross: 2 5 48
2 5 48

我的意思是我猜这是因为子数组有三个元素而不是两个元素。所以有两对而不是一对。当你认为理所当然但却看不到它时，这是有道理的。

最后编辑：

因此，当我出去8时，它会成对出现。前两个元素然后返回原始调用。接下来的两对并返回通话。我不确定为什么虽然在奇怪的情况下它不会返回通话，直到第一对和第二对以及第一对和第三对完成。

5 -23 1 44 -2 5 6 -3 
left: 0 0 5
right: 1 1 -23
cross: 0 1 -18
left: 0 0 5
left: 2 2 1
right: 3 3 44
cross: 2 3 45
right: 2 3 45
cross: 0 3 27
left: 2 3 45
left: 4 4 -2
right: 5 5 5
cross: 4 5 3
left: 5 5 5
left: 6 6 6
right: 7 7 -3
cross: 6 7 3
right: 6 6 6
cross: 5 6 11
right: 5 6 11
cross: 2 6 54
2 6 54

问题已解决：

我在理解递归时遇到的问题是，对于每个递归步骤，我使用的是原始high值。实际上，我使用正确的high在块中将其写在纸上，所有内容都汇集在一起。

Answer 1

如上所述，在上一次编辑后的问题解决部分中，我意识到在我的分析中我使用的是high的错误值。我没有看到这个，因为虽然我使用的是块，但我是按顺序排列而不是块块。

我逐块进行了每个子块的更新high。我发布了下面的插图。这与我得到的输出一致。每个块都附带return语句。

四要素案例：

(0,3)
    (0,1)
        (0,0) -> left
        (1,1) -> right
              -> cross
        return left
    (2,3)
        (2,2) -> left
        (3,3) -> right
              -> cross
        return right
        return cross

五要素案例：

(0,4)
    (0,2)
        (0,1)
            (0,0) -> left
            (1,1) -> right
                  -> cross
            return left
        (2,2) -> right
              -> cross
        return left
    (3,4)
        (3,3) -> left
        (4,4) -> right
              -> cross
        return right
        return cross

更好地理解递归

1 个答案: