Menemukan elemen terkecil dari urutan tertentu hanya dengan O (k) memori O (n) waktu

Misalkan kita membaca urutan $n$ angka, satu per satu. Cara menemukan elemen terkecil $k$ hanya dengan menggunakan memori sel $O(k)$ dan dalam waktu linier ( $O(n)$ ). Saya pikir kita harus menabung dulu $k$ hal urutan dan ketika mendapatkan $k+1$ 'jangka th, menghapus istilah yang kita yakin bahwa itu tidak bisa menjadi $k$ ' th elemen terkecil dan kemudian save $k+1$ 'jangka th. Jadi kita harus memiliki indikator yang menunjukkan istilah tidak dapat digunakan ini di setiap langkah dan indikator ini harus diperbarui di setiap langkah dengan cepat. Saya mulai dengan "maks"; tetapi tidak dapat memperbarui dengan cepat; Berarti jika kita mempertimbangkan maks maka dalam penghapusan pertama kita kehilangan maks dan kita harus mencari maks dalam $O(k)$ dan penyebabnya $(n-k)\times O(k)$ waktu itu tidak linier. Mungkin kita harus menyimpan terlebih dahulu syarat $k$ urutan lebih cerdas.

Bagaimana saya mengatasi masalah ini?

data-structures search-algorithms quicksort

— Shahab_HK
sumber

Apakah Anda tertarik pada algoritma online, atau apakah algoritma apa pun akan melakukannya?

— Yuval Filmus

Jika

maka Anda dapat melakukannya dengan menggunakan algoritma statistik pesanan. Jika

maka Anda dapat melakukannya

memori dan

waktu menggunakan pohon seimbang tinggi.

k = θ (n)

$k = \theta(n)$

k = o (n)

$k = o(n)$

O (k)

$O(k)$

O (n \log k)

$O(n\log k)$

— Shreesh

Ini disebut masalah pemilihan en.wikipedia.org/wiki/Selection_algorithm

— xavierm02

Ada algoritma waktu linear di tempat, yang bisa Anda gunakan untuk google, tetapi agak rumit.

— Yuval Filmus

@ xavierm02 ini bukan masalah pemilihan yang identik. Karena ada batasan batas memori.

— Shahab_HK

Jawaban:

Buat buffer ukuran . Baca dalam elemen dari array. Gunakan algoritma pemilihan waktu linier untuk mempartisi buffer sehingga elemen terkecil adalah yang pertama; ini membutuhkan waktu . Sekarang baca item lain dari array Anda ke buffer, ganti item terbesar di buffer, partisi buffer seperti sebelumnya, dan ulangi. $2k$ $2k$ $k$ $O(k)$ $k$ $k$

Ini membutuhkan waktu dan ruang. $O(k * n/k) = O(n)$ $O(k)$

— jbapple
sumber

+1, ini cocok dengan asimptotik yang diminta. Yang sedang berkata, saya tidak percaya ini lebih cepat daripada melakukan algoritma seleksi linear-waktu tunggal ... kecuali ketika

adalah konstanta kecil, maka itu memberikan perspektif yang menarik. Misalnya untuk

algoritma ini menghasilkan fungsi.

k

$k$

k = 1

$k = 1$ min

— orlp

Kadang-kadang, algoritma seleksi linear-waktu menggunakan terlalu banyak ruang. Misalnya, ini tidak cocok untuk digunakan dalam konteks streaming atau ketika larik input tidak dapat diubah.

— jbapple

Itu adalah poin yang valid.

— orlp

Anda dapat melakukannya dalam memori dan waktu dengan membentuk he-max max heap dari elemen pertama dalam waktu , kemudian mengulangi sisa array dan mendorong yang baru elemen dan kemudian muncul untuk untuk setiap elemen yang memberikan total waktu = . $O(k)$ $O(n \log k)$ $k$ $O(k)$ $O(\log k)$ $O(k + n\log k)$ $O(n \log k)$

Anda dapat melakukannya dalam memori tambahan dan waktu dengan menggunakan algoritma pemilihan median-of-median, memilih pada , dan mengembalikan elemen pertama . Tanpa perubahan asimtotik, Anda dapat menggunakan introselect untuk mempercepat kasing rata-rata. Ini adalah cara kanonik untuk menyelesaikan masalah Anda. $O(\log n)$ $O(n)$ $k$ $k$

Sekarang secara teknis dan tidak ada bandingannya. Namun saya berpendapat bahwa lebih baik dalam praktiknya, karena secara efektif konstan mengingat tidak ada sistem komputer yang memiliki lebih dari byte memori, . Sementara itu dapat tumbuh hingga sebesar . $O(\log n)$ $O(k)$ $O(\log n)$ $2^{64}$ $\log 2^{64}= 64$ $k$ $n$

— orlp
sumber

O (n \times \log min (k, n - k))

$O(n \times \log\min (k, n - k))$

O (m i n (k, n - k))

$O(min(k, n-k))$

O (k)

$O(k)$

k

$k$

n

$n$

m i n (k, n - k)

$min(k, n-k)$

\frac{n}{2}

$n \over 2$

O (m i n (k, n - k))

$O(min(k, n-k))$

O (k)

$O(k)$

@ xavierm02 Yang dikatakan, itu masih speedup bagus :)

— orlp

u_{n, k} = k

$u_{n,k}=k$

O (k)

$O(k)$

O (min (k, n - k))

$O(\min (k, n-k))$

C

$C$

M

$M$

M \leq k \leq n

$M\le k\le n$

k \leq C (n - k)

$k\le C (n-k)$

n = k \to + \infty) .

$n=k \to +\infty).$

O (min (k, n - k)) ⊊ O (k)

$O(\min(k, n-k))\subsetneq O(k)$

@ xavierm02 Saya tidak terbiasa dengan . Agar adil, aku secara umum cukup terbiasa dengan multidimensi besar- notasi, terutama mengingat bahwa dimensi tidak berhubungan.

u_{n, k}

$u_{n, k}$

O

$O$

n, k

$n, k$

— orlp