Временная сложность алгоритма Решета Эратосфена

Из Википедии:

Сложность алгоритма - 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 log n) битовых операций.

То, что сложность включает термин loglogn, говорит мне, что где-то есть sqrt (n).

Имейте в виду, что когда вы находите простое число Pво время просеивания, вы не начинаете вычеркивать числа в вашей текущей позиции + 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))))