अंतिम 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$

यदि इनपुट नंबरों का यह वेक्टर और वेट वेक्टर बहुपद के गुणांक और को परिभाषित करता है, तो में गुणांक के साथ उलट होता है, तो हम देखते हैं कि उत्पाद है बहुपद जिसका गुणांक से सामने होता है, ठीक उसी तरह से भारित रकम जो हम चाहते हैं। इनकी गणना FFT का उपयोग करके समय के साथ की जा सकती है, जो हमें औसत प्रति इनपुट नंबर के लिए समय देती है। $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 मैंने इस प्रश्न को एक जिज्ञासा के रूप में प्रस्तुत किया, मेरे पास व्यावहारिक अनुप्रयोग नहीं है।

— अम्ब्रोज़ बिज्जक

यहाँ आपके दृष्टिकोण का विस्तार है। हर पुनरावृत्तियों, हम गणना करने के लिए FFT एल्गोरिथ्म का उपयोग समय में घुमाव के मूल्यों , यह सोचते हैं कि बाद में मान शून्य है। दूसरे शब्दों में, हम कर रहे हैं जहां वजन हैं (या रिवर्स वेट), इनपुट अनुक्रम है, वर्तमान समय है, और लिए । $m$ $m$ $O(n\log n)$ $m$

\sum_{i = 0}^{n - 1} w_{i} a_{t - i + क}, 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$

ख_{टी, पी, ओ} = Σ_{मैं = 0}^{म - 1} w_{पी म + मैं} ए_{टी म - मैं + ओ}, {सी}_{टी, पी} = ख_{टी, पी, 0}, ..., ख_{टी, पी, म - 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)$

{सी}_{⌊ टी / म ⌋ - पी, पी}, 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})$

— युवल फिल्मस
स्रोत

अद्भुत समाधान, धन्यवाद, मुझे यकीन नहीं था कि अगर यह किया जा सकता है।

— अम्ब्रोज़ बिज्जक

और यह काम करता है! सी कार्यान्वयन: ideone.com/opuoMj

— अम्ब्रोज़ बिज्जक

मेह, मुझे याद आ रहा था कि अंतिम बिट कोड जो वास्तव में गणना को तोड़ता है , यहां ideone.com/GRXMAZ तय किया गया है ।

— अम्ब्रोज़ बिज्जक

मेरी मशीन पर यह एल्गोरिथ्म लगभग 17000 वज़न पर सरल एल्गोरिथ्म से तेज़ होना शुरू होता है। वजन की छोटी संख्या के लिए यह धीमा है। बेंचमार्क: ideone.com/b7erxu

— अंबोज़ बिज्जक

बहुत प्रभावशाली है कि आपने वास्तव में इसे लागू किया है! आप शायद पर ऑप्टिमाइज़ करना चाहते हैं । चुनाव सिर्फ एक मोटा गाइड है, और यह इष्टतम नहीं हो सकता है। क्या आपने विभिन्न मूल्यों के साथ एल्गोरिथ्म चलाने की कोशिश की ?

m

$m$

m = \sqrt{n \log n}

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

m

$m$

— युवल फिल्मस २२'१३