Сложность алгоритмов

Шатилов Максим 271ПИ

Шатилов Максим 271ПИ

Модель вычислений - это множество базовых операций, используемыхдля вычисления, а также относительные издержки их применения.

Модель вычислений - это множество базовых операций, используемыхдля вычисления, а также относительные издержки их применения.

При асимптотической оценке сложности вычислений, модель вычислений определяется через множество базовых операций, для каждой из которых известная ее цена.

При асимптотической оценке сложности вычислений, модель вычислений определяется через множество базовых операций, для каждой из которых известная ее цена.

1) a ← b

2) a + b, a * b,

a – b, a / b

3) a [ i ], a [ i, j ]

4) a > b, a ≥ b,

a ≤ b, a = b

5) and, or, not6) if (a > b) {…} else {…}

Алгоритм А:D – вход алгоритма;|D|= n – длина входа;

fa (D) – трудоемкость, т.е. число базовых операций, заданных алгоритмом A на входе D;

Va (D) – объем памяти, максимальное число ячеек модели вычислений, задействованных алгоритмом A на входе D;

Dn = { D | |D| = n};

fa^

(n) = max f (D) - худший случай ; D Є Dn

fav (n) = min f (D) – лучший случай;

D Є Dn

«хорошо» описывающая алгоритм функция

Аргументами данной функции могут быть

Ресурсные оценки – требования алгоритма к ресурса компьютера(оперативная память, процессор). Например, требования алгоритмак памяти могут быть представлены в виде:V(n)=Vio+Vдоп+Vexe+Vстек

гдеVio - память для чтения/записиVдоп - память, содержащая переменные алгоритмаVexe - код программыVстек - память, выделенная для стека.

Информационная чувствительностьРазмах варьирования - fa

^ (n) - fa

v (n) = R(n);

Время выполнения.

f(n)=Θ(g(n))

Θ(g(n)) = { f(n): существуют положительные константы c1, c2 и n0

такие что 0≤ c1g(n)≤ f(n) ≤ c2g(n) для всех n≥ n0}

Θ(g(n)) = { f(n): существуют положительные константы c1, c2 и n0

такие что 0≤ c1g(n)≤ f(n) ≤ c2g(n) для всех n≥ n0}Функция g(n) является асимптотически точной оценкой функции f(n)

Функция g(n) является асимптотически точной оценкой функции f(n)

f(n) = О(g(n))

Функция g(n) является асимптотической верхней границей функции f(n)Функция g(n) является асимптотической верхней границей функции f(n)

O(g(n)) = { f(n): существуют положительные константы c1, c2 и n0

такие что 0≤ c1g(n)≤ f(n) ≤ c2g(n) для всех n≥ n0}

O(g(n)) = { f(n): существуют положительные константы c1, c2 и n0

такие что 0≤ c1g(n)≤ f(n) ≤ c2g(n) для всех n≥ n0}

Большую часть функций сложности можно разделить на следующие классы:

• O(1) – сложность типа константы• O(log(n)) – логарифмическая сложность• O(n) – линейная сложность• O(n log(n)) – сложность "n-log-n"• O(n2) – квадратичная сложность• O(n3) – кубическая сложность• O(2n) – экспоненциальная сложность

Функции f(x) и g(x) называются полиномиально-эквивалентнтными, если существуют такие полиномы p(x) и p’(x), что, (начиная с некоторого числа) f(x) p(g(x)) и g(x) p’(f(x)).

f1(n) Є O(n)f2(n) Є O(n2)

f3(n) Є O(log(n))

f4(n) Є O(n log(n))

f5(n) Є O(n3)

f6(n) Є O(2n)

Примечание: на рисунке изображены графики для маленьких n (0<n<10)

f1(n) Є O(n)f2(n) Є O(n2)

f3(n) Є O(log(n))

f4(n) Є O(n log(n))

f5(n) Є O(n3)

f6(n) Є O(2n)

Примечание: на рисунке изображены графики для средних n (0<n<6000)

f(n)=Ω(g(n))

Ω(g(n)) = { f(n): существуют положительные константы и n0

такие что 0≤ cg(n)≤ f(n) для всех n≥ n0}

Ω(g(n)) = { f(n): существуют положительные константы и n0

такие что 0≤ cg(n)≤ f(n) для всех n≥ n0}

Функция g(n) является асимптотической нижней оценкой функции f(n)

Функция g(n) является асимптотической нижней оценкой функции f(n)

Max(A, n; max)begin max ← A[1] for i ← 2 to n if max < A[i] then max ← A[i]end

О(g(n)) = fa^

(n) = 2 + 1 + (n-1)(3+2+2) = 7n - 4

Ω(g(n)) = fav (n) = 2 + 1 + (n-1)(3+2) = 5n - 2

Θ(g(n)) = Θ(n)

Задача: найти максимум в массиве A длинной n. Найти асимптотическую верхнюю,асимптотическую нижнею и асимптотически точную границы сложности алгоритма.

Решение:

Суммаэлементов

27

43

32

Задача: найти максимальную сумму непрерывной подпоследовательности элементов последовательности A

Пример:

Решение дальше

/ / Алгоритм поиска максимальной суммы подпоследовательности, // имеющий кубическую сложность (O(n3) )./ / seqStart – индекс начала подпоследовательности/ / seqEnd – индекс конца подпоследовательностиtemplate <class Comparable>Comparable maxSubsequenceSum( const vector<Comparable> & a,

int & seqStart, int & seqEnd ) { int n = a. size ( ) ; Comparable maxSum = 0;

for( int i = 0; i < n; i++ ) for( int j = i; j < n; j++ ) { Comparable thissum = 0; for( int k = i; k<= j; k++) thissum += a[ k ] ; if( thissum > maxSum ) { maxSum = thissum; seqStart = i; seqEnd = j ; } } return maxSum;}

/ / Алгоритм поиска максимальной суммы подпоследовательности, / / имеющий линейную сложность (O(n) )./ / seqStart – индекс начала подпоследовательности/ / seqEnd – индекс конца подпоследовательности template <class Comparable>Comparable maxSubsequenceSum( const vector<Comparable> & a,

int & seqstart, int & seqEnd ){ int n = a. size ( ) ; Comparable thissum = 0, maxSum = 0;

for( int i = 0, j = 0; j < n; j++ ) { thissum += a [ j ] ; if( thissum > maxSum ) { maxSum = thissum; seqstart = i; seqEnd = j ; } else if ( thissum < 0 ) { i = j + 1 ; thissum = 0; } } return maxSum;}

/ / Алгоритм поиска максимальной суммы подпоследовательности, // имеющий квадратическую сложность (O(n2) )./ / seqStart – индекс начала подпоследовательности/ / seqEnd – индекс конца подпоследовательностиtemplate <class Comparable>Comparable maxSubsequenceSum( const vector<Comparable> & a,

int & seqstart, int & seqEnd ){ int n = a.size( ) ; Comparable maxSum = 0;

for( int i = 0; i < n; i++ ) { Comparable thissum = 0; for( int j = i; j < n; j++ ) { thissum += a [ j ] ; if ( thissum > maxSum ) { maxSum = thissum; seqStart = i; seqEnd = j ; } } } return maxSum;}

/ / Алгоритм поиска максимальной суммы подпоследовательности, // имеющий квадратическую сложность (O(n2) )./ / seqStart – индекс начала подпоследовательности/ / seqEnd – индекс конца подпоследовательностиtemplate <class Comparable>Comparable maxSubsequenceSum( const vector<Comparable> & a,

int & seqstart, int & seqEnd ){ int n = a.size( ) ; Comparable maxSum = 0;

for( int i = 0; i < n; i++ ) { Comparable thissum = 0; for( int j = i; j < n; j++ ) { thissum += a [ j ] ; if ( thissum > maxSum ) { maxSum = thissum; seqStart = i; seqEnd = j ; } } } return maxSum;}

Θ(1) Θ(n-i) n

ΣΘ(n-i) = Θ((n-i)2)i=1

N O(n3) O(n2) O(n)

10 0.000009 0.000004 0.000003

100 0.002580 0.000109 0.000006

1000 2.281013 0.010203 0.000031

10000 - 1.2329 0.000317

100000 - 135 0.003206

Время работы (в секундах) различных алгоритмов поиска максимальной суммы непрерывной подпоследовательности элементов

заданной последовательностипри входных данных различной длины

дерево рекурсивных вызовов для вычисления f(6)

int f (int n) { if (n == 1) { return 1; } if (n == 2) { return 1; } return f(n-2) + f(n-1);}

Совокупность равенств такого типаназывается рекуррентностью(возвратное соотношение или рекурсивнаязависимость)

При анализе рекурсивных алгоритмов часто возникают рекуррентныеуравнения вида

где a, b и с – неотрицательные постоянныеn – степень числа с

Решение рекуррентных уравнение такого вида имеет вид

Пример: быстрая сортировкаРазбиение задачи размера n (за линейное время) на две подзадачиразмера n / 2 дает алгоритм сложности O(n log n).

Задача: перемножить два многочлена

Т.е. можно рекурсивно свести данную задачу к трем подзадачам:

Последний член вычисляется на основе решении этих трех подзадач

Задача: найти сложность данного алгоритма