ความซับซ้อนของเวลาของอัลกอริทึม Sieve of Eratosthenes

จากWikipedia:

ความซับซ้อนของอัลกอริทึมคือ O(n(logn)(loglogn))การดำเนินการแบบบิต

คุณมาถึงจุดนั้นได้อย่างไร?

ความซับซ้อนรวมถึงloglognคำที่บอกฉันว่ามีsqrt(n)ที่ไหนสักแห่ง

สมมติว่าฉันใช้ตะแกรงกับตัวเลข 100 ตัวแรก ( n = 100) โดยสมมติว่าการทำเครื่องหมายตัวเลขเป็นแบบผสมต้องใช้เวลาคงที่ (การใช้อาร์เรย์) จำนวนครั้งที่เราใช้mark_composite()จะเป็นดังนี้

n/2 + n/3 + n/5 + n/7 + ... + n/97        =      O(n^2)                         

และเพื่อหาตัวเลขที่สำคัญถัดไป (เช่นการกระโดด7ข้ามจากตัวเลขทั้งหมดที่มีหลายรายการ5) O(n)จำนวนของการดำเนินงานจะเป็น

O(n^3)ดังนั้นความซับซ้อนจะเป็น คุณเห็นด้วยไหม?

1. n / 2 + n / 3 + n / 5 + … n / 97 ของคุณไม่ใช่ O (n) เนื่องจากจำนวนพจน์ไม่คงที่ [แก้ไขหลังการแก้ไขของคุณ: O (n ² ) ขอบเขตบนหลวมเกินไป] ขอบเขตบนหลวมคือ n (1 + 1/2 + 1/3 + 1/4 + 1/5 + 1/6 + ... 1 / n) (ผลรวมของส่วนกลับของทุกหมายเลขได้ถึง n) ซึ่งเป็น O (n log n): ดูจำนวนฮาร์มอนิ ขอบเขตบนที่เหมาะสมกว่าคือ n (1/2 + 1/3 + 1/5 + 1/7 + ... ) นั่นคือผลรวมของไพรม์ซึ่งกันและกันถึง n ซึ่งก็คือ O (n log log n) (ดูที่นี่หรือที่นี่ )

2. "ค้นหาตัวเลขที่สำคัญต่อไป" บิตเป็นเพียง O (n) โดยรวมตัดจำหน่าย - คุณจะย้ายไปข้างหน้าเพื่อหาหมายเลขถัดไป n ครั้งเดียวในทั้งหมดไม่ต่อขั้นตอน ดังนั้นส่วนทั้งหมดของอัลกอริทึมนี้ใช้เวลาเพียง O (n)

ดังนั้นการใช้สองสิ่งนี้คุณจะได้ขอบเขตบนของ O (n log log n) + O (n) = O (n log log n) การดำเนินการทางคณิตศาสตร์ หากคุณนับการดำเนินการบิตเนื่องจากคุณกำลังจัดการกับตัวเลขถึง n จึงมีเกี่ยวกับ log n บิตซึ่งเป็นที่ที่ปัจจัยของ log n เข้ามาให้การดำเนินการบิต O (n log n log n)

ความซับซ้อนรวมถึงคำ loglogn บอกฉันว่ามี sqrt (n) ที่ไหนสักแห่ง

เก็บไว้ในใจว่าเมื่อคุณพบว่ามีจำนวนที่สำคัญPในขณะที่ sieving คุณไม่เริ่มข้ามปิดตัวเลขที่ตำแหน่งปัจจุบันของคุณ + P; P^2ที่จะเริ่มต้นข้ามปิดตัวเลขที่ จำนวนทวีคูณที่Pน้อยกว่าทั้งหมดP^2จะถูกขีดฆ่าด้วยจำนวนเฉพาะก่อนหน้า

1. ห่วงภายในไม่n/iทำตามขั้นตอนที่iเป็นนายก => sum(n/i) = n * sum(1/i)ความซับซ้อนทั้งเป็น ตามที่ประสานชุดสำคัญที่sum (1/i)ที่เป็นนายกรัฐมนตรีi log (log n)โดยรวม, O(n*log(log n)).
2. ฉันคิดว่าวงบนสามารถปรับให้เหมาะสมได้โดยการแทนที่nด้วยsqrt(n)ความซับซ้อนของเวลาโดยรวมจะO(sqrt(n)loglog(n)):

void isPrime(int n){
    int prime[n],i,j,count1=0;
    for(i=0; i < n; i++){
        prime[i] = 1;
    }
    prime[0] = prime[1] = 0;
    for(i=2; i <= n; i++){
        if(prime[i] == 1){
            printf("%d ",i);
            for(j=2; (i*j) <= n; j++)
                prime[i*j] = 0;
        }
    }    
}

ดูคำอธิบายข้างต้นวงในคือผลรวมฮาร์มอนิกของจำนวนเฉพาะทั้งหมดจนถึง sqrt (n) ดังนั้นความซับซ้อนที่แท้จริงของคือ O (sqrt (n) * log (log (sqrt (n))))