对蛮力代码的时间和空间复杂性的困惑

Question

我最近正在研究我在 LeetCode 上发现的一个问题的解决方案。问题可以在这里看到： https://leetcode.com/articles/best-time-to-buy-and-sell-stock-ii/#

关于蛮力方法文章详情，我不明白为什么时间复杂度是O(n^n)。我相信它应该是 O(n!)。我也不明白为什么空间复杂度是 O(N)，因为似乎没有存储数组。

这是该问题的蛮力解决方案的代码：

class Solution {
    public int maxProfit(int[] prices) {
        return calculate(prices, 0);
    }

    public int calculate(int prices[], int s) {
        if (s >= prices.length)
            return 0;
        int max = 0;
        for (int start = s; start < prices.length; start++) {
            int maxprofit = 0;
            for (int i = start + 1; i < prices.length; i++) {
                if (prices[start] < prices[i]) {
                    int profit = calculate(prices, i + 1) + prices[i] - prices[start];
                    if (profit > maxprofit)
                        maxprofit = profit;
                }
            }
            if (maxprofit > max)
                max = maxprofit;
        }
        return max;
    }
}

Answer 1

让我们尝试经验证据，即计算成本。

最坏的情况是prices 的顺序是递增的，所以if (prices[start] < prices[i]) 始终为真。

“成本”是在嵌套的if 语句中运行代码，加上递归调用的成本。

所以为了强制计算成本，我们将方法更改为：

public static int calculate(int n, int s) {
    int cost = 0;
    for (int start = s; start < n; start++) {
        for (int i = start + 1; i < n; i++) {
            cost++; // "cost" is the work we do here
            cost += calculate(n, i + 1); // which includes the recursive call
        }
    }
    return cost;
}

如果我们使用n 的各种值运行，我们会得到：

n = 1: cost = 0, 2^n = 2, factor = 0.00
n = 2: cost = 1, 2^n = 4, factor = 0.25
n = 4: cost = 7, 2^n = 16, factor = 0.44
n = 8: cost = 127, 2^n = 256, factor = 0.50
n = 16: cost = 32767, 2^n = 65536, factor = 0.50
n = 32: cost = 2147483647, 2^n = 4294967296, factor = 0.50

所以我们可以看到成本大约是2^n / 2，这意味着O(2^n)，而不是O(n^n) em>。

---

为了比较，如果我们删除递归调用，即注释掉那行代码，我们得到：

n = 1: cost = 0, n^2 = 1, factor = 0.00
n = 2: cost = 1, n^2 = 4, factor = 0.25
n = 4: cost = 6, n^2 = 16, factor = 0.38
n = 8: cost = 28, n^2 = 64, factor = 0.44
n = 16: cost = 120, n^2 = 256, factor = 0.47
n = 32: cost = 496, n^2 = 1024, factor = 0.48
n = 64: cost = 2016, n^2 = 4096, factor = 0.49
n = 128: cost = 8128, n^2 = 16384, factor = 0.50
n = 256: cost = 32640, n^2 = 65536, factor = 0.50
n = 512: cost = 130816, n^2 = 262144, factor = 0.50
n = 1024: cost = 523776, n^2 = 1048576, factor = 0.50

所以我们可以看到成本约为n^2 / 2，这意味着 O(n^2)，这是我们对嵌套循环的期望。