有條件的 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 ⁴ )，但我將離開作為練習的精確證明。