Thuật toán không cần thiết để tính toán trung bình cửa sổ trượt

Tôi cần tính toán trung bình đang chạy:

• Đầu vào: , k , vectơ ( x 1 , x 2 , Mạnh , x n ) .$n$$k$$(x_1, x_2, \dotsc, x_n)$

• Output: vector , nơi y i là trung bình ( 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})$

(Không gian lận với xấp xỉ; tôi muốn có các giải pháp chính xác. Các yếu tố là các số nguyên lớn.)$x_i$

Có một thuật toán tầm thường duy trì một cây tìm kiếm có kích thước ; tổng thời gian chạy là O ( n log k ) . (Ở đây, "cây tìm kiếm" đề cập đến một số cấu trúc dữ liệu hiệu quả hỗ trợ chèn, xóa và truy vấn trung bình trong thời gian logarit.)$k$$O(n \log k)$

Tuy nhiên, điều này có vẻ hơi ngu ngốc đối với tôi. Chúng tôi sẽ tìm hiểu một cách hiệu quả tất cả các số liệu thống kê đơn hàng trong tất cả các cửa sổ có kích thước , không chỉ trung bình. Hơn nữa, điều này không quá hấp dẫn trong thực tế, đặc biệt nếu k lớn (cây tìm kiếm lớn có xu hướng chậm, chi phí sử dụng bộ nhớ không tầm thường, hiệu quả bộ nhớ cache thường kém, v.v.).$k$$k$

Chúng ta có thể làm bất cứ điều gì tốt hơn đáng kể?

Có bất kỳ giới hạn thấp hơn (ví dụ, thuật toán tầm thường là tối ưu không có triệu chứng cho mô hình so sánh)?

Chỉnh sửa: David Eppstein đã đưa ra một giới hạn dưới tốt đẹp cho mô hình so sánh! Tôi tự hỏi liệu tuy nhiên có thể làm một cái gì đó thông minh hơn một chút so với thuật toán tầm thường không?

Ví dụ, chúng ta có thể làm gì đó dọc theo các dòng này không: chia vectơ đầu vào cho các phần có kích thước ; sắp xếp từng phần (theo dõi các vị trí ban đầu của từng yếu tố); và sau đó sử dụng vectơ được sắp xếp piecewise để tìm các trung vị đang chạy một cách hiệu quả mà không có bất kỳ cấu trúc dữ liệu phụ trợ nào? Tất nhiên đây vẫn là O ( n log k ) , nhưng trong thực tế, việc sắp xếp các mảng có xu hướng nhanh hơn nhiều so với việc duy trì các cây tìm kiếm.$k$$O(n \log k)$

Chỉnh sửa 2: Saeed muốn xem một số lý do tại sao tôi nghĩ sắp xếp nhanh hơn hoạt động của cây tìm kiếm. Dưới đây là các điểm chuẩn rất nhanh, cho , n = 10 8 :$k = 10^7$$n = 10^8$

• 8s: sắp xếp các vectơ với k phần tử mỗi phần tử$n/k$$k$
• 10s: sắp xếp một vectơ với phần tử$n$
• 80s: chèn và xóa trong bảng băm có kích thước $n$$k$
• ≈ 390s: chèn và xóa trong cây tìm kiếm cân bằng có kích thước $n$$k$

Bảng băm là có để so sánh; nó không được sử dụng trực tiếp trong ứng dụng này.

Tóm lại, chúng tôi có sự khác biệt gần như 50 nhân tố trong hiệu suất sắp xếp so với các hoạt động của cây tìm kiếm cân bằng. Và mọi thứ trở nên tồi tệ hơn nếu chúng ta tăng .$k$

(Chi tiết kỹ thuật: Dữ liệu = số nguyên 32 bit ngẫu nhiên. Máy tính = máy tính xách tay hiện đại điển hình. Mã kiểm tra được viết bằng C ++, sử dụng các thường trình thư viện tiêu chuẩn (std :: sort) và cấu trúc dữ liệu (std :: multiset, std :: unsort_multiset). Tôi đã sử dụng hai trình biên dịch C ++ khác nhau (GCC và Clang) và hai triển khai khác nhau của thư viện chuẩn (libstdc ++ và libc ++). Theo truyền thống, std :: multiset đã được triển khai như một cây đen tối ưu hóa cao.)

Đây là một giới hạn thấp hơn từ sắp xếp. Cho một tập hợp đầu vào có độ dài n được sắp xếp, tạo một đầu vào cho bài toán trung bình đang chạy của bạn bao gồm n - 1 bản sao của một số nhỏ hơn tối thiểu của S , sau đó chính S , sau đó n - 1 bản sao của một số lớn hơn tối đa của S và đặt k = 2 n - 1 . Các trung vị chạy đầu vào này cũng giống như trình tự sắp xếp của S .$S$$n$$n-1$$S$$S$$n-1$$S$$k=2n-1$$S$

Vì vậy, trong một mô hình so sánh của tính toán, thời gian là bắt buộc. Có thể nếu đầu vào của bạn là số nguyên và bạn sử dụng thuật toán sắp xếp số nguyên, bạn có thể làm tốt hơn.$\Omega(n\log n)$

Chỉnh sửa: Thuật toán này hiện được trình bày tại đây: http://arxiv.org/abs/1406.1717

Có, để giải quyết vấn đề này, việc thực hiện các thao tác sau là đủ:

• Sắp xếp các vectơ , mỗi vectơ k .$n/k$$k$
• Làm hậu xử lý tuyến tính thời gian.

Rất đại khái, ý tưởng là thế này:

• Xét hai khối đầu vào liền kề, và b , cả hai đều có phần tử k ; để cho các yếu tố có một 1 , một 2 , . . . , a k và b 1 , b 2 , . . . , b k theo thứ tự xuất hiện trong vectơ đầu vào x .$a$$b$$k$$a_1, a_2, ..., a_k$$b_1, b_2, ..., b_k$$x$
• Sắp xếp các khối này và tìm hiểu thứ hạng của từng yếu tố trong khối.
• Tăng cường các vectơ và b bằng các con trỏ của người tiền nhiệm / người kế nhiệm để bằng cách theo các chuỗi con trỏ, chúng ta có thể duyệt qua các phần tử theo thứ tự tăng dần. Bằng cách này, chúng tôi đã xây dựng gấp đôi danh sách liên kết một ' và b ' .$a$$b$$a'$$b'$
• Từng người một, xóa tất cả các yếu tố từ danh sách liên kết , theo thứ tự ngược lại với sự xuất hiện b k , b k - 1 , . . . , b 1 . Bất cứ khi nào chúng tôi xóa một yếu tố, hãy nhớ những gì là người kế thừa và tiền thân của nó tại thời điểm xóa .$b'$$b_k, b_{k-1}, ..., b_1$
• Bây giờ duy trì "con trỏ trung bình" và q điểm đó vào danh sách một ' và b ' , tương ứng. Khởi p đến điểm giữa của một ' , và khởi q để đuôi của danh sách trống b ' .$p$$q$$a'$$b'$$p$$a'$$q$$b'$

• Đối với mỗi :$i$

  • Xóa ra khỏi danh sách một ' (đây là O ( 1 ) thời gian, chỉ cần xóa khỏi danh sách liên kết). So sánh một i với phần tử được chỉ bởi p để xem chúng ta đã xóa trước hay sau p .$a_i$$a'$$O(1)$$a_i$$p$$p$
  • Đặt trở lại danh sách b ′ ở vị trí ban đầu (đây là thời gian O ( 1 ) , chúng tôi ghi nhớ người tiền nhiệm và người kế thừa của b i ). So sánh b i với phần tử được chỉ bởi q để xem chúng ta đã thêm phần tử trước hay sau q .$b_i$$b'$$O(1)$$b_i$$b_i$$q$$q$
  • $p$$q$$a' \cup b'$$p$$q$$O(1)$$p$$q$$p$$q$

$k$

Dưới đây là một triển khai mẫu và điểm chuẩn:

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

$n \approx 2\cdot 10^6$

• $O(n \log k)$
• $O(n \log k)$
• $O(n \log k)$
• $O(n k)$
• $\approx k/2$
• Trục Y = thời gian chạy tính bằng giây.
• Dữ liệu = số nguyên 32 bit và số nguyên 64 bit ngẫu nhiên, từ các bản phân phối khác nhau.

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

$O(\log m)$$O(\log n)$$O(\log n)$ phí chỉ xảy ra một lần trên trung bình.

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