एक स्लाइडिंग विंडो माध्यिका की गणना के लिए Nontrivial एल्गोरिथ्म

मुझे चल रहे माध्य की गणना करने की आवश्यकता है:

इनपुट: , , वेक्टर । $n$ $k$ $(x_1, x_2, \dotsc, x_n)$
आउटपुट: वेक्टर , जहां का माध्य है । $(y_1, y_2, \dotsc, y_{n-k+1})$ $y_i$ $(x_i, x_{i+1}, \dotsc, x_{i+k-1})$

(सन्निकटन के साथ कोई धोखा नहीं; मैं सटीक समाधान करना चाहूंगा। तत्व बड़े पूर्णांक हैं।) $x_i$

एक तुच्छ एल्गोरिथ्म है जो आकार का खोज ट्री बनाए रखता है ; कुल चलने का समय । (यहां "खोज ट्री" कुछ कुशल डेटा संरचना को संदर्भित करता है जो लॉगरिंथ समय में सम्मिलन, विलोपन, और मध्ययुगीन प्रश्नों का समर्थन करता है।) $k$ $O(n \log k)$

हालांकि, यह मुझे थोड़ा बेवकूफ लगता है। हम प्रभावी रूप से सीखना होगा सभी आकार के सभी खिड़कियों के भीतर आदेश आँकड़े ही नहीं, माध्यिकाओं। इसके अलावा, यह व्यवहार में बहुत आकर्षक नहीं है, खासकर यदि बड़ा है (बड़े खोज पेड़ धीमी गति से होते हैं, स्मृति खपत में ओवरहेड गैर-तुच्छ है, कैश-दक्षता अक्सर खराब होती है, आदि)। $k$ $k$

क्या हम कुछ बेहतर कर सकते हैं?

क्या कोई निचली सीमा है (उदाहरण के लिए, तुलनात्मक मॉडल के लिए तिर्यक एल्गोरिथ्म asymptotically इष्टतम है)?

संपादित करें: डेविड एप्पस्टीन ने तुलनात्मक मॉडल के लिए एक अच्छा निचला भाग दिया! मुझे आश्चर्य है कि अगर तुच्छ एल्गोरिथ्म की तुलना में कुछ अधिक चतुर करना संभव है?

उदाहरण के लिए, क्या हम इन पंक्तियों के साथ कुछ कर सकते हैं: इनपुट वेक्टर को आकार भागों में विभाजित करें ; प्रत्येक भाग को क्रमबद्ध करें (प्रत्येक तत्व के मूल पदों का ध्यान रखें); और फिर किसी भी सहायक डेटा संरचनाओं के बिना कुशलता से चल रहे मध्यस्थों को खोजने के लिए टुकड़ावार छांटे वेक्टर का उपयोग करें? बेशक यह अभी भी , लेकिन व्यवहार में सरणियों में खोज पेड़ों को बनाए रखने की तुलना में बहुत तेजी से होता है। $k$ $O(n \log k)$

संपादित करें 2: सईद कुछ कारणों को देखना चाहता था कि मुझे क्यों लगता है कि खोज के पेड़ के संचालन की तुलना में छंटनी तेज है। यहाँ बहुत ही तेज़ बेंचमार्क हैं, , : $k = 10^7$ $n = 10^8$

≈ 8s: साथ वैक्टर को $n/k$ $k$ प्रत्येक तत्वों के
। 10 एस: तत्वों के साथ एक सदिश छँटाई $n$
≈ 80: सम्मिलन और आकार का एक हैश तालिका में हटाए गए $n$ $k$
≈ 390s: सम्मिलन और आकार का एक संतुलित खोज पेड़ काट-छांट $n$ $k$

हैश तालिका तुलना के लिए वहाँ है; यह इस आवेदन में कोई सीधा उपयोग नहीं है।

सारांश में, हमारे पास सॉर्टिंग बनाम संतुलित खोज ट्री ऑपरेशन के प्रदर्शन में लगभग 50 का अंतर है। और चीजें बहुत खराब हो जाती हैं अगर हम बढ़ाते हैं । $k$

(तकनीकी विवरण: डेटा = यादृच्छिक 32-बिट पूर्णांक। कंप्यूटर = एक सामान्य आधुनिक लैपटॉप। मानक पुस्तकालय दिनचर्या (std :: सॉर्ट) और डेटा संरचनाओं (std :: multiset, std ::) का उपयोग करके परीक्षण कोड C ++ में लिखा गया था। unsorted_multiset)। मैंने दो अलग-अलग C ++ कंपाइलर (GCC और Clang) का उपयोग किया, और मानक पुस्तकालय के दो अलग-अलग कार्यान्वयन (libstdc ++ और libc ++)। परंपरागत रूप से, std :: multiset को अत्यधिक अनुकूलित लाल-काले वृक्ष के रूप में लागू किया गया है।)

ds.algorithms ds.data-structures lower-bounds

— जुक्का सूमेला
स्रोत

मुझे नहीं लगता कि आप

सुधार कर पाएंगे । कारण, अगर आप एक खिड़की को देखो

, आप कभी भी संख्याओं

से कोई भी नियम नहीं बना सकते

n l o g k

$nlogk$

x_{t}, . . ., x_{t + k - 1}

$x_t,...,x_{t+k-1}$

भविष्य की खिड़की के मध्यस्थ होने से। इसका मतलब है कि किसी भी समय आपको कम से कम

रखना होगा

x_{t + \frac{k}{2}}, . . ., x_{t + k - 1}

$x_{t+\frac{k}{2}},...,x_{t+k-1}$

डेटा संरचना में

पूर्णांक, और यह लॉग टाइम से कम समय में अपडेट नहीं होता है।

\frac{k}{2}

$\frac{k}{2}$

— आरबी

मेरे लिए आपका तुच्छ एल्गोरिथ्म

नहीं

प्रतीत होता है , क्या मैं कुछ गलत समझ रहा हूं? और मुझे लगता है कि इस वजह से आपको बड़ी

साथ समस्या है , अन्यथा लॉगरिदमिक कारक व्यावहारिक अनुप्रयोगों में कुछ भी नहीं है, इस एल्गोरिथ्म में कोई बड़ा छिपी स्थिरांक भी नहीं है।

O ((n - k) \cdot k \cdot \log k)

$O((n-k)\cdot k \cdot \log k)$

O (n \log k)

$O(n \log k)$

k

$k$

— सईद

@ सईद: तुच्छ एल्गोरिथ्म में, आप तत्वों को एक-एक करके संसाधित करते हैं; कदम में

आप जोड़ना

खोज पेड़ से और (अगर

) आप भी हटाने

खोज पेड़ से। यह

चरण है, जिनमें से प्रत्येक

समय लेता है ।

i

$i$

x_{i}

$x_i$

i > k

$i > k$

x_{i - k}

$x_{i-k}$

n

$n$

O (\log k)

$O(\log k)$

— जुल्का सुमेला

तो आपका मतलब है कि आपके पास एक संतुलित खोज वृक्ष है जो आकस्मिक खोज वृक्ष नहीं है?

— सईद

@ सईद: कृपया ध्यान दें कि मेरे बेंचमार्क में मैंने मंझले लोगों को खोजने की कोशिश भी नहीं की। मैंने अभी आकार

खोज ट्री में

सम्मिलन और

विलोपन किया है , और इन कार्यों को

समय लेने की गारंटी है । आपको बस यह स्वीकार करने की आवश्यकता है कि खोज ट्री ऑपरेशन छँटाई की तुलना में अभ्यास में बहुत धीमी है। आप इसे आसानी से देखेंगे यदि आप एक सॉर्टिंग एल्गोरिदम लिखने की कोशिश करते हैं जो एक संतुलित खोज ट्री में तत्वों को जोड़कर काम करता है - यह निश्चित रूप से

समय में काम करता है , लेकिन यह अभ्यास में हास्यास्पद रूप से धीमा होगा, और बहुत अधिक बर्बाद करेगा स्मृति का।

n

$n$

n

$n$

k

$k$

O (\log k)

$O(\log k)$

O (n \log n)

$O(n \log n)$

— जुक्का सुओमेला

जवाबों:

यहाँ छँटाई से एक कम बाउंड है। किसी इनपुट सेट की लंबाई के अनुसार को सॉर्ट किया जाना है, अपनी रनिंग माध्यिका समस्या के लिए एक इनपुट बनाएं जिसमें की संख्या की न्यूनतम से छोटी संख्या की , फिर , फिर तुलना में बड़ी संख्या की प्रतियां की अधिकतम , और सेट । इस इनपुट के रनिंग माध्य के क्रमबद्ध क्रम के समान हैं । $S$ $n$ $n-1$ $S$ $S$ $n-1$ $S$ $k=2n-1$ $S$

इसलिए गणना के एक तुलना मॉडल में, समय की आवश्यकता होती है। संभवतः यदि आपके इनपुट पूर्णांक हैं और आप पूर्णांक एल्गोरिदम का उपयोग करते हैं तो आप बेहतर कर सकते हैं। $\Omega(n\log n)$

— डेविड एप्पस्टीन
स्रोत

यह उत्तर वास्तव में मुझे आश्चर्यचकित करता है कि क्या काफिला भी सुरक्षित है: एक कुशल छँटाई एल्गोरिथ्म दिया, क्या हमें एक कुशल चल मंझला एल्गोरिथ्म मिलता है? (उदाहरण के लिए, क्या कुशल पूर्णांक छँटाई एल्गोरिथ्म का अर्थ है पूर्णांक के लिए एक कुशल चल मंझला एल्गोरिथ्म? या एक IO- कुशल छँटाई एल्गोरिथ्म एक IO- कुशल चल मंझला एल्गोरिथ्म प्रदान करता है?)

— Jukka Suomela

एक बार फिर, आपके उत्तर के लिए बहुत धन्यवाद, इसने वास्तव में मुझे सही रास्ते पर सेट किया और सॉर्टिंग-आधारित माध्य फ़िल्टर एल्गोरिथ्म के लिए प्रेरणा दी! अंत में मैं 1991 से एक पेपर खोजने में सक्षम था जो मूल रूप से वही तर्क प्रस्तुत करता था जो आप यहां देते हैं, और पैट मॉरिन ने 2005 से एक और प्रासंगिक पेपर को एक संकेतक दिया; रेफरी देखें। [६] और [९] यहां ।

— जुका सुओमेला

संपादित करें: यह एल्गोरिथ्म अब यहां प्रस्तुत किया गया है: http://arxiv.org/abs/1406.1717

हां, इस समस्या को हल करने के लिए यह निम्नलिखित ऑपरेशन करने के लिए पर्याप्त है:

क्रमबद्ध वैक्टर, के साथ प्रत्येक तत्वों। $n/k$ $k$
लीनियर-टाइम पोस्ट-प्रोसेसिंग करें।

बहुत मोटे तौर पर, यह विचार है:

इनपुट के दो आसन्न ब्लॉकों पर विचार करें, और , दोनों के साथ तत्वों; तत्वों रहने दो और इनपुट वेक्टर में उपस्थिति के क्रम में । $a$ $b$ $k$ $a_1, a_2, ..., a_k$ $b_1, b_2, ..., b_k$ $x$
इन ब्लॉकों को क्रमबद्ध करें और ब्लॉक के भीतर प्रत्येक तत्व की रैंक जानें।
वैक्टर में वृद्धि और पूर्ववर्ती / उत्तराधिकारी संकेत के साथ ताकि सूचक चेन का पालन करते हुए हम एक बढ़ते क्रम में तत्वों पार कर सकते हैं। इस तरह से हम का निर्माण किया है दोगुना सूचियों जुड़ा हुआ और । $a$ $b$ $a'$ $b'$
एक-एक करके लिंक्ड सूची से सभी तत्वों को हटाने के लिए, उपस्थिति के विपरीत क्रम में, । जब भी हम किसी तत्व को हटाते हैं, तो याद रखें कि विलोपन के समय उसका उत्तराधिकारी और पूर्ववर्ती क्या था । $b'$ $b_k, b_{k-1}, ..., b_1$
अब बनाए रखने के "मंझला संकेत" और कि सूची में बिंदु और , क्रमशः। आरंभ के मध्य करने के लिए , और आरंभ खाली सूची की पूंछ को । $p$ $q$ $a'$ $b'$ $p$ $a'$ $q$ $b'$
प्रत्येक के लिए : $i$
- हटाएँ सूची में से (यह समय, लिंक किए गए सूची से हटाना)। की तुलना तत्व के साथ द्वारा बताया देखने के लिए अगर हम पहले या बाद में नष्ट कर दिया $a_i$ $a'$ $O(1)$ $a_i$ $p$ $p$ ।
- रखो वापस सूची में अपनी मूल स्थिति में (यह बार, हम पूर्ववर्ती और उत्तराधिकारी की याद )। तुलना तत्व द्वारा बताया साथ अगर हम पहले या बाद में तत्व जोड़े को देखने के लिए $b_i$ $b'$ $O(1)$ $b_i$ $b_i$ $q$ $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).

यहाँ एक नमूना कार्यान्वयन और बेंचमार्क है:

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

यहाँ (के लिए बार चलाने का एक साजिश है ): $n \approx 2\cdot 10^6$

ब्लू = सॉर्टिंग + पोस्ट-प्रोसेसिंग, । $O(n \log k)$
ग्रीन = दो ढेर बनाए रखें, , https://github.com/craffel/median-filter से कार्यान्वयन $O(n \log k)$
लाल = दो खोज पेड़ बनाए रखें, । $O(n \log k)$
काला = एक क्रमबद्ध वेक्टर, बनाए रखें । $O(n k)$
एक्स अक्ष = विंडो का आकार ( $\approx k/2$ ).
Y axis = running time in seconds.
Data = 32-bit integers and random 64-bit integers, from various distributions.

running times

— Jukka Suomela
स्रोत

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.

— Geoffrey Irving
स्रोत

Oops, this doesn't work as written, since if you don't delete elements the counts won't reflect the new window. I'm not sure if it can be fixed, but I will leave the answer in case there is a way.

— Geoffrey Irving

So I think this algorithm may in fact take

O (n \log m)

$O(n \log m)$ if you delete nodes from the Fibonacci heaps, since the Fibonacci heap depth increases only when delete-min is called. Does anyone know nice bounds on Fibonacci heap complexity taking the number of delete-min calls into account?

— Geoffrey Irving

side note: Question is not clear, underling data structure is not defined, we just know something very vague. how do you want improve something that you don't know what it is? how do you want compare your approach?

— Saeed

I apologize for the incomplete work. I've asked the concrete question needed to fix this answer here: cstheory.stackexchange.com/questions/21778/…. If you think it's appropriate I can remove this answer until the secondary question is resolved.

— Geoffrey Irving