Sürgülü pencere medyanını hesaplamak için önemsiz algoritma

Çalışan medyanı hesaplamam gerekiyor:

• Giriş: , k , vektör ( x 1 , x 2 , … , x n ) .$n$$k$$(x_1, x_2, \dotsc, x_n)$

• Çıkış: vektörü , y i ortancasıdır ( x i , x i + 1 , ... , x i + k - 1 ) .$(y_1, y_2, \dotsc, y_{n-k+1})$$y_i$$(x_i, x_{i+1}, \dotsc, x_{i+k-1})$

(Yaklaşımlarla aldatma yok; Kesin çözümlere sahip olmak istiyorum. Elements büyük tamsayılar.)$x_i$

boyutunda bir arama ağacını koruyan önemsiz bir algoritma vardır ; toplam çalışma süresi O ( n log k ) ' dır . (Burada bir "arama ağacı", logaritmik zamandaki ekleme, silme ve ortanca sorguları destekleyen bazı verimli veri yapılarını ifade eder.)$k$$O(n \log k)$

Ancak, bu bana biraz aptal görünüyor. Sadece medyanayı değil, k boyutundaki tüm pencerelerde tüm sipariş istatistiklerini etkili bir şekilde öğreneceğiz . Ayrıca, bu pratikte çok çekici değildir, özellikle k$k$$k$ büyükse (büyük arama ağaçları yavaş olma eğilimindedir, bellek tüketiminde ek yük önemsiz değildir, önbellek verimliliği genellikle düşüktür, vb.).

Daha iyi bir şey yapabilir miyiz?

Daha düşük sınırlar var mı (örneğin karşılaştırma modeli için önemsiz algoritma asimptotik olarak optimal mi?)?

Düzenleme: David Eppstein karşılaştırma modeli için güzel bir alt sınır verdi! Yine de önemsiz algoritmadan biraz daha akıllıca bir şey yapmanın mümkün olup olmadığını merak ediyorum?

Örneğin, bu satırlar boyunca bir şeyler yapabilir miyiz: giriş vektörünü boyutunda parçalara böler ; her bir parçayı sıralayın (her bir elemanın orijinal konumlarını takip ederek); ve daha sonra, yardımcı veri yapıları olmadan verimli çalışan ortancaları bulmak için parçalara ayrılmış vektörleri kullanın. Tabii ki bu hala O ( n log k ) olacaktır , ancak pratikte dizilerin sıralanması arama ağaçlarının korunmasından çok daha hızlı olma eğilimindedir.$k$$O(n \log k)$

Düzenleme 2: Saeed, sıralama işleminin arama ağacı işlemlerinden daha hızlı olduğunu düşündüğüm nedenleri görmek istedi. İşte , n = 10 8 için çok hızlı karşılaştırmalar :$k = 10^7$$n = 10^8$

• ≈ 8s: sıralama vektörleri ile k elemanları, her$n/k$$k$
• ≈ 10s: elemanlı bir vektörü sıralama$n$
• ≈ 80'ler: boyutu bir karma tablo ekleme & silme $n$$k$
• ≈ 390s: , k boyutunda dengeli bir arama ağacına yapılan yerleştirmeler ve silmeler$n$$k$

Karma tablo sadece karşılaştırma için var; Bu uygulamada doğrudan kullanım yok.

Özetle, sıralama ve dengeli arama ağacı işlemlerinin performansında neredeyse 50 faktör farkımız var. Ve arttıkça işler daha da kötüleşiyor .$k$

(Teknik detaylar: Veriler = rastgele 32 bit tam sayılar. Bilgisayar = tipik bir modern dizüstü bilgisayar. Test kodu standart kütüphane yordamları (std :: sort) ve veri yapıları (std :: multiset, std ::) kullanılarak C ++ dilinde yazılmıştır. sıralanmamış_multiset) İki farklı C ++ derleyicisi (GCC ve Clang) ve standart kitaplığın iki farklı uygulamasını kullandım (libstdc ++ ve libc ++).

İşte sıralamadan daha düşük bir sınır. Bir giriş seti Verilen uzunluğunun n sıralanmasını, senin medyan problemi oluşan çalışan bir girdiyi oluşturmak n - 1 minimum daha küçük bir sayı kopyalarını S ardından, S kendisi daha sonra n - 1 den çok sayıda kopya daha büyük S maksimum , ve k = 2 n - 1 olarak ayarlayın . Bu girişin çalışan medyanları S'nin sıralanmış sırasına aynıdır.$S$$n$$n-1$$S$$S$$n-1$$S$$k=2n-1$$S$ .

Bu yüzden bir karşılaştırma modelinde zamanı gereklidir. Muhtemelen girişleriniz tamsayılarsa ve tamsayı sıralama algoritmaları kullanıyorsanız, daha iyisini yapabilirsiniz.$\Omega(n\log n)$

Düzenleme: Bu algoritma şimdi burada sunulmuştur: http://arxiv.org/abs/1406.1717

Evet, bu sorunu çözmek için aşağıdaki işlemleri yapmanız yeterlidir:

• Sıralama vektörler, her biri$n/k$ elementleri.$k$
• Doğrusal zaman sonrası işleme yapın.

Çok kabaca, fikir şudur:

• Her ikisi de k elementli iki bitişik giriş bloğu, ve b'yi göz önüne alın ; elemanlar olsun bir 1 , bir 2 , . . . , Bir k ve b 1 , b , 2 , . . . , B k girdi vektörü içerisinde geçiş sırasına göre $a$$b$$k$$a_1, a_2, ..., a_k$$b_1, b_2, ..., b_k$$x$ .
• Bu blokları sıralayın ve blok içindeki her bir elemanın sırasını öğrenin.
• ve b vektörlerini selefi / ardışık işaretçilerle arttırın, böylece imleç zincirlerini takip ederek elemanları artan bir sırayla geçebiliriz. Kadar inşa ettiğimiz bu şekilde iki kat listeler bağlantılı bir ' ve b ' .$a$$b$$a'$$b'$
• Tek tek, bağlantılı liste tüm unsurları silmek görünümü ters sırasında, b k , b , k - 1 , . . . , b 1 . Ne zaman bir öğeyi silersek, silme sırasındaki halefi ve öncülü ne olduğunu hatırla .$b'$$b_k, b_{k-1}, ..., b_1$
• Şimdi korumak "medyan işaretçileri" ve q o listelere nokta bir ' ve b ' , sırasıyla. Initialise s orta noktasına bir " ve başlatma işlemini q boş liste kuyruğuna b ' .$p$$q$$a'$$b'$$p$$a'$$q$$b'$

• Her biri için :$i$

  • Sil listesinden a ' (bu Ç ( 1 ) sefer, sadece bağlantılı listeden silin). Bir i'yi , p'den önce mi yoksa sonra mı sildiğimizi görmek için p ile gösterilen elemanla karşılaştırın .$a_i$$a'$$O(1)$$a_i$$p$$p$
  • Put $b_i$ back to list $b'$ in its original position (this is $O(1)$ time, we memorised the predecessor and successor of $b_i$). Compare $b_i$ with the element pointed by $q$ to see if we added the element before or after $q$.
  • Update pointers $p$ and $q$ so that the median of the joined list $a' \cup b'$ is either at $p$ or at $q$. (This is $O(1)$ time, just follow the linked lists one or two steps to fix everything. We will keep track of how many items are before/after $p$ and $q$ in each list, and we will maintain the invariant that both $p$ and $q$ point to elements that are as close to the median as possible.)

The linked lists are just $k$-element arrays of indexes, so they are lightweight (except that the locality of memory access is poor).

Here is a sample implementation and benchmarks:

• https://github.com/suomela/median-filter

Here is a plot of running times (for $n \approx 2\cdot 10^6$):

• Blue = sorting + post-processing, $O(n \log k)$.
• Green = maintain two heaps, $O(n \log k)$, implementation from https://github.com/craffel/median-filter
• Red = maintain two search trees, $O(n \log k)$.
• Black = maintain a sorted vector, $O(n k)$.
• X axis = window size ($\approx k/2$).
• Y axis = running time in seconds.
• Data = 32-bit integers and random 64-bit integers, from various distributions.

Given David's bound it's unlikely you can do better worst case, but there are better output sensitive algorithms. Specifically, if $m$ in the number of medians in the result, we can solve the problem in time $O(n \log m + m \log n)$.

To do this, replace the balanced binary tree with a balanced binary tree consisting of only those elements that were medians in the past, plus two Fibonacci heaps in between each pair of previous medians (one for each direction), plus counts so that we can locate which Fibonacci heap contains a particular element in the order. Don't bother ever deleting elements. When we insert a new element, we can update our data structure in $O(\log m)$ time. If the new counts indicate that the median is in one of the Fibonacci heaps, it takes an additional $O(\log n)$ to pull the new median out. This $O(\log n)$ charge occurs only once per median.

If there was a clean way to delete elements without damaging the nice Fibonacci heap complexity, we'd get down to $O(n \log m + m \log k)$, but I'm not sure if this is possible.