为什么计算复杂度为 O(n^4)？

Question

int sum = 0;
for(int i = 1; i < n; i++) {
    for(int j = 1; j < i * i; j++) {
        if(j % i == 0) {
            for(int k = 0; k < j; k++) {
                sum++;
            }
        }
    }
}

我不明白什么时候 j = i, 2i, 3i... 最后一个 for 循环运行 n 次。我想我只是不明白我们是如何根据if 声明得出这个结论的。

编辑：我知道如何计算所有循环的复杂性，除了为什么最后一个循环基于 mod 运算符执行 i 次......我只是不明白它是如何 i 的。基本上，为什么 j % i 不能达到 i * i 而不是 i？

Answer 1

让我们标记循环 A、B 和 C：

int sum = 0;
// loop A
for(int i = 1; i < n; i++) {
    // loop B
    for(int j = 1; j < i * i; j++) {
        if(j % i == 0) {
            // loop C
            for(int k = 0; k < j; k++) {
                sum++;
            }
        }
    }
}

• 循环 A 迭代 O(n) 次。
• 循环 B 迭代 O(一世²) 次A 的每次迭代.对于这些迭代中的每一个：
  • j % i == 0 被评估，这需要 O(1) 时间。
  • 在 1/一世在这些迭代中，循环 C 迭代j次，每次迭代做 O(1) 工作。自从j是 O(一世²) 平均而言，这仅适用于 1/一世循环B的迭代，平均成本为O(一世² / 一世) = O(一世）。

将所有这些相乘，我们得到 O(n×一世²× (1 +一世)) = O(n×一世³）。自从一世平均为 O(n), 这是 O(n⁴）。

---

棘手的部分是说if 条件仅为真 1/一世的时间：

基本上，为什么 j % i 不能达到 i * i 而不是 i？

事实上，j 确实上升到 j < i * i，而不仅仅是上升到 j < i。但条件j % i == 0 为真当且仅当j 是i 的倍数。

范围内i的倍数为i、2*i、3*i、...、(i-1) * i。其中有i - 1，因此尽管循环B 迭代i * i - 1 次，但循环C 仍到达i - 1 次。

Answer 2

• 第一个循环消耗n 迭代。
• 第二个循环消耗n*n 迭代。想象一下i=n，然后是j=n*n 的情况。
• 第三个循环消耗n 迭代，因为它只执行i 次，其中i 在最坏的情况下绑定到n。

因此，代码复杂度为 O(n×n×n×n)。

我希望这能帮助你理解。

Answer 3

所有其他答案都是正确的，我只想修改以下内容。 我想看看，如果减少内部 k-loop 的执行是否足以将实际复杂度降低到O(n⁴). 以下，所以我写了以下内容：

for (int n = 1; n < 363; ++n) {
    int sum = 0;
    for(int i = 1; i < n; ++i) {
        for(int j = 1; j < i * i; ++j) {
            if(j % i == 0) {
                for(int k = 0; k < j; ++k) {
                    sum++;
                }
            }
        }
    }

    long cubic = (long) Math.pow(n, 3);
    long hypCubic = (long) Math.pow(n, 4);
    double relative = (double) (sum / (double) hypCubic);
    System.out.println("n = " + n + ": iterations = " + sum +
            ", n³ = " + cubic + ", n⁴ = " + hypCubic + ", rel = " + relative);
}

执行此操作后，很明显，复杂度实际上是n⁴。输出的最后几行如下所示：

n = 356: iterations = 1989000035, n³ = 45118016, n⁴ = 16062013696, rel = 0.12383254507467704
n = 357: iterations = 2011495675, n³ = 45499293, n⁴ = 16243247601, rel = 0.12383580700180696
n = 358: iterations = 2034181597, n³ = 45882712, n⁴ = 16426010896, rel = 0.12383905075183874
n = 359: iterations = 2057058871, n³ = 46268279, n⁴ = 16610312161, rel = 0.12384227647628734
n = 360: iterations = 2080128570, n³ = 46656000, n⁴ = 16796160000, rel = 0.12384548432498857
n = 361: iterations = 2103391770, n³ = 47045881, n⁴ = 16983563041, rel = 0.12384867444612208
n = 362: iterations = 2126849550, n³ = 47437928, n⁴ = 17172529936, rel = 0.1238518469862343

这表明，实际 n⁴ 与此代码段的复杂性之间的实际相对差异是一个渐近于 0.124... 附近的值（实际上是 0.125）的因素。虽然它没有给我们确切的值，但我们可以推断如下：

时间复杂度为n⁴/8 ~ f(n)，其中f 是您的函数/方法。

• Wikipedia-page on Big O notation 在“Bachmann–Landau 符号家族”的表格中指出，~ 定义了两个操作数边的限制相等。或者：

  f 渐近地等于 g

（我选择 363 作为排除上限，因为n = 362 是我们得到合理结果的最后一个值。之后，我们超过了长空间，相对值变为负数。）

用户 kaya3 发现以下内容：

顺便说一句，渐近常数正好是 1/8 = 0.125； here's the exact formula via Wolfram Alpha。

Answer 4

删除if 和模而不改变复杂度

这是原始方法：

public static long f(int n) {
    int sum = 0;
    for (int i = 1; i < n; i++) {
        for (int j = 1; j < i * i; j++) {
            if (j % i == 0) {
                for (int k = 0; k < j; k++) {
                    sum++;
                }
            }
        }
    }
    return sum;
}

如果你对 if 和模数感到困惑，你可以重构它们，j 直接从 i 跳转到 2*i 到 3*i ... ：

public static long f2(int n) {
    int sum = 0;
    for (int i = 1; i < n; i++) {
        for (int j = i; j < i * i; j = j + i) {
            for (int k = 0; k < j; k++) {
                sum++;
            }
        }
    }
    return sum;
}

为了更容易计算复杂度，您可以引入一个中介 j2 变量，以便每个循环变量在每次迭代时递增 1：

public static long f3(int n) {
    int sum = 0;
    for (int i = 1; i < n; i++) {
        for (int j2 = 1; j2 < i; j2++) {
            int j = j2 * i;
            for (int k = 0; k < j; k++) {
                sum++;
            }
        }
    }
    return sum;
}

您可以使用调试或老式System.out.println 来检查i, j, k 三元组在每种方法中是否始终相同。

封闭式表达式

正如其他人所提到的，您可以使用第一个n 整数之和等于n * (n+1) / 2 的事实（请参阅triangular numbers）。如果对每个循环都使用这种简化，你会得到：

public static long f4(int n) {
    return (n - 1) * n * (n - 2) * (3 * n - 1) / 24;
}

很明显不是与原始代码相同的复杂性，但它确实返回相同的值。

如果你用谷歌搜索第一个术语，你会注意到0 0 0 2 11 35 85 175 322 546 870 1320 1925 2717 3731 出现在"Stirling numbers of the first kind: s(n+2, n)." 中，并且在开头添加了两个0s。这意味着sum 是Stirling number of the first kind s(n, n-2)。

Answer 5

让我们看一下前两个循环。

第一个很简单，它从 1 循环到 n。第二个更有趣。它从 1 到 i 平方。让我们看一些例子：

e.g. n = 4    
i = 1  
j loops from 1 to 1^2  
i = 2  
j loops from 1 to 2^2  
i = 3  
j loops from 1 to 3^2  

总共，i and j loops 组合有1^2 + 2^2 + 3^2。
前n个平方和有一个公式，n * (n+1) * (2n + 1) / 6，大致是O(n^3)。

当且仅当j % i == 0 时，您有最后一个k loop 从0 循环到j。由于 j 从 1 变为 i^2，因此 j % i == 0 在 i 次中为真。由于i loop 迭代了n，因此您多了一个O(n)。

所以你有来自i and j loops的O(n^3)和来自k loop的另一个O(n)，总共有O(n^4)