有条件的 3 个嵌套循环的时间复杂度

Question

这个函数的时间复杂度（大 O）是多少？ 以及如何计算？

我认为是 O(N^3) 但我不确定。

int DAA(int n){
    int i, j, k, x = 0;
    for(i=1; i <= n; i++){
        for(j=1; j <= i*i; j++){
            if(j % i == 0){
                for(k=1; k <= j; k++){
                    x += 10;
                }
            }
        }
    }
    return x;
}

Answer 1

复杂度为O(n^4)

但不是因为你盲目地放弃了未使用的迭代。

这是因为当你考虑所有指令时， O(n + n^3 + n^4) = O(n^4)

int DAA(int n){
   int x = 0;
   for(int i=1; i <= n; i++) // O(n)
      for(int j=1; j <= i*i; j++) // O(1+2+...n^2) = O(n^3)
         if(j % i == 0) // O(n^3) same as loop j
            for(int k=1; k <= j; k++) // O(n^4), see below
               x += 10; // O(n^4) same as loop k

   return x;
}

---

条件内循环的复杂性

循环k仅在j%i==0时执行，即{i, i*2, i*3 ... i*i}

所以对于最内层循环执行的情况，算法是有效的

int DAA(int n){
   int x = 0;
   for(int i=1; i <= n; i++) // O(n)
      for(int t=1; t <= i; t++) // O(1+2+...+n) = O(n^2)
         for(int k=1; k <= t*i; k++) // O(n^4)
               x += 10;
   return x;
}

---

为什么简单地删除未使用的迭代不起作用？

让我们说现在

int DAA(int n){
   int x = 0;
   for(int i=1; i <= n; i++) // O(n)
      for(int j=1; j <= i*i; j++) // O(1+2+...+n^2) = O(n^3)
         if(j == i) 
            for(int k=1; k <= j; k++)
               x += 10; // oops! this only run O(n^2) time

   return x;
}
// if(j==i*log(n)) also cause loop k becomes O((n^2)log(n))
// or, well, if(false) :P

虽然最里面的指令只运行O(n^2)时间。 程序实际上做了if(j==i) (and j++ , j<=i*i ) O(n^3)时间，这使得整个算法O(n^3)

Answer 2

如果您摆脱无所作为的迭代，时间复杂度会更容易计算。 除非j是i的倍数，否则中间循环不会做任何事情。 因此，我们可以强制j为i的倍数并消除if语句，这使代码更易于分析。

int DAA(int n){
    int x = 0;
    for(int i=1; i <= n; i++){
        for(int m=1; m <= i; m++){  // New variable to avoid the if statement
            int j = m*i;            // The values for which the inner loop executes
            for(int k=1; k <= j; k++){
                x += 10;
            }
        }
    }
    return x;
}

外循环迭代n次。 O(n) 到目前为止。

中间循环迭代1次，然后2次，然后…… n次。 人们可能会从 O(n ² ) 排序算法中识别出这种设置。 循环执行n次，迭代次数增加到n ，导致 O(n×n) 复杂度。

内循环按 n×n 次的顺序执行（中间循环的复杂度）。 每次执行的迭代次数增加到 n×n（ j的最大值）。 类似于中间循环如何乘以它的执行次数和最大迭代次数以获得其复杂性，内部循环的复杂性 - 因此整个代码 - 应该变成 O(n ⁴ )，但我将离开作为练习的精确证明。