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++;
            }
        }
    }
}

Tôi không hiểu làm thế nào khi j = i, 2i, 3i ... forvòng lặp cuối chạy n lần. Tôi đoán tôi chỉ không hiểu làm thế nào chúng ta đi đến kết luận đó dựa trên iftuyên bố.

Chỉnh sửa: Tôi biết cách tính độ phức tạp cho tất cả các vòng lặp ngoại trừ lý do tại sao vòng lặp cuối thực hiện i lần dựa trên toán tử mod ... Tôi chỉ không thấy nó như thế nào. Về cơ bản, tại sao j% tôi không thể đi lên i * i chứ không phải tôi?

Hãy gắn nhãn các vòng A, B và 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++;
            }
        }
    }
}

• Vòng lặp A lặp lại O ( n ) lần.
• Vòng B lặp O ( i ² ) lần mỗi lần lặp của A . Đối với mỗi lần lặp này:
  • j % i == 0 được đánh giá, mất O (1) thời gian.
  • Trên 1 / i của các lần lặp này, vòng lặp C lặp lại j lần, thực hiện O (1) mỗi lần lặp. Vì j là O ( i ² ) trung bình và điều này chỉ được thực hiện cho 1 / i lần lặp của vòng B, nên chi phí trung bình là O ( i ²  /  i ) = O ( i ).

Nhân tất cả những thứ này lại với nhau, ta được O ( n  ×  i ²  × (1 +  i )) = O ( n  ×  i ³ ). Vì i là trung bình O ( n ), đây là O ( n ⁴ ).

Phần khó khăn của điều này là nói rằng ifđiều kiện này chỉ đúng 1 / i của thời gian:

Về cơ bản, tại sao j% tôi không thể đi lên i * i chứ không phải tôi?

Trong thực tế, jkhông đi lên j < i * i, không chỉ lên đến j < i. Nhưng điều kiện j % i == 0là đúng khi và chỉ khi jlà bội số của i.

Các bội số của itrong phạm vi là i, 2*i, 3*i, ..., (i-1) * i. Có i - 1những điều này, vì vậy vòng lặp C đạt được i - 1thời gian mặc dù vòng lặp B lặp lại i * i - 1.

• Vòng lặp đầu tiên tiêu thụ các nlần lặp.
• Vòng lặp thứ hai tiêu thụ n*nlặp đi lặp lại. Hãy tưởng tượng trường hợp khi i=n, sau đó j=n*n.
• Vòng lặp thứ ba tiêu thụ các nlần lặp bởi vì nó chỉ được thực hiện ilần, trong trường hợp ibị ràng buộc ntrong trường hợp xấu nhất.

Do đó, độ phức tạp của mã là O (n × n × n × n).

Tôi hy vọng điều này sẽ giúp bạn hiểu.

Tất cả các câu trả lời khác là chính xác, tôi chỉ muốn sửa đổi như sau. Tôi muốn xem, nếu việc giảm các lần thực hiện của vòng lặp k bên trong là đủ để giảm độ phức tạp thực tế bên dưới O(n⁴).Vì vậy tôi đã viết như sau:

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);
}

Sau khi thực hiện điều này, nó trở nên rõ ràng, rằng sự phức tạp là trên thực tế n⁴. Các dòng đầu ra cuối cùng trông như thế này:

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

Điều này cho thấy, sự khác biệt tương đối thực tế giữa thực tế n⁴và độ phức tạp của đoạn mã này là một yếu tố tiệm cận đối với một giá trị xung quanh 0.124...(thực tế là 0,125). Mặc dù nó không cung cấp cho chúng tôi giá trị chính xác, chúng tôi có thể suy luận như sau:

Thời gian phức tạp là n⁴/8 ~ f(n)nơi fchức năng / phương pháp của bạn.

• Trang wikipedia về ký hiệu Big O nêu trong các bảng của 'Gia đình Bachmann dòng Landau' rằng ~định nghĩa giới hạn của hai mặt toán hạng là bằng nhau. Hoặc là:

  f bằng g tiệm cận

(Tôi đã chọn 363 là giới hạn trên bị loại trừ, vì n = 362là giá trị cuối cùng mà chúng tôi nhận được kết quả hợp lý. Sau đó, chúng tôi vượt quá không gian dài và giá trị tương đối trở thành âm.)

Người dùng kaya3 đã tìm ra những điều sau đây:

Hằng số tiệm cận là chính xác 1/8 = 0,125; đây là công thức chính xác thông qua Wolfram Alpha .

Loại bỏ ifvà modulo mà không thay đổi độ phức tạp

Đây là phương pháp ban đầu:

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;
}

Nếu bạn đang nhầm lẫn bởi các ifvà modulo, bạn chỉ có thể cấu trúc lại chúng đi, với jnhảy trực tiếp từ iđể 2*iđến 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;
}

Để làm cho việc tính toán độ phức tạp trở nên dễ dàng hơn, bạn có thể đưa ra một j2biến trung gian , sao cho mỗi biến vòng lặp được tăng thêm 1 ở mỗi lần lặp:

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;
}

Bạn có thể sử dụng gỡ lỗi hoặc trường học cũ System.out.printlnđể kiểm tra i, j, kbộ ba luôn giống nhau trong mỗi phương thức.

Biểu thức dạng đóng

Như đã đề cập bởi những người khác, bạn có thể sử dụng thực tế là tổng của các n số nguyên đầu tiên bằng n * (n+1) / 2(xem số tam giác ). Nếu bạn sử dụng đơn giản hóa này cho mỗi vòng lặp, bạn sẽ nhận được:

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

Nó rõ ràng không phức tạp như mã gốc nhưng nó trả về cùng các giá trị.

Nếu bạn google các thuật ngữ đầu tiên, bạn có thể nhận thấy 0 0 0 2 11 35 85 175 322 546 870 1320 1925 2717 3731xuất hiện trong "Số khuấy của loại thứ nhất: s (n + 2, n)." , với hai 0s được thêm vào lúc đầu. Nó có nghĩa sumlà số Stirling của loại đầu tiên s(n, n-2) .

Chúng ta hãy nhìn vào hai vòng đầu tiên.

Cái đầu tiên rất đơn giản, nó lặp từ 1 đến n. Cái thứ hai thú vị hơn. Nó đi từ 1 đến bình phương. Hãy xem một số ví dụ:

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  

Trong tổng số, i and j loopskết hợp có 1^2 + 2^2 + 3^2.
Có một công thức tính tổng n bình phương đầu tiên n * (n+1) * (2n + 1) / 6, đại khái là O(n^3).

Bạn có một k loopvòng lặp cuối từ 0 đến jnếu và chỉ khi j % i == 0. Kể từ khi jđi từ 1 đến i^2, j % i == 0là đúng cho ithời gian. Kể từ khi i looplặp đi lặp lại n, bạn có thêm một O(n).

Vì vậy, bạn có O(n^3)từ i and j loopsvà khác O(n)từ k looptổng cộngO(n^4)