Взвешенная сумма последних N чисел

Предположим, мы получаем цифры в потоке. После получения каждого числа необходимо вычислить взвешенную сумму последних $N$ чисел, где веса всегда одинаковы, но произвольны.

Насколько эффективно это можно сделать, если нам разрешено сохранять структуру данных, чтобы помочь с вычислениями? Можем ли мы сделать что-то лучше, чем $\Theta(N)$ , то есть пересчитывать сумму при каждом получении числа?

Например: Предположим , что веса $W= \langle w_1, w_2, w_3, w_4\rangle$ . В какой -то момент мы имеем список последних $N$ чисел $L_1= \langle a, b, c, d \rangle>$ , а взвешенная сумма $S_1=w_1*a+w_2*b+w_3*c+w_4*d$ .

Когда другой номер, $e$ , получена, мы обновить список , чтобы получить $L_2= \langle b,c,d,e\rangle$ и нам нужно вычислить $S_2=w_1*b+w_2*c+w_3*d+w_4*e$ .

Рассмотрение использования БПФ . Особый случай этой проблемы, по-видимому, эффективно решается с помощью быстрого преобразования Фурье. Здесь мы вычислим взвешенные суммы в упаковке . Другими словами, мы получаем чисел, и только тогда мы можем вычислить соответствующие взвешенных сумм. Для этого нам нужно прошлых чисел (для которых суммы уже были вычислены) и новых чисел, всего чисел. $S$ $N$ $N$ $N$ $N-1$ $N$ $2N-1$

Если этот вектор входных чисел и весовой вектор определяют коэффициенты многочленов и с обратными коэффициентами в , мы видим, что произведение является полиномом чьи коэффициенты перед до - это именно те взвешенные суммы, которые мы ищем. Они могут быть вычислены с использованием БПФ в $W$ $P(x)$ $Q(x)$ $Q$ $P(x)\times Q(x)$ $x^{N-1}$ $x^{2N-2}$ времени, что дает нам в среднем раз в номер входа. $\Theta(N*\log (N))$ $Θ(\log (N))$

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

algorithms data-structures online-algorithms

— Амброз Бижак
источник

Обратите внимание, что вы можете использовать LaTeX здесь.

— Рафаэль

Входят ли из какого-то известного распределения? Есть ли у них полезные математические свойства? Если они этого не делают, то маловероятно, что это возможно (если кто-то не может найти аккуратную замкнутую форму, которая является сублинейной вычислимой - я, конечно, не могу ее найти). Кроме того, приближения в порядке? Это может быть одним из способов, если это вообще полезно для вас.

— RDN

КИХ-фильтры делают это, поэтому их дизайн будет актуален.

— adrianN

@ RDN Я поставил этот вопрос как любопытство, я не имею в виду практическое применение.

— Амброз Бизжак

Вот разработка вашего подхода. Каждые итераций мы используем алгоритм FFT для вычисления значений свертки за время , предполагая, что последующие значений равны нулю. Другими словами, мы вычисляем $m$ $m$ $O(n\log n)$ $m$ где - это весов (или обратных весов), - входная последовательность, - текущее время и для .

Σ_{я знак равно 0}^{N - 1} {вес}_{я} a_{T - я + К}, 0 \leq К \leq м - 1,

$\sum_{i=0}^{n-1} w_i a_{t-i+k}, \quad 0 \leq k \leq m-1,$

w_{i}

$w_i$

n

$n$

a_{i}

$a_i$

t

$t$

a_{t^{'}} = 0

$a_{t'} = 0$

t^{'} > t

$t' > t$

Для каждой из следующих итераций мы можем рассчитать требуемую свертку за время (для й итерации требуется время ). Таким образом, амортизированное время составляет . Это минимизируется путем выбора $m$ $O(m)$ $i$ $O(i)$ $O(m) + O(n\log n/m)$ , который дает амортизированное время работы $m = \sqrt{n\log n}$ . $O(\sqrt{n\log n})$

Мы можем улучшить это до наихудшего времени работы , разбив вычисление на части. Зафиксируеми определим $O(\sqrt{n\log n})$ $m$ Каждый зависит только от входов, поэтому его можно вычислить за время . Кроме того, учитывая для

б_{T, п, о} знак равно Σ_{я знак равно 0}^{м - 1} {вес}_{п м + я} a_{T м - я + о}, С_{T, п} знак равно б_{T, п, 0}, ..., б_{T, п, м - 1},

$b_{T,p,o} = \sum_{i=0}^{m-1} w_{pm+i} a_{Tm-i+o}, \quad C_{T,p} = b_{T,p,0}, \ldots, b_{T,p,m-1}.$

C_{T, p}

$C_{T,p}$

2 m

$2m$

O (m \log m)

$O(m\log m)$

C_{⌊ t / m ⌋ - p, p}

$C_{\lfloor t/m \rfloor-p,p}$

, мы можем вычислить свертку за время

. Поэтому план состоит в том, чтобы сохранить список

0 \leq p \leq n / m - 1

$0 \leq p \leq n/m-1$

O (n / m + m)

$O(n/m + m)$

Для каждого периода из

входов нам необходимо обновить

из них. Каждое обновление занимает время

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

С_{⌊ T / м ⌋ - п, п}, 0 \leq п \leq N / м - 1.

$C_{\lfloor t/m \rfloor-p,p}, \quad 0 \leq p \leq n/m-1.$

m

$m$

n / m

$n/m$

O (m \log m)

$O(m\log m)$

O ((n / m^{2}) m \log m) = O ((n / m) \log m)

$O((n/m^2) m\log m) = O((n/m) \log m)$ , Вместе с вычислением самой свертки временная сложность на вход составляет

. Выбор

O ((n / m) \log m + m)

$O((n/m)\log m + m)$

как и раньше, это дает

m = \sqrt{n \log n}

$m = \sqrt{n\log n}$

O (\sqrt{n \log n})

$O(\sqrt{n\log n})$

— Юваль Фильмус
источник

Замечательное решение, спасибо, я не был уверен, можно ли это сделать.

— Амброз Бизжак

И это работает! Реализация на C: ideone.com/opuoMj

— Амброз Бизжак

Мех, мне не хватало того последнего куска кода, который фактически делает его разбивающим вычисления, зафиксированные здесь ideone.com/GRXMAZ .

— Амброз Бизжак

На моей машине этот алгоритм начинает работать быстрее простого алгоритма на 17000 весах. Для небольшого количества весов это медленно. Тест: ideone.com/b7erxu

— Амброз Бижак

m

$m$

m = \sqrt{n \log n}

$m = \sqrt{n\log n}$

m

$m$