Как узнать, какую нотацию анализа сложности времени использовать?

В большинстве вводных классов алгоритмов вводятся нотации, такие как (Big O) и , и студент, как правило, учится использовать одну из них для определения сложности времени. $O$ $\Theta$

Однако есть и другие обозначения, такие как , и . Существуют ли какие-либо конкретные сценарии, в которых одна нотация предпочтительнее другой? $o$ $\Omega$ $\omega$

— Джек Н
источник

это не так предпочтительнее, как применимо ...

— vzn

Вы имеете в виду обозначение Ландау . Они не разные символы для одной и той же вещи, но имеют совершенно разные значения. Какой из них «предпочтителен», полностью зависит от желаемого утверждения.

$f \in \cal{O}(g)$ означает, что растет не более, чем , асимптотически и с постоянным множителем; думать об этом как . - более строгая форма, т . е. . $f$ $g$ $\leq$ $f \in o(g)$ $<$

$f \in \Omega(g)$ имеет симметричное значение: растет по крайней мере так же быстро, как . является его более строгим родственником. Вы можете видеть, что эквивалентно . $f$ $g$ $\omega$ $f \in \Omega(g)$ $g \in \cal{O}(f)$

$f \in \Theta(g)$ означает, что растет примерно так же быстро, как ; формально . (асимптотическое равенство) является его более сильной формой. Мы часто имеем в виду когда используем . $f$ $g$ $f \in \cal{O}(g) \cap \Omega(g)$ $f \sim g$ $\Theta$ $\cal{O}$

Обратите внимание, что и его братья и сестры являются классами функций . Важно осознавать это и их точные определения - которые могут различаться в зависимости от того, кто говорит, - когда вы выполняете «арифметику» с ними. $\cal{O}(g)$

При доказательстве вещей старайтесь работать с вашим точным определением. Существует множество определений символов Ландау вокруг (все с одинаковой базовой интуицией), некоторые из которых эквивалентны в одних наборах функций, но не в других.

Предлагаемое чтение:

Если вы заинтересованы в строгом и правильном использовании обозначений Ландау, вас могут заинтересовать недавние работы Rutanen et al. [1]. Они формулируют необходимые и достаточные критерии для асимптотических обозначений, поскольку мы используем их в алгоритмике, показывают, что общее определение не соответствует им, и предоставляют (на самом деле) работоспособное определение.

Общее определение О-нотации для алгоритмического анализа К. Рутанен и соавт. (2015)

— Рафаэль
источник

Я просто хочу указать, что, хотя действует как а действует как , есть различия; нетрудно найти функции и такие, что и .

O

$\mathcal{O}$

\leq

$\le$

Ω

$\Omega$

\geq

$\ge$

g

$g$

f

$f$

f \notin O (g)

$f \not\in \mathcal{O}(g)$

f \notin Ω (g)

$f \not\in \Omega(g)$

— Зак Лэнгли

+1 за упоминание классов функций. Такие вещи, как и встречаются повсеместно в статьях и книгах, что может ввести в заблуждение людей, впервые сталкивающихся с этими обозначениями.

o (1)

$o(1)$

Ω (2^{n})

$\Omega(2^n)$

— Janoma

@ZachLangley То, что вы говорите, очень верно. Там нет общего порядка здесь. Возможно, вообще опасно поднимать , но я думаю, что это служит цели интуитивного построения.

\leq

$\leq$

— Рафаэль

Большой O: верхняя граница

«Большой O» ( ), безусловно, самый распространенный. Когда вы анализируете сложность алгоритма, в большинстве случаев важно иметь некоторую верхнюю границу для того, насколько быстро время выполнения увеличивается с увеличением размера входных данных. По сути, мы хотим знать, что выполнение алгоритма не займет «слишком много времени». Мы не можем выразить это в фактических единицах времени (секундах), потому что это будет зависеть от точной реализации (от того, как написана программа, насколько хорош компилятор, насколько быстрым является процессор машины,…). Таким образом, мы оцениваем то, что не зависит от таких деталей, а именно, сколько времени потребуется для запуска алгоритма, когда мы вводим больший вход. И нам в основном важно, когда мы можем быть уверены, что программа выполнена, поэтому мы обычно хотим знать, что она займет столько-то времени или меньше. $O$

Сказать, что алгоритм имеет время выполнения для входного размера означает, что существует некоторая постоянная такая, что алгоритм завершает самое большее шагов, т.е. время выполнения алгоритма растет максимально быстро, как (до коэффициента масштабирования). Отмечая время выполнения алгоритма для входного размера , неофициально означает, что точностью до некоторого коэффициента масштабирования. $O(f(n))$ $n$ $K$ $K \, f(n)$ $f$ $T(n)$ $n$ $O(n)$ $T(n) \le f(n)$

Нижняя граница

Иногда полезно иметь больше информации, чем верхняя граница. - это обратное к : оно выражает то, что функция растет по крайней мере так же быстро, как и другая. означает, что для некоторой константы или, если говорить неформально, вверх к некоторому коэффициенту масштабирования. $\Omega$ $O$ $T(n) = \Omega(g(n))$ $T(N) \ge K' g(n)$ $K'$ $T(n) \ge g(n)$

Когда время выполнения алгоритма может быть точно определено, объединяет и : это выражает то, что скорость роста функции известна, вплоть до коэффициента масштабирования. означает, что для некоторых констант и . Неформально говоря, точностью до некоторого коэффициента масштабирования. $\Theta$ $O$ $\Omega$ $T(n) = \Theta(h(n))$ $K h(n) \ge T(n) \ge K' h(n)$ $K$ $K'$ $T(n) \approx h(n)$

Дальнейшие соображения

«Маленькие» и используются гораздо реже в анализе сложности. Маленькая сильнее, чем большая ; где указывает на рост, который происходит не быстрее, указывает на то, что рост строго медленнее. И наоборот, указывает на строго более быстрый рост. $o$ $\omega$ $o$ $O$ $O$ $o$ $\omega$

Я был немного неформальным в обсуждении выше. В Википедии есть небольшие определения и более математический подход.

Имейте в виду, что использование знака равенства в и т. П. Является неправильным. Строго говоря, - это набор функций переменной , и мы должны написать . $T(n) = O(f(n))$ $O(f(n))$ $n$ $T \in O(f)$

Пример: некоторые алгоритмы сортировки

Поскольку это довольно сухо, позвольте мне привести пример. Большинство алгоритмов сортировки имеют квадратичное время выполнения в наихудшем случае, т. Е. Для входа размера время выполнения алгоритма равно . Например, сортировка выбора имеет время выполнения , потому что выбор го элемента требует сравнений, в общей сложности сравнений. На самом деле, число сравнений всегда ровно , которое растет как . Таким образом, мы можем быть более точными относительно временной сложности выбора сортировки: это . $n$ $O(n^2)$ $O(n^2)$ $k$ $n-k$ $n(n-1)/2$ $n(n-1)/2$ $n^2$ $\Theta(n^2)$

Теперь возьмите сортировку слиянием . Сортировка слиянием также квадратична ( ). Это правда, но не очень точно. На самом деле сортировка слиянием имеет время выполнения в худшем случае. Как и сортировка выбора, рабочий процесс сортировки слиянием, по существу, не зависит от формы ввода, и его время выполнения всегда равно точностью до постоянного множительного множителя, т.е. это . $O(n^2)$ $O(n \: \mathrm{lg}(n))$ $n \: \mathrm{lg}(n)$ $\Theta(n \: \mathrm{lg}(n))$

Далее рассмотрим быструю сортировку . Быстрая сортировка сложнее. Это, конечно, . Кроме того, наихудший случай быстрой сортировки является квадратичным: наихудший случай - . Однако лучший случай быстрой сортировки (когда вход уже отсортирован) является линейным: лучшее, что мы можем сказать для нижней границы быстрой сортировки в целом, это . Я не буду повторять здесь доказательство, но средняя сложность быстрой сортировки (среднее значение по всем возможным перестановкам входных данных) равна . $O(n^2)$ $\Theta(n^2)$ $\Omega(n)$ $\Theta(n \: \mathrm{lg}(n))$

Существуют общие результаты о сложности алгоритмов сортировки в общих настройках. Предположим, что алгоритм сортировки может сравнивать только два элемента одновременно, с результатом да или нет (либо либо ). Тогда очевидно, что время выполнения любого алгоритма сортировки всегда равно (где - количество элементов для сортировки), потому что алгоритм должен хотя бы один раз сравнить каждый элемент, чтобы узнать, где он будет соответствовать. Эта нижняя граница может быть достигнута, например, если входные данные уже отсортированы, и алгоритм просто сравнивает каждый элемент со следующим и сохраняет их в порядке (это сравнений). Что менее очевидно, так это то, что максимальное время работы обязательно $x \le y$ $x > y$ $\Omega(n)$ $n$ $n-1$ $\Omega(n \: \mathrm{lg}(n))$ . Вполне возможно, что алгоритм иногда делает меньше сравнений, но должна быть некоторая постоянная такая, что для любого входного размера существует хотя бы один вход, на котором алгоритм делает больше, чем сравнения. Идея доказательства состоит в том, чтобы построить дерево решений алгоритма, т.е. следовать решениям, которые алгоритм принимает из результатов каждого сравнения. Поскольку каждое сравнение возвращает результат «да» или «нет», дерево решений представляет собой двоичное дерево. Естьвозможные перестановки входных данных, и алгоритм должен различать их все, поэтому размер дерева решений равен $K$ $n$ $K n \mathrm{lg}(n)$ $n!$ $n!$ , Поскольку дерево является бинарным деревом, для соответствия всем этим узлам требуется глубина . Глубина - это максимальное количество решений, которые принимает алгоритм, поэтому выполнение алгоритма включает в себя как минимум столько сравнений: максимальное время выполнения равно . $\Theta(\mathrm{lg}(n!)) = \Theta(n\:\mathrm{lg}(n))$ $\Omega(n \: \mathrm{lg}(n))$

¹ _{Или другое потребление ресурсов, например, объем памяти. В этом ответе я рассматриваю только время выполнения.}

— жилль
источник

«Однако лучший случай быстрой сортировки (когда вход уже отсортирован) является линейным», это худший случай !!

— user5507

@ user5507: На самом деле, это зависит от стратегии разворота. Если первый (или последний) элемент выбран как опорный, то вы правы; но если вы выберете средний элемент или медиану первого, среднего, последнего, тогда сортированный ввод будет лучшим вариантом.

— Чирлу

«Маленькие o и ω используются гораздо реже в анализе сложности». Это не так в анализе сложности космоса. В анализе временной сложности вы обычно используете o и ω, когда подсчитываете конкретные операции (сравнения, поиск диска, ошибки кэширования, что у вас есть). Но поскольку вы всегда можете подождать и купить более быстрый компьютер, «время стены» всегда «зависит от постоянного фактора», поэтому big-O встречается гораздо чаще. В пространственном анализе часто существуют жесткие нижние границы из-за теории информации, поэтому очень часто можно видеть размер, сообщаемый как «f (n) + o (f (n)) бит», где f (n) - нижняя граница.

— псевдоним

Хотя я думаю об этом: если f (n) является теоретической нижней границей для размера некоторой структуры данных, то та, которая использует f (n) + O (1) (постоянные издержки), называется «неявной», та, которая использует f (n) + O (f (n)) (постоянные относительные издержки) называется «компактным», а тот, который использует f (n) + o (f (n)) (относительные накладные расходы в конечном итоге становятся незначительными), называется «кратким» ». Хорошие условия, чтобы знать, нужно ли вам когда-либо работать в этом пространстве.

— псевдоним

$O$ $\Omega$ $\Theta$ $\Theta$

— Кава
источник

« Как правило»? Их можно использовать для чего-то еще?

— svick

P = D T i m e (n^{O (1)})

$\mathsf{P} = \mathsf{DTime}(n^{O(1)})$

f = O (g)

$f = O(g)$

f

$f$

P = D T i m e (n^{O (1)})

$P = DTime(n^{O(1)})$

P = D T i m e (n^{Θ (1)})

$P = DTime(n^{\Theta(1)})$

@JeffE, я думаю об этом как о равенстве между наборами функций, но вы правы, о нем также можно думать как о верхней границе в более общем смысле.

— Каве

@JeffE На самом деле, , поскольку but .

P \neq D T I M E (n^{Θ (1)})

$\mathrm{P}\neq \mathrm{DTIME}(n^{\Theta(1)})$

D T I M E (Θ (n \log n)) \subset P

$\mathrm{DTIME}(\Theta(n\log n))\subset \mathrm{P}$

D T I M E (Θ (n \log n)) \cap D T I M E (n^{Θ (1)}) = \emptyset

$\mathrm{DTIME}(\Theta(n\log n))\cap\mathrm{DTIME}(n^{\Theta(1)})=\emptyset$

— Дэвид Ричерби