C++ 我如何记忆这种循环关系？

我正在解决LeetCode问题：

给定一个整数数组，返回最多删除一个元素的非空子数组（连续元素）的最大和。对于输入

arr=[1，-2,0,3]

，输出应为

4

我提出了一个递归解决方案，如下所示：

class Solution { public: int helper(vector<int>& n, vector<int>& cache, int startIndex) { if(startIndex>=n.size()) return INT_MIN; if(cache[startIndex]!=-1) return cache[startIndex]; int allInclusiveSum=0, sumWithOneDel=0, lowestVal=INT_MAX, maxVal=INT_MIN; for(int i=startIndex; i<n.size(); i++) { allInclusiveSum+=n[i]; maxVal=max(maxVal, allInclusiveSum); if(i!=startIndex) { lowestVal=min(lowestVal, n[i]); sumWithOneDel=allInclusiveSum-lowestVal; maxVal=max(maxVal, sumWithOneDel); } } maxVal=max(maxVal, helper(n, cache, startIndex+1)); return cache[startIndex]=maxVal; } int maximumSum(vector<int>& arr) { int i=0, first=arr[0]; for(i=1; i<arr.size(); i++) if(arr[i]!=first) break; if(i==arr.size()) return first; vector<int> cache(arr.size(), -1); return helper(arr, cache, 0); } }; 类解决方案{ 公众： int-helper（向量&n、向量&cache、int-startIndex）{ 如果（startIndex>=n.size（））返回INT\u MIN； if（cache[startIndex]！=-1）返回cache[startIndex]； int allinclusiesum=0，sumWithOneDel=0，lowerstval=int_MAX，maxVal=int_MIN；

---

对于使用动态规划的（int i=startIndex；i，我们只需定义一个包含N行和两列的

std:：vector

，然后一次遍历我们的

arr

，并使用

std:：max

查找

max\u sum

：

#include <vector>
#include <algorithm>


class Solution {
public:
    static inline int maximumSum(const std::vector<int> &arr) {
        int length = arr.size();
        std::vector<std::vector<int>> dynamic_sums(length, std::vector<int>(2, 0));
        dynamic_sums[0][0] = arr[0];
        int max_sum = arr[0];

        for (unsigned int row = 1; row < length; row++) {
            dynamic_sums[row][0] = std::max(arr[row], dynamic_sums[row - 1][0] + arr[row]);
            dynamic_sums[row][1] = std::max(arr[row], std::max(dynamic_sums[row - 1][1] + arr[row], dynamic_sums[row - 1][0]));
            max_sum = std::max(max_sum, std::max(dynamic_sums[row][0], dynamic_sums[row][1]));
        }

        return max_sum;
    }
};

#包括
#包括。这里有很多公认的解决方案，有各种解释、有效的算法以及渐近/复杂性分析
使用动态规划，我们只需定义一个包含N行和两列的
std:：vector
，然后一次遍历我们的
arr
，并使用
std:：max
查找
max\u sum
：

#include <vector>
#include <algorithm>


class Solution {
public:
    static inline int maximumSum(const std::vector<int> &arr) {
        int length = arr.size();
        std::vector<std::vector<int>> dynamic_sums(length, std::vector<int>(2, 0));
        dynamic_sums[0][0] = arr[0];
        int max_sum = arr[0];

        for (unsigned int row = 1; row < length; row++) {
            dynamic_sums[row][0] = std::max(arr[row], dynamic_sums[row - 1][0] + arr[row]);
            dynamic_sums[row][1] = std::max(arr[row], std::max(dynamic_sums[row - 1][1] + arr[row], dynamic_sums[row - 1][0]));
            max_sum = std::max(max_sum, std::max(dynamic_sums[row][0], dynamic_sums[row][1]));
        }

        return max_sum;
    }
};

#包括
#包括。这里有很多公认的解决方案，有各种解释、有效的算法以及渐近/复杂性分析
嗯，26个视图和无评论让我觉得我遗漏了什么/我的问题不正确。请有人指出，以便我可以编辑它吗？谢谢！这是视图27；-）。问题是，理解你的（或任何）算法现在对我来说太长了，更不用说理解与另一个算法的细微差别了；-）。这里有太多的代码，对于从哪里开始寻找问题没有真正的指导。当我听到“memoize”时，我立即想到“为什么不使用
std:：map
来缓存呢？”但是我没有看到，所以…@user3386109，所以我想我的错误是我使用了递归和迭代的组合，这就是为什么我不能有效地缓存它。（本质上这只是蛮力）。谢谢，这很有帮助！：）我倾向于放弃这一条。你可以随时自我回答：）嗯，26个观点，没有评论，让我觉得我错过了什么/我的问题是不正确的。有人能指出，这样我就可以编辑它了吗？谢谢！这是观点27；-）。问题是，理解你的（或任何）算法现在对我来说太长了，更不用说理解与另一个算法的细微差别了；-）。这里有太多的代码，对于从哪里开始寻找问题没有真正的指导。当我听到“memoize”时，我立即想到“为什么不使用
std:：map
来缓存呢？”但是我没有看到一个，所以…@user3386109，所以我猜我的错误是我使用了递归和迭代的组合，这就是为什么我不能有效地缓存它。（本质上这只是蛮力）。谢谢你，这很有帮助！：）我倾向于放手这一个。你总是可以自我回答：）