Как найти 5 повторных значений в O (n) времени?

Предположим, у вас есть массив размером содержащий целые числа от до включительно, с ровно пятью повторениями. Мне нужно предложить алгоритм, который может найти повторяющиеся числа в времени. Я не могу ни о чем думать. Я думаю, что сортировка, в лучшем случае, будет ? Тогда при обходе массива будет , что приведет к . Тем не менее, я не уверен, что сортировка будет необходима, поскольку я видел некоторые хитрые вещи со связанным списком, очередями, стеками и т. Д.$n \geq 6$$1$$n − 5$$O(n)$$O(n\log n)$$O(n)$$O(n^2\log n)$

Вы можете создать дополнительный массив $B$ размером $n$ . Изначально установите все элементы массива на $0$ . Затем переберите входной массив $A$ и увеличьте $B[A[i]]$ на 1 для каждого $i$ . После этого вы просто проверяете массив $B$ : цикл над $A$ и если $B[A[i]] > 1$ то $A[i]$ повторяется. Вы решаете это в $O(n)$время за счет памяти, которая составляет $O(n)$ и потому, что ваши целые числа находятся в диапазоне от $1$ до $n-5$ .

Решение в ответе fade2black является стандартным, но использует пространство $O(n)$ . Вы можете улучшить это до $O(1)$ пространство следующим образом:

1. Пусть массив будет $A[1],\ldots,A[n]$ . Для $d=1,\ldots,5$ вычислим $\sigma_d = \sum_{i=1}^n A[i]^d$ .
2. Вычислить $\tau_d = \sigma_d - \sum_{i=1}^{n-5} i^d$ (вы можете использовать известные формулы для вычисления последней суммы в $O(1)$ ). Обратите внимание, что $\tau_d = m_1^d + \cdots + m_5^d$ , где $m_1,\ldots,m_5$ - повторяющиеся числа.
3. Вычислить полином $P(t) = (t-m_1)\cdots(t-m_5)$ . Коэффициенты этого многочлена являются симметричными функциями $m_1,\ldots,m_5$ которые можно вычислить из $\tau_1,\ldots,\tau_5$ в $O(1)$ .
4. Найдите все корни многочлена $P(t)$ , испробовав все $n-5$ возможностей.

Этот алгоритм предполагает модель машины ОЗУ, в которой базовые арифметические операции над -битными словами занимают O ( 1 ) времени.$O(\log n)$$O(1)$

Другой способ сформулировать это решение заключается в следующем:

1. Вычислить , и вывести у 1 = т 1 + ⋯ + м 5 по формуле у 1 = х 1 - Σ п - 5 я = 1 я .$x_1 = \sum_{i=1}^n A[i]$$y_1 = m_1 + \cdots + m_5$$y_1 = x_1 - \sum_{i=1}^{n-5} i$
2. Вычислите в O ( n ), используя формулу x 2 = ( A [ 1 ] ) A [ 2 ] + ( A [ 1 ] + A [ 2] ] ) A [ 3 ] + ( A [ $x_2 = \sum_{1 \leq i < j \leq} A[i] A[j]$$O(n)$ $$x_2 = (A[1]) A[2] + (A[1] + A[2]) A[3] + (A[1] + A[2] + A[3]) A[4] + \cdots + (A[1] + \cdots + A[n-1]) A[n].$$
3. Выведите , используя формулу у 2 = х 2 - Σ 1 ≤ я < J ≤ п - 5 я J - ( п - 5 Σ я = 1 я ) у 1$y_2 = \sum_{1 \leq i < j \leq 5} m_i m_j$ $$y_2 = x_2 - \sum_{1 \leq i < j \leq n-5} ij - \left(\sum_{i=1}^{n-5} i\right) y_1.$$
4. Вычислите и выведите y 3 , y 4 , y 5 по аналогичной линии.$x_3,x_4,x_5$$y_3,y_4,y_5$
5. Значения являются (с точностью до знака) коэффициентами многочлена P ( t ) из предыдущего решения.$y_1,\ldots,y_5$$P(t)$

Это решение показывает, что если мы заменим 5 на , то получим (я полагаю) алгоритм O ( d 2 n ) , используя пространство O ( d 2 ) , которое выполняет O ( d n ) арифметические операции над целыми числами битовой длины O ( d log n ) , сохраняя не более O ( d ) из них в любой момент времени. (Это требует тщательного анализа умножений, которые мы выполняем, большинство из которых включает в себя один операнд длины только O ( log $d$$O(d^2n)$$O(d^2)$$O(dn)$$O(d\log n)$$O(d)$ .) Возможно, что это можно улучшить до O ( d n ) времени и O ( d ) пространства с помощью модульной арифметики.$O(\log n)$$O(dn)$$O(d)$

Существует также линейный алгоритм времени и постоянного пространства, основанный на разбиении, который может быть более гибким, если вы пытаетесь применить это к вариантам задачи, над которыми математический подход не работает должным образом. Это требует изменения базового массива и имеет худшие постоянные факторы, чем математический подход. Точнее говоря, я считаю, что затраты с точки зрения общего числа значений и количества дубликатов d равны O ( n log d ) и O ( d ) соответственно, хотя для точного подтверждения этого потребуется больше времени, чем у меня на данный момент. ,$n$$d$$\mathcal{O}(n \log d)$$\mathcal{O}(d)$

Алгоритм

Начните со списка пар, где первая пара - это диапазон по всему массиву, или если 1 проиндексирован.$[(1, n)]$

Повторяйте следующие шаги, пока список не станет пустым:

1. Возьмите и удалите любую пару из списка.$(i, j)$
2. Найти минимальное и максимальное, и максимальное обозначенного подмассива.$\text{min}$$\text{max}$
3. Если , подмассив состоит только из равных элементов. Получите его элементы, кроме одного, и пропустите шаги с 4 по 6.$\text{min} = \text{max}$
4. Если , подмассив не содержит дубликатов. Пропустите шаги 5 и 6.$\text{max} - \text{min} = j - i$
5. Разбить подмассив вокруг , так что элементы до некоторого индексаkменьше разделителя, а элементы выше этого индекса - нет.$\frac{\text{min}+\text{max}}{2}$$k$
6. Добавьте и ( k + 1 , j ) в список.$(i, k)$$(k + 1, j)$

Беглый анализ сложности времени.

Шаги с 1 по 6 занимают время, так как поиск минимума и максимума и разбиение могут быть выполнены за линейное время.$\mathcal{O}(j - i)$

Каждая пара в списке является либо первой парой ( 1 , n ) , либо дочерним элементом некоторой пары, для которой соответствующий подмассив содержит дубликат элемента. Существует не более d ⌈ log 2 n + 1 ⌉ таких родителей, так как каждый обход делит пополам диапазон, в котором может быть дубликат, таким образом, получается не более 2 d ⌈ log 2 n + 1 ⌉ всего при включении пар над подмассивами без дубликаты. Размер списка не более 2 $(i, j)$$(1, n)$$d \lceil \log_2 n + 1\rceil$$2d \lceil \log_2 n + 1\rceil$$2d$,

Рассмотрим работу по поиску любого дубликата. Он состоит из последовательности пар в экспоненциально убывающем диапазоне, поэтому общая работа представляет собой сумму геометрической последовательности или . Это дает очевидное следствие того, что общая работа для d дубликатов должна быть O ( n d ) , которая является линейной по n .$\mathcal{O}(n)$$d$$\mathcal{O}(nd)$$n$

Чтобы найти более жесткую границу, рассмотрим наихудший сценарий максимального распространения дубликатов. Интуитивно понятно, что поиск занимает две фазы: одна, где каждый раз просматривается полный массив, в постепенно меньших частях, и одна, где части меньше так что только части массива пройдены. Первая фаза может быть толькоглубинойlogd, поэтому имеет стоимостьO(nlogd), а вторая фаза имеет стоимостьO(n),потому что общая область поиска снова экспоненциально уменьшается.$\frac{n}{d}$$\log d$$\mathcal{O}(n \log d)$$\mathcal{O}(n)$

Оставив это как ответ, потому что ему нужно больше места, чем дает комментарий.

Вы делаете ошибку в ОП, когда предлагаете метод. Сортировка списка с последующим преобразованием его время, а не O ( n 2 log n ) время. Когда вы делаете две вещи (которые принимают O ( f ) и O ( g ) соответственно) последовательно, то результирующая временная сложность составляет O ( f + g ) = O ( max f , g ) (в большинстве случаев).$O(n\log n)$$O(n^2\log n)$$O(f)$$O(g)$$O(f+g)=O(\max{f,g})$

Чтобы умножить временные сложности, вам нужно использовать цикл for. Если у вас есть цикл длины и для каждого значения в цикле вы выполняете функцию, которая принимает O ( g ) , тогда вы получите время O ( f g ) .$f$$O(g)$$O(fg)$

Итак, в вашем случае вы сортируете по а затем поперечно по O ( n ), в результате чего O ( n log n + n ) = O ( n log n ) . Если для каждого сравнения алгоритма сортировки вам нужно выполнить вычисление, которое принимает O ( n ) , то это займет O ( n 2 log n ), но здесь это не так.$O(n\log n)$$O(n)$$O(n\log n+n)=O(n\log n)$$O(n)$$O(n^2\log n)$

Если вам интересно мое утверждение о том, что , важно отметить, что это не всегда так. Но если f ∈ O ( g ) или g ∈ O ( f ) (что верно для целого множества общих функций), то оно будет выполнено. Чаще всего это не выполняется, когда включаются дополнительные параметры, и вы получаете выражения типа O ( 2 c n + n log n ) .$O(f+g)=O(\max{f,g})$$f\in O(g)$$g\in O(f)$$O(2^cn+n\log n)$

Существует очевидный вариант техники логического массива на месте, использующий порядок элементов в качестве хранилища (где arr[x] == xдля «найденных» элементов). В отличие от варианта раздела, который может быть оправдан для того, чтобы быть более общим, я не уверен, когда вам на самом деле нужно что-то подобное, но это просто.

for idx from n-4 to n
    while arr[arr[idx]] != arr[idx]
        swap(arr[arr[idx]], arr[idx])

Это просто многократно помещает arr[idx]в место, arr[idx]пока вы не найдете это место уже занято, в этот момент он должен быть дубликатом. Обратите внимание, что общее количество свопов ограничено так как каждый своп делает свое условие выхода корректным.$n$

Вычтите полученные значения из суммы .$\sum_{i=1}^{n} i = \frac{(n-1) \cdot n}{2}$

Итак, после времени (при условии, что арифметика равна O (1), чего на самом деле нет, но давайте представим), у вас есть сумма σ 1 из 5 целых чисел от 1 до n:$\Theta(n)$$\sigma_1$

$x_1 + x_2 + x_3 + x_4 + x_5 = \sigma_1$

Предположительно, это не хорошо, верно? Вы не можете понять, как разбить это на 5 различных чисел.

Ах, но это то, где это будет весело! Теперь сделайте то же самое, что и раньше, но вычитать квадраты значений из . Теперь у вас есть:$\sum_{i=1}^{n} i^2$

${x_1}^2 + {x_2}^2 + {x_3}^2 + {x_4}^2 + {x_5}^2 = \sigma_2$

Видишь, куда я иду с этим? Сделайте то же самое для степеней 3, 4 и 5, и вы получите 5 независимых уравнений с 5 переменными. Я уверен, что вы можете решить для .$\vec{x}$

$\lceil\log(5n^6)\rceil$

Easiest way to solve the problem is to create array in which we will count the apperances for each number in the original array, and then traverse all number from $1$ to $n-5$ and check if the number appears more than once, the complexity for this solution in both memory and time is linear, or $O(N)$

Map an array to 1 << A[i] and then XOR everything together. Your duplicates will be the numbers where corresponding bit is off.

DATA=[1,2,2,2,2,2]

from collections import defaultdict

collated=defaultdict(list):
for item in DATA:
    collated[item].append(item)
    if len(collated) == 5:
        return item.

# n time