Чет про программирование / туф / 12_O / main

{$mode objfpc}

var i, j, n: integer;
    a: array of integer;
    //a[i] = 1 - число зачёркнуто
    
begin
    read(n);
    setlength(a, n+1);
    
    for i := 2 to n do begin
        if a[i] = 1 then continue;
        write(i, ' ');
        j := 2*i;
        while j <= n do begin      O(nlnn)    e-maxx.ru
            a[j] := 1;
            j += i;
        end;
    end;

    writeln();
end.

{
II. Алгоритмы и структуры данных: построение и анализ
Кормен, Лейзерсон, Ривест, Штайн
ocw.mit.edu SMA5503 

Алгоритм - формальная вычислительная процедура.
Т.е. последовательность шагов, которая получает результат по входным данным
Как соотносятся алгоритм и программа? Программа - это реализация алгоритма.

RAM-машина - абстрактный исполнитель, используемый для анализа алгоритмов
Выполняет арифметические дейсвтия, работает с памятью,...

Задача: на входе a_1, a_2, ..., a_n - последовательность чисел.
Необходимо получить её перестановку a_1', a_2', ..., a_n',
такую что a_1' <= a_2' <= ... <= a_n'.

Сортировка  вставками.

var i, j, n, key: integer;
    a: array [1..100] of integer;

begin
    read(n);
    for i := 1 to n do
        read(a[i]);
    
    for i := 2 to n do begin
c_1        key := a[i];
c_2        j := i;
c_3*t_i        while (j > 1) and (a[j-1] > key) do begin
c_4*(t_i-1)            a[j] := a[j-1];
c_5*(t_i-1)            dec(j);
        end;
c_6        a[j] := key;
    end;
    
    for i := 1 to n do begin
        write(a[i], ' ');
    end;
    writeln();
end.

Если последовательность уже отсортирована (лучший случай), то t_i = 1 для всех i из 2..n
Если последовательность отсортирована в обратном порядке (худший случай) t_i = i-1
Время работы алгоритма в лучшем случае: (n-1)(с_1 + с_2 + с_3 + с_6)
Время работы алгоритма в худшем случае: (n-1)(с_1 + с_2 + с_6) + c3*(n-1) + (c3+c4+c5)(n-2)*(n-1)/2
Время работы алгоритма в среднем случае: сейчас не будем

1. время работы бывает: в лучшем, в худшем, в среднем.
   при этом "в среднем" и "в худшем" может отличаться слабо.
2. консанты c_k различны для различных компьютеров,
   поэтому при анализе работы алгоритма мультипликативные константы будем отбрасывать.
3. нужно считать колчество дейсвий, полагая, что каждое действие RAM-машины занимет константное кол-во времени.

Асимптотический анализ времени работы

f(n) = (n-1)(с_1 + с_2 + с_6) + c3*(n-1) + (c3+c4+c5)(n-2)*(n-1)/2
g(n) = n^2

lim f(n)/g(n) = (с3+с4+с5)/2

f(n) - истинное время работы программы
g(n) - выражение, которым мы будем аппроксимировать время работы программы
f(n) и g(n) должны одинаково (с точностью до мультипликативной константы) расти при n -> inf

f(n) = O(g(n)) <=> (def, n->inf) E n_0, c>0: A n>n_0: f(n) <= c*g(n)
например  
An^2 + Bn + C = O(n^2) т.к. в качестве "c" нужно взять A + eps
An^2 + Bn + C = O(n^3)
An^2 + Bn + C = O(n^4)

f(n) = omega(g(n)) <=> (def, n->inf) E n_0, c>0: A n>n_0: f(n) >= c*g(n)

f(n) = theta(g(n)) <=> (def, n->inf) E n_0, c1>0, c2>0: A n>n_0: c_1*g(n) <= f(n) <= c_2*g(n)


(n-1)(с_1 + с_2 + с_6) + c3*(n-1) + (c3+c4+c5)(n-2)*(n-1)/2 = Theta(n^2)

Следствия:
1. Если количество действий в алгоритме оценивается как многочлен
   a_k*n^k + a_(k-1)*n^(k-1) + ... + a_0, то можно сказать, 
   что время работы алгоритма есть O(n^k).
2. Если время работы некоторого алгитма занимает фиксированное время,
   то можно сказать, что это есть O(1).

Время работы сортировки пузырьком есть O(n^2).
Время работы сортировки вставками есть тоже O(n^2), но константа 1/2, и то, это оценка сверху
Время работы сортировки обменом есть O(n^2), и константа 1/2

Сортировка слиянием
6 1 4 | 3 5 2
1 4 6 | 2 3 5
1 2 3 4 5 6

........*********************|...........................

T(n) - количество действий для сортировки массива из n чисел
T(1) <= k
T(n) <= T(floor(n/2)) + T(ceil(n/2)) + k*n
n  T(n)
1  k
2  k + k + 2k = 4k
3  T(2) + T(1) + 3k = 8k
4  T(2) + T(2) + 4k = 12k
5  T(2) + T(3) + 5k = 17k
6  T(3) + T(3) + 6k = 22k

T(n) = O(nlogn)

Карманная сортировка
O(m+n), где m - максимальное число в массиве

f(n, m) = O(g(n, m)) <=> def (n, m -> inf) Ex n0, m0, c >0: All n>n0, m>m0: f(n, m) <= c*g(n, m) 

O(n^2) O(n+m) O(nlogn)

}