Постоянное амортизированное время

Это означает, что со временем в наихудшем 9X_algorithm-design сценарии по умолчанию будет установлено 9X_algorithm-design значение O (1) или постоянное время. Типичный 9X_asymptotic-complexity пример - динамический массив. Если мы уже 9X_complexity-theory выделили память для новой записи, добавление 9X_complexity-theory будет O (1). Если мы не распределили его, мы 9X_complexity сделаем это, выделив, скажем, в два раза 9X_complexity больше текущей суммы. Эта конкретная вставка 9X_complexity-theory будет не O (1), а скорее чем-то другим.

Что 9X_algorithm важно, так это то, что алгоритм гарантирует, что 9X_algorithm после последовательности операций дорогостоящие 9X_complexity операции будут амортизированы, и, таким 9X_complexity образом, вся операция будет выполнена как 9X_algorithms O (1).

Или, говоря более строго,

Существует 9X_complexity-theory постоянная c, такая, что для каждую последовательность 9X_algorithm операций (также заканчивающуюся дорогостоящей 9X_asymptotic-complexity операцией) длина L, время не более c 9X_big-theta * L (Спасибо, Rafał Dowgird)

Чтобы выработать интуитивно понятное представление 9X_asymptotic-complexity об этом, рассмотрите возможность вставки 9X_o-notation элементов в dynamic array (например, std::vector в C++). Построим 9X_algorithm-design график, показывающий зависимость количества 9X_asymptotic-complexity операций (Y), необходимых для вставки N 9X_complexity элементов в массив:

Вертикальные части черного 9X_algorithm графика соответствуют перераспределению 9X_algorithms памяти для расширения массива. Здесь мы 9X_algorithms видим, что эту зависимость можно грубо представить 9X_complexity в виде линии. И это линейное уравнение - Y=C*N + b (C является 9X_asymptotic-complexity константой, b = 0 в нашем случае). Поэтому 9X_complexity-theory мы можем сказать, что нам нужно потратить 9X_algorithms в среднем операции C*N, чтобы добавить N элементов 9X_big-o в массив, или операции C*1, чтобы добавить 9X_complexity-theory один элемент (амортизированное постоянное 9X_complexity время).

Я нашел ниже объяснение Википедии полезным 9X_algorithms после повторного чтения 3 раза:

Источник: https://en.wikipedia.org/wiki/Amortized_analysis#Dynamic_Array

"Динамический 9X_complexity массив

Амортизированный анализ операции push 9X_o-notation для динамического массива

Представьте динамический 9X_o-notation массив, размер которого увеличивается по 9X_o-notation мере добавления в него дополнительных элементов. например, ArrayList 9X_algorithms в Java. Если бы мы начали с динамического 9X_algorithm-design массива размера 4 потребуется постоянное 9X_algorithm время, чтобы поместить на него четыре элемента. Однако 9X_big-theta добавление пятого элемента в этот массив 9X_algorithm займет больше времени, так как array должен 9X_complexity-theory был бы создать новый массив в два раза больше 9X_asymptotic-complexity текущего размера (8), скопируйте старые 9X_big-o элементы в новый массив, а затем добавьте 9X_big-theta новые элемент. Следующие три операции 9X_o-notation push аналогично будут иметь постоянное значение. времени, а 9X_big-o затем для последующего добавления потребуется 9X_algorithms еще один медленный удвоение размера массива.

В 9X_big-o общем, если мы рассмотрим произвольное количество 9X_algorithm-design нажатий n на массив размера n, мы замечаем, что 9X_algorithm операции push занимают постоянное время, за 9X_big-o исключением для последнего, который занимает 9X_algorithm O (n) времени, чтобы выполнить удвоение 9X_o-notation размера операция. Поскольку всего было 9X_algorithm n операций, мы можем взять среднее этого 9X_asymptotic-complexity и найдите, что для вставки элементов в динамический 9X_o-notation массив принимает: O (n / n) = O (1), постоянное 9X_big-o время ».

Насколько я понимаю, простая история:

Предположим, у 9X_complexity вас много денег. И вы хотите сложить их 9X_algorithm в комнате. И у вас длинные руки и ноги, столько, сколько 9X_o-notation вам нужно сейчас или в будущем. И вам нужно 9X_asymptotic-complexity заполнить все в одной комнате, чтобы ее 9X_complexity было легко заблокировать.

Итак, вы идете 9X_algorithm вправо в конец / угол комнаты и начинаете 9X_algorithm складывать их. По мере того, как вы складываете 9X_o-notation их, в комнате постепенно будет не хватать 9X_big-o места. Однако по мере заполнения их было 9X_complexity-theory легко складывать. Деньги есть, деньги положены. Легкий. Это 9X_big-theta O (1). Нам не нужно переводить предыдущие 9X_big-o деньги.

Когда в комнате заканчивается место. Нам 9X_big-o нужна другая комната, побольше. Здесь возникает 9X_asymptotic-complexity проблема, поскольку у нас может быть только 9X_complexity 1 комната, поэтому у нас может быть только 9X_algorithms 1 замок, нам нужно переместить все существующие 9X_algorithm-design деньги в этой комнате в новую большую комнату. Итак, переместите 9X_algorithm-design все деньги из маленькой комнаты в комнату 9X_algorithm-design побольше. То есть сложите их все снова. Итак, нам 9X_complexity-theory ДЕЙСТВИТЕЛЬНО нужно переместить все предыдущие 9X_o-notation деньги. Итак, это O (N). (при условии, что 9X_algorithm N - общее количество денег предыдущих денег)

Другими 9X_complexity словами, это было легко до N, всего 1 операции, но 9X_big-theta когда нам нужно переехать в комнату побольше, мы 9X_complexity-theory выполняли N операций. Другими словами, если 9X_big-o мы усредним, это будет 1 вставка в начале 9X_complexity-theory и еще 1 ход при переходе в другую комнату. Всего 9X_big-theta 2 операции, одна вставка, один ход.

Если 9X_algorithm предположить, что N большое, например 1 9X_algorithms миллион, даже в маленькой комнате, 2 операции 9X_asymptotic-complexity по сравнению с N (1 миллион) на самом деле 9X_algorithm-design не сопоставимое число, поэтому оно считается 9X_algorithm постоянным или O (1).

Предположим, когда 9X_o-notation мы делаем все вышесказанное в другой комнате 9X_complexity побольше, и снова нужно двигаться. Это все 9X_algorithm-design то же самое. скажем, N2 (скажем, 1 миллиард) - это 9X_big-theta новая сумма денег в большей комнате

Итак, у 9X_asymptotic-complexity нас есть N2 (которое включает N предыдущих, поскольку 9X_o-notation мы перемещаем все из маленькой комнаты в 9X_o-notation большую)

Нам по-прежнему нужны только две 9X_complexity операции: одна - вставка в большую комнату, а 9X_algorithm-design вторая - перемещение, чтобы переместиться 9X_asymptotic-complexity в еще большую комнату.

Итак, даже для N2 9X_big-o (1 миллиард) это 2 операции на каждую. что 9X_big-o снова ничто. Значит, это константа, или 9X_algorithm-design O (1)

Таким образом, если N увеличивается 9X_complexity от N до N2 или другого, это не имеет большого 9X_complexity значения. Он по-прежнему постоянен или требуется 9X_big-theta O (1) операций для каждого из N.

---

Теперь предположим, что 9X_o-notation у вас N равно 1, очень мало, счетчик денег 9X_algorithm невелик, и у вас есть очень маленькая комната, в 9X_big-theta которую поместится только 1 счетчик денег.

Как 9X_complexity только вы наполняете комнату деньгами, комната 9X_big-o заполняется.

Когда вы идете в большую комнату, предположите, что 9X_big-theta в нее поместится только одна сумма денег, всего 9X_algorithms 2 единицы денег. Это означает, что предыдущие 9X_complexity-theory переместили деньги и еще 1. И снова он заполнен.

Таким 9X_asymptotic-complexity образом, N растет медленно, и оно больше 9X_algorithm-design не является постоянным O (1), так как мы 9X_big-theta перемещаем все деньги из предыдущей комнаты, но 9X_complexity-theory можем разместить только еще 1 деньги.

После 9X_algorithm-design 100 раз в новую комнату помещается 100 единиц 9X_complexity предыдущей и еще 1 сумма, которую она может 9X_algorithm-design вместить. Это O (N), так как O (N + 1) равно 9X_algorithms O (N), то есть степень 100 или 101 одинакова, оба 9X_algorithm-design являются сотнями, в отличие от предыдущей 9X_complexity-theory истории, от единиц к миллионам и единиц 9X_algorithm к миллиардам. .

Итак, это неэффективный способ 9X_algorithms выделения комнат (или памяти / RAM) за наши 9X_algorithms деньги (переменные).

---

Итак, хороший способ 9X_complexity-theory - выделить больше места с увеличением 2

1-й 9X_complexity размер комнаты = вмещает 1 денежную единицу 9X_complexity
2-й размер комнаты = вмещает 4 счета
Размер 9X_complexity-theory 3-й комнаты = вмещает 8 счетов
4-й размер 9X_algorithm комнаты = вмещает 16 шт.
5-й размер комнаты 9X_o-notation = вмещает 32 счета
Шестой размер комнаты 9X_algorithm = вмещает 64 счета
7-й размер комнаты = вмещает 9X_algorithm-design 128 счетов
8-й размер комнаты = вмещает 9X_asymptotic-complexity 256 счетов
9-я комната = вмещает 512 счетов 9X_algorithm
10-й размер комнаты = вмещает 1024 счета 9X_asymptotic-complexity
11-й размер комнаты = 2048 шт.
...
16-й 9X_o-notation размер комнаты = вмещает 65 536 шт.
...
32-й 9X_algorithm-design размер комнаты = вмещает 4 294 967 296 денежных 9X_complexity-theory единиц
...
Размер 64-й комнаты = 18 446 9X_asymptotic-complexity 744 073 709 551 616 денег

Почему так лучше? Потому 9X_algorithms что вначале кажется, что он растет медленно, а 9X_complexity-theory позже - быстрее, то есть по сравнению с 9X_asymptotic-complexity объемом памяти в нашей оперативной памяти.

Это 9X_big-o полезно, потому что, хотя в первом случае 9X_algorithm это и хорошо, общий объем работы, которую 9X_asymptotic-complexity необходимо выполнить за деньги, фиксирован 9X_complexity (2) и не сопоставим с размером комнаты (N), той 9X_complexity комнаты, которую мы взяли на начальных этапах. может 9X_algorithm-design быть слишком большим (1 миллион), который 9X_algorithms мы не сможем использовать полностью, в зависимости 9X_complexity от того, сможем ли мы вообще получить столько 9X_complexity денег, чтобы сэкономить в первом случае.

Однако 9X_algorithms в последнем случае, степень двойки, она 9X_o-notation растет в пределах нашей оперативной памяти. Таким 9X_algorithms образом, при увеличении в степени 2 и Armotized-анализ 9X_algorithms остается постоянным, и он удобен для ограниченной 9X_algorithm оперативной памяти, которая у нас есть на 9X_complexity сегодняшний день.

Я создал этот простой скрипт Python, чтобы 9X_algorithm продемонстрировать амортизированную сложность 9X_algorithm-design операции добавления в список Python. Мы 9X_big-theta продолжаем добавлять элементы в список и 9X_algorithms время каждой операции. Во время этого процесса 9X_algorithm мы замечаем, что некоторые конкретные операции 9X_big-theta добавления занимают гораздо больше времени. Эти 9X_big-o всплески связаны с новым выделением памяти. Важно 9X_complexity-theory отметить, что по мере увеличения количества 9X_big-o операций добавления пики становятся выше, но 9X_o-notation увеличиваются интервалы. Увеличение интервала 9X_o-notation связано с тем, что больший объем памяти 9X_algorithm-design (обычно вдвое больше предыдущего) резервируется 9X_o-notation каждый раз, когда начальная память достигает 9X_algorithm-design переполнения. Надеюсь, это поможет, я смогу 9X_complexity-theory улучшить его, основываясь на предложениях.

import matplotlib.pyplot as plt import time a = [] N = 1000000 totalTimeList = [0]*N timeForThisIterationList = [0]*N for i in range(1, N): startTime = time.time() a.append([0]*500) # every iteartion, we append a value(which is a list so that it takes more time) timeForThisIterationList[i] = time.time() - startTime totalTimeList[i] = totalTimeList[i-1] + timeForThisIterationList[i] max_1 = max(totalTimeList) max_2 = max(timeForThisIterationList) plt.plot(totalTimeList, label='cumulative time') plt.plot(timeForThisIterationList, label='time taken per append') plt.legend() plt.title('List-append time per operation showing amortised linear complexity') plt.show() 

Это 9X_asymptotic-complexity дает следующий график

Приведенные выше объяснения относятся к 9X_complexity агрегированному анализу, идее использования 9X_big-o «среднего» по нескольким операциям. Я не 9X_big-o уверен, как они применимы к Банкирскому 9X_complexity методу или Физическому методу амортизированного 9X_complexity-theory анализа.

Сейчас. Я не совсем уверен в правильном 9X_big-o ответе. Но это должно быть связано с основным 9X_complexity-theory условием обоих методов физики + банкира:

(Сумма 9X_o-notation амортизированной стоимости операций)> = (Сумма 9X_big-theta фактической стоимости операций).

Основная 9X_complexity трудность, с которой я сталкиваюсь, заключается 9X_big-o в том, что, учитывая, что амортизированная 9X_complexity асимптотическая стоимость операций отличается 9X_complexity-theory от нормальной асимптотической стоимости, я 9X_complexity-theory не уверен, как оценить значимость амортизированной 9X_algorithm-design стоимости.

То есть, когда кто-то дает мне 9X_o-notation амортизированную стоимость, я знаю, что 9X_algorithm это не то же самое, что и нормальная асимптотическая 9X_algorithm стоимость. Какие выводы я тогда должен сделать 9X_o-notation из амортизированной стоимости?

Поскольку 9X_algorithm у нас есть случай, когда некоторые операции 9X_algorithms оплачиваются с завышенной ценой, а другие 9X_asymptotic-complexity - заниженными, одна из гипотез может заключаться 9X_algorithms в том, что указание амортизированных затрат 9X_algorithms на отдельные операции было бы бессмысленным.

Например: для 9X_asymptotic-complexity кучи Фибоначчи указание амортизированной 9X_asymptotic-complexity стоимости просто Decreasing-Key равной O 9X_asymptotic-complexity (1) бессмысленно, поскольку затраты снижаются 9X_complexity за счет «работы, выполненной более ранними 9X_big-theta операциями по увеличению потенциала кучи».

ИЛИ

У 9X_algorithms нас могла бы быть другая гипотеза, которая 9X_big-o объясняет амортизированные затраты следующим 9X_o-notation образом:

1. Я знаю, что дорогостоящей операции 9X_big-theta будут предшествовать НЕСКОЛЬКО НИЗКИХ операций.

2. Для 9X_big-theta анализа я собираюсь завышать цену за некоторые 9X_algorithms недорогие операции, ТАКИЕ, ЧТО ИХ АСИМПТОТИЧЕСКАЯ 9X_asymptotic-complexity СТОИМОСТЬ НЕ ИЗМЕНЯЕТСЯ.

3. Благодаря этим увеличившимся 9X_asymptotic-complexity малозатратным операциям я могу ДОКАЗАТЬ, ЧТО 9X_complexity ДОРОГИЕ ОПЕРАЦИИ имеют МЕНЬШУЮ АСИМПТОТИЧЕСКУЮ 9X_complexity СТОИМОСТЬ.

4. Таким образом, я улучшил / уменьшил 9X_complexity АСИМПТОТИЧЕСКУЮ ОЦЕНКУ стоимости n операций.

Таким 9X_asymptotic-complexity образом, анализ амортизированной стоимости 9X_complexity + границы амортизированной стоимости теперь 9X_big-theta применимы только к дорогостоящим операциям. У 9X_o-notation дешевых операций такая же асимптотическая 9X_asymptotic-complexity амортизированная стоимость, что и их нормальная 9X_complexity-theory асимптотическая стоимость.

Производительность любой функции можно усреднить, разделив 9X_algorithm «общее количество вызовов функций» на «общее 9X_complexity время, затраченное на все эти вызовы». Таким 9X_big-o образом можно усреднить даже функции, которые 9X_complexity-theory занимают все больше и больше времени для 9X_complexity-theory каждого выполняемого вами вызова.

Итак, суть 9X_asymptotic-complexity функции, которая выполняется в Constant Amortized Time, заключается 9X_algorithm в том, что это «среднее время» достигает 9X_algorithm потолка, который не может быть превышен, поскольку 9X_big-o количество вызовов продолжает увеличиваться. Производительность 9X_big-theta любого конкретного вызова может отличаться, но 9X_asymptotic-complexity в долгосрочной перспективе это среднее время 9X_asymptotic-complexity не будет расти все больше и больше.

Это основная 9X_big-o заслуга того, что работает на Constant Amortized Time.