Algorithm 包含条件的代码的时间复杂度 foo（int n） { int s=0； 对于（inti=1；i

来说，复杂性是

O（n^4）

最里面的循环将为每个

i

执行

i

次（

i

在

0..i*i

内

i

的倍数）

这就像内部循环将运行

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

这些

x

表示复杂度

j

的最内层for循环的执行。其余时间未触及该循环，仅完成测试，结果失败

现在检查一下，这些

\-/

有

i*j

（j=1,2,3…i）

循环和

i

检查

现在我们精确地执行

i

次

j = 0 1 2...i i+1 ...2*i ....3*i .... 4*i .... 5*i... i*i
            x         x       x        x        x      x
    \------/\--------/\-------/                 \------/

对于外部循环，它将是

n^4

这是什么意思？整个作品可以这样划分

So total work = i*(1+1+1+...1) + i*(1+2+3+..i)
              = i*i+ i*i*(i+1)/2 ~ i^3

现在，如果我们迭代

j

，那么它将具有复杂性

O（n^3）

---

通过添加外部循环，它将是

O（n^4）

您的函数计算四维金字塔数（）。可以使用以下公式计算到

s

的增量数：

O(i*j+i)
  ^^^ ^
   |   The other cases when it simply skips
  The innermost loop executed

因此，函数的复杂性为O（n4）

它不是O（n5）的原因是

if（j%i==0）

仅对

i

的倍数进行“有效载荷”循环，其中我们在所有

j

中有

i

，范围从

1

到i2，包括在内

因此，我们添加一个最外循环，一个用于中间的循环，一个用于最内层循环，因为它迭代到I2，总共为4。

为什么中间（j）只有一个？它运行到i2，对吗

如果我们重写代码以排除该条件，可能会更容易看到：

a(n) = n*(1+n)*(2+n)*(1+3*n)/24

ints=0；
对于（int i=1；i关于j循环呢？它将被执行i*i次。@Zephyr.：是的……等待将在一段时间内尝试解释更多。那么求和表达式将像（从i=1到n）{（（i^2-i）+（从k=1到i）（ki））}@Zephyr.：是的。这就是解释的。为什么中间（j）只有一个它运行到$i ^ 2 $右边？@ ZePHR是正确的，即使中间的循环上升到<代码> n^ 2 < /代码>，它也不会做任何事情，除非<代码> i <代码>分割<代码> j>代码>，这对于<代码>（n^ 2-n）< /代码> < <代码> j>代码>是正确的。仅对
j
的
n
值执行。因此求和表达式将类似于（从i=1到n）{（（i^2-i）+（从k=1到i）（ki））}
int s=0;
for(int i=1;i<=n;i++)
    for(int j=1;j<=i;j++)
        for(int k=1;k<=i*j;k++)
            s++;
return s;