首先，分治解决方案。让我们看看我们是否可以通过将输入分成两半来解决这个问题，解决每个子阵列中的问题，然后将两者组合在一起。事实证明，我们实际上可以做到这一点，并可以有效地做到这一点！直觉如下。如果我们有一天，最好的选择是在那一天买，然后在同一天卖回，没有利润。否则，将数组拆分为两半。如果我们考虑最佳答案可能是什么，它必须在三个地方之一：

>正确的买/卖对完全在上半年内发生。
>正确的买/卖对完全在下半年内发生。
>正确的买/卖对出现在两半 – 我们在上半年买入，然后在下半年卖出。

我们可以通过递归调用我们的算法在第一和第二半获得(1)和(2)的值。对于期权(3)，赚取最高利润的方式是在上半年的最低点买入，在下半年的最高点卖出。我们可以通过对输入进行简单的线性扫描并找到两个值，在两半中找到最小值和最大值。然后这给我们一个算法与以下递归：

T(1) <= O(1)
T(n) <= 2T(n / 2) + O(n)

使用Master Theorem来解决复发，我们发现这在O(n lg n)时间运行，并将使用O(lg n)空间用于递归调用。我们刚刚打败了天真的O(n2)解决方案！

可是等等！我们可以做得比这更好。请注意，我们在循环中使用O(n)项的唯一原因是我们必须扫描整个输入，以尝试在每一半中找到最小值和最大值。由于我们已经递归地探索了每一半，也许我们可以做得更好，通过递归也递回存储在每一半的最小和最大值！换句话说，我们的递归递回三件事：

>买入和卖出时间以最大化利润。
>范围内的最小值。
>范围内的最大值。

最后两个值可以使用直接递归计算，我们可以在递归计算(1)的同时运行：

>单元素范围的最大值和最小值只是那个元素。
>通过将输入分成两半可以找到多元素范围的最大值和最小值，找到每一半的最大值和最小值，然后取其各自的最大值和最小值。

如果我们使用这种方法，我们的递推关系现在

T(1) <= O(1)
T(n) <= 2T(n / 2) + O(1)

使用主定理这里给出了O(n)与O(lg n)空间的运行时间，这甚至比我们的原始解决方案更好！

但等一下 – 我们可以做得比这更好！让我们考虑使用动态规划来解决这个问题。这个想法是想想问题如下。假设我们在查看前k个元素之后知道问题的答案。我们可以使用我们对第(k 1)个元素的知识，结合我们的初始解决方案来解决第一个(k 1)元素的问题吗？如果是这样，我们可以通过解决第一个元素的问题，然后前两个，然后前三个等等，直到我们计算它的前n个元素，我们可以得到一个伟大的算法。

让我们考虑如何做到这一点。如果我们只有一个元素，我们已经知道它必须是最好的买/卖对。现在假设我们知道前k个元素的最佳答案，并查看第(k 1)个元素。然后，这个值可以创建一个解决方案比我们对于前k个元素的唯一方法是如果前k个元素的最小值和新元素之间的差异大于我们迄今为止计算的最大差异。因此，假设当我们跨越元素时，我们跟踪两个值 – 我们目前为止看到的最小值，以及只有前k个元素可以获得的最大利润。最初，我们已经看到的最小值是第一个元素，最大利润为零。当我们看到一个新的元素，我们首先更新我们的最佳利润，计算我们将通过购买到目前为止看到的最低价格，并以当前价格卖出多少。如果这优于我们迄今为止计算的最优值，那么我们将最优解更新为这个新的利润。接下来，我们更新到目前为止看到的最小元素是当前最小元素和新元素的最小值。

因为在每一步我们只做O(1)工作，我们正在访问n个元素中的每一个一次，这需要O(n)时间完成！此外，它只使用O(1)辅助存储。这是我们已经到目前为止好！

例如，在您的输入上，以下是此算法的运行方式。阵列的每个值之间的数字对应于该点处算法保持的值。你实际上不会存储所有这些(它将需要O(n)内存！)，但有助于看到算法演变：

5        10         4         6        7
min         5         5        4          4         4    
best      (5,5)     (5,10)   (5,10)     (5,10)    (5,10)

答：(5，10)

5        10         4         6        12
min         5         5        4          4         4    
best      (5,10)    (4,12)

答案：(4，12)

1       2       3      4      5
min         1       1       1      1      1
best      (1,1)   (1,2)   (1,3)  (1,4)  (1,5)

答：(1，5)

我们现在能做得更好吗？不幸的是，不是一个渐近的意义。如果我们使用小于O(n)的时间，我们不能查看大输入的所有数字，因此不能保证我们不会错过最佳答案(我们可以“隐藏”它在元素中没有看)。另外，我们不能使用任何小于O(1)的空间。可能会有一些优化隐藏在大O符号的常数因子，但否则我们不能指望找到任何根本更好的选择。

总的来说，这意味着我们有以下算法：

> Naive：O(n2)时间，O(1)空间。
>分而治之：O(n lg n)时间，O(lg n)空间。
>优化的分治：O(n)时间，O(lg n)空间。
>动态规划：O(n)时间，O(1)空间。

希望这可以帮助！

编辑：如果你有兴趣，我编码a Python version of these four algorithms，让你可以玩弄他们，判断他们的相对表现。请享用！