Kompleksitas bit O (1) kueri rentang waktu dalam a

Pertimbangkan masalah berikut:

Membiarkan $k$ menjadi konstan. Kita diberi a $k$ array -ary $A_{d_1\times\ldots\times d_k}$ dari $0$ dan $1$ ini Membiarkan $N = \prod_{i=1}^k d_i$ .

Kami ingin membuat struktur data dengan preprocessing $A$ untuk melakukan jenis operasi permintaan berikut:

Diberikan koordinat a $k$ kotak -ary $D$ , Apakah ada $1$ dalam kotak?
Diberikan koordinat a $k$ kotak -ary $D$ , kembalikan posisi a $1$ di dalam kotak (jika ada).

Operasi harus dilakukan dalam waktu yang konstan $O(1)$ . Kompleksitas waktu diukur pada mesin RAM. Waktu dan ruang preprocessing untuk struktur data tidak penting bagi kami.

Pertanyaannya adalah berapa banyak ruang (dalam kompleksitas bit) yang kita perlukan untuk menyimpan struktur data yang memungkinkan operasi di atas?

Batas bawah sepele adalah $N$ bit karena array dapat direkonstruksi untuk permintaan ini (jadi struktur data harus memiliki setidaknya jumlah informasi yang sama di dalamnya).

Batas atas sepele adalah untuk menyimpan jawaban untuk semua pertanyaan. Itu akan membutuhkan bit. Namun kami menduga ini bisa dilakukan dengan lebih efisien. $\prod_{i=1}^k {d_i \choose 2} = \Theta(N^2)$

Sebagai contoh, perhatikan kasus khusus di mana . Dalam hal ini kita dapat menggunakan struktur data RMQ yang ringkas untuk menyelesaikan masalah pertama, dan struktur data membutuhkan bit untuk disimpan. $k=1$ $2N+o(N)$

Apa struktur data yang efisien untuk tugas ini?
Seberapa rendah kompleksitas ruang (jumlah bit) untuk mendukung operasi ini (atau hanya operasi pertama)?

Pembaruan (1/15): Dalam kasus khusus , menggunakan bit sudah cukup (sebenarnya lebih baik, , di mana adalah angka ada di ) dengan mengurangi masalah menjadi masalah pendahulu dan menggunakan pengurangan dari masalah pendahulunya ke kamus yang sepenuhnya dapat diindeks (FID). Lihat " Lebih Tergesa-gesa, Lebih Sedikit Buang: Menurunkan Redundansi dalam Kamus yang Diindeks Sepenuhnya " oleh Grossi, Orlandi, Raman dan Rao (2009). $k=1$ $N +o(N)$ $\log {N\choose t}+O(t)$ $t$ $1$ $A$

Pembaruan (6/27): Sekali lagi dengan mengurangi masalah menjadi RMQ. Kami menggunakan dimensi RMQ oleh Yuan dan Atallah untuk mendapatkan batas atas pada jumlah ruang yang dibutuhkan ketika diperbaiki. $k$ $O(n\log n)$ $k$

reference-request data-structures space-complexity

— Chao Xu
sumber

Pertanyaannya tidak jelas: apakah ini pertanyaan struktur data? Jika demikian, apa operasi lain pada array kD ini? Jika tidak ada operasi lain maka tidak ada 1 di atasnya. Jika pertanyaannya adalah kita diberi array kD dan apa yang harus dilakukan preprocessing di atasnya dan kemudian menyimpannya sehingga kita menggunakan sedikit memori tetapi dapat melakukan operasi pengecekan ini dalam kasus terburuk kemudian mengklarifikasi itu. Juga jelaskan apa model komputasi jika Anda ingin batas bawah.

O (1)

$O(1)$

— Kaveh

citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.72.5421

— Kaveh

IIUC, makalah itu mengatakan jawaban untuk 1D benar-benar bit dan idenya adalah untuk menyimpan semua kotak kecil plus semua kotak dengan panjang daya 2 dan kotak lainnya dapat diperoleh dari len pow-2 kotak dalam konstanta waktu ( ) dan bagi saya tampaknya hal yang sama akan bekerja di sini dan bit akan cukup.

O (n \lg n)

$O(n\lg n)$

O (2^{k})

$O(2^k)$

O (n^{k} \lg^{k} n)

$O(n^k\lg^k n)$

— Kaveh

Terima kasih, saya telah menambahkan beberapa klarifikasi. Bukankah koran itu mengatakan kontribusi utama mereka adalah penggunaan

2 n + o (n)

$2n+o(n)$ bit dalam preprocessing dan penyimpanan?

— Chao Xu

Maaf, yang saya jelaskan adalah dari pekerjaan sebelumnya. Namun hasil mereka tampaknya mirip secara konseptual, yaitu mereka membagi array ke blok, precompute jawabannya, dan menggunakan jumlah konstan dari mereka untuk menghitung jawaban untuk setiap yang diberikan. Jika dalam kD jumlah blok dasar yang diperlukan untuk menghitung jawaban untuk blok arbitrer adalah konstan maka algoritma yang sama akan bekerja di sini dan akan memberikan sesuatu seperti

O (n^{k}) = O (N)

$O(n^k) = O(N)$ (Saya belum memeriksa apakah ini masalahnya).

— Kaveh

Anda dapat menyimpan lebih banyak pada memori jika Anda mengizinkan kompleksitas waktu logaritmik. Anda bisa mengimplementasikan pohon segmen kD yang membutuhkan memori N * 2 ^ k bit, dan berjalan dalam kompleksitas waktu logaritmik untuk kedua subtugas, dan kompleksitas waktu linier untuk membangun pohon.

Jika Anda benar-benar ingin O (1), lakukan precompute semuanya.

— Bojan Serafimov
sumber

Bisakah Anda menjelaskan bagaimana pohon itu dibangun dalam waktu logaritmik?

— Raphael

maaf, ini dibangun dalam waktu linier

— Bojan Serafimov

@BojanSerafimov Anda harus memperbarui jawabannya :) :) Komentar mungkin dihapus.

— Juho

Saya pikir ini bisa menjadi jawaban yang baik, jika Anda baru saja mengeditnya agar benar dan mungkin sedikit lebih rumit tentang seperti apa pohon-pohon ini dan bagaimana Anda membangunnya.

— Raphael