Чи є стабільна купа?

Чи існує структура даних пріоритетної черги, яка підтримує наступні операції?

• Вставка (x, p) : додайте новий запис x з пріоритетом p
• StableExtractMin () : Повернення та видалення запису з мінімальним пріоритетом, розрив зв'язків у порядку вставки .

Таким чином, після Insert (a, 1), Insert (b, 2), Insert (c, 1), Insert (d, 2) послідовність StableExtractMin повернеться a, то c, тоді b, d.

Очевидно, що можна використовувати будь-яку структуру даних черги пріоритету, зберігаючи пару як фактичний пріоритет, але мене цікавлять структури даних, які явно не зберігають час вставки (або порядок вставки) за аналогією до стабільного сортування.$(p, time)$

Еквівалентно (?): Чи існує стабільна версія сукупності, яка не потребує додаткового простору ?$\Omega(n)$

Метод Бенті-Сакса дає досить природну стійку чергу пріоритетів.

Зберігайте свої дані в послідовності відсортованих масивів . A i має розмір 2 i . Кожен масив також підтримує лічильник c i . Записи масиву A i [ c i ] , … , A i [ 2 i - 1 ] містять дані.$A_0,\ldots,A_k$$A_i$$2^i$$c_i$$A_i[c_i],\ldots,A_i[2^i-1]$

Для кожного , все елементи А я були додані пізніше , ніж в А я + 1 , і в межах кожного A I елементи впорядковані за значенням зі зв'язками порушуються шляхом розміщення старих елементів попереду нових елементів. Зауважте, що це означає, що ми можемо об'єднати A i і A i + 1 і зберегти це впорядкування. (У випадку зв’язків під час злиття візьміть елемент з A i + 1. )$i$$A_i$$A_{i+1}$$A_i$$A_i$$A_{i+1}$$A_{i+1}$

Щоб вставити значення , знайдіть найменше i таке, що A i містить 0 елементів, об'єднайте A 0 , … , A i - 1 і x , збережіть це в A i і встановіть c 0 , … , c i відповідним чином.$x$$i$$A_i$$A_0,\ldots,A_{i-1}$$x$$A_i$$c_0,\ldots,c_i$

Для витягування min знайдіть найбільший індекс такий, що перший елемент в A i [ c i ] мінімальний за всі i i з приростом c i .$i$$A_i[c_i]$$i$$c_i$

За стандартним аргументу, це дає амортизується час на операцію і стабільно з - за впорядкування описано вище.$O(\log n)$

Для послідовності з вставок та вилучень для цього використовується n записів масиву (не зберігайте порожні масиви) плюс O ( log n ) слів даних бухгалтерії. Це не відповідає версії питання Міхай, але показує, що стійке обмеження не потребує великих витрат на приміщення. Зокрема, це свідчить про відсутність нижньої межі Ω ( n ) на необхідному додатковому просторі.$n$$n$$O(\log n)$$\Omega(n)$

Оновлення: Рольф Фагерберг вказує, що якщо ми можемо зберігати нульові (не дані) значення, то всю цю структуру даних можна упакувати в масив розміром , де n - кількість вставок на даний момент.$n$$n$

По-перше, зауважте, що ми можемо запакувати у масив у такому порядку ( спочатку A k , а потім A k - 1, якщо він не порожній тощо). Структура цього повністю закодована двійковим поданням n , кількістю елементів, вставлених дотепер. Якщо бінарне подання n має 1 у положенні i , то A i буде займати розташування масиву 2 i , інакше воно не займе жодного місця розташування масиву.$A_k,\ldots,A_0$$A_k$$A_{k-1}$$n$$n$$i$$A_i$$2^i$

Під час вставки, та довжини нашого масиву збільшуємо на 1, і ми можемо об'єднати A 0 , … , A i плюс новий елемент, використовуючи існуючі на місці стабільні алгоритми злиття.$n$$A_0,\ldots,A_i$

Тепер, де ми використовуємо нульові значення, це позбавлення від лічильників . У A i ми зберігаємо перше значення, за ним - значення c i null, а потім - 2 i - c i - 1 . Під час витягу-хв ми все ще можемо знайти значення для вилучення за час O ( log n ) , дослідивши A 0 [ 0 ] , … , A k [ 0 ] . Коли ми знайдемо це значення в A i [ $c_i$$A_i$$c_i$$2^i-c_i-1$$O(\log n)$$A_0[0],\ldots,A_k[0]$ ми встановлюємо A i [ 0 ] на null, а потім робимо двійковий пошук на A i, щоб знайти перше ненулеве значення A i [ c i ] і підміняти A i [ 0 ] і A i [ c i ] .$A_i[0]$$A_i[0]$$A_i$$A_i[c_i]$$A_i[0]$$A_i[c_i]$

Кінцевий результат: Вся структура може бути реалізована за допомогою одного масиву, довжина якого збільшується з кожною вставкою, і одного лічильника, , який підраховує кількість вставок.$n$

Я не впевнений, які ваші обмеження; чи відповідає наступне? Зберігайте дані в масиві, який ми інтерпретуємо як неявне бінарне дерево (як бінарне коло), але з елементами даних на нижньому рівні дерева, а не у його внутрішніх вузлах. Кожен внутрішній вузол дерева зберігає менші значення, скопійовані з двох його дітей; у разі зв’язків скопіюйте ліву дитину.

Щоб знайти мінімум, подивіться на корінь дерева.

Щоб видалити елемент, позначте його як видалений (ліниве видалення) та розповсюдьте дерево (кожен вузол на шляху до кореня, який містив копію видаленого елемента, повинен бути замінений на копію його іншої дочірні). Підтримуйте кількість видалених елементів, і якщо коли-небудь стає занадто великою частину всіх елементів, тоді відновіть структуру, зберігаючи порядок елементів на нижньому рівні - відновлення займає лінійний час, тому ця частина додає лише постійний амортизований час до складність операції.

Щоб вставити елемент, додайте його до наступного вільного положення в нижньому рядку дерева та оновіть шлях до кореня. Або, якщо нижній рядок стає заповненим, подвоюйте розмір дерева (знову ж таки аргументом амортизації; зауважте, що ця частина нічим не відрізняється від необхідності перебудови, коли стандартна двійкова купа переростає її масив).

Це не є відповіддю на більш сувору версію питання Михайла, оскільки вона використовує вдвічі більше пам’яті, ніж повинна бути справжня неявна структура даних, навіть якщо ми ігноруємо космічну вартість обробки видалень.

Чи є наступним правильне тлумачення вашої проблеми:

Ви повинні зберігати N клавіш у масиві A [1..N] без допоміжної інформації, щоб ви могли підтримувати: * клавіша вставки * delete min, яка вибирає найраніший вставлений елемент, якщо є кілька мінімумів

Це здається досить важким, враховуючи, що більшість неявних структур даних відтворюють хитрість кодування бітів в локальному впорядкуванні деяких елементів. Тут, якщо кілька хлопців рівні, їх впорядкування повинно зберігатися, тому такі хитрощі неможливі.

Цікаво.

Коротка відповідь: Ви не можете.

Трохи довша відповідь:

Вам знадобиться додатковий простір, щоб зберігати "вік" вашої записи, що дозволить вам розрізняти однакові пріоритети. І вам знадобиться простір Ω ( n ) для інформації, яка дозволить швидко вставляти та витягувати. Плюс ваше корисне навантаження (значення та пріоритет).$\Omega(n)$$\Omega(n)$

І за кожне збережене вами корисне навантаження ви зможете "заховати" деяку інформацію в адресу (наприклад, означає, що Y старше X). Але в цій "прихованій" інформації ви або приховатимете "вік", або "швидкий пошук" інформації. Не обоє.$addr(X) < addr(Y)$

Дуже довга відповідь неточною лускатою псевдо-математикою:

Примітка: сам кінець другої частини є схематичним, як згадувалося. Якби якийсь математик міг запропонувати кращу версію, я буду вдячний.

Давайте подумаємо про кількість даних, що беруть участь у X-бітовій машині (скажімо, 32 або 64-бітної), із записами (значення та пріоритет) машинними словами.$P$

У вас є набір потенційних записів, який частково впорядкований: та ( a , 1 ) = ( a , 1 ), але ви не можете порівняти ( a , 1 ) та ( b , 1 ) .$(a,1) < (a,2)$$(a,1) = (a,1)$$(a,1)$$(b,1)$

Однак ви хочете мати можливість порівняти два непорівнянні значення зі свого набору записів, залежно від того, коли вони були вставлені. Так що у вас є тут ще один набір значень: ті , які були вставлені, і ви хочете підвищити його за допомогою часткового порядку: тоді і тільки тоді X був вставлений перед Y .$X < Y$$X$$Y$

У гіршому випадку ваша пам’ять заповниться записами форми (з ? Різними для кожного), тому вам доведеться повністю покладатися на час вставки, щоб вирішити, який з них буде перший.$(?,1)$$?$

• Час вставки (по відношенню до інших записів, що все ще в структурі) вимагає бітів інформації (з корисним навантаженням P-байтів та 2 X доступними байтами пам'яті).$X - log_2(P)$$2^X$
• Корисне навантаження (значення та пріоритет вашого запису) вимагає машинних слів інформації.$P$

Це означає, що ви повинні якось зберігати додаткові біти інформації для кожної записи, яку ви зберігаєте. І це O ( n ) для n записів.$X - log_2(P)$$O(n)$$n$

Тепер, скільки бітів інформації нам надає кожна "комірка" пам'яті?

• біт даних ( W - ширина машинного слова).$W$$W$
• біт адреси.$X$

Тепер припустимо (корисна навантаження становить щонайменше одне машинне слово в ширину (зазвичай один октет)). Це означає, що X - l o g 2 ( P ) < X , тому ми можемо помістити інформацію про порядок вставки в адресу комірки. Ось що відбувається в стеку: клітинки з найнижчою адресою увійшли в стек першими (і вийдуть останніми).$P \geq 1$$X - log_2(P) < X$

Отже, для зберігання всієї нашої інформації у нас є дві можливості:

• Зберігайте порядок вставки за адресою та корисне навантаження в пам'яті.
• Зберігайте обидва в пам’яті та залиште адресу вільною для іншого використання.

Очевидно, щоб уникнути відходів, ми використаємо перше рішення.

Тепер про операції. Я думаю, ви хочете мати:

• з O ( l o g n ) часовою складністю.$Insert(task, priority)$$O(log n)$
• з O ( l o g n ) часовою складністю.$StableExtractMin()$$O(log n)$

Давайте подивимось на :$StableExtractMin()$

Дійсно загальний алгоритм виглядає так:

1. $O(log n)$
2. $O(log n)$
3. Поверніть його.

$0(1)$$O(1)$$O(1)$

$O(log n)$$2^(X - log_2(P))$

$X - log_2(P)$$O(log n)$$O(log n)$

$O(log n)$

$O(log n)$$X - log_2(P)$

$O(log n)$

$X - log_2(P)$$O(log n)$

Алгоритм вставки зазвичай просто потребує оновлення частини цієї інформації, я не думаю, що для швидкої роботи це обійдеться дорожче (залежно від пам'яті).

$X - log_2(P)$

• $X - log_2(P)$
• $P$
• $X - log_2(P)$

$\Omega(n)$

Якщо ви реалізуєте свою чергу пріоритетів як збалансоване бінарне дерево (популярний вибір), тоді вам просто потрібно переконатися, що коли ви додаєте елемент до дерева, він вставляється зліва від будь-яких елементів з рівним пріоритетом.
Таким чином, порядок вставки кодується в структурі самого дерева.

Я не думаю, що це можливо

конкретний випадок:

       x
    x    x
  x  x  1  x
1  x  

хв. хв з усіма х> 1

загострення зрештою дасть щось подібне на вибір

       x
    1    1
  x  x  x  x
x  x  

тепер, який 1 поширити на корінь?