Сортування за допомогою стеків лише для читання

Розглянемо наступне налаштування:

• нам дається стек який містить n елементів.$s$$n$
• ми можемо використовувати постійну кількість додаткових стеків.$O(1)$
• ми можемо застосувати наступні операції до цих стеків:
  1. перевірити, чи стек порожній,
  2. порівняйте основні елементи двох стеків,
  3. видаліть верхній елемент із стека,
  4. надрукувати верхній елемент у стеці,
  5. скопіюйте верхній елемент стека в інший стек,
  6. скопіюйте вміст одного стека в інший стек.

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

Ось алгоритм сортування стеків за допомогою порівнянь :$O(n^2)$

last := empty
for i from 1 to n
  min := empty
  w := s
  while w is not empty
    if w.top > last and w.top < min
      min := w.top
    delete w.top
  print min
  last := min

Чи можемо ми зробити краще?

Чи існує програма, яка друкує відсортований список елементів у стеках, використовуючи лише ?$O(n\log n)$

Я думаю, що зараз можу продемонструвати нетривіальну нижню межу. Ідея полягає в тому, щоб реалізувати будь-яку таку програму з сімейством програм розгалуження порівняння. Припущення "лише для читання" означає, що наше сімейство програм розгалуження використовує мало, тобто простору. Потім застосуємо нижню межу S T = Ω ( n 2 ), доведену Бородіном та ін. в "Часово-космічний компроміс для сортування на непомітних машинах". Це дає нам нижню межу на час n 2 / log n .$O(\log n)$$ST=\Omega(n^2)$$n^2/\log n$

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

Припустимо, у нашій програмі регістрів є рядки коду та k регістри, X 1 , … , X k .$\ell$$k$$X_1,\dots,X_k$

Виправити . Побудуємо програму порівняння розгалуження для рядків довжиною n наступним чином. Створіть вузол для кожного кортежа ( i , d 1 , … , d k ), де 1 ≤ i ≤ ℓ і 0 ≤ d 1 , … , d k ≤ n . Ідея полягає в тому, що обчислення в машині реєстрації відповідають шляхам в програмі розгалуження, і ми знаходимося у вузлі ( i , d 1 , $n$$n$$(i,d_1,\dots,d_k)$$1\le i\le \ell$$0\le d_1 ,\dots, d_k \le n$. Тепер ми повинні визначити спрямовані краї програми розгалуження$(i,d_1 ,\dots, d_k)$якщо ми знаходимося в рядку в машині регістра, а довжина рядка, що зберігається в X i, є d $i$$X_i$$d_i$

Якщо рядок $i$ має форму

якщо то goto i 1 else goto i $X_u<X_v$$i_1$$i_2$

то для всіх , вузол ( i , d 1 , … , d k ) позначається, порівнюючи d u -th та d v -th елемент введення та маючи “справжній” край перейти до ( i 1 , d 1 , ... , d k ) , а "хибний" край до ( i 2 , d 1 , ... , d $d_1,\dots,d_k$$(i,d_1,\dots,d_k)$$d_u$$d_v$$(i_1,d_1,\dots,d_k)$ .$(i_2,d_1,\dots,d_k)$

Якщо рядок має форму$i$

, пряма лінія i $X_1 \leftarrow tail(X_2)$$i'$

то є стрілка від будь-якого вузла до ( i ′ , d 2 - 1 , … , d k ) .$(i,d_1,\dots,d_k)$$(i',d_2-1,\dots,d_k)$

Якщо рядок має форму$i$

$print(head(X_u))$$i'$

then there is an arrow from any node $(i,d_1,\dots,d_k)$ to $(i',d_1,\dots,d_k)$ which is labelled by the $d_u$-th node of the input.

Hopefully these examples make it clear how I intend to construct my branching program. When all is said and done, this branching program has at most $\ell\cdot n^k$ nodes, so it has space $O(\log n)$

Are you able to count elements? Then, I think, there is a fairly easy Mergesort implementation. If you were able to put additional symbols on the stack you could solve it with 3 stacks like this:

If we have only one element, the list is already sorted. Now assume we have already sorted the top half of the stack. We can copy the top half (in reverse order) to the second stack and place a separation symbol on top of it. Now we have again 3 Stacks (since we can ignore the already sorted symbols below the separation symbol) and can sort the lower half. Finally we can copy the sorted lower half to a third stack in reverse order and merge both halfs back to the original stack.

All operations cost linear time, therefore we have sorted the list in $O(n \log n)$

(Note, that we need stacks of size $n \log n$ because of the separation symbols, but this can be easily corrected by using another stack)

Since you can't put new elements on the stack you may get problems at the separation points. To solve this you may do the following with some additional stacks:

Copy the top $n-2^{\lfloor \log n\rfloor}$ elements to an additional stack, then proceed with the remaining elements as before. Now you know exactly the number of elements you need to consider in each step and therefore don't need any separation symbols.

Finally repeat the procedure with the additional elements at most $\log n$ times and merge them to the original stack in linear time. Sorting the stacks costs, for some constant $c$, at most $cn \log n+c\frac{n}{2} \log \frac{n}{2}+c\frac{n}{4} \log \frac{n}{4}+\ ... = O(n \log n)$ time, while merging costs an additional $O(n \log n)$.