Ефективно знаходити кількість менших елементів для кожного елемента в масиві

Я застряг у цій проблемі:

Дано масив $A$ першої $n$ натуральні числа випадковим чином перестановлені, масив $B$ будується так, що $B(k)$ - кількість елементів від $A(1)$ до $A(k-1)$ які менші, ніж $A(k)$.

і) Дано $A$ ви можете знайти $B$ в $O(n)$час?
ii) Дано$B$ ви можете знайти $A$ в $O(n)$ час?

Ось $B(1) = 0$. Для конкретного прикладу:

$$\begin{vmatrix} A & 8 & 4 & 3 & 1 & 7 & 2 & 9 & 6 & 5 \\ B & 0 & 0 & 0 & 0 & 3 & 1 & 6 & 4 & 4 \\ \end{vmatrix}$$

Хтось може мені допомогти? Дякую.

Наївний алгоритм визначення $B$ з $A$:

Для $k=1,\dots,n$, визначте значення $B(k)$ шляхом порівняння кожного $A(i)$ до $A(k)$ для $i=1,\dots,k$ і рахувати тих, що задовольняють $A(i)<A(k)$.

Цей алгоритм порівнює $A(1)$ всім іншим ($n-1$ разів), $A(2)$ до $n-2$ інші тощо, тому загальна кількість порівнянь становить $\frac{(n-1)(n-2)}{2}$. Але це не найкраще, що ми можемо зробити. Наприклад, дивлячись на$B(n)$, ми не повинні робити ніяких порівнянь! $B(n)=A(n)-1$бо це перше $n$ натуральні числа, і гарантовано (незалежно від перестановки), що $n-1$нижчі натуральні числа будуть там. А як на рахунок$B(n-1)$? Замість перевірки$A(1)$ наскрізь $A(n-2)$, ми могли просто перевірити $A(n)$. Це є:

Для $k=1, \dots,\frac{n}{2}$, використовувати алгоритм, наведений вище; для $k=\frac{n}{2},\dots,n$ використовувати зворотний алгоритм: визначити $B(k)$ встановивши його спочатку на $A(n)-1$ а потім віднімання $1$ для кожного запису $A(i)$ для $i=k+1,\dots,n$ що менше, ніж $A(k)$.

Це займе $2\times\frac{(\frac{n}{2}-1) (\frac{n}{2}-2)}{2}=\frac{(n-2)(n-4)}{4}$ кроки, що досі $O(n^2)$. Зауважимо також, що при конструюванні$A$ з $B$, якщо $B(n)=A(n)-1$ тоді $A(n)=B(n)+1$.

Але тепер для більшої витонченості. Якщо нам дозволено додаткове місце або сортувати на місці, ми можемо сортувати числа, порівнюючи їх. Наприклад:

$$\begin{vmatrix} A & 8 & 4 & 3 & 1 & 7 & 2 & 9 & 6 & 5 \\ S & 9 & 8 & 7 & 4 & 3 & 2 & 1 & 6 & 5 \\ B & 0 & 0 & 0 & 0 & 3 & 1 & 6 & & \\ \end{vmatrix}$$

Замість того, щоб перевіряти їх усіх (або перевіряти їх по порядку), ми могли б використовувати двійковий пошук для визначення кожного $B(k)$. Однак сортування все ж потребує часу$O(n\log n)$.

Замість визначення кожного $B(k)$ один за одним, ми можемо дивитися вперед і лише проходити кожне число $A$ раз ! Але ми скористаємось$n$ простір:

$$\begin{vmatrix} A & & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 & & B \\ 8 & & 0 & 0 & 0 & 0 & 0 & 0 & 0 & \color{red}{0} & 1 & & 0\\ 4 & & 0 & 0 & 0 & \color{red}{0} & 1 & 1 & 1 & 1 & 2 & & 0\\ 3 & & 0 & 0 & \color{red}{0} & 1 & 2 & 2 & 2 & 2 & 3 & & 0\\ 1 & & \color{red}{0} & 1 & 1 & 2 & 3 & 3 & 3 & 3 & 4 & & 0\\ 7 & & 0 & 1 & 1 & 2 & 3 & 3 & \color{red}{3} & 4 & 5 & & 3\\ 2 & & 0 & \color{red}{1} & 2 & 3 & 4 & 4 & 4 & 5 & 6 & & 1\\ 9 & & 0 & 1 & 2 & 3 & 4 & 4 & 4 & 5 & \color{red}{6} & & 6\\ 6 & & 0 & 1 & 2 & 3 & 4 & \color{red}{4} & 5 & 6 & 7 & & 4\\ 5 & & 0 & 1 & 2 & 3 & \color{red}{4} & 5 & 6 & 7 & 8 & & 4\\ \end{vmatrix}$$

Ми могли б заощадити ще більше часу, не оновлюючи вже визначені (тобто немає сенсу в оновленні $8$ після першого кроку), але в гіршому випадку нам ще належить оновити $\frac{(n)(n+2)}{2}$ разів

і я, і II вирішуються за допомогою #next_greater_element, що я пояснив тут . але це трохи складніше, ніж просто проблема, але перед вирішенням потрібно вивчити наступний більший елемент:

1. вважаємо, що у нас є вектор для кожного елемента $A$ назвіть його $S_i$ для елемента $i$. тепер один раз запустіть наступний більший алгоритм, починаючи справа наліво, але крім елемента настройки$i$ в $A$ його наступний більший індекс елемента, натисніть $S_i$ елементи, які $i$ є їх наступним більшим елементом. потім перейдіть по масиву зліва направо, а потім $B[i]=\sum_{j=0}^x (S_i[j]+1)$ де $x$ - розмір вектора $S_i$.і його $\Theta(n)$ тому що кожен наступний більший алгоритм є $\Theta(n)$ а також ітерація є $\Theta(n)$

Друга частина також схожа на те, що ми можемо отримати значення найсправедливішого елемента $O(1)$ EDIT: моє рішення неправильне, здається, що у нього немає$o(n)$ рішення